diff options
| author | somov <somov@yandex-team.ru> | 2022-02-10 16:45:49 +0300 |
|---|---|---|
| committer | Daniil Cherednik <dcherednik@yandex-team.ru> | 2022-02-10 16:45:49 +0300 |
| commit | 7489e4682331202b9c7d863c0898eb83d7b12c2b (patch) | |
| tree | 9142afc54d335ea52910662635b898e79e192e49 /contrib/restricted/abseil-cpp-tstring | |
| parent | a5950576e397b1909261050b8c7da16db58f10b1 (diff) | |
| download | ydb-7489e4682331202b9c7d863c0898eb83d7b12c2b.tar.gz | |
Restoring authorship annotation for <somov@yandex-team.ru>. Commit 2 of 2.
Diffstat (limited to 'contrib/restricted/abseil-cpp-tstring')
286 files changed, 4259 insertions, 4259 deletions
diff --git a/contrib/restricted/abseil-cpp-tstring/CONTRIBUTING.md b/contrib/restricted/abseil-cpp-tstring/CONTRIBUTING.md index b21998774a..a252cfac31 100644 --- a/contrib/restricted/abseil-cpp-tstring/CONTRIBUTING.md +++ b/contrib/restricted/abseil-cpp-tstring/CONTRIBUTING.md @@ -39,16 +39,16 @@ of the following criteria: of the libraries we've released have tens of thousands of users. * **Anticipated widespread usage** - Pre-adoption of some standard-compliant APIs may not have broad adoption initially but can be expected to pick up - usage when it replaces legacy APIs. `y_absl::from_chars`, for example, + usage when it replaces legacy APIs. `y_absl::from_chars`, for example, replaces existing code that converts strings to numbers and will therefore likely see usage growth. * **High impact** - APIs that provide a key solution to a specific problem, - such as `y_absl::FixedArray`, have higher impact than usage numbers may signal + such as `y_absl::FixedArray`, have higher impact than usage numbers may signal and are released because of their importance. * **Direct support for a library that falls under one of the above** - When we want access to a smaller library as an implementation detail for a higher-priority library we plan to release, we may release it, as we did - with portions of `y_absl/meta/type_traits.h`. One consequence of this is that + with portions of `y_absl/meta/type_traits.h`. One consequence of this is that the presence of a library in Abseil does not necessarily mean that other similar libraries would be a high priority. diff --git a/contrib/restricted/abseil-cpp-tstring/README.md b/contrib/restricted/abseil-cpp-tstring/README.md index b88f7c69e4..a63901a422 100644 --- a/contrib/restricted/abseil-cpp-tstring/README.md +++ b/contrib/restricted/abseil-cpp-tstring/README.md @@ -65,32 +65,32 @@ supported operating systems, compilers, CPUs, etc. Abseil contains the following C++ library components: -* [`base`](y_absl/base/) Abseil Fundamentals +* [`base`](y_absl/base/) Abseil Fundamentals <br /> The `base` library contains initialization code and other code which all other Abseil code depends on. Code within `base` may not depend on any other code (other than the C++ standard library). -* [`algorithm`](y_absl/algorithm/) +* [`algorithm`](y_absl/algorithm/) <br /> The `algorithm` library contains additions to the C++ `<algorithm>` library and container-based versions of such algorithms. * [`cleanup`](y_absl/cleanup/) <br /> The `cleanup` library contains the control-flow-construct-like type `y_absl::Cleanup` which is used for executing a callback on scope exit. -* [`container`](y_absl/container/) +* [`container`](y_absl/container/) <br /> The `container` library contains additional STL-style containers, including Abseil's unordered "Swiss table" containers. -* [`debugging`](y_absl/debugging/) +* [`debugging`](y_absl/debugging/) <br /> The `debugging` library contains code useful for enabling leak checks, and stacktrace and symbolization utilities. -* [`hash`](y_absl/hash/) +* [`hash`](y_absl/hash/) <br /> The `hash` library contains the hashing framework and default hash functor implementations for hashable types in Abseil. -* [`memory`](y_absl/memory/) +* [`memory`](y_absl/memory/) <br /> The `memory` library contains C++11-compatible versions of `std::make_unique()` and related memory management facilities. -* [`meta`](y_absl/meta/) +* [`meta`](y_absl/meta/) <br /> The `meta` library contains C++11-compatible versions of type checks available within C++14 and C++17 versions of the C++ `<type_traits>` library. -* [`numeric`](y_absl/numeric/) +* [`numeric`](y_absl/numeric/) <br /> The `numeric` library contains C++11-compatible 128-bit integers. * [`profiling`](y_absl/profiling/) <br /> The `profiling` library contains utility code for profiling C++ @@ -98,22 +98,22 @@ Abseil contains the following C++ library components: * [`status`](y_absl/status/) <br /> The `status` contains abstractions for error handling, specifically `y_absl::Status` and `y_absl::StatusOr<T>`. -* [`strings`](y_absl/strings/) +* [`strings`](y_absl/strings/) <br /> The `strings` library contains a variety of strings routines and utilities, including a C++11-compatible version of the C++17 `std::string_view` type. -* [`synchronization`](y_absl/synchronization/) +* [`synchronization`](y_absl/synchronization/) <br /> The `synchronization` library contains concurrency primitives (Abseil's - `y_absl::Mutex` class, an alternative to `std::mutex`) and a variety of + `y_absl::Mutex` class, an alternative to `std::mutex`) and a variety of synchronization abstractions. -* [`time`](y_absl/time/) +* [`time`](y_absl/time/) <br /> The `time` library contains abstractions for computing with absolute points in time, durations of time, and formatting and parsing time within time zones. -* [`types`](y_absl/types/) +* [`types`](y_absl/types/) <br /> The `types` library contains non-container utility types, like a C++11-compatible version of the C++17 `std::optional` type. -* [`utility`](y_absl/utility/) +* [`utility`](y_absl/utility/) <br /> The `utility` library contains utility and helper code. ## Releases diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/algorithm.h b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/algorithm.h index 6ef61e5b33..b1003bd0a9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/algorithm.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/algorithm.h @@ -28,7 +28,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace algorithm_internal { @@ -114,7 +114,7 @@ bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2, template <typename InputIter1, typename InputIter2> bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2) { - return y_absl::equal(first1, last1, first2, last2, + return y_absl::equal(first1, last1, first2, last2, algorithm_internal::EqualTo{}); } @@ -142,7 +142,7 @@ bool linear_search(InputIterator first, InputIterator last, // <= 4.9 where `std::rotate` returns `void` instead of an iterator. // // The complexity of this algorithm is the same as that of `std::rotate`, but if -// `ForwardIterator` is not a random-access iterator, then `y_absl::rotate` +// `ForwardIterator` is not a random-access iterator, then `y_absl::rotate` // performs an additional pass over the range to construct the return value. template <typename ForwardIterator> ForwardIterator rotate(ForwardIterator first, ForwardIterator middle, @@ -154,6 +154,6 @@ ForwardIterator rotate(ForwardIterator first, ForwardIterator middle, } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_ALGORITHM_ALGORITHM_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h index 6591e9599f..d6bf385964 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h @@ -28,7 +28,7 @@ // within this API operate on containers, though many return iterator ranges. // // All functions within this API are named with a `c_` prefix. Calls such as -// `y_absl::c_xx(container, ...) are equivalent to std:: functions such as +// `y_absl::c_xx(container, ...) are equivalent to std:: functions such as // `std::xx(std::begin(cont), std::end(cont), ...)`. Functions that act on // iterators but not conceptually on iterator ranges (e.g. `std::iter_swap`) // have no equivalent here. @@ -50,11 +50,11 @@ #include <utility> #include <vector> -#include "y_absl/algorithm/algorithm.h" -#include "y_absl/base/macros.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/algorithm/algorithm.h" +#include "y_absl/base/macros.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_algorithm_internal { @@ -135,7 +135,7 @@ constexpr std::size_t c_size(T (&)[N]) { // c_linear_search() // -// Container-based version of y_absl::linear_search() for performing a linear +// Container-based version of y_absl::linear_search() for performing a linear // search within a container. template <typename C, typename EqualityComparable> bool c_linear_search(const C& c, EqualityComparable&& value) { @@ -785,7 +785,7 @@ OutputIterator c_reverse_copy(const C& sequence, OutputIterator result) { template <typename C, typename Iterator = container_algorithm_internal::ContainerIter<C>> Iterator c_rotate(C& sequence, Iterator middle) { - return y_absl::rotate(container_algorithm_internal::c_begin(sequence), middle, + return y_absl::rotate(container_algorithm_internal::c_begin(sequence), middle, container_algorithm_internal::c_end(sequence)); } @@ -1671,7 +1671,7 @@ void c_iota(Sequence& sequence, T&& value) { // accumulation by value. // // Note: Due to a language technicality this function has return type -// y_absl::decay_t<T>. As a user of this function you can casually read +// y_absl::decay_t<T>. As a user of this function you can casually read // this as "returns T by value" and assume it does the right thing. template <typename Sequence, typename T> decay_t<T> c_accumulate(const Sequence& sequence, T&& init) { @@ -1697,7 +1697,7 @@ decay_t<T> c_accumulate(const Sequence& sequence, T&& init, // to compute the cumulative inner product of container element pairs. // // Note: Due to a language technicality this function has return type -// y_absl::decay_t<T>. As a user of this function you can casually read +// y_absl::decay_t<T>. As a user of this function you can casually read // this as "returns T by value" and assume it does the right thing. template <typename Sequence1, typename Sequence2, typename T> decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2, @@ -1769,6 +1769,6 @@ OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first, } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_ALGORITHM_CONTAINER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/call_once.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/call_once.h index 68ab3210ec..5d80e4e7ca 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/call_once.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/call_once.h @@ -31,22 +31,22 @@ #include <type_traits> #include <utility> -#include "y_absl/base/internal/invoke.h" -#include "y_absl/base/internal/low_level_scheduling.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/scheduling_mode.h" -#include "y_absl/base/internal/spinlock_wait.h" -#include "y_absl/base/macros.h" -#include "y_absl/base/optimization.h" -#include "y_absl/base/port.h" - -namespace y_absl { +#include "y_absl/base/internal/invoke.h" +#include "y_absl/base/internal/low_level_scheduling.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/scheduling_mode.h" +#include "y_absl/base/internal/spinlock_wait.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/optimization.h" +#include "y_absl/base/port.h" + +namespace y_absl { ABSL_NAMESPACE_BEGIN class once_flag; namespace base_internal { -std::atomic<uint32_t>* ControlWord(y_absl::once_flag* flag); +std::atomic<uint32_t>* ControlWord(y_absl::once_flag* flag); } // namespace base_internal // call_once() @@ -66,15 +66,15 @@ std::atomic<uint32_t>* ControlWord(y_absl::once_flag* flag); // class MyInitClass { // public: // ... -// mutable y_absl::once_flag once_; +// mutable y_absl::once_flag once_; // // MyInitClass* init() const { -// y_absl::call_once(once_, &MyInitClass::Init, this); +// y_absl::call_once(once_, &MyInitClass::Init, this); // return ptr_; // } // template <typename Callable, typename... Args> -void call_once(y_absl::once_flag& flag, Callable&& fn, Args&&... args); +void call_once(y_absl::once_flag& flag, Callable&& fn, Args&&... args); // once_flag // @@ -103,7 +103,7 @@ namespace base_internal { // Like call_once, but uses KERNEL_ONLY scheduling. Intended to be used to // initialize entities used by the scheduler implementation. template <typename Callable, typename... Args> -void LowLevelCallOnce(y_absl::once_flag* flag, Callable&& fn, Args&&... args); +void LowLevelCallOnce(y_absl::once_flag* flag, Callable&& fn, Args&&... args); // Disables scheduling while on stack when scheduling mode is non-cooperative. // No effect for cooperative scheduling modes. @@ -190,7 +190,7 @@ inline std::atomic<uint32_t>* ControlWord(once_flag* flag) { } template <typename Callable, typename... Args> -void LowLevelCallOnce(y_absl::once_flag* flag, Callable&& fn, Args&&... args) { +void LowLevelCallOnce(y_absl::once_flag* flag, Callable&& fn, Args&&... args) { std::atomic<uint32_t>* once = base_internal::ControlWord(flag); uint32_t s = once->load(std::memory_order_acquire); if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) { @@ -203,7 +203,7 @@ void LowLevelCallOnce(y_absl::once_flag* flag, Callable&& fn, Args&&... args) { } // namespace base_internal template <typename Callable, typename... Args> -void call_once(y_absl::once_flag& flag, Callable&& fn, Args&&... args) { +void call_once(y_absl::once_flag& flag, Callable&& fn, Args&&... args) { std::atomic<uint32_t>* once = base_internal::ControlWord(&flag); uint32_t s = once->load(std::memory_order_acquire); if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) { @@ -214,6 +214,6 @@ void call_once(y_absl::once_flag& flag, Callable&& fn, Args&&... args) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_CALL_ONCE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h index 515b1b66f8..6270ede21e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h @@ -29,11 +29,11 @@ #include <type_traits> #include <utility> -#include "y_absl/base/internal/identity.h" -#include "y_absl/base/macros.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/base/internal/identity.h" +#include "y_absl/base/macros.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace internal_casts { @@ -99,7 +99,7 @@ struct is_bitcastable // // Such implicit cast chaining may be useful within template logic. template <typename To> -constexpr To implicit_cast(typename y_absl::internal::identity_t<To> to) { +constexpr To implicit_cast(typename y_absl::internal::identity_t<To> to) { return to; } @@ -182,6 +182,6 @@ inline Dest bit_cast(const Source& source) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_CASTS_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h index e8e3fd1b32..162843aa00 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h @@ -33,7 +33,7 @@ // selectively include the `mmap.h` header and bracket code using that feature // in the macro: // -// #include "y_absl/base/config.h" +// #include "y_absl/base/config.h" // // #ifdef ABSL_HAVE_MMAP // #include "sys/mman.h" @@ -63,8 +63,8 @@ #include <TargetConditionals.h> #endif -#include "y_absl/base/options.h" -#include "y_absl/base/policy_checks.h" +#include "y_absl/base/options.h" +#include "y_absl/base/policy_checks.h" // Abseil long-term support (LTS) releases will define // `ABSL_LTS_RELEASE_VERSION` to the integer representing the date string of the @@ -261,7 +261,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' || // ABSL_HAVE_SOURCE_LOCATION_CURRENT // -// Indicates whether `y_absl::SourceLocation::current()` will return useful +// Indicates whether `y_absl::SourceLocation::current()` will return useful // information in some contexts. #ifndef ABSL_HAVE_SOURCE_LOCATION_CURRENT #if ABSL_INTERNAL_HAS_KEYWORD(__builtin_LINE) && \ @@ -517,7 +517,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' || #elif defined(_WIN32) #define ABSL_IS_LITTLE_ENDIAN 1 #else -#error "y_absl endian detection needs to be set up for your compiler" +#error "y_absl endian detection needs to be set up for your compiler" #endif // macOS 10.13 and iOS 10.11 don't let you use <any>, <optional>, or <variant> @@ -610,7 +610,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' || // ABSL_USES_STD_ANY // -// Indicates whether y_absl::any is an alias for std::any. +// Indicates whether y_absl::any is an alias for std::any. #if !defined(ABSL_OPTION_USE_STD_ANY) #error options.h is misconfigured. #elif ABSL_OPTION_USE_STD_ANY == 0 || \ @@ -625,7 +625,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' || // ABSL_USES_STD_OPTIONAL // -// Indicates whether y_absl::optional is an alias for std::optional. +// Indicates whether y_absl::optional is an alias for std::optional. #if !defined(ABSL_OPTION_USE_STD_OPTIONAL) #error options.h is misconfigured. #elif ABSL_OPTION_USE_STD_OPTIONAL == 0 || \ @@ -640,7 +640,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' || // ABSL_USES_STD_VARIANT // -// Indicates whether y_absl::variant is an alias for std::variant. +// Indicates whether y_absl::variant is an alias for std::variant. #if !defined(ABSL_OPTION_USE_STD_VARIANT) #error options.h is misconfigured. #elif ABSL_OPTION_USE_STD_VARIANT == 0 || \ @@ -655,7 +655,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' || // ABSL_USES_STD_STRING_VIEW // -// Indicates whether y_absl::string_view is an alias for std::string_view. +// Indicates whether y_absl::string_view is an alias for std::string_view. #if !defined(ABSL_OPTION_USE_STD_STRING_VIEW) #error options.h is misconfigured. #elif ABSL_OPTION_USE_STD_STRING_VIEW == 0 || \ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/const_init.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/const_init.h index 6dd29294fd..4bab055dda 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/const_init.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/const_init.h @@ -51,19 +51,19 @@ // // For a few core Abseil classes, we make a best effort to allow for safe global // instances, even though these classes have non-trivial destructors. These -// objects can be created with the y_absl::kConstInit tag. For example: -// ABSL_CONST_INIT y_absl::Mutex global_mutex(y_absl::kConstInit); +// objects can be created with the y_absl::kConstInit tag. For example: +// ABSL_CONST_INIT y_absl::Mutex global_mutex(y_absl::kConstInit); // -// The line above declares a global variable of type y_absl::Mutex which can be +// The line above declares a global variable of type y_absl::Mutex which can be // accessed at any point during startup or shutdown. global_mutex's destructor // will still run, but will not invalidate the object. Note that C++ specifies // that accessing an object after its destructor has run results in undefined // behavior, but this pattern works on the toolchains we support. // -// The y_absl::kConstInit tag should only be used to define objects with static +// The y_absl::kConstInit tag should only be used to define objects with static // or thread_local storage duration. -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN enum ConstInitType { @@ -71,6 +71,6 @@ enum ConstInitType { }; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_CONST_INIT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook.h index 9923de44f7..5bdf360a57 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook.h @@ -35,7 +35,7 @@ #define ABSL_HAVE_WORKING_ATOMIC_POINTER 1 #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -195,6 +195,6 @@ class AtomicHook<ReturnType (*)(Args...)> { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook_test_helper.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook_test_helper.h index 0d64d626e7..e600d27f4f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook_test_helper.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook_test_helper.h @@ -15,20 +15,20 @@ #ifndef ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_ #define ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_ -#include "y_absl/base/internal/atomic_hook.h" +#include "y_absl/base/internal/atomic_hook.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace atomic_hook_internal { using VoidF = void (*)(); -extern y_absl::base_internal::AtomicHook<VoidF> func; +extern y_absl::base_internal::AtomicHook<VoidF> func; extern int default_func_calls; void DefaultFunc(); void RegisterFunc(VoidF func); } // namespace atomic_hook_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.cc index dfb79fb656..6b43f7c184 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.cc @@ -20,14 +20,14 @@ // with modifications by m3b. See also // https://setisvn.ssl.berkeley.edu/svn/lib/fftw-3.0.1/kernel/cycle.h -#include "y_absl/base/internal/cycleclock.h" +#include "y_absl/base/internal/cycleclock.h" #include <atomic> #include <chrono> // NOLINT(build/c++11) -#include "y_absl/base/internal/unscaledcycleclock.h" +#include "y_absl/base/internal/unscaledcycleclock.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -104,4 +104,4 @@ double CycleClock::Frequency() { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.h index 1ebe79b0d1..389c9093e3 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.h @@ -46,7 +46,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -89,6 +89,6 @@ class CycleClockSource { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_CYCLECLOCK_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/direct_mmap.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/direct_mmap.h index f129dfa49b..82be9f94ab 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/direct_mmap.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/direct_mmap.h @@ -18,7 +18,7 @@ #ifndef ABSL_BASE_INTERNAL_DIRECT_MMAP_H_ #define ABSL_BASE_INTERNAL_DIRECT_MMAP_H_ -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" #if ABSL_HAVE_MMAP @@ -65,7 +65,7 @@ extern "C" void* __mmap2(void*, size_t, int, int, int, size_t); #define SYS_mmap2 __NR_mmap2 #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -138,14 +138,14 @@ inline int DirectMunmap(void* start, size_t length) { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else // !__linux__ // For non-linux platforms where we have mmap, just dispatch directly to the // actual mmap()/munmap() methods. -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -160,7 +160,7 @@ inline int DirectMunmap(void* start, size_t length) { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // __linux__ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/endian.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/endian.h index 70a2c25f29..0f7adb8bf6 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/endian.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/endian.h @@ -27,11 +27,11 @@ #include <cstdint> #include "y_absl/base/casts.h" -#include "y_absl/base/config.h" -#include "y_absl/base/internal/unaligned_access.h" -#include "y_absl/base/port.h" +#include "y_absl/base/config.h" +#include "y_absl/base/internal/unaligned_access.h" +#include "y_absl/base/port.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // Use compiler byte-swapping intrinsics if they are available. 32-bit @@ -322,6 +322,6 @@ inline void Store64(void *p, uint64_t v) { } // namespace big_endian ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_ENDIAN_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_safety_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_safety_testing.h index 5f28af8acb..3009f17875 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_safety_testing.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_safety_testing.h @@ -17,7 +17,7 @@ #ifndef ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_ #define ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_ -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" #ifdef ABSL_HAVE_EXCEPTIONS @@ -31,12 +31,12 @@ #include <unordered_map> #include "gtest/gtest.h" -#include "y_absl/base/internal/pretty_function.h" -#include "y_absl/memory/memory.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/strings/string_view.h" -#include "y_absl/strings/substitute.h" -#include "y_absl/utility/utility.h" +#include "y_absl/base/internal/pretty_function.h" +#include "y_absl/memory/memory.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/strings/string_view.h" +#include "y_absl/strings/substitute.h" +#include "y_absl/utility/utility.h" namespace testing { @@ -44,29 +44,29 @@ enum class TypeSpec; enum class AllocSpec; constexpr TypeSpec operator|(TypeSpec a, TypeSpec b) { - using T = y_absl::underlying_type_t<TypeSpec>; + using T = y_absl::underlying_type_t<TypeSpec>; return static_cast<TypeSpec>(static_cast<T>(a) | static_cast<T>(b)); } constexpr TypeSpec operator&(TypeSpec a, TypeSpec b) { - using T = y_absl::underlying_type_t<TypeSpec>; + using T = y_absl::underlying_type_t<TypeSpec>; return static_cast<TypeSpec>(static_cast<T>(a) & static_cast<T>(b)); } constexpr AllocSpec operator|(AllocSpec a, AllocSpec b) { - using T = y_absl::underlying_type_t<AllocSpec>; + using T = y_absl::underlying_type_t<AllocSpec>; return static_cast<AllocSpec>(static_cast<T>(a) | static_cast<T>(b)); } constexpr AllocSpec operator&(AllocSpec a, AllocSpec b) { - using T = y_absl::underlying_type_t<AllocSpec>; + using T = y_absl::underlying_type_t<AllocSpec>; return static_cast<AllocSpec>(static_cast<T>(a) & static_cast<T>(b)); } namespace exceptions_internal { -TString GetSpecString(TypeSpec); -TString GetSpecString(AllocSpec); +TString GetSpecString(TypeSpec); +TString GetSpecString(AllocSpec); struct NoThrowTag {}; struct StrongGuaranteeTagType {}; @@ -75,12 +75,12 @@ struct StrongGuaranteeTagType {}; // exceptions specifically thrown by ThrowingValue. class TestException { public: - explicit TestException(y_absl::string_view msg) : msg_(msg) {} + explicit TestException(y_absl::string_view msg) : msg_(msg) {} virtual ~TestException() {} virtual const char* what() const noexcept { return msg_.c_str(); } private: - TString msg_; + TString msg_; }; // TestBadAllocException exists because allocation functions must throw an @@ -90,7 +90,7 @@ class TestException { // bad_alloc exception in TestExceptionSafety. class TestBadAllocException : public std::bad_alloc, public TestException { public: - explicit TestBadAllocException(y_absl::string_view msg) : TestException(msg) {} + explicit TestBadAllocException(y_absl::string_view msg) : TestException(msg) {} using TestException::what; }; @@ -102,14 +102,14 @@ inline void SetCountdown(int i = 0) { countdown = i; } // Sets the countdown to the terminal value -1 inline void UnsetCountdown() { SetCountdown(-1); } -void MaybeThrow(y_absl::string_view msg, bool throw_bad_alloc = false); +void MaybeThrow(y_absl::string_view msg, bool throw_bad_alloc = false); testing::AssertionResult FailureMessage(const TestException& e, int countdown) noexcept; struct TrackedAddress { bool is_alive; - TString description; + TString description; }; // Inspects the constructions and destructions of anything inheriting from @@ -136,7 +136,7 @@ class ConstructorTracker { } } - static void ObjectConstructed(void* address, TString description) { + static void ObjectConstructed(void* address, TString description) { if (!CurrentlyTracking()) return; TrackedAddress& tracked_address = @@ -172,11 +172,11 @@ class ConstructorTracker { return current_tracker_instance_ != nullptr; } - static TString ErrorMessage(void* address, - const TString& address_description, + static TString ErrorMessage(void* address, + const TString& address_description, int countdown, - const TString& error_description) { - return y_absl::Substitute( + const TString& error_description) { + return y_absl::Substitute( "With coundtown at $0:\n" " $1\n" " Object originally constructed by $2\n" @@ -196,7 +196,7 @@ class TrackedObject { TrackedObject(TrackedObject&&) = delete; protected: - explicit TrackedObject(TString description) { + explicit TrackedObject(TString description) { ConstructorTracker::ObjectConstructed(this, std::move(description)); } @@ -294,7 +294,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject { ThrowingValue(int i, exceptions_internal::NoThrowTag) noexcept : TrackedObject(GetInstanceString(i)), dummy_(i) {} - // y_absl expects nothrow destructors + // y_absl expects nothrow destructors ~ThrowingValue() noexcept = default; ThrowingValue& operator=(const ThrowingValue& other) noexcept( @@ -592,8 +592,8 @@ class ThrowingValue : private exceptions_internal::TrackedObject { const int& Get() const noexcept { return dummy_; } private: - static TString GetInstanceString(int dummy) { - return y_absl::StrCat("ThrowingValue<", + static TString GetInstanceString(int dummy) { + return y_absl::StrCat("ThrowingValue<", exceptions_internal::GetSpecString(Spec), ">(", dummy, ")"); } @@ -753,8 +753,8 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject { friend class ThrowingAllocator; private: - static TString GetInstanceString(int dummy) { - return y_absl::StrCat("ThrowingAllocator<", + static TString GetInstanceString(int dummy) { + return y_absl::StrCat("ThrowingAllocator<", exceptions_internal::GetSpecString(Spec), ">(", dummy, ")"); } @@ -768,10 +768,10 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject { if (*dummy_ < 0) std::abort(); } - void ReadStateAndMaybeThrow(y_absl::string_view msg) const { + void ReadStateAndMaybeThrow(y_absl::string_view msg) const { if (!IsSpecified(AllocSpec::kNoThrowAllocate)) { exceptions_internal::MaybeThrow( - y_absl::Substitute("Allocator id $0 threw from $1", *dummy_, msg)); + y_absl::Substitute("Allocator id $0 threw from $1", *dummy_, msg)); } } @@ -834,7 +834,7 @@ template <typename T> class DefaultFactory { public: explicit DefaultFactory(const T& t) : t_(t) {} - std::unique_ptr<T> operator()() const { return y_absl::make_unique<T>(t_); } + std::unique_ptr<T> operator()() const { return y_absl::make_unique<T>(t_); } private: T t_; @@ -842,7 +842,7 @@ class DefaultFactory { template <size_t LazyContractsCount, typename LazyFactory, typename LazyOperation> -using EnableIfTestable = typename y_absl::enable_if_t< +using EnableIfTestable = typename y_absl::enable_if_t< LazyContractsCount != 0 && !std::is_same<LazyFactory, UninitializedT>::value && !std::is_same<LazyOperation, UninitializedT>::value>; @@ -994,7 +994,7 @@ class ExceptionSafetyTestBuilder { * method tester.WithInitialValue(...). */ template <typename NewFactory> - ExceptionSafetyTestBuilder<y_absl::decay_t<NewFactory>, Operation, Contracts...> + ExceptionSafetyTestBuilder<y_absl::decay_t<NewFactory>, Operation, Contracts...> WithFactory(const NewFactory& new_factory) const { return {new_factory, operation_, contracts_}; } @@ -1005,7 +1005,7 @@ class ExceptionSafetyTestBuilder { * newly created tester. */ template <typename NewOperation> - ExceptionSafetyTestBuilder<Factory, y_absl::decay_t<NewOperation>, Contracts...> + ExceptionSafetyTestBuilder<Factory, y_absl::decay_t<NewOperation>, Contracts...> WithOperation(const NewOperation& new_operation) const { return {factory_, new_operation, contracts_}; } @@ -1025,11 +1025,11 @@ class ExceptionSafetyTestBuilder { */ template <typename... MoreContracts> ExceptionSafetyTestBuilder<Factory, Operation, Contracts..., - y_absl::decay_t<MoreContracts>...> + y_absl::decay_t<MoreContracts>...> WithContracts(const MoreContracts&... more_contracts) const { return { factory_, operation_, - std::tuple_cat(contracts_, std::tuple<y_absl::decay_t<MoreContracts>...>( + std::tuple_cat(contracts_, std::tuple<y_absl::decay_t<MoreContracts>...>( more_contracts...))}; } @@ -1053,7 +1053,7 @@ class ExceptionSafetyTestBuilder { typename NewOperation, typename = EnableIfTestable<sizeof...(Contracts), Factory, NewOperation>> testing::AssertionResult Test(const NewOperation& new_operation) const { - return TestImpl(new_operation, y_absl::index_sequence_for<Contracts...>()); + return TestImpl(new_operation, y_absl::index_sequence_for<Contracts...>()); } /* @@ -1089,7 +1089,7 @@ class ExceptionSafetyTestBuilder { template <typename SelectedOperation, size_t... Indices> testing::AssertionResult TestImpl(SelectedOperation selected_operation, - y_absl::index_sequence<Indices...>) const { + y_absl::index_sequence<Indices...>) const { return ExceptionSafetyTest<FactoryElementType<Factory>>( factory_, selected_operation, std::get<Indices>(contracts_)...) .Test(); diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_testing.h index 8d29682c06..f2dd04b9d6 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_testing.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_testing.h @@ -18,7 +18,7 @@ #define ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_ #include "gtest/gtest.h" -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" // ABSL_BASE_INTERNAL_EXPECT_FAIL tests either for a specified thrown exception // if exceptions are enabled, or for death with a specified text in the error diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/hide_ptr.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/hide_ptr.h index d956570954..ccdad25cb7 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/hide_ptr.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/hide_ptr.h @@ -19,7 +19,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -30,7 +30,7 @@ constexpr uintptr_t HideMask() { } // Hide a pointer from the leak checker. For internal use only. -// Differs from y_absl::IgnoreLeak(ptr) in that y_absl::IgnoreLeak(ptr) causes ptr +// Differs from y_absl::IgnoreLeak(ptr) in that y_absl::IgnoreLeak(ptr) causes ptr // and all objects reachable from ptr to be ignored by the leak checker. template <class T> inline uintptr_t HidePtr(T* ptr) { @@ -46,6 +46,6 @@ inline T* UnhidePtr(uintptr_t hidden) { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_HIDE_PTR_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/identity.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/identity.h index ef4cac601d..2360afeed2 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/identity.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/identity.h @@ -18,7 +18,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace internal { @@ -32,6 +32,6 @@ using identity_t = typename identity<T>::type; } // namespace internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_IDENTITY_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable.h index d608fe41a3..38799c5722 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable.h @@ -17,7 +17,7 @@ #include <type_traits> -#include "y_absl/base/internal/identity.h" +#include "y_absl/base/internal/identity.h" // File: // This file define a macro that allows the creation of or emulation of C++17 @@ -68,7 +68,7 @@ // types, etc.. #if defined(__clang__) #define ABSL_INTERNAL_EXTERN_DECL(type, name) \ - extern const ::y_absl::internal::identity_t<type> name; + extern const ::y_absl::internal::identity_t<type> name; #else // Otherwise, just define the macro to do nothing. #define ABSL_INTERNAL_EXTERN_DECL(type, name) #endif // defined(__clang__) @@ -76,7 +76,7 @@ // See above comment at top of file for details. #define ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init) \ ABSL_INTERNAL_EXTERN_DECL(type, name) \ - inline constexpr ::y_absl::internal::identity_t<type> name = init + inline constexpr ::y_absl::internal::identity_t<type> name = init #else @@ -89,14 +89,14 @@ #define ABSL_INTERNAL_INLINE_CONSTEXPR(var_type, name, init) \ template <class /*AbslInternalDummy*/ = void> \ struct AbslInternalInlineVariableHolder##name { \ - static constexpr ::y_absl::internal::identity_t<var_type> kInstance = init; \ + static constexpr ::y_absl::internal::identity_t<var_type> kInstance = init; \ }; \ \ template <class AbslInternalDummy> \ - constexpr ::y_absl::internal::identity_t<var_type> \ + constexpr ::y_absl::internal::identity_t<var_type> \ AbslInternalInlineVariableHolder##name<AbslInternalDummy>::kInstance; \ \ - static constexpr const ::y_absl::internal::identity_t<var_type>& \ + static constexpr const ::y_absl::internal::identity_t<var_type>& \ name = /* NOLINT */ \ AbslInternalInlineVariableHolder##name<>::kInstance; \ static_assert(sizeof(void (*)(decltype(name))) != 0, \ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable_testing.h index bc4f469ff0..190e74e643 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable_testing.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable_testing.h @@ -15,9 +15,9 @@ #ifndef ABSL_BASE_INLINE_VARIABLE_TESTING_H_ #define ABSL_BASE_INLINE_VARIABLE_TESTING_H_ -#include "y_absl/base/internal/inline_variable.h" +#include "y_absl/base/internal/inline_variable.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace inline_variable_testing_internal { @@ -41,6 +41,6 @@ const int& get_int_b(); } // namespace inline_variable_testing_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INLINE_VARIABLE_TESTING_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/invoke.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/invoke.h index 8b505a9365..928666ff44 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/invoke.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/invoke.h @@ -39,12 +39,12 @@ #include <type_traits> #include <utility> -#include "y_absl/meta/type_traits.h" +#include "y_absl/meta/type_traits.h" // The following code is internal implementation detail. See the comment at the // top of this file for the API documentation. -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -73,7 +73,7 @@ struct MemFunAndRef : StrippedAccept<MemFunAndRef> { template <typename MemFunType, typename C, typename Obj, typename... Args> struct AcceptImpl<MemFunType C::*, Obj, Args...> : std::integral_constant<bool, std::is_base_of<C, Obj>::value && - y_absl::is_function<MemFunType>::value> { + y_absl::is_function<MemFunType>::value> { }; template <typename MemFun, typename Obj, typename... Args> @@ -94,7 +94,7 @@ struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> { template <typename MemFunType, typename C, typename Ptr, typename... Args> struct AcceptImpl<MemFunType C::*, Ptr, Args...> : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value && - y_absl::is_function<MemFunType>::value> { + y_absl::is_function<MemFunType>::value> { }; template <typename MemFun, typename Ptr, typename... Args> @@ -116,7 +116,7 @@ struct DataMemAndRef : StrippedAccept<DataMemAndRef> { template <typename R, typename C, typename Obj> struct AcceptImpl<R C::*, Obj> : std::integral_constant<bool, std::is_base_of<C, Obj>::value && - !y_absl::is_function<R>::value> {}; + !y_absl::is_function<R>::value> {}; template <typename DataMem, typename Ref> static decltype(std::declval<Ref>().*std::declval<DataMem>()) Invoke( @@ -134,7 +134,7 @@ struct DataMemAndPtr : StrippedAccept<DataMemAndPtr> { template <typename R, typename C, typename Ptr> struct AcceptImpl<R C::*, Ptr> : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value && - !y_absl::is_function<R>::value> {}; + !y_absl::is_function<R>::value> {}; template <typename DataMem, typename Ptr> static decltype((*std::declval<Ptr>()).*std::declval<DataMem>()) Invoke( @@ -182,6 +182,6 @@ invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) { } } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_INVOKE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.cc index 8d39bec9e1..0c477d1b28 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.cc @@ -17,16 +17,16 @@ // This allocator is slow and wasteful of memory; // it should not be used when performance is key. -#include "y_absl/base/internal/low_level_alloc.h" +#include "y_absl/base/internal/low_level_alloc.h" #include <type_traits> -#include "y_absl/base/call_once.h" -#include "y_absl/base/config.h" -#include "y_absl/base/internal/direct_mmap.h" -#include "y_absl/base/internal/scheduling_mode.h" -#include "y_absl/base/macros.h" -#include "y_absl/base/thread_annotations.h" +#include "y_absl/base/call_once.h" +#include "y_absl/base/config.h" +#include "y_absl/base/internal/direct_mmap.h" +#include "y_absl/base/internal/scheduling_mode.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/thread_annotations.h" // LowLevelAlloc requires that the platform support low-level // allocation of virtual memory. Platforms lacking this cannot use @@ -49,9 +49,9 @@ #include <cstddef> #include <new> // for placement-new -#include "y_absl/base/dynamic_annotations.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/spinlock.h" +#include "y_absl/base/dynamic_annotations.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/spinlock.h" // MAP_ANONYMOUS #if defined(__APPLE__) @@ -62,7 +62,7 @@ #endif // !MAP_ANONYMOUS #endif // __APPLE__ -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -235,7 +235,7 @@ alignas( // We must use LowLevelCallOnce here to construct the global arenas, rather than // using function-level statics, to avoid recursively invoking the scheduler. -y_absl::once_flag create_globals_once; +y_absl::once_flag create_globals_once; void CreateGlobalArenas() { new (&default_arena_storage) @@ -615,6 +615,6 @@ void *LowLevelAlloc::AllocWithArena(size_t request, Arena *arena) { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_LOW_LEVEL_ALLOC_MISSING diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.h index 0354b1585c..fa109d53ec 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.h @@ -28,8 +28,8 @@ #include <cstdint> -#include "y_absl/base/attributes.h" -#include "y_absl/base/config.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/config.h" // LowLevelAlloc requires that the platform support low-level // allocation of virtual memory. Platforms lacking this cannot use @@ -52,9 +52,9 @@ #include <cstddef> -#include "y_absl/base/port.h" +#include "y_absl/base/port.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -121,6 +121,6 @@ class LowLevelAlloc { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc/ya.make index 39d05b98ea..fabba74677 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc/ya.make @@ -12,10 +12,10 @@ OWNER( LICENSE(Apache-2.0) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity ) ADDINCL( @@ -24,7 +24,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/base/internal) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/base/internal) SRCS( low_level_alloc.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_scheduling.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_scheduling.h index 01d26e0002..61eb4ac643 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_scheduling.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_scheduling.h @@ -19,8 +19,8 @@ #define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_ #include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/scheduling_mode.h" -#include "y_absl/base/macros.h" +#include "y_absl/base/internal/scheduling_mode.h" +#include "y_absl/base/macros.h" // The following two declarations exist so SchedulingGuard may friend them with // the appropriate language linkage. These callbacks allow libc internals, such @@ -28,7 +28,7 @@ extern "C" bool __google_disable_rescheduling(void); extern "C" void __google_enable_rescheduling(bool disable_result); -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN class CondVar; class Mutex; @@ -129,6 +129,6 @@ inline SchedulingGuard::ScopedEnable::~ScopedEnable() { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/per_thread_tls.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/per_thread_tls.h index bdea411548..943f72a433 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/per_thread_tls.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/per_thread_tls.h @@ -32,7 +32,7 @@ // GCC supports it if the appropriate version of glibc is available, // which the programmer can indicate by defining ABSL_HAVE_TLS -#include "y_absl/base/port.h" // For ABSL_HAVE_TLS +#include "y_absl/base/port.h" // For ABSL_HAVE_TLS #if defined(ABSL_PER_THREAD_TLS) #error ABSL_PER_THREAD_TLS cannot be directly set diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.cc index 8413ca0adf..ea9a48c2c0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" #include <stddef.h> #include <cstdarg> @@ -20,10 +20,10 @@ #include <cstdlib> #include <cstring> -#include "y_absl/base/attributes.h" -#include "y_absl/base/config.h" -#include "y_absl/base/internal/atomic_hook.h" -#include "y_absl/base/log_severity.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/config.h" +#include "y_absl/base/internal/atomic_hook.h" +#include "y_absl/base/log_severity.h" // We know how to perform low-level writes to stderr in POSIX and Windows. For // these platforms, we define the token ABSL_LOW_LEVEL_WRITE_SUPPORTED. @@ -130,9 +130,9 @@ bool DoRawLog(char** buf, int* size, const char* format, ...) { return true; } -void RawLogVA(y_absl::LogSeverity severity, const char* file, int line, +void RawLogVA(y_absl::LogSeverity severity, const char* file, int line, const char* format, va_list ap) ABSL_PRINTF_ATTRIBUTE(4, 0); -void RawLogVA(y_absl::LogSeverity severity, const char* file, int line, +void RawLogVA(y_absl::LogSeverity severity, const char* file, int line, const char* format, va_list ap) { char buffer[kLogBufSize]; char* buf = buffer; @@ -144,8 +144,8 @@ void RawLogVA(y_absl::LogSeverity severity, const char* file, int line, #endif #ifdef ABSL_MIN_LOG_LEVEL - if (severity < static_cast<y_absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) && - severity < y_absl::LogSeverity::kFatal) { + if (severity < static_cast<y_absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) && + severity < y_absl::LogSeverity::kFatal) { enabled = false; } #endif @@ -177,7 +177,7 @@ void RawLogVA(y_absl::LogSeverity severity, const char* file, int line, // Abort the process after logging a FATAL message, even if the output itself // was suppressed. - if (severity == y_absl::LogSeverity::kFatal) { + if (severity == y_absl::LogSeverity::kFatal) { abort_hook(file, line, buffer, prefix_end, buffer + kLogBufSize); abort(); } @@ -209,7 +209,7 @@ void SafeWriteToStderr(const char *s, size_t len) { #endif } -void RawLog(y_absl::LogSeverity severity, const char* file, int line, +void RawLog(y_absl::LogSeverity severity, const char* file, int line, const char* format, ...) { va_list ap; va_start(ap, format); @@ -239,4 +239,4 @@ void RegisterInternalLogFunction(InternalLogFunction func) { } // namespace raw_logging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.h index 2839288651..4d5c77003f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.h @@ -21,13 +21,13 @@ #include <util/generic/string.h> -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" #include "y_absl/base/config.h" -#include "y_absl/base/internal/atomic_hook.h" -#include "y_absl/base/log_severity.h" -#include "y_absl/base/macros.h" +#include "y_absl/base/internal/atomic_hook.h" +#include "y_absl/base/log_severity.h" +#include "y_absl/base/macros.h" #include "y_absl/base/optimization.h" -#include "y_absl/base/port.h" +#include "y_absl/base/port.h" // This is similar to LOG(severity) << format..., but // * it is to be used ONLY by low-level modules that can't use normal LOG() @@ -44,9 +44,9 @@ #define ABSL_RAW_LOG(severity, ...) \ do { \ constexpr const char* absl_raw_logging_internal_basename = \ - ::y_absl::raw_logging_internal::Basename(__FILE__, \ + ::y_absl::raw_logging_internal::Basename(__FILE__, \ sizeof(__FILE__) - 1); \ - ::y_absl::raw_logging_internal::RawLog(ABSL_RAW_LOGGING_INTERNAL_##severity, \ + ::y_absl::raw_logging_internal::RawLog(ABSL_RAW_LOGGING_INTERNAL_##severity, \ absl_raw_logging_internal_basename, \ __LINE__, __VA_ARGS__); \ } while (0) @@ -85,20 +85,20 @@ #define ABSL_INTERNAL_CHECK(condition, message) \ do { \ if (ABSL_PREDICT_FALSE(!(condition))) { \ - TString death_message = "Check " #condition " failed: "; \ - death_message += TString(message); \ + TString death_message = "Check " #condition " failed: "; \ + death_message += TString(message); \ ABSL_INTERNAL_LOG(FATAL, death_message); \ } \ } while (0) -#define ABSL_RAW_LOGGING_INTERNAL_INFO ::y_absl::LogSeverity::kInfo -#define ABSL_RAW_LOGGING_INTERNAL_WARNING ::y_absl::LogSeverity::kWarning -#define ABSL_RAW_LOGGING_INTERNAL_ERROR ::y_absl::LogSeverity::kError -#define ABSL_RAW_LOGGING_INTERNAL_FATAL ::y_absl::LogSeverity::kFatal +#define ABSL_RAW_LOGGING_INTERNAL_INFO ::y_absl::LogSeverity::kInfo +#define ABSL_RAW_LOGGING_INTERNAL_WARNING ::y_absl::LogSeverity::kWarning +#define ABSL_RAW_LOGGING_INTERNAL_ERROR ::y_absl::LogSeverity::kError +#define ABSL_RAW_LOGGING_INTERNAL_FATAL ::y_absl::LogSeverity::kFatal #define ABSL_RAW_LOGGING_INTERNAL_LEVEL(severity) \ - ::y_absl::NormalizeLogSeverity(severity) + ::y_absl::NormalizeLogSeverity(severity) -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace raw_logging_internal { @@ -106,7 +106,7 @@ namespace raw_logging_internal { // Logs format... at "severity" level, reporting it // as called from file:line. // This does not allocate memory or acquire locks. -void RawLog(y_absl::LogSeverity severity, const char* file, int line, +void RawLog(y_absl::LogSeverity severity, const char* file, int line, const char* format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5); // Writes the provided buffer directly to stderr, in a safe, low-level manner. @@ -151,7 +151,7 @@ bool RawLoggingFullySupported(); // 'buffer' and 'buf_size' are pointers to the buffer and buffer size. If the // hook writes a prefix, it must increment *buffer and decrement *buf_size // accordingly. -using LogPrefixHook = bool (*)(y_absl::LogSeverity severity, const char* file, +using LogPrefixHook = bool (*)(y_absl::LogSeverity severity, const char* file, int line, char** buffer, int* buf_size); // Function type for a raw_logging customization hook called to abort a process @@ -170,9 +170,9 @@ using AbortHook = void (*)(const char* file, int line, const char* buf_start, // // TODO(gfalcon): When string_view no longer depends on base, change this // interface to take its message as a string_view instead. -using InternalLogFunction = void (*)(y_absl::LogSeverity severity, +using InternalLogFunction = void (*)(y_absl::LogSeverity severity, const char* file, int line, - const TString& message); + const TString& message); ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL extern base_internal::AtomicHook< InternalLogFunction> @@ -190,6 +190,6 @@ void RegisterInternalLogFunction(InternalLogFunction func); } // namespace raw_logging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_RAW_LOGGING_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging/ya.make index 08f768c777..e7cfe7d216 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging/ya.make @@ -12,7 +12,7 @@ OWNER( LICENSE(Apache-2.0) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity ) ADDINCL( @@ -21,7 +21,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/base/internal) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/base/internal) SRCS( raw_logging.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scheduling_mode.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scheduling_mode.h index 9c7af08a42..0165e7233b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scheduling_mode.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scheduling_mode.h @@ -20,7 +20,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -53,6 +53,6 @@ enum SchedulingMode { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.cc index 7968f02db7..e489272b45 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/base/internal/scoped_set_env.h" +#include "y_absl/base/internal/scoped_set_env.h" #ifdef _WIN32 #include <windows.h> @@ -20,9 +20,9 @@ #include <cstdlib> -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -78,4 +78,4 @@ ScopedSetEnv::~ScopedSetEnv() { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.h index 69ba53e1fe..5641562f1b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.h @@ -17,11 +17,11 @@ #ifndef ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_ #define ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_ -#include <util/generic/string.h> - +#include <util/generic/string.h> + #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -31,8 +31,8 @@ class ScopedSetEnv { ~ScopedSetEnv(); private: - TString var_name_; - TString old_value_; + TString var_name_; + TString old_value_; // True if the environment variable was initially not set. bool was_unset_; @@ -40,6 +40,6 @@ class ScopedSetEnv { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.cc index 23bbdac64d..2ee7cde432 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.cc @@ -12,18 +12,18 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/base/internal/spinlock.h" +#include "y_absl/base/internal/spinlock.h" #include <algorithm> #include <atomic> #include <limits> -#include "y_absl/base/attributes.h" -#include "y_absl/base/internal/atomic_hook.h" -#include "y_absl/base/internal/cycleclock.h" -#include "y_absl/base/internal/spinlock_wait.h" -#include "y_absl/base/internal/sysinfo.h" /* For NumCPUs() */ -#include "y_absl/base/call_once.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/internal/atomic_hook.h" +#include "y_absl/base/internal/cycleclock.h" +#include "y_absl/base/internal/spinlock_wait.h" +#include "y_absl/base/internal/sysinfo.h" /* For NumCPUs() */ +#include "y_absl/base/call_once.h" // Description of lock-word: // 31..00: [............................3][2][1][0] @@ -53,7 +53,7 @@ // Otherwise, bits [31..3] represent the time spent by the current lock // holder to acquire the lock. There may be outstanding waiter(s). -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -85,7 +85,7 @@ SpinLock::SpinLock(base_internal::SchedulingMode mode) uint32_t SpinLock::SpinLoop() { // We are already in the slow path of SpinLock, initialize the // adaptive_spin_count here. - ABSL_CONST_INIT static y_absl::once_flag init_adaptive_spin_count; + ABSL_CONST_INIT static y_absl::once_flag init_adaptive_spin_count; ABSL_CONST_INIT static int adaptive_spin_count = 0; base_internal::LowLevelCallOnce(&init_adaptive_spin_count, []() { adaptive_spin_count = base_internal::NumCPUs() > 1 ? 1000 : 1; @@ -226,4 +226,4 @@ uint64_t SpinLock::DecodeWaitCycles(uint32_t lock_value) { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.h index 0c6d685966..ef88cb52c0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.h @@ -34,18 +34,18 @@ #include <atomic> -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" #include "y_absl/base/const_init.h" -#include "y_absl/base/dynamic_annotations.h" -#include "y_absl/base/internal/low_level_scheduling.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/scheduling_mode.h" -#include "y_absl/base/internal/tsan_mutex_interface.h" -#include "y_absl/base/macros.h" -#include "y_absl/base/port.h" -#include "y_absl/base/thread_annotations.h" - -namespace y_absl { +#include "y_absl/base/dynamic_annotations.h" +#include "y_absl/base/internal/low_level_scheduling.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/scheduling_mode.h" +#include "y_absl/base/internal/tsan_mutex_interface.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/port.h" +#include "y_absl/base/thread_annotations.h" + +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -243,6 +243,6 @@ inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value, } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_SPINLOCK_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_akaros.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_akaros.inc index f893337e0c..69955dc765 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_akaros.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_akaros.inc @@ -16,13 +16,13 @@ #include <atomic> -#include "y_absl/base/internal/scheduling_mode.h" +#include "y_absl/base/internal/scheduling_mode.h" extern "C" { ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, - int /* loop */, y_absl::base_internal::SchedulingMode /* mode */) { + int /* loop */, y_absl::base_internal::SchedulingMode /* mode */) { // In Akaros, one must take care not to call anything that could cause a // malloc(), a blocking system call, or a uthread_yield() while holding a // spinlock. Our callers assume will not call into libraries or other diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_linux.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_linux.inc index 4a1e285590..5b4480d133 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_linux.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_linux.inc @@ -23,7 +23,7 @@ #include <cstdint> #include <ctime> -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" #include "y_absl/base/internal/errno_saver.h" // The SpinLock lockword is `std::atomic<uint32_t>`. Here we assert that @@ -58,11 +58,11 @@ extern "C" { ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( std::atomic<uint32_t> *w, uint32_t value, int loop, - y_absl::base_internal::SchedulingMode) { + y_absl::base_internal::SchedulingMode) { y_absl::base_internal::ErrnoSaver errno_saver; struct timespec tm; tm.tv_sec = 0; - tm.tv_nsec = y_absl::base_internal::SpinLockSuggestedDelayNS(loop); + tm.tv_nsec = y_absl::base_internal::SpinLockSuggestedDelayNS(loop); syscall(SYS_futex, w, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, value, &tm); } diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_posix.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_posix.inc index 5f057ab085..12a9b86599 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_posix.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_posix.inc @@ -20,14 +20,14 @@ #include <ctime> #include "y_absl/base/internal/errno_saver.h" -#include "y_absl/base/internal/scheduling_mode.h" -#include "y_absl/base/port.h" +#include "y_absl/base/internal/scheduling_mode.h" +#include "y_absl/base/port.h" extern "C" { ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, int loop, - y_absl::base_internal::SchedulingMode /* mode */) { + y_absl::base_internal::SchedulingMode /* mode */) { y_absl::base_internal::ErrnoSaver errno_saver; if (loop == 0) { } else if (loop == 1) { @@ -35,7 +35,7 @@ ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( } else { struct timespec tm; tm.tv_sec = 0; - tm.tv_nsec = y_absl::base_internal::SpinLockSuggestedDelayNS(loop); + tm.tv_nsec = y_absl::base_internal::SpinLockSuggestedDelayNS(loop); nanosleep(&tm, nullptr); } } diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.cc index 1b726d2c0e..138cb3c5f0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.cc @@ -19,19 +19,19 @@ #include <atomic> #include <cstdint> -#include "y_absl/base/internal/spinlock_wait.h" +#include "y_absl/base/internal/spinlock_wait.h" #if defined(_WIN32) -#include "y_absl/base/internal/spinlock_win32.inc" +#include "y_absl/base/internal/spinlock_win32.inc" #elif defined(__linux__) -#include "y_absl/base/internal/spinlock_linux.inc" +#include "y_absl/base/internal/spinlock_linux.inc" #elif defined(__akaros__) -#include "y_absl/base/internal/spinlock_akaros.inc" +#include "y_absl/base/internal/spinlock_akaros.inc" #else -#include "y_absl/base/internal/spinlock_posix.inc" +#include "y_absl/base/internal/spinlock_posix.inc" #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -78,4 +78,4 @@ int SpinLockSuggestedDelayNS(int loop) { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.h index e994951ebb..2e34d7026b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.h @@ -21,9 +21,9 @@ #include <stdint.h> #include <atomic> -#include "y_absl/base/internal/scheduling_mode.h" +#include "y_absl/base/internal/scheduling_mode.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -64,7 +64,7 @@ int SpinLockSuggestedDelayNS(int loop); } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl // In some build configurations we pass --detect-odr-violations to the // gold linker. This causes it to flag weak symbol overrides as ODR @@ -77,17 +77,17 @@ void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(std::atomic<uint32_t> *w, bool all); void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( std::atomic<uint32_t> *w, uint32_t value, int loop, - y_absl::base_internal::SchedulingMode scheduling_mode); + y_absl::base_internal::SchedulingMode scheduling_mode); } -inline void y_absl::base_internal::SpinLockWake(std::atomic<uint32_t> *w, +inline void y_absl::base_internal::SpinLockWake(std::atomic<uint32_t> *w, bool all) { ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(w, all); } -inline void y_absl::base_internal::SpinLockDelay( +inline void y_absl::base_internal::SpinLockDelay( std::atomic<uint32_t> *w, uint32_t value, int loop, - y_absl::base_internal::SchedulingMode scheduling_mode) { + y_absl::base_internal::SchedulingMode scheduling_mode) { ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay) (w, value, loop, scheduling_mode); } diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait/ya.make index b90bdb19de..902ffe394f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait/ya.make @@ -17,7 +17,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/base/internal) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/base/internal) SRCS( spinlock_wait.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_win32.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_win32.inc index 6ea69285cd..648f74134f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_win32.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_win32.inc @@ -16,7 +16,7 @@ #include <windows.h> #include <atomic> -#include "y_absl/base/internal/scheduling_mode.h" +#include "y_absl/base/internal/scheduling_mode.h" extern "C" { @@ -27,7 +27,7 @@ void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( } else if (loop == 1) { Sleep(0); } else { - Sleep(y_absl::base_internal::SpinLockSuggestedDelayNS(loop) / 1000000); + Sleep(y_absl::base_internal::SpinLockSuggestedDelayNS(loop) / 1000000); } } diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.cc index 204860e3fb..9eb0cf3f8c 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.cc @@ -12,9 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/base/internal/sysinfo.h" +#include "y_absl/base/internal/sysinfo.h" -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" #ifdef _WIN32 #include <windows.h> @@ -50,14 +50,14 @@ #include <utility> #include <vector> -#include "y_absl/base/call_once.h" +#include "y_absl/base/call_once.h" #include "y_absl/base/config.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/spinlock.h" -#include "y_absl/base/internal/unscaledcycleclock.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/spinlock.h" +#include "y_absl/base/internal/unscaledcycleclock.h" #include "y_absl/base/thread_annotations.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -432,7 +432,7 @@ static void FreeTID(void *v) { intptr_t tid = reinterpret_cast<intptr_t>(v); int word = tid / kBitsPerWord; uint32_t mask = ~(1u << (tid % kBitsPerWord)); - y_absl::base_internal::SpinLockHolder lock(&tid_lock); + y_absl::base_internal::SpinLockHolder lock(&tid_lock); assert(0 <= word && static_cast<size_t>(word) < tid_array->size()); (*tid_array)[word] &= mask; } @@ -445,14 +445,14 @@ static void InitGetTID() { } // Initialize tid_array. - y_absl::base_internal::SpinLockHolder lock(&tid_lock); + y_absl::base_internal::SpinLockHolder lock(&tid_lock); tid_array = new std::vector<uint32_t>(1); (*tid_array)[0] = 1; // ID 0 is never-allocated. } // Return a per-thread small integer ID from pthread's thread-specific data. pid_t GetTID() { - y_absl::call_once(tid_once, InitGetTID); + y_absl::call_once(tid_once, InitGetTID); intptr_t tid = reinterpret_cast<intptr_t>(pthread_getspecific(tid_key)); if (tid != 0) { @@ -463,7 +463,7 @@ pid_t GetTID() { size_t word; { // Search for the first unused ID. - y_absl::base_internal::SpinLockHolder lock(&tid_lock); + y_absl::base_internal::SpinLockHolder lock(&tid_lock); // First search for a word in the array that is not all ones. word = 0; while (word < tid_array->size() && ~(*tid_array)[word] == 0) { @@ -505,4 +505,4 @@ pid_t GetCachedTID() { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.h index e1d1819f62..0fd7207a38 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.h @@ -31,9 +31,9 @@ #include <cstdint> #include "y_absl/base/config.h" -#include "y_absl/base/port.h" +#include "y_absl/base/port.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -69,6 +69,6 @@ pid_t GetCachedTID(); } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_SYSINFO_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_annotations.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_annotations.h index e2b490e5b8..b4b01a8fb4 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_annotations.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_annotations.h @@ -18,7 +18,7 @@ // // WARNING: This is a backwards compatible header and it will be removed after // the migration to prefixed thread annotations is finished; please include -// "y_absl/base/thread_annotations.h". +// "y_absl/base/thread_annotations.h". // // This header file contains macro definitions for thread safety annotations // that allow developers to document the locking policies of multi-threaded diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.cc index c9d49f47bd..b5e88ae302 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/base/internal/thread_identity.h" +#include "y_absl/base/internal/thread_identity.h" #ifndef _WIN32 #include <pthread.h> @@ -24,18 +24,18 @@ #include <memory> #include "y_absl/base/attributes.h" -#include "y_absl/base/call_once.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/spinlock.h" +#include "y_absl/base/call_once.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/spinlock.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { #if ABSL_THREAD_IDENTITY_MODE != ABSL_THREAD_IDENTITY_MODE_USE_CPP11 namespace { // Used to co-ordinate one-time creation of our pthread_key -y_absl::once_flag init_thread_identity_key_once; +y_absl::once_flag init_thread_identity_key_once; pthread_key_t thread_identity_pthread_key; std::atomic<bool> pthread_key_initialized(false); @@ -75,7 +75,7 @@ void SetCurrentThreadIdentity( // barrier to CurrentThreadIdentity() always being async signal safe. #if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC // NOTE: Not async-safe. But can be open-coded. - y_absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey, + y_absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey, reclaimer); #if defined(__EMSCRIPTEN__) || defined(__MINGW32__) @@ -102,7 +102,7 @@ void SetCurrentThreadIdentity( #elif ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS // NOTE: Not async-safe. But can be open-coded. - y_absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey, + y_absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey, reclaimer); pthread_setspecific(thread_identity_pthread_key, reinterpret_cast<void*>(identity)); @@ -152,4 +152,4 @@ ThreadIdentity* CurrentThreadIdentityIfPresent() { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.h index e641f0036d..09a6c0bce1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.h @@ -31,10 +31,10 @@ #include <cstdint> #include "y_absl/base/config.h" -#include "y_absl/base/internal/per_thread_tls.h" +#include "y_absl/base/internal/per_thread_tls.h" #include "y_absl/base/optimization.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN struct SynchLocksHeld; @@ -45,9 +45,9 @@ namespace base_internal { class SpinLock; struct ThreadIdentity; -// Used by the implementation of y_absl::Mutex and y_absl::CondVar. +// Used by the implementation of y_absl::Mutex and y_absl::CondVar. struct PerThreadSynch { - // The internal representation of y_absl::Mutex and y_absl::CondVar rely + // The internal representation of y_absl::Mutex and y_absl::CondVar rely // on the alignment of PerThreadSynch. Both store the address of the // PerThreadSynch in the high-order bits of their internal state, // which means the low kLowZeroBits of the address of PerThreadSynch @@ -141,7 +141,7 @@ struct ThreadIdentity { // ThreadIdentity itself. PerThreadSynch per_thread_synch; - // Private: Reserved for y_absl::synchronization_internal::Waiter. + // Private: Reserved for y_absl::synchronization_internal::Waiter. struct WaiterState { alignas(void*) char data[128]; } waiter_state; @@ -260,6 +260,6 @@ inline ThreadIdentity* CurrentThreadIdentityIfPresent() { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.cc index 388465500d..dcce5aedc3 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.cc @@ -12,17 +12,17 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/base/internal/throw_delegate.h" +#include "y_absl/base/internal/throw_delegate.h" #include <cstdlib> #include <functional> #include <new> #include <stdexcept> -#include "y_absl/base/config.h" -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/config.h" +#include "y_absl/base/internal/raw_logging.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -39,7 +39,7 @@ template <typename T> #endif } // namespace -void ThrowStdLogicError(const TString& what_arg) { +void ThrowStdLogicError(const TString& what_arg) { #ifdef ABSL_HAVE_EXCEPTIONS Throw(std::logic_error(what_arg)); #else @@ -55,7 +55,7 @@ void ThrowStdLogicError(const char* what_arg) { std::abort(); #endif } -void ThrowStdInvalidArgument(const TString& what_arg) { +void ThrowStdInvalidArgument(const TString& what_arg) { #ifdef ABSL_HAVE_EXCEPTIONS Throw(std::invalid_argument(what_arg)); #else @@ -72,7 +72,7 @@ void ThrowStdInvalidArgument(const char* what_arg) { #endif } -void ThrowStdDomainError(const TString& what_arg) { +void ThrowStdDomainError(const TString& what_arg) { #ifdef ABSL_HAVE_EXCEPTIONS Throw(std::domain_error(what_arg)); #else @@ -89,7 +89,7 @@ void ThrowStdDomainError(const char* what_arg) { #endif } -void ThrowStdLengthError(const TString& what_arg) { +void ThrowStdLengthError(const TString& what_arg) { #ifdef ABSL_HAVE_EXCEPTIONS Throw(std::length_error(what_arg)); #else @@ -106,7 +106,7 @@ void ThrowStdLengthError(const char* what_arg) { #endif } -void ThrowStdOutOfRange(const TString& what_arg) { +void ThrowStdOutOfRange(const TString& what_arg) { #ifdef ABSL_HAVE_EXCEPTIONS Throw(std::out_of_range(what_arg)); #else @@ -123,7 +123,7 @@ void ThrowStdOutOfRange(const char* what_arg) { #endif } -void ThrowStdRuntimeError(const TString& what_arg) { +void ThrowStdRuntimeError(const TString& what_arg) { #ifdef ABSL_HAVE_EXCEPTIONS Throw(std::runtime_error(what_arg)); #else @@ -140,7 +140,7 @@ void ThrowStdRuntimeError(const char* what_arg) { #endif } -void ThrowStdRangeError(const TString& what_arg) { +void ThrowStdRangeError(const TString& what_arg) { #ifdef ABSL_HAVE_EXCEPTIONS Throw(std::range_error(what_arg)); #else @@ -157,7 +157,7 @@ void ThrowStdRangeError(const char* what_arg) { #endif } -void ThrowStdOverflowError(const TString& what_arg) { +void ThrowStdOverflowError(const TString& what_arg) { #ifdef ABSL_HAVE_EXCEPTIONS Throw(std::overflow_error(what_arg)); #else @@ -174,7 +174,7 @@ void ThrowStdOverflowError(const char* what_arg) { #endif } -void ThrowStdUnderflowError(const TString& what_arg) { +void ThrowStdUnderflowError(const TString& what_arg) { #ifdef ABSL_HAVE_EXCEPTIONS Throw(std::underflow_error(what_arg)); #else @@ -209,4 +209,4 @@ void ThrowStdBadAlloc() { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.h index d66384a3c8..fda03a5db3 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.h @@ -17,11 +17,11 @@ #ifndef ABSL_BASE_INTERNAL_THROW_DELEGATE_H_ #define ABSL_BASE_INTERNAL_THROW_DELEGATE_H_ -#include <util/generic/string.h> - +#include <util/generic/string.h> + #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -39,23 +39,23 @@ namespace base_internal { // both with and without exceptions and you need to conform to an interface // that uses exceptions. -[[noreturn]] void ThrowStdLogicError(const TString& what_arg); +[[noreturn]] void ThrowStdLogicError(const TString& what_arg); [[noreturn]] void ThrowStdLogicError(const char* what_arg); -[[noreturn]] void ThrowStdInvalidArgument(const TString& what_arg); +[[noreturn]] void ThrowStdInvalidArgument(const TString& what_arg); [[noreturn]] void ThrowStdInvalidArgument(const char* what_arg); -[[noreturn]] void ThrowStdDomainError(const TString& what_arg); +[[noreturn]] void ThrowStdDomainError(const TString& what_arg); [[noreturn]] void ThrowStdDomainError(const char* what_arg); -[[noreturn]] void ThrowStdLengthError(const TString& what_arg); +[[noreturn]] void ThrowStdLengthError(const TString& what_arg); [[noreturn]] void ThrowStdLengthError(const char* what_arg); -[[noreturn]] void ThrowStdOutOfRange(const TString& what_arg); +[[noreturn]] void ThrowStdOutOfRange(const TString& what_arg); [[noreturn]] void ThrowStdOutOfRange(const char* what_arg); -[[noreturn]] void ThrowStdRuntimeError(const TString& what_arg); +[[noreturn]] void ThrowStdRuntimeError(const TString& what_arg); [[noreturn]] void ThrowStdRuntimeError(const char* what_arg); -[[noreturn]] void ThrowStdRangeError(const TString& what_arg); +[[noreturn]] void ThrowStdRangeError(const TString& what_arg); [[noreturn]] void ThrowStdRangeError(const char* what_arg); -[[noreturn]] void ThrowStdOverflowError(const TString& what_arg); +[[noreturn]] void ThrowStdOverflowError(const TString& what_arg); [[noreturn]] void ThrowStdOverflowError(const char* what_arg); -[[noreturn]] void ThrowStdUnderflowError(const TString& what_arg); +[[noreturn]] void ThrowStdUnderflowError(const TString& what_arg); [[noreturn]] void ThrowStdUnderflowError(const char* what_arg); [[noreturn]] void ThrowStdBadFunctionCall(); @@ -70,6 +70,6 @@ namespace base_internal { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_INTERNAL_THROW_DELEGATE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate/ya.make index 107f21cc6c..1b956ad494 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate/ya.make @@ -12,8 +12,8 @@ OWNER( LICENSE(Apache-2.0) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity ) ADDINCL( @@ -22,7 +22,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/base/internal) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/base/internal) SRCS( throw_delegate.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unaligned_access.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unaligned_access.h index b882631a53..7dbb23b1de 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unaligned_access.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unaligned_access.h @@ -21,7 +21,7 @@ #include <cstdint> -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" #include "y_absl/base/config.h" // unaligned APIs @@ -31,7 +31,7 @@ // The unaligned API is C++ only. The declarations use C++ features // (namespaces, inline) which are absent or incompatible in C. #if defined(__cplusplus) -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -61,21 +61,21 @@ inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); } } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #define ABSL_INTERNAL_UNALIGNED_LOAD16(_p) \ - (y_absl::base_internal::UnalignedLoad16(_p)) + (y_absl::base_internal::UnalignedLoad16(_p)) #define ABSL_INTERNAL_UNALIGNED_LOAD32(_p) \ - (y_absl::base_internal::UnalignedLoad32(_p)) + (y_absl::base_internal::UnalignedLoad32(_p)) #define ABSL_INTERNAL_UNALIGNED_LOAD64(_p) \ - (y_absl::base_internal::UnalignedLoad64(_p)) + (y_absl::base_internal::UnalignedLoad64(_p)) #define ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val) \ - (y_absl::base_internal::UnalignedStore16(_p, _val)) + (y_absl::base_internal::UnalignedStore16(_p, _val)) #define ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val) \ - (y_absl::base_internal::UnalignedStore32(_p, _val)) + (y_absl::base_internal::UnalignedStore32(_p, _val)) #define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \ - (y_absl::base_internal::UnalignedStore64(_p, _val)) + (y_absl::base_internal::UnalignedStore64(_p, _val)) #endif // defined(__cplusplus), end of unaligned API diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.cc index 4dabba4549..072a9852fa 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/base/internal/unscaledcycleclock.h" +#include "y_absl/base/internal/unscaledcycleclock.h" #if ABSL_USE_UNSCALED_CYCLECLOCK @@ -29,9 +29,9 @@ #endif #endif -#include "y_absl/base/internal/sysinfo.h" +#include "y_absl/base/internal/sysinfo.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -149,6 +149,6 @@ double UnscaledCycleClock::Frequency() { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_USE_UNSCALED_CYCLECLOCK diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.h index 686349cee7..618c5c7e73 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.h @@ -42,7 +42,7 @@ #include <TargetConditionals.h> #endif -#include "y_absl/base/port.h" +#include "y_absl/base/port.h" // The following platforms have an implementation of a hardware counter. #if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__) || \ @@ -85,7 +85,7 @@ #define ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { class UnscaledCycleClockWrapperForGetCurrentTime; @@ -117,7 +117,7 @@ class UnscaledCycleClock { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_USE_UNSCALED_CYCLECLOCK diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.cc index d4d5e02531..2ae8c75aec 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.cc @@ -12,16 +12,16 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/base/log_severity.h" +#include "y_absl/base/log_severity.h" #include <ostream> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN -std::ostream& operator<<(std::ostream& os, y_absl::LogSeverity s) { - if (s == y_absl::NormalizeLogSeverity(s)) return os << y_absl::LogSeverityName(s); - return os << "y_absl::LogSeverity(" << static_cast<int>(s) << ")"; +std::ostream& operator<<(std::ostream& os, y_absl::LogSeverity s) { + if (s == y_absl::NormalizeLogSeverity(s)) return os << y_absl::LogSeverityName(s); + return os << "y_absl::LogSeverity(" << static_cast<int>(s) << ")"; } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.h index c9e6ccb389..26f20ad8e1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.h @@ -18,10 +18,10 @@ #include <array> #include <ostream> -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // y_absl::LogSeverity @@ -64,7 +64,7 @@ ABSL_NAMESPACE_BEGIN // --my_log_level=info // --my_log_level=0 // -// Unparsing a flag produces the same result as `y_absl::LogSeverityName()` for +// Unparsing a flag produces the same result as `y_absl::LogSeverityName()` for // the standard levels and a base-ten integer otherwise. enum class LogSeverity : int { kInfo = 0, @@ -75,47 +75,47 @@ enum class LogSeverity : int { // LogSeverities() // -// Returns an iterable of all standard `y_absl::LogSeverity` values, ordered from +// Returns an iterable of all standard `y_absl::LogSeverity` values, ordered from // least to most severe. -constexpr std::array<y_absl::LogSeverity, 4> LogSeverities() { - return {{y_absl::LogSeverity::kInfo, y_absl::LogSeverity::kWarning, - y_absl::LogSeverity::kError, y_absl::LogSeverity::kFatal}}; +constexpr std::array<y_absl::LogSeverity, 4> LogSeverities() { + return {{y_absl::LogSeverity::kInfo, y_absl::LogSeverity::kWarning, + y_absl::LogSeverity::kError, y_absl::LogSeverity::kFatal}}; } // LogSeverityName() // // Returns the all-caps string representation (e.g. "INFO") of the specified // severity level if it is one of the standard levels and "UNKNOWN" otherwise. -constexpr const char* LogSeverityName(y_absl::LogSeverity s) { - return s == y_absl::LogSeverity::kInfo +constexpr const char* LogSeverityName(y_absl::LogSeverity s) { + return s == y_absl::LogSeverity::kInfo ? "INFO" - : s == y_absl::LogSeverity::kWarning + : s == y_absl::LogSeverity::kWarning ? "WARNING" - : s == y_absl::LogSeverity::kError + : s == y_absl::LogSeverity::kError ? "ERROR" - : s == y_absl::LogSeverity::kFatal ? "FATAL" : "UNKNOWN"; + : s == y_absl::LogSeverity::kFatal ? "FATAL" : "UNKNOWN"; } // NormalizeLogSeverity() // // Values less than `kInfo` normalize to `kInfo`; values greater than `kFatal` // normalize to `kError` (**NOT** `kFatal`). -constexpr y_absl::LogSeverity NormalizeLogSeverity(y_absl::LogSeverity s) { - return s < y_absl::LogSeverity::kInfo - ? y_absl::LogSeverity::kInfo - : s > y_absl::LogSeverity::kFatal ? y_absl::LogSeverity::kError : s; +constexpr y_absl::LogSeverity NormalizeLogSeverity(y_absl::LogSeverity s) { + return s < y_absl::LogSeverity::kInfo + ? y_absl::LogSeverity::kInfo + : s > y_absl::LogSeverity::kFatal ? y_absl::LogSeverity::kError : s; } -constexpr y_absl::LogSeverity NormalizeLogSeverity(int s) { - return y_absl::NormalizeLogSeverity(static_cast<y_absl::LogSeverity>(s)); +constexpr y_absl::LogSeverity NormalizeLogSeverity(int s) { + return y_absl::NormalizeLogSeverity(static_cast<y_absl::LogSeverity>(s)); } // operator<< // -// The exact representation of a streamed `y_absl::LogSeverity` is deliberately +// The exact representation of a streamed `y_absl::LogSeverity` is deliberately // unspecified; do not rely on it. -std::ostream& operator<<(std::ostream& os, y_absl::LogSeverity s); +std::ostream& operator<<(std::ostream& os, y_absl::LogSeverity s); ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_LOG_SEVERITY_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity/ya.make index b0c1b5a23f..3e4b5634c2 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity/ya.make @@ -17,7 +17,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/base) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/base) SRCS( log_severity.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h index 7aba6ddfeb..b09a81877d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h @@ -19,7 +19,7 @@ // // This header file defines the set of language macros used within Abseil code. // For the set of macros used to determine supported compilers and platforms, -// see y_absl/base/config.h instead. +// see y_absl/base/config.h instead. // // This code is compiled directly on many platforms, including client // platforms like Windows, Mac, and embedded systems. Before making @@ -33,8 +33,8 @@ #include "y_absl/base/attributes.h" #include "y_absl/base/config.h" -#include "y_absl/base/optimization.h" -#include "y_absl/base/port.h" +#include "y_absl/base/optimization.h" +#include "y_absl/base/port.h" // ABSL_ARRAYSIZE() // @@ -42,9 +42,9 @@ // can be used in defining new arrays. If you use this macro on a pointer by // mistake, you will get a compile-time error. #define ABSL_ARRAYSIZE(array) \ - (sizeof(::y_absl::macros_internal::ArraySizeHelper(array))) + (sizeof(::y_absl::macros_internal::ArraySizeHelper(array))) -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace macros_internal { // Note: this internal template function declaration is used by ABSL_ARRAYSIZE. @@ -53,7 +53,7 @@ template <typename T, size_t N> auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N]; } // namespace macros_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl // ABSL_BAD_CALL_IF() // diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/optimization.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/optimization.h index d9ae379293..501530ae30 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/optimization.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/optimization.h @@ -24,7 +24,7 @@ #include <assert.h> -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" // ABSL_BLOCK_TAIL_CALL_OPTIMIZATION // diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h index d09c3a5c11..906310cde0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h @@ -79,7 +79,7 @@ // // ABSL_OPTION_USE_STD_ANY // -// This option controls whether y_absl::any is implemented as an alias to +// This option controls whether y_absl::any is implemented as an alias to // std::any, or as an independent implementation. // // A value of 0 means to use Abseil's implementation. This requires only C++11 @@ -93,19 +93,19 @@ // useful when you are building your entire program, including all of its // dependencies, from source. It should not be used otherwise -- for example, // if you are distributing Abseil in a binary package manager -- since in -// mode 2, y_absl::any will name a different type, with a different mangled name +// mode 2, y_absl::any will name a different type, with a different mangled name // and binary layout, depending on the compiler flags passed by the end user. // For more info, see https://abseil.io/about/design/dropin-types. // // User code should not inspect this macro. To check in the preprocessor if -// y_absl::any is a typedef of std::any, use the feature macro ABSL_USES_STD_ANY. +// y_absl::any is a typedef of std::any, use the feature macro ABSL_USES_STD_ANY. #define ABSL_OPTION_USE_STD_ANY 2 // ABSL_OPTION_USE_STD_OPTIONAL // -// This option controls whether y_absl::optional is implemented as an alias to +// This option controls whether y_absl::optional is implemented as an alias to // std::optional, or as an independent implementation. // // A value of 0 means to use Abseil's implementation. This requires only C++11 @@ -118,13 +118,13 @@ // and use an alias only if a working std::optional is available. This option // is useful when you are building your program from source. It should not be // used otherwise -- for example, if you are distributing Abseil in a binary -// package manager -- since in mode 2, y_absl::optional will name a different +// package manager -- since in mode 2, y_absl::optional will name a different // type, with a different mangled name and binary layout, depending on the // compiler flags passed by the end user. For more info, see // https://abseil.io/about/design/dropin-types. // User code should not inspect this macro. To check in the preprocessor if -// y_absl::optional is a typedef of std::optional, use the feature macro +// y_absl::optional is a typedef of std::optional, use the feature macro // ABSL_USES_STD_OPTIONAL. #define ABSL_OPTION_USE_STD_OPTIONAL 2 @@ -132,7 +132,7 @@ // ABSL_OPTION_USE_STD_STRING_VIEW // -// This option controls whether y_absl::string_view is implemented as an alias to +// This option controls whether y_absl::string_view is implemented as an alias to // std::string_view, or as an independent implementation. // // A value of 0 means to use Abseil's implementation. This requires only C++11 @@ -145,20 +145,20 @@ // and use an alias only if a working std::string_view is available. This // option is useful when you are building your program from source. It should // not be used otherwise -- for example, if you are distributing Abseil in a -// binary package manager -- since in mode 2, y_absl::string_view will name a +// binary package manager -- since in mode 2, y_absl::string_view will name a // different type, with a different mangled name and binary layout, depending on // the compiler flags passed by the end user. For more info, see // https://abseil.io/about/design/dropin-types. // // User code should not inspect this macro. To check in the preprocessor if -// y_absl::string_view is a typedef of std::string_view, use the feature macro +// y_absl::string_view is a typedef of std::string_view, use the feature macro // ABSL_USES_STD_STRING_VIEW. #define ABSL_OPTION_USE_STD_STRING_VIEW 2 // ABSL_OPTION_USE_STD_VARIANT // -// This option controls whether y_absl::variant is implemented as an alias to +// This option controls whether y_absl::variant is implemented as an alias to // std::variant, or as an independent implementation. // // A value of 0 means to use Abseil's implementation. This requires only C++11 @@ -171,13 +171,13 @@ // and use an alias only if a working std::variant is available. This option // is useful when you are building your program from source. It should not be // used otherwise -- for example, if you are distributing Abseil in a binary -// package manager -- since in mode 2, y_absl::variant will name a different +// package manager -- since in mode 2, y_absl::variant will name a different // type, with a different mangled name and binary layout, depending on the // compiler flags passed by the end user. For more info, see // https://abseil.io/about/design/dropin-types. // // User code should not inspect this macro. To check in the preprocessor if -// y_absl::variant is a typedef of std::variant, use the feature macro +// y_absl::variant is a typedef of std::variant, use the feature macro // ABSL_USES_STD_VARIANT. #define ABSL_OPTION_USE_STD_VARIANT 2 diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/port.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/port.h index 607fb87d57..69ec795d46 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/port.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/port.h @@ -18,8 +18,8 @@ #ifndef ABSL_BASE_PORT_H_ #define ABSL_BASE_PORT_H_ -#include "y_absl/base/attributes.h" -#include "y_absl/base/config.h" -#include "y_absl/base/optimization.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/config.h" +#include "y_absl/base/optimization.h" #endif // ABSL_BASE_PORT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h index 2713086a77..aba5d58dc3 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h @@ -37,7 +37,7 @@ #include "y_absl/base/attributes.h" #include "y_absl/base/config.h" // TODO(mbonadei): Remove after the backward compatibility period. -#include "y_absl/base/internal/thread_annotations.h" // IWYU pragma: export +#include "y_absl/base/internal/thread_annotations.h" // IWYU pragma: export // ABSL_GUARDED_BY() // @@ -309,9 +309,9 @@ // Disables warnings for a single read operation. This can be used to avoid // warnings when it is known that the read is not actually involved in a race, // but the compiler cannot confirm that. -#define ABSL_TS_UNCHECKED_READ(x) y_absl::base_internal::ts_unchecked_read(x) +#define ABSL_TS_UNCHECKED_READ(x) y_absl::base_internal::ts_unchecked_read(x) -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace base_internal { @@ -330,6 +330,6 @@ inline T& ts_unchecked_read(T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS { } // namespace base_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_BASE_THREAD_ANNOTATIONS_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/ya.make index 6f97c8cb44..9e0d53060e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/ya.make @@ -12,9 +12,9 @@ LICENSE(Apache-2.0) LICENSE_TEXTS(.yandex_meta/licenses.list.txt) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity ) ADDINCL( diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/city/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/city/ya.make index 389e1168b0..7fc856d796 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/city/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/city/ya.make @@ -24,7 +24,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal) SRCS( city.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h index e70caa303f..3f46c541b8 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h @@ -19,8 +19,8 @@ // This header file defines B-tree maps: sorted associative containers mapping // keys to values. // -// * `y_absl::btree_map<>` -// * `y_absl::btree_multimap<>` +// * `y_absl::btree_map<>` +// * `y_absl::btree_multimap<>` // // These B-tree types are similar to the corresponding types in the STL // (`std::map` and `std::multimap`) and generally conform to the STL interfaces @@ -47,26 +47,26 @@ #ifndef ABSL_CONTAINER_BTREE_MAP_H_ #define ABSL_CONTAINER_BTREE_MAP_H_ -#include "y_absl/container/internal/btree.h" // IWYU pragma: export -#include "y_absl/container/internal/btree_container.h" // IWYU pragma: export +#include "y_absl/container/internal/btree.h" // IWYU pragma: export +#include "y_absl/container/internal/btree_container.h" // IWYU pragma: export -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN -// y_absl::btree_map<> +// y_absl::btree_map<> // -// An `y_absl::btree_map<K, V>` is an ordered associative container of +// An `y_absl::btree_map<K, V>` is an ordered associative container of // unique keys and associated values designed to be a more efficient replacement // for `std::map` (in most cases). // // Keys are sorted using an (optional) comparison function, which defaults to // `std::less<K>`. // -// An `y_absl::btree_map<K, V>` uses a default allocator of +// An `y_absl::btree_map<K, V>` uses a default allocator of // `std::allocator<std::pair<const K, V>>` to allocate (and deallocate) // nodes, and construct and destruct values within those nodes. You may // instead specify a custom allocator `A` (which in turn requires specifying a -// custom comparator `C`) as in `y_absl::btree_map<K, V, C, A>`. +// custom comparator `C`) as in `y_absl::btree_map<K, V, C, A>`. // template <typename Key, typename Value, typename Compare = std::less<Key>, typename Alloc = std::allocator<std::pair<const Key, Value>>> @@ -85,37 +85,37 @@ class btree_map // // * Default constructor // - // y_absl::btree_map<int, TString> map1; + // y_absl::btree_map<int, TString> map1; // // * Initializer List constructor // - // y_absl::btree_map<int, TString> map2 = + // y_absl::btree_map<int, TString> map2 = // {{1, "huey"}, {2, "dewey"}, {3, "louie"},}; // // * Copy constructor // - // y_absl::btree_map<int, TString> map3(map2); + // y_absl::btree_map<int, TString> map3(map2); // // * Copy assignment operator // - // y_absl::btree_map<int, TString> map4; + // y_absl::btree_map<int, TString> map4; // map4 = map3; // // * Move constructor // // // Move is guaranteed efficient - // y_absl::btree_map<int, TString> map5(std::move(map4)); + // y_absl::btree_map<int, TString> map5(std::move(map4)); // // * Move assignment operator // // // May be efficient if allocators are compatible - // y_absl::btree_map<int, TString> map6; + // y_absl::btree_map<int, TString> map6; // map6 = std::move(map5); // // * Range constructor // - // std::vector<std::pair<int, TString>> v = {{1, "a"}, {2, "b"}}; - // y_absl::btree_map<int, TString> map7(v.begin(), v.end()); + // std::vector<std::pair<int, TString>> v = {{1, "a"}, {2, "b"}}; + // y_absl::btree_map<int, TString> map7(v.begin(), v.end()); btree_map() {} using Base::Base; @@ -456,9 +456,9 @@ class btree_map using Base::value_comp; }; -// y_absl::swap(y_absl::btree_map<>, y_absl::btree_map<>) +// y_absl::swap(y_absl::btree_map<>, y_absl::btree_map<>) // -// Swaps the contents of two `y_absl::btree_map` containers. +// Swaps the contents of two `y_absl::btree_map` containers. template <typename K, typename V, typename C, typename A> void swap(btree_map<K, V, C, A> &x, btree_map<K, V, C, A> &y) { return x.swap(y); @@ -478,21 +478,21 @@ void erase_if(btree_map<K, V, C, A> &map, Pred pred) { } } -// y_absl::btree_multimap +// y_absl::btree_multimap // -// An `y_absl::btree_multimap<K, V>` is an ordered associative container of +// An `y_absl::btree_multimap<K, V>` is an ordered associative container of // keys and associated values designed to be a more efficient replacement for -// `std::multimap` (in most cases). Unlike `y_absl::btree_map`, a B-tree multimap +// `std::multimap` (in most cases). Unlike `y_absl::btree_map`, a B-tree multimap // allows multiple elements with equivalent keys. // // Keys are sorted using an (optional) comparison function, which defaults to // `std::less<K>`. // -// An `y_absl::btree_multimap<K, V>` uses a default allocator of +// An `y_absl::btree_multimap<K, V>` uses a default allocator of // `std::allocator<std::pair<const K, V>>` to allocate (and deallocate) // nodes, and construct and destruct values within those nodes. You may // instead specify a custom allocator `A` (which in turn requires specifying a -// custom comparator `C`) as in `y_absl::btree_multimap<K, V, C, A>`. +// custom comparator `C`) as in `y_absl::btree_multimap<K, V, C, A>`. // template <typename Key, typename Value, typename Compare = std::less<Key>, typename Alloc = std::allocator<std::pair<const Key, Value>>> @@ -511,37 +511,37 @@ class btree_multimap // // * Default constructor // - // y_absl::btree_multimap<int, TString> map1; + // y_absl::btree_multimap<int, TString> map1; // // * Initializer List constructor // - // y_absl::btree_multimap<int, TString> map2 = + // y_absl::btree_multimap<int, TString> map2 = // {{1, "huey"}, {2, "dewey"}, {3, "louie"},}; // // * Copy constructor // - // y_absl::btree_multimap<int, TString> map3(map2); + // y_absl::btree_multimap<int, TString> map3(map2); // // * Copy assignment operator // - // y_absl::btree_multimap<int, TString> map4; + // y_absl::btree_multimap<int, TString> map4; // map4 = map3; // // * Move constructor // // // Move is guaranteed efficient - // y_absl::btree_multimap<int, TString> map5(std::move(map4)); + // y_absl::btree_multimap<int, TString> map5(std::move(map4)); // // * Move assignment operator // // // May be efficient if allocators are compatible - // y_absl::btree_multimap<int, TString> map6; + // y_absl::btree_multimap<int, TString> map6; // map6 = std::move(map5); // // * Range constructor // - // std::vector<std::pair<int, TString>> v = {{1, "a"}, {2, "b"}}; - // y_absl::btree_multimap<int, TString> map7(v.begin(), v.end()); + // std::vector<std::pair<int, TString>> v = {{1, "a"}, {2, "b"}}; + // y_absl::btree_multimap<int, TString> map7(v.begin(), v.end()); btree_multimap() {} using Base::Base; @@ -787,9 +787,9 @@ class btree_multimap using Base::value_comp; }; -// y_absl::swap(y_absl::btree_multimap<>, y_absl::btree_multimap<>) +// y_absl::swap(y_absl::btree_multimap<>, y_absl::btree_multimap<>) // -// Swaps the contents of two `y_absl::btree_multimap` containers. +// Swaps the contents of two `y_absl::btree_multimap` containers. template <typename K, typename V, typename C, typename A> void swap(btree_multimap<K, V, C, A> &x, btree_multimap<K, V, C, A> &y) { return x.swap(y); @@ -810,6 +810,6 @@ void erase_if(btree_multimap<K, V, C, A> &map, Pred pred) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_BTREE_MAP_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h index 807547d180..905fb8e964 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h @@ -19,8 +19,8 @@ // This header file defines B-tree sets: sorted associative containers of // values. // -// * `y_absl::btree_set<>` -// * `y_absl::btree_multiset<>` +// * `y_absl::btree_set<>` +// * `y_absl::btree_multiset<>` // // These B-tree types are similar to the corresponding types in the STL // (`std::set` and `std::multiset`) and generally conform to the STL interfaces @@ -47,26 +47,26 @@ #ifndef ABSL_CONTAINER_BTREE_SET_H_ #define ABSL_CONTAINER_BTREE_SET_H_ -#include "y_absl/container/internal/btree.h" // IWYU pragma: export -#include "y_absl/container/internal/btree_container.h" // IWYU pragma: export +#include "y_absl/container/internal/btree.h" // IWYU pragma: export +#include "y_absl/container/internal/btree_container.h" // IWYU pragma: export -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN -// y_absl::btree_set<> +// y_absl::btree_set<> // -// An `y_absl::btree_set<K>` is an ordered associative container of unique key +// An `y_absl::btree_set<K>` is an ordered associative container of unique key // values designed to be a more efficient replacement for `std::set` (in most // cases). // // Keys are sorted using an (optional) comparison function, which defaults to // `std::less<K>`. // -// An `y_absl::btree_set<K>` uses a default allocator of `std::allocator<K>` to +// An `y_absl::btree_set<K>` uses a default allocator of `std::allocator<K>` to // allocate (and deallocate) nodes, and construct and destruct values within // those nodes. You may instead specify a custom allocator `A` (which in turn // requires specifying a custom comparator `C`) as in -// `y_absl::btree_set<K, C, A>`. +// `y_absl::btree_set<K, C, A>`. // template <typename Key, typename Compare = std::less<Key>, typename Alloc = std::allocator<Key>> @@ -85,37 +85,37 @@ class btree_set // // * Default constructor // - // y_absl::btree_set<TString> set1; + // y_absl::btree_set<TString> set1; // // * Initializer List constructor // - // y_absl::btree_set<TString> set2 = + // y_absl::btree_set<TString> set2 = // {{"huey"}, {"dewey"}, {"louie"},}; // // * Copy constructor // - // y_absl::btree_set<TString> set3(set2); + // y_absl::btree_set<TString> set3(set2); // // * Copy assignment operator // - // y_absl::btree_set<TString> set4; + // y_absl::btree_set<TString> set4; // set4 = set3; // // * Move constructor // // // Move is guaranteed efficient - // y_absl::btree_set<TString> set5(std::move(set4)); + // y_absl::btree_set<TString> set5(std::move(set4)); // // * Move assignment operator // // // May be efficient if allocators are compatible - // y_absl::btree_set<TString> set6; + // y_absl::btree_set<TString> set6; // set6 = std::move(set5); // // * Range constructor // - // std::vector<TString> v = {"a", "b"}; - // y_absl::btree_set<TString> set7(v.begin(), v.end()); + // std::vector<TString> v = {"a", "b"}; + // y_absl::btree_set<TString> set7(v.begin(), v.end()); btree_set() {} using Base::Base; @@ -374,9 +374,9 @@ class btree_set using Base::value_comp; }; -// y_absl::swap(y_absl::btree_set<>, y_absl::btree_set<>) +// y_absl::swap(y_absl::btree_set<>, y_absl::btree_set<>) // -// Swaps the contents of two `y_absl::btree_set` containers. +// Swaps the contents of two `y_absl::btree_set` containers. template <typename K, typename C, typename A> void swap(btree_set<K, C, A> &x, btree_set<K, C, A> &y) { return x.swap(y); @@ -396,21 +396,21 @@ void erase_if(btree_set<K, C, A> &set, Pred pred) { } } -// y_absl::btree_multiset<> +// y_absl::btree_multiset<> // -// An `y_absl::btree_multiset<K>` is an ordered associative container of +// An `y_absl::btree_multiset<K>` is an ordered associative container of // keys and associated values designed to be a more efficient replacement -// for `std::multiset` (in most cases). Unlike `y_absl::btree_set`, a B-tree +// for `std::multiset` (in most cases). Unlike `y_absl::btree_set`, a B-tree // multiset allows equivalent elements. // // Keys are sorted using an (optional) comparison function, which defaults to // `std::less<K>`. // -// An `y_absl::btree_multiset<K>` uses a default allocator of `std::allocator<K>` +// An `y_absl::btree_multiset<K>` uses a default allocator of `std::allocator<K>` // to allocate (and deallocate) nodes, and construct and destruct values within // those nodes. You may instead specify a custom allocator `A` (which in turn // requires specifying a custom comparator `C`) as in -// `y_absl::btree_multiset<K, C, A>`. +// `y_absl::btree_multiset<K, C, A>`. // template <typename Key, typename Compare = std::less<Key>, typename Alloc = std::allocator<Key>> @@ -429,37 +429,37 @@ class btree_multiset // // * Default constructor // - // y_absl::btree_multiset<TString> set1; + // y_absl::btree_multiset<TString> set1; // // * Initializer List constructor // - // y_absl::btree_multiset<TString> set2 = + // y_absl::btree_multiset<TString> set2 = // {{"huey"}, {"dewey"}, {"louie"},}; // // * Copy constructor // - // y_absl::btree_multiset<TString> set3(set2); + // y_absl::btree_multiset<TString> set3(set2); // // * Copy assignment operator // - // y_absl::btree_multiset<TString> set4; + // y_absl::btree_multiset<TString> set4; // set4 = set3; // // * Move constructor // // // Move is guaranteed efficient - // y_absl::btree_multiset<TString> set5(std::move(set4)); + // y_absl::btree_multiset<TString> set5(std::move(set4)); // // * Move assignment operator // // // May be efficient if allocators are compatible - // y_absl::btree_multiset<TString> set6; + // y_absl::btree_multiset<TString> set6; // set6 = std::move(set5); // // * Range constructor // - // std::vector<TString> v = {"a", "b"}; - // y_absl::btree_multiset<TString> set7(v.begin(), v.end()); + // std::vector<TString> v = {"a", "b"}; + // y_absl::btree_multiset<TString> set7(v.begin(), v.end()); btree_multiset() {} using Base::Base; @@ -700,9 +700,9 @@ class btree_multiset using Base::value_comp; }; -// y_absl::swap(y_absl::btree_multiset<>, y_absl::btree_multiset<>) +// y_absl::swap(y_absl::btree_multiset<>, y_absl::btree_multiset<>) // -// Swaps the contents of two `y_absl::btree_multiset` containers. +// Swaps the contents of two `y_absl::btree_multiset` containers. template <typename K, typename C, typename A> void swap(btree_multiset<K, C, A> &x, btree_multiset<K, C, A> &y) { return x.swap(y); @@ -723,6 +723,6 @@ void erase_if(btree_multiset<K, C, A> &set, Pred pred) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_BTREE_SET_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h index 44d5d834a3..97ed054ce8 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h @@ -22,13 +22,13 @@ #include <utility> #include <vector> -#include "y_absl/container/btree_map.h" -#include "y_absl/container/btree_set.h" -#include "y_absl/container/flat_hash_set.h" +#include "y_absl/container/btree_map.h" +#include "y_absl/container/btree_set.h" +#include "y_absl/container/flat_hash_set.h" #include "y_absl/strings/cord.h" -#include "y_absl/time/time.h" +#include "y_absl/time/time.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -85,17 +85,17 @@ struct Generator { }; template <> -struct Generator<y_absl::Time> { +struct Generator<y_absl::Time> { int maxval; explicit Generator(int m) : maxval(m) {} - y_absl::Time operator()(int i) const { return y_absl::FromUnixMillis(i); } + y_absl::Time operator()(int i) const { return y_absl::FromUnixMillis(i); } }; template <> -struct Generator<TString> { +struct Generator<TString> { int maxval; explicit Generator(int m) : maxval(m) {} - TString operator()(int i) const { + TString operator()(int i) const { char buf[16]; return GenerateDigits(buf, i, maxval); } @@ -130,7 +130,7 @@ inline std::vector<int> GenerateNumbersWithSeed(int n, int maxval, int seed) { std::minstd_rand0 rng(seed); std::vector<int> values; - y_absl::flat_hash_set<int> unique_values; + y_absl::flat_hash_set<int> unique_values; if (values.size() < n) { for (int i = values.size(); i < n; i++) { int value; @@ -161,6 +161,6 @@ std::vector<V> GenerateValuesWithSeed(int n, int maxval, int seed) { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_BTREE_TEST_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h index e0deb30efc..33b6caf00d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h @@ -40,17 +40,17 @@ #include <new> #include <type_traits> -#include "y_absl/algorithm/algorithm.h" +#include "y_absl/algorithm/algorithm.h" #include "y_absl/base/config.h" -#include "y_absl/base/dynamic_annotations.h" -#include "y_absl/base/internal/throw_delegate.h" -#include "y_absl/base/macros.h" -#include "y_absl/base/optimization.h" -#include "y_absl/base/port.h" -#include "y_absl/container/internal/compressed_tuple.h" -#include "y_absl/memory/memory.h" - -namespace y_absl { +#include "y_absl/base/dynamic_annotations.h" +#include "y_absl/base/internal/throw_delegate.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/optimization.h" +#include "y_absl/base/port.h" +#include "y_absl/container/internal/compressed_tuple.h" +#include "y_absl/memory/memory.h" + +namespace y_absl { ABSL_NAMESPACE_BEGIN constexpr static auto kFixedArrayUseDefault = static_cast<size_t>(-1); @@ -85,19 +85,19 @@ class FixedArray { // std::iterator_traits isn't guaranteed to be SFINAE-friendly until C++17, // but this seems to be mostly pedantic. template <typename Iterator> - using EnableIfForwardIterator = y_absl::enable_if_t<std::is_convertible< + using EnableIfForwardIterator = y_absl::enable_if_t<std::is_convertible< typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>::value>; static constexpr bool NoexceptCopyable() { return std::is_nothrow_copy_constructible<StorageElement>::value && - y_absl::allocator_is_nothrow<allocator_type>::value; + y_absl::allocator_is_nothrow<allocator_type>::value; } static constexpr bool NoexceptMovable() { return std::is_nothrow_move_constructible<StorageElement>::value && - y_absl::allocator_is_nothrow<allocator_type>::value; + y_absl::allocator_is_nothrow<allocator_type>::value; } static constexpr bool DefaultConstructorIsNonTrivial() { - return !y_absl::is_trivially_default_constructible<StorageElement>::value; + return !y_absl::is_trivially_default_constructible<StorageElement>::value; } public: @@ -343,7 +343,7 @@ class FixedArray { // Relational operators. Equality operators are elementwise using // `operator==`, while order operators order FixedArrays lexicographically. friend bool operator==(const FixedArray& lhs, const FixedArray& rhs) { - return y_absl::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return y_absl::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } friend bool operator!=(const FixedArray& lhs, const FixedArray& rhs) { @@ -394,14 +394,14 @@ class FixedArray { // error: call to int __builtin___sprintf_chk(etc...) // will always overflow destination buffer [-Werror] // - template <typename OuterT, typename InnerT = y_absl::remove_extent_t<OuterT>, + template <typename OuterT, typename InnerT = y_absl::remove_extent_t<OuterT>, size_t InnerN = std::extent<OuterT>::value> struct StorageElementWrapper { InnerT array[InnerN]; }; using StorageElement = - y_absl::conditional_t<std::is_array<value_type>::value, + y_absl::conditional_t<std::is_array<value_type>::value, StorageElementWrapper<value_type>, value_type>; static pointer AsValueType(pointer ptr) { return ptr; } @@ -437,7 +437,7 @@ class FixedArray { }; using InlinedStorage = - y_absl::conditional_t<inline_elements == 0, EmptyInlinedStorage, + y_absl::conditional_t<inline_elements == 0, EmptyInlinedStorage, NonEmptyInlinedStorage>; // Storage @@ -522,6 +522,6 @@ void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateDestruct( static_cast<void>(n); // Mark used when not in asan mode } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_FIXED_ARRAY_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h index 9c771831b0..eb3f09f06d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h @@ -16,7 +16,7 @@ // File: flat_hash_map.h // ----------------------------------------------------------------------------- // -// An `y_absl::flat_hash_map<K, V>` is an unordered associative container of +// An `y_absl::flat_hash_map<K, V>` is an unordered associative container of // unique keys and associated values designed to be a more efficient replacement // for `std::unordered_map`. Like `unordered_map`, search, insertion, and // deletion of map elements can be done as an `O(1)` operation. However, @@ -35,13 +35,13 @@ #include <type_traits> #include <utility> -#include "y_absl/algorithm/container.h" -#include "y_absl/container/internal/container_memory.h" -#include "y_absl/container/internal/hash_function_defaults.h" // IWYU pragma: export -#include "y_absl/container/internal/raw_hash_map.h" // IWYU pragma: export -#include "y_absl/memory/memory.h" +#include "y_absl/algorithm/container.h" +#include "y_absl/container/internal/container_memory.h" +#include "y_absl/container/internal/hash_function_defaults.h" // IWYU pragma: export +#include "y_absl/container/internal/raw_hash_map.h" // IWYU pragma: export +#include "y_absl/memory/memory.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { template <class K, class V> @@ -49,10 +49,10 @@ struct FlatHashMapPolicy; } // namespace container_internal // ----------------------------------------------------------------------------- -// y_absl::flat_hash_map +// y_absl::flat_hash_map // ----------------------------------------------------------------------------- // -// An `y_absl::flat_hash_map<K, V>` is an unordered associative container which +// An `y_absl::flat_hash_map<K, V>` is an unordered associative container which // has been optimized for both speed and memory footprint in most common use // cases. Its interface is similar to that of `std::unordered_map<K, V>` with // the following notable differences: @@ -68,25 +68,25 @@ struct FlatHashMapPolicy; // slots (open, deleted, and empty) within the hash map. // * Returns `void` from the `erase(iterator)` overload. // -// By default, `flat_hash_map` uses the `y_absl::Hash` hashing framework. -// All fundamental and Abseil types that support the `y_absl::Hash` framework have +// By default, `flat_hash_map` uses the `y_absl::Hash` hashing framework. +// All fundamental and Abseil types that support the `y_absl::Hash` framework have // a compatible equality operator for comparing insertions into `flat_hash_map`. -// If your type is not yet supported by the `y_absl::Hash` framework, see -// y_absl/hash/hash.h for information on extending Abseil hashing to user-defined +// If your type is not yet supported by the `y_absl::Hash` framework, see +// y_absl/hash/hash.h for information on extending Abseil hashing to user-defined // types. // // NOTE: A `flat_hash_map` stores its value types directly inside its // implementation array to avoid memory indirection. Because a `flat_hash_map` // is designed to move data when rehashed, map values will not retain pointer // stability. If you require pointer stability, or if your values are large, -// consider using `y_absl::flat_hash_map<Key, std::unique_ptr<Value>>` instead. +// consider using `y_absl::flat_hash_map<Key, std::unique_ptr<Value>>` instead. // If your types are not moveable or you require pointer stability for keys, -// consider `y_absl::node_hash_map`. +// consider `y_absl::node_hash_map`. // // Example: // // // Create a flat hash map of three strings (that map to strings) -// y_absl::flat_hash_map<TString, TString> ducks = +// y_absl::flat_hash_map<TString, TString> ducks = // {{"a", "huey"}, {"b", "dewey"}, {"c", "louie"}}; // // // Insert a new element into the flat hash map @@ -96,17 +96,17 @@ struct FlatHashMapPolicy; // ducks.rehash(0); // // // Find the element with the key "b" -// TString search_key = "b"; +// TString search_key = "b"; // auto result = ducks.find(search_key); // if (result != ducks.end()) { // std::cout << "Result: " << result->second << std::endl; // } template <class K, class V, - class Hash = y_absl::container_internal::hash_default_hash<K>, - class Eq = y_absl::container_internal::hash_default_eq<K>, + class Hash = y_absl::container_internal::hash_default_hash<K>, + class Eq = y_absl::container_internal::hash_default_eq<K>, class Allocator = std::allocator<std::pair<const K, V>>> -class flat_hash_map : public y_absl::container_internal::raw_hash_map< - y_absl::container_internal::FlatHashMapPolicy<K, V>, +class flat_hash_map : public y_absl::container_internal::raw_hash_map< + y_absl::container_internal::FlatHashMapPolicy<K, V>, Hash, Eq, Allocator> { using Base = typename flat_hash_map::raw_hash_map; @@ -119,38 +119,38 @@ class flat_hash_map : public y_absl::container_internal::raw_hash_map< // * Default constructor // // // No allocation for the table's elements is made. - // y_absl::flat_hash_map<int, TString> map1; + // y_absl::flat_hash_map<int, TString> map1; // // * Initializer List constructor // - // y_absl::flat_hash_map<int, TString> map2 = + // y_absl::flat_hash_map<int, TString> map2 = // {{1, "huey"}, {2, "dewey"}, {3, "louie"},}; // // * Copy constructor // - // y_absl::flat_hash_map<int, TString> map3(map2); + // y_absl::flat_hash_map<int, TString> map3(map2); // // * Copy assignment operator // // // Hash functor and Comparator are copied as well - // y_absl::flat_hash_map<int, TString> map4; + // y_absl::flat_hash_map<int, TString> map4; // map4 = map3; // // * Move constructor // // // Move is guaranteed efficient - // y_absl::flat_hash_map<int, TString> map5(std::move(map4)); + // y_absl::flat_hash_map<int, TString> map5(std::move(map4)); // // * Move assignment operator // // // May be efficient if allocators are compatible - // y_absl::flat_hash_map<int, TString> map6; + // y_absl::flat_hash_map<int, TString> map6; // map6 = std::move(map5); // // * Range constructor // - // std::vector<std::pair<int, TString>> v = {{1, "a"}, {2, "b"}}; - // y_absl::flat_hash_map<int, TString> map7(v.begin(), v.end()); + // std::vector<std::pair<int, TString>> v = {{1, "a"}, {2, "b"}}; + // y_absl::flat_hash_map<int, TString> map7(v.begin(), v.end()); flat_hash_map() {} using Base::Base; @@ -179,7 +179,7 @@ class flat_hash_map : public y_absl::container_internal::raw_hash_map< // Returns the number of element slots (assigned, deleted, and empty) // available within the `flat_hash_map`. // - // NOTE: this member function is particular to `y_absl::flat_hash_map` and is + // NOTE: this member function is particular to `y_absl::flat_hash_map` and is // not provided in the `std::unordered_map` API. using Base::capacity; @@ -574,10 +574,10 @@ struct FlatHashMapPolicy { } template <class F, class... Args> - static decltype(y_absl::container_internal::DecomposePair( + static decltype(y_absl::container_internal::DecomposePair( std::declval<F>(), std::declval<Args>()...)) apply(F&& f, Args&&... args) { - return y_absl::container_internal::DecomposePair(std::forward<F>(f), + return y_absl::container_internal::DecomposePair(std::forward<F>(f), std::forward<Args>(args)...); } @@ -593,14 +593,14 @@ struct FlatHashMapPolicy { namespace container_algorithm_internal { -// Specialization of trait in y_absl/algorithm/container.h +// Specialization of trait in y_absl/algorithm/container.h template <class Key, class T, class Hash, class KeyEqual, class Allocator> struct IsUnorderedContainer< - y_absl::flat_hash_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {}; + y_absl::flat_hash_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {}; } // namespace container_algorithm_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_FLAT_HASH_MAP_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h index b9117dfd7a..23fe02a950 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h @@ -16,7 +16,7 @@ // File: flat_hash_set.h // ----------------------------------------------------------------------------- // -// An `y_absl::flat_hash_set<T>` is an unordered associative container designed to +// An `y_absl::flat_hash_set<T>` is an unordered associative container designed to // be a more efficient replacement for `std::unordered_set`. Like // `unordered_set`, search, insertion, and deletion of set elements can be done // as an `O(1)` operation. However, `flat_hash_set` (and other unordered @@ -32,14 +32,14 @@ #include <type_traits> #include <utility> -#include "y_absl/algorithm/container.h" -#include "y_absl/base/macros.h" -#include "y_absl/container/internal/container_memory.h" -#include "y_absl/container/internal/hash_function_defaults.h" // IWYU pragma: export -#include "y_absl/container/internal/raw_hash_set.h" // IWYU pragma: export -#include "y_absl/memory/memory.h" +#include "y_absl/algorithm/container.h" +#include "y_absl/base/macros.h" +#include "y_absl/container/internal/container_memory.h" +#include "y_absl/container/internal/hash_function_defaults.h" // IWYU pragma: export +#include "y_absl/container/internal/raw_hash_set.h" // IWYU pragma: export +#include "y_absl/memory/memory.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { template <typename T> @@ -47,10 +47,10 @@ struct FlatHashSetPolicy; } // namespace container_internal // ----------------------------------------------------------------------------- -// y_absl::flat_hash_set +// y_absl::flat_hash_set // ----------------------------------------------------------------------------- // -// An `y_absl::flat_hash_set<T>` is an unordered associative container which has +// An `y_absl::flat_hash_set<T>` is an unordered associative container which has // been optimized for both speed and memory footprint in most common use cases. // Its interface is similar to that of `std::unordered_set<T>` with the // following notable differences: @@ -65,24 +65,24 @@ struct FlatHashSetPolicy; // slots (open, deleted, and empty) within the hash set. // * Returns `void` from the `erase(iterator)` overload. // -// By default, `flat_hash_set` uses the `y_absl::Hash` hashing framework. All -// fundamental and Abseil types that support the `y_absl::Hash` framework have a +// By default, `flat_hash_set` uses the `y_absl::Hash` hashing framework. All +// fundamental and Abseil types that support the `y_absl::Hash` framework have a // compatible equality operator for comparing insertions into `flat_hash_map`. -// If your type is not yet supported by the `y_absl::Hash` framework, see -// y_absl/hash/hash.h for information on extending Abseil hashing to user-defined +// If your type is not yet supported by the `y_absl::Hash` framework, see +// y_absl/hash/hash.h for information on extending Abseil hashing to user-defined // types. // // NOTE: A `flat_hash_set` stores its keys directly inside its implementation // array to avoid memory indirection. Because a `flat_hash_set` is designed to // move data when rehashed, set keys will not retain pointer stability. If you // require pointer stability, consider using -// `y_absl::flat_hash_set<std::unique_ptr<T>>`. If your type is not moveable and -// you require pointer stability, consider `y_absl::node_hash_set` instead. +// `y_absl::flat_hash_set<std::unique_ptr<T>>`. If your type is not moveable and +// you require pointer stability, consider `y_absl::node_hash_set` instead. // // Example: // // // Create a flat hash set of three strings -// y_absl::flat_hash_set<TString> ducks = +// y_absl::flat_hash_set<TString> ducks = // {"huey", "dewey", "louie"}; // // // Insert a new element into the flat hash set @@ -95,12 +95,12 @@ struct FlatHashSetPolicy; // if (ducks.contains("dewey")) { // std::cout << "We found dewey!" << std::endl; // } -template <class T, class Hash = y_absl::container_internal::hash_default_hash<T>, - class Eq = y_absl::container_internal::hash_default_eq<T>, +template <class T, class Hash = y_absl::container_internal::hash_default_hash<T>, + class Eq = y_absl::container_internal::hash_default_eq<T>, class Allocator = std::allocator<T>> class flat_hash_set - : public y_absl::container_internal::raw_hash_set< - y_absl::container_internal::FlatHashSetPolicy<T>, Hash, Eq, Allocator> { + : public y_absl::container_internal::raw_hash_set< + y_absl::container_internal::FlatHashSetPolicy<T>, Hash, Eq, Allocator> { using Base = typename flat_hash_set::raw_hash_set; public: @@ -112,38 +112,38 @@ class flat_hash_set // * Default constructor // // // No allocation for the table's elements is made. - // y_absl::flat_hash_set<TString> set1; + // y_absl::flat_hash_set<TString> set1; // // * Initializer List constructor // - // y_absl::flat_hash_set<TString> set2 = + // y_absl::flat_hash_set<TString> set2 = // {{"huey"}, {"dewey"}, {"louie"},}; // // * Copy constructor // - // y_absl::flat_hash_set<TString> set3(set2); + // y_absl::flat_hash_set<TString> set3(set2); // // * Copy assignment operator // // // Hash functor and Comparator are copied as well - // y_absl::flat_hash_set<TString> set4; + // y_absl::flat_hash_set<TString> set4; // set4 = set3; // // * Move constructor // // // Move is guaranteed efficient - // y_absl::flat_hash_set<TString> set5(std::move(set4)); + // y_absl::flat_hash_set<TString> set5(std::move(set4)); // // * Move assignment operator // // // May be efficient if allocators are compatible - // y_absl::flat_hash_set<TString> set6; + // y_absl::flat_hash_set<TString> set6; // set6 = std::move(set5); // // * Range constructor // - // std::vector<TString> v = {"a", "b"}; - // y_absl::flat_hash_set<TString> set7(v.begin(), v.end()); + // std::vector<TString> v = {"a", "b"}; + // y_absl::flat_hash_set<TString> set7(v.begin(), v.end()); flat_hash_set() {} using Base::Base; @@ -172,7 +172,7 @@ class flat_hash_set // Returns the number of element slots (assigned, deleted, and empty) // available within the `flat_hash_set`. // - // NOTE: this member function is particular to `y_absl::flat_hash_set` and is + // NOTE: this member function is particular to `y_absl::flat_hash_set` and is // not provided in the `std::unordered_map` API. using Base::capacity; @@ -459,13 +459,13 @@ struct FlatHashSetPolicy { template <class Allocator, class... Args> static void construct(Allocator* alloc, slot_type* slot, Args&&... args) { - y_absl::allocator_traits<Allocator>::construct(*alloc, slot, + y_absl::allocator_traits<Allocator>::construct(*alloc, slot, std::forward<Args>(args)...); } template <class Allocator> static void destroy(Allocator* alloc, slot_type* slot) { - y_absl::allocator_traits<Allocator>::destroy(*alloc, slot); + y_absl::allocator_traits<Allocator>::destroy(*alloc, slot); } template <class Allocator> @@ -478,10 +478,10 @@ struct FlatHashSetPolicy { static T& element(slot_type* slot) { return *slot; } template <class F, class... Args> - static decltype(y_absl::container_internal::DecomposeValue( + static decltype(y_absl::container_internal::DecomposeValue( std::declval<F>(), std::declval<Args>()...)) apply(F&& f, Args&&... args) { - return y_absl::container_internal::DecomposeValue( + return y_absl::container_internal::DecomposeValue( std::forward<F>(f), std::forward<Args>(args)...); } @@ -491,14 +491,14 @@ struct FlatHashSetPolicy { namespace container_algorithm_internal { -// Specialization of trait in y_absl/algorithm/container.h +// Specialization of trait in y_absl/algorithm/container.h template <class Key, class Hash, class KeyEqual, class Allocator> -struct IsUnorderedContainer<y_absl::flat_hash_set<Key, Hash, KeyEqual, Allocator>> +struct IsUnorderedContainer<y_absl::flat_hash_set<Key, Hash, KeyEqual, Allocator>> : std::true_type {}; } // namespace container_algorithm_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_FLAT_HASH_SET_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h index 5f82d8a9e2..34af121cf7 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h @@ -21,16 +21,16 @@ // that storage for small sequences of the vector are provided inline without // requiring any heap allocation. // -// An `y_absl::InlinedVector<T, N>` specifies the default capacity `N` as one of +// An `y_absl::InlinedVector<T, N>` specifies the default capacity `N` as one of // its template parameters. Instances where `size() <= N` hold contained // elements in inline space. Typically `N` is very small so that sequences that // are expected to be short do not require allocations. // -// An `y_absl::InlinedVector` does not usually require a specific allocator. If +// An `y_absl::InlinedVector` does not usually require a specific allocator. If // the inlined vector grows beyond its initial constraints, it will need to // allocate (as any normal `std::vector` would). This is usually performed with // the default allocator (defined as `std::allocator<T>`). Optionally, a custom -// allocator type may be specified as `A` in `y_absl::InlinedVector<T, N, A>`. +// allocator type may be specified as `A` in `y_absl::InlinedVector<T, N, A>`. #ifndef ABSL_CONTAINER_INLINED_VECTOR_H_ #define ABSL_CONTAINER_INLINED_VECTOR_H_ @@ -46,21 +46,21 @@ #include <type_traits> #include <utility> -#include "y_absl/algorithm/algorithm.h" -#include "y_absl/base/internal/throw_delegate.h" +#include "y_absl/algorithm/algorithm.h" +#include "y_absl/base/internal/throw_delegate.h" #include "y_absl/base/macros.h" -#include "y_absl/base/optimization.h" -#include "y_absl/base/port.h" -#include "y_absl/container/internal/inlined_vector.h" -#include "y_absl/memory/memory.h" +#include "y_absl/base/optimization.h" +#include "y_absl/base/port.h" +#include "y_absl/container/internal/inlined_vector.h" +#include "y_absl/memory/memory.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ----------------------------------------------------------------------------- // InlinedVector // ----------------------------------------------------------------------------- // -// An `y_absl::InlinedVector` is designed to be a drop-in replacement for +// An `y_absl::InlinedVector` is designed to be a drop-in replacement for // `std::vector` for use cases where the vector's size is sufficiently small // that it can be inlined. If the inlined vector does grow beyond its estimated // capacity, it will trigger an initial allocation on the heap, and will behave @@ -68,7 +68,7 @@ ABSL_NAMESPACE_BEGIN // designed to cover the same API footprint as covered by `std::vector`. template <typename T, size_t N, typename A = std::allocator<T>> class InlinedVector { - static_assert(N > 0, "`y_absl::InlinedVector` requires an inlined capacity."); + static_assert(N > 0, "`y_absl::InlinedVector` requires an inlined capacity."); using Storage = inlined_vector_internal::Storage<T, N, A>; @@ -89,10 +89,10 @@ class InlinedVector { inlined_vector_internal::DefaultValueAdapter<TheA>; template <typename Iterator> - using EnableIfAtLeastForwardIterator = y_absl::enable_if_t< + using EnableIfAtLeastForwardIterator = y_absl::enable_if_t< inlined_vector_internal::IsAtLeastForwardIterator<Iterator>::value, int>; template <typename Iterator> - using DisableIfAtLeastForwardIterator = y_absl::enable_if_t< + using DisableIfAtLeastForwardIterator = y_absl::enable_if_t< !inlined_vector_internal::IsAtLeastForwardIterator<Iterator>::value, int>; public: @@ -199,7 +199,7 @@ class InlinedVector { // Thus, the move constructor is non-throwing if the allocator is non-throwing // or `value_type`'s move constructor is specified as `noexcept`. InlinedVector(InlinedVector&& other) noexcept( - y_absl::allocator_is_nothrow<allocator_type>::value || + y_absl::allocator_is_nothrow<allocator_type>::value || std::is_nothrow_move_constructible<value_type>::value) : storage_(other.storage_.GetAllocator()) { if (IsMemcpyOk<A>::value) { @@ -758,7 +758,7 @@ class InlinedVector { private: template <typename H, typename TheT, size_t TheN, typename TheA> - friend H AbslHashValue(H h, const y_absl::InlinedVector<TheT, TheN, TheA>& a); + friend H AbslHashValue(H h, const y_absl::InlinedVector<TheT, TheN, TheA>& a); Storage storage_; }; @@ -771,8 +771,8 @@ class InlinedVector { // // Swaps the contents of two inlined vectors. template <typename T, size_t N, typename A> -void swap(y_absl::InlinedVector<T, N, A>& a, - y_absl::InlinedVector<T, N, A>& b) noexcept(noexcept(a.swap(b))) { +void swap(y_absl::InlinedVector<T, N, A>& a, + y_absl::InlinedVector<T, N, A>& b) noexcept(noexcept(a.swap(b))) { a.swap(b); } @@ -780,19 +780,19 @@ void swap(y_absl::InlinedVector<T, N, A>& a, // // Tests for value-equality of two inlined vectors. template <typename T, size_t N, typename A> -bool operator==(const y_absl::InlinedVector<T, N, A>& a, - const y_absl::InlinedVector<T, N, A>& b) { +bool operator==(const y_absl::InlinedVector<T, N, A>& a, + const y_absl::InlinedVector<T, N, A>& b) { auto a_data = a.data(); auto b_data = b.data(); - return y_absl::equal(a_data, a_data + a.size(), b_data, b_data + b.size()); + return y_absl::equal(a_data, a_data + a.size(), b_data, b_data + b.size()); } // `operator!=(...)` // // Tests for value-inequality of two inlined vectors. template <typename T, size_t N, typename A> -bool operator!=(const y_absl::InlinedVector<T, N, A>& a, - const y_absl::InlinedVector<T, N, A>& b) { +bool operator!=(const y_absl::InlinedVector<T, N, A>& a, + const y_absl::InlinedVector<T, N, A>& b) { return !(a == b); } @@ -801,8 +801,8 @@ bool operator!=(const y_absl::InlinedVector<T, N, A>& a, // Tests whether the value of an inlined vector is less than the value of // another inlined vector using a lexicographical comparison algorithm. template <typename T, size_t N, typename A> -bool operator<(const y_absl::InlinedVector<T, N, A>& a, - const y_absl::InlinedVector<T, N, A>& b) { +bool operator<(const y_absl::InlinedVector<T, N, A>& a, + const y_absl::InlinedVector<T, N, A>& b) { auto a_data = a.data(); auto b_data = b.data(); return std::lexicographical_compare(a_data, a_data + a.size(), b_data, @@ -814,8 +814,8 @@ bool operator<(const y_absl::InlinedVector<T, N, A>& a, // Tests whether the value of an inlined vector is greater than the value of // another inlined vector using a lexicographical comparison algorithm. template <typename T, size_t N, typename A> -bool operator>(const y_absl::InlinedVector<T, N, A>& a, - const y_absl::InlinedVector<T, N, A>& b) { +bool operator>(const y_absl::InlinedVector<T, N, A>& a, + const y_absl::InlinedVector<T, N, A>& b) { return b < a; } @@ -824,8 +824,8 @@ bool operator>(const y_absl::InlinedVector<T, N, A>& a, // Tests whether the value of an inlined vector is less than or equal to the // value of another inlined vector using a lexicographical comparison algorithm. template <typename T, size_t N, typename A> -bool operator<=(const y_absl::InlinedVector<T, N, A>& a, - const y_absl::InlinedVector<T, N, A>& b) { +bool operator<=(const y_absl::InlinedVector<T, N, A>& a, + const y_absl::InlinedVector<T, N, A>& b) { return !(b < a); } @@ -834,22 +834,22 @@ bool operator<=(const y_absl::InlinedVector<T, N, A>& a, // Tests whether the value of an inlined vector is greater than or equal to the // value of another inlined vector using a lexicographical comparison algorithm. template <typename T, size_t N, typename A> -bool operator>=(const y_absl::InlinedVector<T, N, A>& a, - const y_absl::InlinedVector<T, N, A>& b) { +bool operator>=(const y_absl::InlinedVector<T, N, A>& a, + const y_absl::InlinedVector<T, N, A>& b) { return !(a < b); } // `AbslHashValue(...)` // -// Provides `y_absl::Hash` support for `y_absl::InlinedVector`. It is uncommon to +// Provides `y_absl::Hash` support for `y_absl::InlinedVector`. It is uncommon to // call this directly. template <typename H, typename T, size_t N, typename A> -H AbslHashValue(H h, const y_absl::InlinedVector<T, N, A>& a) { +H AbslHashValue(H h, const y_absl::InlinedVector<T, N, A>& a) { auto size = a.size(); return H::combine(H::combine_contiguous(std::move(h), a.data(), size), size); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INLINED_VECTOR_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h index d0834c4ebc..a249260811 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h @@ -58,19 +58,19 @@ #include <type_traits> #include <utility> -#include "y_absl/base/macros.h" -#include "y_absl/container/internal/common.h" -#include "y_absl/container/internal/compressed_tuple.h" -#include "y_absl/container/internal/container_memory.h" -#include "y_absl/container/internal/layout.h" -#include "y_absl/memory/memory.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/base/macros.h" +#include "y_absl/container/internal/common.h" +#include "y_absl/container/internal/compressed_tuple.h" +#include "y_absl/container/internal/container_memory.h" +#include "y_absl/container/internal/layout.h" +#include "y_absl/memory/memory.h" +#include "y_absl/meta/type_traits.h" #include "y_absl/strings/cord.h" -#include "y_absl/strings/string_view.h" -#include "y_absl/types/compare.h" -#include "y_absl/utility/utility.h" +#include "y_absl/strings/string_view.h" +#include "y_absl/types/compare.h" +#include "y_absl/utility/utility.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -78,8 +78,8 @@ namespace container_internal { // comparator. template <typename Compare, typename T> using btree_is_key_compare_to = - std::is_convertible<y_absl::result_of_t<Compare(const T &, const T &)>, - y_absl::weak_ordering>; + std::is_convertible<y_absl::result_of_t<Compare(const T &, const T &)>, + y_absl::weak_ordering>; struct StringBtreeDefaultLess { using is_transparent = void; @@ -87,7 +87,7 @@ struct StringBtreeDefaultLess { StringBtreeDefaultLess() = default; // Compatibility constructor. - StringBtreeDefaultLess(std::less<TString>) {} // NOLINT + StringBtreeDefaultLess(std::less<TString>) {} // NOLINT StringBtreeDefaultLess(std::less<y_absl::string_view>) {} // NOLINT // Allow converting to std::less for use in key_comp()/value_comp(). @@ -95,8 +95,8 @@ struct StringBtreeDefaultLess { explicit operator std::less<y_absl::string_view>() const { return {}; } explicit operator std::less<y_absl::Cord>() const { return {}; } - y_absl::weak_ordering operator()(y_absl::string_view lhs, - y_absl::string_view rhs) const { + y_absl::weak_ordering operator()(y_absl::string_view lhs, + y_absl::string_view rhs) const { return compare_internal::compare_result_as_ordering(lhs.compare(rhs)); } StringBtreeDefaultLess(std::less<y_absl::Cord>) {} // NOLINT @@ -119,7 +119,7 @@ struct StringBtreeDefaultGreater { StringBtreeDefaultGreater() = default; - StringBtreeDefaultGreater(std::greater<TString>) {} // NOLINT + StringBtreeDefaultGreater(std::greater<TString>) {} // NOLINT StringBtreeDefaultGreater(std::greater<y_absl::string_view>) {} // NOLINT // Allow converting to std::greater for use in key_comp()/value_comp(). @@ -127,8 +127,8 @@ struct StringBtreeDefaultGreater { explicit operator std::greater<y_absl::string_view>() const { return {}; } explicit operator std::greater<y_absl::Cord>() const { return {}; } - y_absl::weak_ordering operator()(y_absl::string_view lhs, - y_absl::string_view rhs) const { + y_absl::weak_ordering operator()(y_absl::string_view lhs, + y_absl::string_view rhs) const { return compare_internal::compare_result_as_ordering(rhs.compare(lhs)); } StringBtreeDefaultGreater(std::greater<y_absl::Cord>) {} // NOLINT @@ -148,7 +148,7 @@ struct StringBtreeDefaultGreater { // A helper class to convert a boolean comparison into a three-way "compare-to" // comparison that returns an `y_absl::weak_ordering`. This helper -// class is specialized for less<TString>, greater<TString>, +// class is specialized for less<TString>, greater<TString>, // less<string_view>, greater<string_view>, less<y_absl::Cord>, and // greater<y_absl::Cord>. // @@ -163,22 +163,22 @@ struct key_compare_to_adapter { }; template <> -struct key_compare_to_adapter<std::less<TString>> { +struct key_compare_to_adapter<std::less<TString>> { using type = StringBtreeDefaultLess; }; template <> -struct key_compare_to_adapter<std::greater<TString>> { +struct key_compare_to_adapter<std::greater<TString>> { using type = StringBtreeDefaultGreater; }; template <> -struct key_compare_to_adapter<std::less<y_absl::string_view>> { +struct key_compare_to_adapter<std::less<y_absl::string_view>> { using type = StringBtreeDefaultLess; }; template <> -struct key_compare_to_adapter<std::greater<y_absl::string_view>> { +struct key_compare_to_adapter<std::greater<y_absl::string_view>> { using type = StringBtreeDefaultGreater; }; @@ -280,7 +280,7 @@ struct common_params { // This is an integral type large enough to hold as many // ValueSize-values as will fit a node of TargetNodeSize bytes. using node_count_type = - y_absl::conditional_t<(kNodeValueSpace / sizeof(value_type) > + y_absl::conditional_t<(kNodeValueSpace / sizeof(value_type) > (std::numeric_limits<uint8_t>::max)()), uint16_t, uint8_t>; // NOLINT @@ -363,7 +363,7 @@ struct map_params : common_params<Key, Compare, Alloc, TargetNodeSize, Multi, }; // This type implements the necessary functions from the -// y_absl::container_internal::slot_type interface. +// y_absl::container_internal::slot_type interface. template <typename Key> struct set_slot_policy { using slot_type = Key; @@ -375,18 +375,18 @@ struct set_slot_policy { template <typename Alloc, class... Args> static void construct(Alloc *alloc, slot_type *slot, Args &&... args) { - y_absl::allocator_traits<Alloc>::construct(*alloc, slot, + y_absl::allocator_traits<Alloc>::construct(*alloc, slot, std::forward<Args>(args)...); } template <typename Alloc> static void construct(Alloc *alloc, slot_type *slot, slot_type *other) { - y_absl::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other)); + y_absl::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other)); } template <typename Alloc> static void destroy(Alloc *alloc, slot_type *slot) { - y_absl::allocator_traits<Alloc>::destroy(*alloc, slot); + y_absl::allocator_traits<Alloc>::destroy(*alloc, slot); } template <typename Alloc> @@ -553,7 +553,7 @@ class btree_node { btree_node() = default; private: - using layout_type = y_absl::container_internal::Layout<btree_node *, field_type, + using layout_type = y_absl::container_internal::Layout<btree_node *, field_type, slot_type, btree_node *>; constexpr static size_type SizeWithNSlots(size_type n) { return layout_type(/*parent*/ 1, @@ -695,10 +695,10 @@ class btree_node { btree_node *start_child() const { return child(start()); } btree_node *&mutable_child(int i) { return GetField<3>()[i]; } void clear_child(int i) { - y_absl::container_internal::SanitizerPoisonObject(&mutable_child(i)); + y_absl::container_internal::SanitizerPoisonObject(&mutable_child(i)); } void set_child(int i, btree_node *c) { - y_absl::container_internal::SanitizerUnpoisonObject(&mutable_child(i)); + y_absl::container_internal::SanitizerUnpoisonObject(&mutable_child(i)); mutable_child(i) = c; c->set_position(i); } @@ -758,7 +758,7 @@ class btree_node { const K &k, int s, const int e, const Compare &comp, std::true_type /* IsCompareTo */) const { while (s < e) { - const y_absl::weak_ordering c = comp(key(s), k); + const y_absl::weak_ordering c = comp(key(s), k); if (c == 0) { return {s, MatchKind::kEq}; } else if (c > 0) { @@ -796,7 +796,7 @@ class btree_node { MatchKind exact_match = MatchKind::kNe; while (s != e) { const int mid = (s + e) >> 1; - const y_absl::weak_ordering c = comp(key(mid), k); + const y_absl::weak_ordering c = comp(key(mid), k); if (c < 0) { s = mid + 1; } else { @@ -813,7 +813,7 @@ class btree_node { } else { // Can't have multiple equivalent keys. while (s != e) { const int mid = (s + e) >> 1; - const y_absl::weak_ordering c = comp(key(mid), k); + const y_absl::weak_ordering c = comp(key(mid), k); if (c < 0) { s = mid + 1; } else if (c > 0) { @@ -856,7 +856,7 @@ class btree_node { set_start(0); set_finish(0); set_max_count(max_count); - y_absl::container_internal::SanitizerPoisonMemoryRegion( + y_absl::container_internal::SanitizerPoisonMemoryRegion( start_slot(), max_count * sizeof(slot_type)); } void init_internal(btree_node *parent) { @@ -864,7 +864,7 @@ class btree_node { // Set `max_count` to a sentinel value to indicate that this node is // internal. set_max_count(kInternalNodeMaxCount); - y_absl::container_internal::SanitizerPoisonMemoryRegion( + y_absl::container_internal::SanitizerPoisonMemoryRegion( &mutable_child(start()), (kNodeSlots + 1) * sizeof(btree_node *)); } @@ -879,12 +879,12 @@ class btree_node { private: template <typename... Args> void value_init(const field_type i, allocator_type *alloc, Args &&... args) { - y_absl::container_internal::SanitizerUnpoisonObject(slot(i)); + y_absl::container_internal::SanitizerUnpoisonObject(slot(i)); params_type::construct(alloc, slot(i), std::forward<Args>(args)...); } void value_destroy(const field_type i, allocator_type *alloc) { params_type::destroy(alloc, slot(i)); - y_absl::container_internal::SanitizerPoisonObject(slot(i)); + y_absl::container_internal::SanitizerPoisonObject(slot(i)); } void value_destroy_n(const field_type i, const field_type n, allocator_type *alloc) { @@ -975,7 +975,7 @@ struct btree_iterator { // const_iterator, but it specifically avoids hiding the copy constructor so // that the trivial one will be used when possible. template <typename N, typename R, typename P, - y_absl::enable_if_t< + y_absl::enable_if_t< std::is_same<btree_iterator<N, R, P>, iterator>::value && std::is_same<btree_iterator, const_iterator>::value, int> = 0> @@ -988,7 +988,7 @@ struct btree_iterator { // NOTE: the const_cast is safe because this constructor is only called by // non-const methods and the container owns the nodes. template <typename N, typename R, typename P, - y_absl::enable_if_t< + y_absl::enable_if_t< std::is_same<btree_iterator<N, R, P>, const_iterator>::value && std::is_same<btree_iterator, iterator>::value, int> = 0> @@ -1462,7 +1462,7 @@ class btree { // allocator. node_type *allocate(const size_type size) { return reinterpret_cast<node_type *>( - y_absl::container_internal::Allocate<node_type::Alignment()>( + y_absl::container_internal::Allocate<node_type::Alignment()>( mutable_allocator(), size)); } @@ -1566,7 +1566,7 @@ class btree { // We use compressed tuple in order to save space because key_compare and // allocator_type are usually empty. - y_absl::container_internal::CompressedTuple<key_compare, allocator_type, + y_absl::container_internal::CompressedTuple<key_compare, allocator_type, node_type *> root_; @@ -1920,13 +1920,13 @@ constexpr bool btree<P>::static_assert_validation() { kNodeSlots < (1 << (8 * sizeof(typename node_type::field_type))), "target node size too large"); - // Verify that key_compare returns an y_absl::{weak,strong}_ordering or bool. + // Verify that key_compare returns an y_absl::{weak,strong}_ordering or bool. using compare_result_type = - y_absl::result_of_t<key_compare(key_type, key_type)>; + y_absl::result_of_t<key_compare(key_type, key_type)>; static_assert( std::is_same<compare_result_type, bool>::value || - std::is_convertible<compare_result_type, y_absl::weak_ordering>::value, - "key comparison function must return y_absl::{weak,strong}_ordering or " + std::is_convertible<compare_result_type, y_absl::weak_ordering>::value, + "key comparison function must return y_absl::{weak,strong}_ordering or " "bool."); // Test the assumption made in setting kNodeValueSpace. @@ -2096,7 +2096,7 @@ auto btree<P>::operator=(const btree &other) -> btree & { clear(); *mutable_key_comp() = other.key_comp(); - if (y_absl::allocator_traits< + if (y_absl::allocator_traits< allocator_type>::propagate_on_container_copy_assignment::value) { *mutable_allocator() = other.allocator(); } @@ -2112,7 +2112,7 @@ auto btree<P>::operator=(btree &&other) noexcept -> btree & { clear(); using std::swap; - if (y_absl::allocator_traits< + if (y_absl::allocator_traits< allocator_type>::propagate_on_container_copy_assignment::value) { // Note: `root_` also contains the allocator and the key comparator. swap(root_, other.root_); @@ -2267,7 +2267,7 @@ void btree<P>::clear() { template <typename P> void btree<P>::swap(btree &other) { using std::swap; - if (y_absl::allocator_traits< + if (y_absl::allocator_traits< allocator_type>::propagate_on_container_swap::value) { // Note: `root_` also contains the allocator and the key comparator. swap(root_, other.root_); @@ -2636,6 +2636,6 @@ int btree<P>::internal_verify(const node_type *node, const key_type *lo, } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_BTREE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h index 167d907bd8..d23feff31b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h @@ -21,13 +21,13 @@ #include <utility> #include "y_absl/base/attributes.h" -#include "y_absl/base/internal/throw_delegate.h" -#include "y_absl/container/internal/btree.h" // IWYU pragma: export -#include "y_absl/container/internal/common.h" +#include "y_absl/base/internal/throw_delegate.h" +#include "y_absl/container/internal/btree.h" // IWYU pragma: export +#include "y_absl/container/internal/common.h" #include "y_absl/memory/memory.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -218,7 +218,7 @@ class btree_container { key_compare key_comp() const { return key_compare(tree_.key_comp()); } value_compare value_comp() const { return tree_.value_comp(); } - // Support y_absl::Hash. + // Support y_absl::Hash. template <typename State> friend State AbslHashValue(State h, const btree_container &b) { for (const auto &v : b) { @@ -353,8 +353,8 @@ class btree_set_container : public btree_container<Tree> { // `this`, it is left unmodified in `src`. template < typename T, - typename y_absl::enable_if_t< - y_absl::conjunction< + typename y_absl::enable_if_t< + y_absl::conjunction< std::is_same<value_type, typename T::value_type>, std::is_same<allocator_type, typename T::allocator_type>, std::is_same<typename params_type::is_map_container, @@ -372,8 +372,8 @@ class btree_set_container : public btree_container<Tree> { template < typename T, - typename y_absl::enable_if_t< - y_absl::conjunction< + typename y_absl::enable_if_t< + y_absl::conjunction< std::is_same<value_type, typename T::value_type>, std::is_same<allocator_type, typename T::allocator_type>, std::is_same<typename params_type::is_map_container, @@ -483,14 +483,14 @@ class btree_map_container : public btree_set_container<Tree> { mapped_type &at(const key_arg<K> &key) { auto it = this->find(key); if (it == this->end()) - base_internal::ThrowStdOutOfRange("y_absl::btree_map::at"); + base_internal::ThrowStdOutOfRange("y_absl::btree_map::at"); return it->second; } template <typename K = key_type> const mapped_type &at(const key_arg<K> &key) const { auto it = this->find(key); if (it == this->end()) - base_internal::ThrowStdOutOfRange("y_absl::btree_map::at"); + base_internal::ThrowStdOutOfRange("y_absl::btree_map::at"); return it->second; } @@ -634,8 +634,8 @@ class btree_multiset_container : public btree_container<Tree> { // Moves all elements from `src` into `this`. template < typename T, - typename y_absl::enable_if_t< - y_absl::conjunction< + typename y_absl::enable_if_t< + y_absl::conjunction< std::is_same<value_type, typename T::value_type>, std::is_same<allocator_type, typename T::allocator_type>, std::is_same<typename params_type::is_map_container, @@ -650,8 +650,8 @@ class btree_multiset_container : public btree_container<Tree> { template < typename T, - typename y_absl::enable_if_t< - y_absl::conjunction< + typename y_absl::enable_if_t< + y_absl::conjunction< std::is_same<value_type, typename T::value_type>, std::is_same<allocator_type, typename T::allocator_type>, std::is_same<typename params_type::is_map_container, @@ -678,6 +678,6 @@ class btree_multimap_container : public btree_multiset_container<Tree> { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h index fff41f3501..ec84f975e5 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h @@ -18,17 +18,17 @@ #include <cassert> #include <type_traits> -#include "y_absl/meta/type_traits.h" -#include "y_absl/types/optional.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/types/optional.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { template <class, class = void> struct IsTransparent : std::false_type {}; template <class T> -struct IsTransparent<T, y_absl::void_t<typename T::is_transparent>> +struct IsTransparent<T, y_absl::void_t<typename T::is_transparent>> : std::true_type {}; template <bool is_transparent> @@ -99,7 +99,7 @@ class node_handle_base { void reset() { assert(alloc_.has_value()); - alloc_ = y_absl::nullopt; + alloc_ = y_absl::nullopt; } slot_type* slot() const { @@ -135,7 +135,7 @@ class node_handle : public node_handle_base<PolicyTraits, Alloc> { // For maps. template <typename Policy, typename PolicyTraits, typename Alloc> class node_handle<Policy, PolicyTraits, Alloc, - y_absl::void_t<typename Policy::mapped_type>> + y_absl::void_t<typename Policy::mapped_type>> : public node_handle_base<PolicyTraits, Alloc> { using Base = node_handle_base<PolicyTraits, Alloc>; using slot_type = typename PolicyTraits::slot_type; @@ -201,6 +201,6 @@ struct InsertReturnType { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_CONTAINER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h index 16c901c4d2..735b738a9b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h @@ -20,7 +20,7 @@ // To access the members, use member get<N>() function. // // Eg: -// y_absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2, +// y_absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2, // t3); // assert(value.get<0>() == 7); // T1& t1 = value.get<1>(); @@ -37,7 +37,7 @@ #include <type_traits> #include <utility> -#include "y_absl/utility/utility.h" +#include "y_absl/utility/utility.h" #if defined(_MSC_VER) && !defined(__NVCC__) // We need to mark these classes with this declspec to ensure that @@ -47,7 +47,7 @@ #define ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -104,11 +104,11 @@ struct Storage { T value; constexpr Storage() = default; template <typename V> - explicit constexpr Storage(y_absl::in_place_t, V&& v) - : value(y_absl::forward<V>(v)) {} + explicit constexpr Storage(y_absl::in_place_t, V&& v) + : value(y_absl::forward<V>(v)) {} constexpr const T& get() const& { return value; } T& get() & { return value; } - constexpr const T&& get() const&& { return y_absl::move(*this).value; } + constexpr const T&& get() const&& { return y_absl::move(*this).value; } T&& get() && { return std::move(*this).value; } }; @@ -117,12 +117,12 @@ struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<T, I, true> : T { constexpr Storage() = default; template <typename V> - explicit constexpr Storage(y_absl::in_place_t, V&& v) - : T(y_absl::forward<V>(v)) {} + explicit constexpr Storage(y_absl::in_place_t, V&& v) + : T(y_absl::forward<V>(v)) {} constexpr const T& get() const& { return *this; } T& get() & { return *this; } - constexpr const T&& get() const&& { return y_absl::move(*this); } + constexpr const T&& get() const&& { return y_absl::move(*this); } T&& get() && { return std::move(*this); } }; @@ -131,7 +131,7 @@ struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl; template <typename... Ts, size_t... I, bool ShouldAnyUseBase> struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl< - CompressedTuple<Ts...>, y_absl::index_sequence<I...>, ShouldAnyUseBase> + CompressedTuple<Ts...>, y_absl::index_sequence<I...>, ShouldAnyUseBase> // We use the dummy identity function through std::integral_constant to // convince MSVC of accepting and expanding I in that context. Without it // you would get: @@ -140,20 +140,20 @@ struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl< Storage<Ts, std::integral_constant<size_t, I>::value>... { constexpr CompressedTupleImpl() = default; template <typename... Vs> - explicit constexpr CompressedTupleImpl(y_absl::in_place_t, Vs&&... args) - : Storage<Ts, I>(y_absl::in_place, y_absl::forward<Vs>(args))... {} + explicit constexpr CompressedTupleImpl(y_absl::in_place_t, Vs&&... args) + : Storage<Ts, I>(y_absl::in_place, y_absl::forward<Vs>(args))... {} friend CompressedTuple<Ts...>; }; template <typename... Ts, size_t... I> struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl< - CompressedTuple<Ts...>, y_absl::index_sequence<I...>, false> + CompressedTuple<Ts...>, y_absl::index_sequence<I...>, false> // We use the dummy identity function as above... : Storage<Ts, std::integral_constant<size_t, I>::value, false>... { constexpr CompressedTupleImpl() = default; template <typename... Vs> - explicit constexpr CompressedTupleImpl(y_absl::in_place_t, Vs&&... args) - : Storage<Ts, I, false>(y_absl::in_place, y_absl::forward<Vs>(args))... {} + explicit constexpr CompressedTupleImpl(y_absl::in_place_t, Vs&&... args) + : Storage<Ts, I, false>(y_absl::in_place, y_absl::forward<Vs>(args))... {} friend CompressedTuple<Ts...>; }; @@ -209,7 +209,7 @@ struct TupleItemsMoveConstructible // To access the members, use member .get<N>() function. // // Eg: -// y_absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2, +// y_absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2, // t3); // assert(value.get<0>() == 7); // T1& t1 = value.get<1>(); @@ -220,7 +220,7 @@ struct TupleItemsMoveConstructible template <typename... Ts> class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple : private internal_compressed_tuple::CompressedTupleImpl< - CompressedTuple<Ts...>, y_absl::index_sequence_for<Ts...>, + CompressedTuple<Ts...>, y_absl::index_sequence_for<Ts...>, internal_compressed_tuple::ShouldAnyUseBase<Ts...>()> { private: template <int I> @@ -239,21 +239,21 @@ class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple constexpr CompressedTuple() = default; #endif explicit constexpr CompressedTuple(const Ts&... base) - : CompressedTuple::CompressedTupleImpl(y_absl::in_place, base...) {} + : CompressedTuple::CompressedTupleImpl(y_absl::in_place, base...) {} template <typename First, typename... Vs, - y_absl::enable_if_t< - y_absl::conjunction< + y_absl::enable_if_t< + y_absl::conjunction< // Ensure we are not hiding default copy/move constructors. - y_absl::negation<std::is_same<void(CompressedTuple), + y_absl::negation<std::is_same<void(CompressedTuple), void(y_absl::decay_t<First>)>>, internal_compressed_tuple::TupleItemsMoveConstructible< CompressedTuple<Ts...>, First, Vs...>>::value, bool> = true> explicit constexpr CompressedTuple(First&& first, Vs&&... base) - : CompressedTuple::CompressedTupleImpl(y_absl::in_place, + : CompressedTuple::CompressedTupleImpl(y_absl::in_place, y_absl::forward<First>(first), - y_absl::forward<Vs>(base)...) {} + y_absl::forward<Vs>(base)...) {} template <int I> ElemT<I>& get() & { @@ -272,7 +272,7 @@ class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple template <int I> constexpr const ElemT<I>&& get() const&& { - return y_absl::move(*this).StorageT<I>::get(); + return y_absl::move(*this).StorageT<I>::get(); } }; @@ -283,7 +283,7 @@ class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {}; } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #undef ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h index c15b0e49ba..348bc8c0d0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h @@ -24,9 +24,9 @@ #include <utility> #include "y_absl/base/config.h" -#include "y_absl/memory/memory.h" +#include "y_absl/memory/memory.h" #include "y_absl/meta/type_traits.h" -#include "y_absl/utility/utility.h" +#include "y_absl/utility/utility.h" #ifdef ABSL_HAVE_ADDRESS_SANITIZER #include <sanitizer/asan_interface.h> @@ -36,7 +36,7 @@ #include <sanitizer/msan_interface.h> #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -55,8 +55,8 @@ void* Allocate(Alloc* alloc, size_t n) { static_assert(Alignment > 0, ""); assert(n && "n must be positive"); using M = AlignedType<Alignment>; - using A = typename y_absl::allocator_traits<Alloc>::template rebind_alloc<M>; - using AT = typename y_absl::allocator_traits<Alloc>::template rebind_traits<M>; + using A = typename y_absl::allocator_traits<Alloc>::template rebind_alloc<M>; + using AT = typename y_absl::allocator_traits<Alloc>::template rebind_traits<M>; // On macOS, "mem_alloc" is a #define with one argument defined in // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it // with the "foo(bar)" syntax. @@ -74,8 +74,8 @@ void Deallocate(Alloc* alloc, void* p, size_t n) { static_assert(Alignment > 0, ""); assert(n && "n must be positive"); using M = AlignedType<Alignment>; - using A = typename y_absl::allocator_traits<Alloc>::template rebind_alloc<M>; - using AT = typename y_absl::allocator_traits<Alloc>::template rebind_traits<M>; + using A = typename y_absl::allocator_traits<Alloc>::template rebind_alloc<M>; + using AT = typename y_absl::allocator_traits<Alloc>::template rebind_traits<M>; // On macOS, "mem_alloc" is a #define with one argument defined in // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it // with the "foo(bar)" syntax. @@ -90,8 +90,8 @@ namespace memory_internal { // specified in the tuple. template <class Alloc, class T, class Tuple, size_t... I> void ConstructFromTupleImpl(Alloc* alloc, T* ptr, Tuple&& t, - y_absl::index_sequence<I...>) { - y_absl::allocator_traits<Alloc>::construct( + y_absl::index_sequence<I...>) { + y_absl::allocator_traits<Alloc>::construct( *alloc, ptr, std::get<I>(std::forward<Tuple>(t))...); } @@ -107,13 +107,13 @@ struct WithConstructedImplF { template <class T, class Tuple, size_t... Is, class F> decltype(std::declval<F>()(std::declval<T>())) WithConstructedImpl( - Tuple&& t, y_absl::index_sequence<Is...>, F&& f) { + Tuple&& t, y_absl::index_sequence<Is...>, F&& f) { return WithConstructedImplF<T, F>{std::forward<F>(f)}( std::get<Is>(std::forward<Tuple>(t))...); } template <class T, size_t... Is> -auto TupleRefImpl(T&& t, y_absl::index_sequence<Is...>) +auto TupleRefImpl(T&& t, y_absl::index_sequence<Is...>) -> decltype(std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...)) { return std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...); } @@ -123,11 +123,11 @@ auto TupleRefImpl(T&& t, y_absl::index_sequence<Is...>) template <class T> auto TupleRef(T&& t) -> decltype( TupleRefImpl(std::forward<T>(t), - y_absl::make_index_sequence< + y_absl::make_index_sequence< std::tuple_size<typename std::decay<T>::type>::value>())) { return TupleRefImpl( std::forward<T>(t), - y_absl::make_index_sequence< + y_absl::make_index_sequence< std::tuple_size<typename std::decay<T>::type>::value>()); } @@ -148,7 +148,7 @@ template <class Alloc, class T, class Tuple> void ConstructFromTuple(Alloc* alloc, T* ptr, Tuple&& t) { memory_internal::ConstructFromTupleImpl( alloc, ptr, std::forward<Tuple>(t), - y_absl::make_index_sequence< + y_absl::make_index_sequence< std::tuple_size<typename std::decay<Tuple>::type>::value>()); } @@ -159,7 +159,7 @@ decltype(std::declval<F>()(std::declval<T>())) WithConstructed( Tuple&& t, F&& f) { return memory_internal::WithConstructedImpl<T>( std::forward<Tuple>(t), - y_absl::make_index_sequence< + y_absl::make_index_sequence< std::tuple_size<typename std::decay<Tuple>::type>::value>(), std::forward<F>(f)); } @@ -381,10 +381,10 @@ struct map_slot_policy { static void construct(Allocator* alloc, slot_type* slot, Args&&... args) { emplace(slot); if (kMutableKeys::value) { - y_absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value, + y_absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value, std::forward<Args>(args)...); } else { - y_absl::allocator_traits<Allocator>::construct(*alloc, &slot->value, + y_absl::allocator_traits<Allocator>::construct(*alloc, &slot->value, std::forward<Args>(args)...); } } @@ -394,10 +394,10 @@ struct map_slot_policy { static void construct(Allocator* alloc, slot_type* slot, slot_type* other) { emplace(slot); if (kMutableKeys::value) { - y_absl::allocator_traits<Allocator>::construct( + y_absl::allocator_traits<Allocator>::construct( *alloc, &slot->mutable_value, std::move(other->mutable_value)); } else { - y_absl::allocator_traits<Allocator>::construct(*alloc, &slot->value, + y_absl::allocator_traits<Allocator>::construct(*alloc, &slot->value, std::move(other->value)); } } @@ -405,9 +405,9 @@ struct map_slot_policy { template <class Allocator> static void destroy(Allocator* alloc, slot_type* slot) { if (kMutableKeys::value) { - y_absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value); + y_absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value); } else { - y_absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value); + y_absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value); } } @@ -416,10 +416,10 @@ struct map_slot_policy { slot_type* old_slot) { emplace(new_slot); if (kMutableKeys::value) { - y_absl::allocator_traits<Allocator>::construct( + y_absl::allocator_traits<Allocator>::construct( *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value)); } else { - y_absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value, + y_absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value, std::move(old_slot->value)); } destroy(alloc, old_slot); @@ -432,11 +432,11 @@ struct map_slot_policy { swap(a->mutable_value, b->mutable_value); } else { value_type tmp = std::move(a->value); - y_absl::allocator_traits<Allocator>::destroy(*alloc, &a->value); - y_absl::allocator_traits<Allocator>::construct(*alloc, &a->value, + y_absl::allocator_traits<Allocator>::destroy(*alloc, &a->value); + y_absl::allocator_traits<Allocator>::construct(*alloc, &a->value, std::move(b->value)); - y_absl::allocator_traits<Allocator>::destroy(*alloc, &b->value); - y_absl::allocator_traits<Allocator>::construct(*alloc, &b->value, + y_absl::allocator_traits<Allocator>::destroy(*alloc, &b->value); + y_absl::allocator_traits<Allocator>::construct(*alloc, &b->value, std::move(tmp)); } } @@ -446,8 +446,8 @@ struct map_slot_policy { if (kMutableKeys::value) { dest->mutable_value = std::move(src->mutable_value); } else { - y_absl::allocator_traits<Allocator>::destroy(*alloc, &dest->value); - y_absl::allocator_traits<Allocator>::construct(*alloc, &dest->value, + y_absl::allocator_traits<Allocator>::destroy(*alloc, &dest->value); + y_absl::allocator_traits<Allocator>::construct(*alloc, &dest->value, std::move(src->value)); } } @@ -455,6 +455,6 @@ struct map_slot_policy { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h index d9ce35a180..c8975dbd90 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h @@ -20,7 +20,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -109,6 +109,6 @@ class CountingAllocator { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h index dd867bed4a..68a18058d1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h @@ -39,7 +39,7 @@ // equal functions are still bound to T. This is important because some type U // can be hashed by/tested for equality differently depending on T. A notable // example is `const char*`. `const char*` is treated as a c-style string when -// the hash function is hash<TString> but as a pointer when the hash +// the hash function is hash<TString> but as a pointer when the hash // function is hash<void*>. // #ifndef ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_ @@ -51,27 +51,27 @@ #include <util/generic/string.h> #include <type_traits> -#include "y_absl/base/config.h" -#include "y_absl/hash/hash.h" +#include "y_absl/base/config.h" +#include "y_absl/hash/hash.h" #include "y_absl/strings/cord.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { -// The hash of an object of type T is computed by using y_absl::Hash. +// The hash of an object of type T is computed by using y_absl::Hash. template <class T, class E = void> struct HashEq { - using Hash = y_absl::Hash<T>; + using Hash = y_absl::Hash<T>; using Eq = std::equal_to<T>; }; struct StringHash { using is_transparent = void; - size_t operator()(y_absl::string_view v) const { - return y_absl::Hash<y_absl::string_view>{}(v); + size_t operator()(y_absl::string_view v) const { + return y_absl::Hash<y_absl::string_view>{}(v); } size_t operator()(const y_absl::Cord& v) const { return y_absl::Hash<y_absl::Cord>{}(v); @@ -101,9 +101,9 @@ struct StringHashEq { }; template <> -struct HashEq<TString> : StringHashEq {}; +struct HashEq<TString> : StringHashEq {}; template <> -struct HashEq<y_absl::string_view> : StringHashEq {}; +struct HashEq<y_absl::string_view> : StringHashEq {}; template <> struct HashEq<y_absl::Cord> : StringHashEq {}; @@ -114,7 +114,7 @@ struct HashEq<T*> { using is_transparent = void; template <class U> size_t operator()(const U& ptr) const { - return y_absl::Hash<const T*>{}(HashEq::ToPtr(ptr)); + return y_absl::Hash<const T*>{}(HashEq::ToPtr(ptr)); } }; struct Eq { @@ -145,19 +145,19 @@ struct HashEq<std::shared_ptr<T>> : HashEq<T*> {}; // This header's visibility is restricted. If you need to access the default // hasher please use the container's ::hasher alias instead. // -// Example: typename Hash = typename y_absl::flat_hash_map<K, V>::hasher +// Example: typename Hash = typename y_absl::flat_hash_map<K, V>::hasher template <class T> using hash_default_hash = typename container_internal::HashEq<T>::Hash; // This header's visibility is restricted. If you need to access the default // key equal please use the container's ::key_equal alias instead. // -// Example: typename Eq = typename y_absl::flat_hash_map<K, V, Hash>::key_equal +// Example: typename Eq = typename y_absl::flat_hash_map<K, V, Hash>::key_equal template <class T> using hash_default_eq = typename container_internal::HashEq<T>::Eq; } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_generator_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_generator_testing.h index 7aa160f26c..79b215465e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_generator_testing.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_generator_testing.h @@ -29,12 +29,12 @@ #include <utility> #include <vector> -#include "y_absl/container/internal/hash_policy_testing.h" -#include "y_absl/memory/memory.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/container/internal/hash_policy_testing.h" +#include "y_absl/memory/memory.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { namespace hash_internal { @@ -44,7 +44,7 @@ template <class Container, class = void> struct IsMap : std::false_type {}; template <class Map> -struct IsMap<Map, y_absl::void_t<typename Map::mapped_type>> : std::true_type {}; +struct IsMap<Map, y_absl::void_t<typename Map::mapped_type>> : std::true_type {}; } // namespace generator_internal @@ -103,19 +103,19 @@ struct Generator<EnumClass> { }; template <> -struct Generator<TString> { - TString operator()() const; +struct Generator<TString> { + TString operator()() const; }; template <> -struct Generator<y_absl::string_view> { - y_absl::string_view operator()() const; +struct Generator<y_absl::string_view> { + y_absl::string_view operator()() const; }; template <> struct Generator<NonStandardLayout> { NonStandardLayout operator()() const { - return NonStandardLayout(Generator<TString>()()); + return NonStandardLayout(Generator<TString>()()); } }; @@ -137,12 +137,12 @@ struct Generator<std::tuple<Ts...>> { template <class T> struct Generator<std::unique_ptr<T>> { std::unique_ptr<T> operator()() const { - return y_absl::make_unique<T>(Generator<T>()()); + return y_absl::make_unique<T>(Generator<T>()()); } }; template <class U> -struct Generator<U, y_absl::void_t<decltype(std::declval<U&>().key()), +struct Generator<U, y_absl::void_t<decltype(std::declval<U&>().key()), decltype(std::declval<U&>().value())>> : Generator<std::pair< typename std::decay<decltype(std::declval<U&>().key())>::type, @@ -177,6 +177,6 @@ struct UniqueGenerator { } // namespace hash_internal } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_testing.h index 024d9670d0..baa367eee6 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_testing.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_testing.h @@ -26,10 +26,10 @@ #include <utility> #include <vector> -#include "y_absl/hash/hash.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/hash/hash.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { namespace hash_testing_internal { @@ -74,7 +74,7 @@ struct WithId { struct NonStandardLayout { NonStandardLayout() {} - explicit NonStandardLayout(TString s) : value(std::move(s)) {} + explicit NonStandardLayout(TString s) : value(std::move(s)) {} virtual ~NonStandardLayout() {} friend bool operator==(const NonStandardLayout& a, @@ -91,20 +91,20 @@ struct NonStandardLayout { return H::combine(std::move(h), v.value); } - TString value; + TString value; }; struct StatefulTestingHash - : y_absl::container_internal::hash_testing_internal::WithId< + : y_absl::container_internal::hash_testing_internal::WithId< StatefulTestingHash> { template <class T> size_t operator()(const T& t) const { - return y_absl::Hash<T>{}(t); + return y_absl::Hash<T>{}(t); } }; struct StatefulTestingEqual - : y_absl::container_internal::hash_testing_internal::WithId< + : y_absl::container_internal::hash_testing_internal::WithId< StatefulTestingEqual> { template <class T, class U> bool operator()(const T& t, const U& u) const { @@ -164,7 +164,7 @@ auto keys(const Set& s) } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl // ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS is false for glibcxx versions // where the unordered containers are missing certain constructors that diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h index fc03816897..33f704fc4b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h @@ -21,9 +21,9 @@ #include <type_traits> #include <utility> -#include "y_absl/meta/type_traits.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -65,7 +65,7 @@ struct hash_policy_traits { struct ConstantIteratorsImpl : std::false_type {}; template <class P> - struct ConstantIteratorsImpl<P, y_absl::void_t<typename P::constant_iterators>> + struct ConstantIteratorsImpl<P, y_absl::void_t<typename P::constant_iterators>> : P::constant_iterators {}; public: @@ -203,6 +203,6 @@ struct hash_policy_traits { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug.h index ddc8fb9543..2be9db2297 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug.h @@ -25,7 +25,7 @@ // well in a different one. // // This library supports std::unordered_{set,map}, dense_hash_{set,map} and -// y_absl::{flat,node,string}_hash_{set,map}. +// y_absl::{flat,node,string}_hash_{set,map}. #ifndef ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_ #define ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_ @@ -35,9 +35,9 @@ #include <type_traits> #include <vector> -#include "y_absl/container/internal/hashtable_debug_hooks.h" +#include "y_absl/container/internal/hashtable_debug_hooks.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -48,7 +48,7 @@ namespace container_internal { template <typename C> size_t GetHashtableDebugNumProbes( const C& c, const typename C::key_type& key) { - return y_absl::container_internal::hashtable_debug_internal:: + return y_absl::container_internal::hashtable_debug_internal:: HashtableDebugAccess<C>::GetNumProbes(c, key); } @@ -60,7 +60,7 @@ std::vector<size_t> GetHashtableDebugNumProbesHistogram(const C& container) { for (auto it = container.begin(); it != container.end(); ++it) { size_t num_probes = GetHashtableDebugNumProbes( container, - y_absl::container_internal::hashtable_debug_internal::GetKey<C>(*it, 0)); + y_absl::container_internal::hashtable_debug_internal::GetKey<C>(*it, 0)); v.resize((std::max)(v.size(), num_probes + 1)); v[num_probes]++; } @@ -91,7 +91,7 @@ HashtableDebugProbeSummary GetHashtableDebugProbeSummary(const C& container) { // and not freed. template <typename C> size_t AllocatedByteSize(const C& c) { - return y_absl::container_internal::hashtable_debug_internal:: + return y_absl::container_internal::hashtable_debug_internal:: HashtableDebugAccess<C>::AllocatedByteSize(c); } @@ -99,12 +99,12 @@ size_t AllocatedByteSize(const C& c) { // and `c.size()` is equal to `num_elements`. template <typename C> size_t LowerBoundAllocatedByteSize(size_t num_elements) { - return y_absl::container_internal::hashtable_debug_internal:: + return y_absl::container_internal::hashtable_debug_internal:: HashtableDebugAccess<C>::LowerBoundAllocatedByteSize(num_elements); } } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug_hooks.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug_hooks.h index 889e10b5a5..ec8c0fd29d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug_hooks.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug_hooks.h @@ -25,7 +25,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { namespace hashtable_debug_internal { @@ -80,6 +80,6 @@ struct HashtableDebugAccess { } // namespace hashtable_debug_internal } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc index e91c70632d..6017ac9bb0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/container/internal/hashtablez_sampler.h" +#include "y_absl/container/internal/hashtablez_sampler.h" #include <atomic> #include <cassert> @@ -20,15 +20,15 @@ #include <functional> #include <limits> -#include "y_absl/base/attributes.h" -#include "y_absl/container/internal/have_sse.h" -#include "y_absl/debugging/stacktrace.h" -#include "y_absl/memory/memory.h" +#include "y_absl/base/attributes.h" +#include "y_absl/container/internal/have_sse.h" +#include "y_absl/debugging/stacktrace.h" +#include "y_absl/memory/memory.h" #include "y_absl/profiling/internal/exponential_biased.h" #include "y_absl/profiling/internal/sample_recorder.h" -#include "y_absl/synchronization/mutex.h" +#include "y_absl/synchronization/mutex.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { constexpr int HashtablezInfo::kMaxStackDepth; @@ -73,11 +73,11 @@ void HashtablezInfo::PrepareForSampling() { hashes_bitwise_xor.store(0, std::memory_order_relaxed); max_reserve.store(0, std::memory_order_relaxed); - create_time = y_absl::Now(); + create_time = y_absl::Now(); // The inliner makes hardcoded skip_count difficult (especially when combined // with LTO). We use the ability to exclude stacks by regex when encoding // instead. - depth = y_absl::GetStackTrace(stack, HashtablezInfo::kMaxStackDepth, + depth = y_absl::GetStackTrace(stack, HashtablezInfo::kMaxStackDepth, /* skip_count= */ 0); } @@ -187,4 +187,4 @@ void SetHashtablezMaxSamples(int32_t max) { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h index c739963ea3..8521ee754a 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h @@ -44,14 +44,14 @@ #include <memory> #include <vector> -#include "y_absl/base/internal/per_thread_tls.h" -#include "y_absl/base/optimization.h" -#include "y_absl/container/internal/have_sse.h" +#include "y_absl/base/internal/per_thread_tls.h" +#include "y_absl/base/optimization.h" +#include "y_absl/container/internal/have_sse.h" #include "y_absl/profiling/internal/sample_recorder.h" -#include "y_absl/synchronization/mutex.h" -#include "y_absl/utility/utility.h" +#include "y_absl/synchronization/mutex.h" +#include "y_absl/utility/utility.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -88,7 +88,7 @@ struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> { // can only read them during `HashtablezSampler::Iterate` which will hold the // lock. static constexpr int kMaxStackDepth = 64; - y_absl::Time create_time; + y_absl::Time create_time; int32_t depth; void* stack[kMaxStackDepth]; size_t inline_element_size; @@ -165,12 +165,12 @@ class HashtablezInfoHandle { HashtablezInfoHandle& operator=(const HashtablezInfoHandle&) = delete; HashtablezInfoHandle(HashtablezInfoHandle&& o) noexcept - : info_(y_absl::exchange(o.info_, nullptr)) {} + : info_(y_absl::exchange(o.info_, nullptr)) {} HashtablezInfoHandle& operator=(HashtablezInfoHandle&& o) noexcept { if (ABSL_PREDICT_FALSE(info_ != nullptr)) { UnsampleSlow(info_); } - info_ = y_absl::exchange(o.info_, nullptr); + info_ = y_absl::exchange(o.info_, nullptr); return *this; } @@ -276,6 +276,6 @@ extern "C" bool ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)(); } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc index 3aa4b3ccfe..79a3122981 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc @@ -12,11 +12,11 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/container/internal/hashtablez_sampler.h" +#include "y_absl/container/internal/hashtablez_sampler.h" -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -28,4 +28,4 @@ extern "C" ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL( } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h index 1efa60e82e..e6488e843e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h @@ -26,13 +26,13 @@ #include <utility> #include "y_absl/base/attributes.h" -#include "y_absl/base/macros.h" -#include "y_absl/container/internal/compressed_tuple.h" -#include "y_absl/memory/memory.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/types/span.h" +#include "y_absl/base/macros.h" +#include "y_absl/container/internal/compressed_tuple.h" +#include "y_absl/memory/memory.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/types/span.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace inlined_vector_internal { @@ -927,6 +927,6 @@ auto Storage<T, N, A>::Swap(Storage* other_storage_ptr) -> void { } // namespace inlined_vector_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h index c2070d2349..4c3f668943 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h @@ -172,10 +172,10 @@ #include <utility> #include "y_absl/base/config.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/strings/str_cat.h" -#include "y_absl/types/span.h" -#include "y_absl/utility/utility.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/strings/str_cat.h" +#include "y_absl/types/span.h" +#include "y_absl/utility/utility.h" #ifdef ABSL_HAVE_ADDRESS_SANITIZER #include <sanitizer/asan_interface.h> @@ -189,7 +189,7 @@ #include <cxxabi.h> #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -250,13 +250,13 @@ struct AlignOf<Aligned<T, N>> { // Does `Ts...` contain `T`? template <class T, class... Ts> -using Contains = y_absl::disjunction<std::is_same<T, Ts>...>; +using Contains = y_absl::disjunction<std::is_same<T, Ts>...>; template <class From, class To> using CopyConst = typename std::conditional<std::is_const<From>::value, const To, To>::type; -// Note: We're not qualifying this with y_absl:: because it doesn't compile under +// Note: We're not qualifying this with y_absl:: because it doesn't compile under // MSVC. template <class T> using SliceType = Span<T>; @@ -292,19 +292,19 @@ constexpr size_t Max(size_t a, size_t b, Ts... rest) { } template <class T> -TString TypeName() { - TString out; +TString TypeName() { + TString out; int status = 0; char* demangled = nullptr; #ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE demangled = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status); #endif if (status == 0 && demangled != nullptr) { // Demangling succeeded. - y_absl::StrAppend(&out, "<", demangled, ">"); + y_absl::StrAppend(&out, "<", demangled, ">"); free(demangled); } else { #if defined(__GXX_RTTI) || defined(_CPPRTTI) - y_absl::StrAppend(&out, "<", typeid(T).name(), ">"); + y_absl::StrAppend(&out, "<", typeid(T).name(), ">"); #endif } return out; @@ -338,11 +338,11 @@ class LayoutImpl; // `Min(sizeof...(Elements), NumSizes + 1)` (the number of arrays for which we // can compute offsets). template <class... Elements, size_t... SizeSeq, size_t... OffsetSeq> -class LayoutImpl<std::tuple<Elements...>, y_absl::index_sequence<SizeSeq...>, - y_absl::index_sequence<OffsetSeq...>> { +class LayoutImpl<std::tuple<Elements...>, y_absl::index_sequence<SizeSeq...>, + y_absl::index_sequence<OffsetSeq...>> { private: static_assert(sizeof...(Elements) > 0, "At least one field is required"); - static_assert(y_absl::conjunction<IsLegalElementType<Elements>...>::value, + static_assert(y_absl::conjunction<IsLegalElementType<Elements>...>::value, "Invalid element type (see IsLegalElementType)"); enum { @@ -643,21 +643,21 @@ class LayoutImpl<std::tuple<Elements...>, y_absl::index_sequence<SizeSeq...>, // be missing (as in the example above). Only fields with known offsets are // described. Type names may differ across platforms: one compiler might // produce "unsigned*" where another produces "unsigned int *". - TString DebugString() const { + TString DebugString() const { const auto offsets = Offsets(); const size_t sizes[] = {SizeOf<ElementType<OffsetSeq>>::value...}; - const TString types[] = { + const TString types[] = { adl_barrier::TypeName<ElementType<OffsetSeq>>()...}; - TString res = y_absl::StrCat("@0", types[0], "(", sizes[0], ")"); + TString res = y_absl::StrCat("@0", types[0], "(", sizes[0], ")"); for (size_t i = 0; i != NumOffsets - 1; ++i) { - y_absl::StrAppend(&res, "[", size_[i], "]; @", offsets[i + 1], types[i + 1], + y_absl::StrAppend(&res, "[", size_[i], "]; @", offsets[i + 1], types[i + 1], "(", sizes[i + 1], ")"); } // NumSizes is a constant that may be zero. Some compilers cannot see that // inside the if statement "size_[NumSizes - 1]" must be valid. int last = static_cast<int>(NumSizes) - 1; if (NumTypes == NumSizes && last >= 0) { - y_absl::StrAppend(&res, "[", size_[last], "]"); + y_absl::StrAppend(&res, "[", size_[last], "]"); } return res; } @@ -669,8 +669,8 @@ class LayoutImpl<std::tuple<Elements...>, y_absl::index_sequence<SizeSeq...>, template <size_t NumSizes, class... Ts> using LayoutType = LayoutImpl< - std::tuple<Ts...>, y_absl::make_index_sequence<NumSizes>, - y_absl::make_index_sequence<adl_barrier::Min(sizeof...(Ts), NumSizes + 1)>>; + std::tuple<Ts...>, y_absl::make_index_sequence<NumSizes>, + y_absl::make_index_sequence<adl_barrier::Min(sizeof...(Ts), NumSizes + 1)>>; } // namespace internal_layout @@ -685,7 +685,7 @@ class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...> { public: static_assert(sizeof...(Ts) > 0, "At least one field is required"); static_assert( - y_absl::conjunction<internal_layout::IsLegalElementType<Ts>...>::value, + y_absl::conjunction<internal_layout::IsLegalElementType<Ts>...>::value, "Invalid element type (see IsLegalElementType)"); // The result type of `Partial()` with `NumSizes` arguments. @@ -721,7 +721,7 @@ class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...> { template <class... Sizes> static constexpr PartialType<sizeof...(Sizes)> Partial(Sizes&&... sizes) { static_assert(sizeof...(Sizes) <= sizeof...(Ts), ""); - return PartialType<sizeof...(Sizes)>(y_absl::forward<Sizes>(sizes)...); + return PartialType<sizeof...(Sizes)>(y_absl::forward<Sizes>(sizes)...); } // Creates a layout with the sizes of all arrays specified. If you know @@ -738,6 +738,6 @@ class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...> { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_LAYOUT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/node_hash_policy.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/node_hash_policy.h index 7d83cf5f60..24d0eaf5ee 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/node_hash_policy.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/node_hash_policy.h @@ -41,7 +41,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -87,6 +87,6 @@ struct node_hash_policy { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_NODE_HASH_POLICY_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_map.h index b523226084..8a0591f581 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_map.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_map.h @@ -19,11 +19,11 @@ #include <type_traits> #include <utility> -#include "y_absl/base/internal/throw_delegate.h" -#include "y_absl/container/internal/container_memory.h" -#include "y_absl/container/internal/raw_hash_set.h" // IWYU pragma: export +#include "y_absl/base/internal/throw_delegate.h" +#include "y_absl/container/internal/container_memory.h" +#include "y_absl/container/internal/raw_hash_set.h" // IWYU pragma: export -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -144,7 +144,7 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> { auto it = this->find(key); if (it == this->end()) { base_internal::ThrowStdOutOfRange( - "y_absl::container_internal::raw_hash_map<>::at"); + "y_absl::container_internal::raw_hash_map<>::at"); } return Policy::value(&*it); } @@ -154,7 +154,7 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> { auto it = this->find(key); if (it == this->end()) { base_internal::ThrowStdOutOfRange( - "y_absl::container_internal::raw_hash_map<>::at"); + "y_absl::container_internal::raw_hash_map<>::at"); } return Policy::value(&*it); } @@ -193,6 +193,6 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc index f5b29c21a4..bf2a15a678 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc @@ -12,14 +12,14 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/container/internal/raw_hash_set.h" +#include "y_absl/container/internal/raw_hash_set.h" #include <atomic> #include <cstddef> -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -64,4 +64,4 @@ template FindInfo find_first_non_full(const ctrl_t*, size_t, size_t); } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h index ac04c9c56f..8f45559b31 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h @@ -113,22 +113,22 @@ #include <type_traits> #include <utility> -#include "y_absl/base/internal/endian.h" +#include "y_absl/base/internal/endian.h" #include "y_absl/base/optimization.h" -#include "y_absl/base/port.h" -#include "y_absl/container/internal/common.h" -#include "y_absl/container/internal/compressed_tuple.h" -#include "y_absl/container/internal/container_memory.h" -#include "y_absl/container/internal/hash_policy_traits.h" -#include "y_absl/container/internal/hashtable_debug_hooks.h" -#include "y_absl/container/internal/hashtablez_sampler.h" -#include "y_absl/container/internal/have_sse.h" -#include "y_absl/memory/memory.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/base/port.h" +#include "y_absl/container/internal/common.h" +#include "y_absl/container/internal/compressed_tuple.h" +#include "y_absl/container/internal/container_memory.h" +#include "y_absl/container/internal/hash_policy_traits.h" +#include "y_absl/container/internal/hashtable_debug_hooks.h" +#include "y_absl/container/internal/hashtablez_sampler.h" +#include "y_absl/container/internal/have_sse.h" +#include "y_absl/memory/memory.h" +#include "y_absl/meta/type_traits.h" #include "y_absl/numeric/bits.h" -#include "y_absl/utility/utility.h" +#include "y_absl/utility/utility.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -182,7 +182,7 @@ struct IsDecomposable : std::false_type {}; template <class Policy, class Hash, class Eq, class... Ts> struct IsDecomposable< - y_absl::void_t<decltype( + y_absl::void_t<decltype( Policy::apply(RequireUsableKey<typename Policy::key_type, Hash, Eq>(), std::declval<Ts>()...))>, Policy, Hash, Eq, Ts...> : std::true_type {}; @@ -694,9 +694,9 @@ class raw_hash_set { using value_type = typename PolicyTraits::value_type; using reference = value_type&; using const_reference = const value_type&; - using pointer = typename y_absl::allocator_traits< + using pointer = typename y_absl::allocator_traits< allocator_type>::template rebind_traits<value_type>::pointer; - using const_pointer = typename y_absl::allocator_traits< + using const_pointer = typename y_absl::allocator_traits< allocator_type>::template rebind_traits<value_type>::const_pointer; // Alias used for heterogeneous lookup functions. @@ -711,10 +711,10 @@ class raw_hash_set { auto KeyTypeCanBeHashed(const Hash& h, const key_type& k) -> decltype(h(k)); auto KeyTypeCanBeEq(const Eq& eq, const key_type& k) -> decltype(eq(k, k)); - using AllocTraits = y_absl::allocator_traits<allocator_type>; - using SlotAlloc = typename y_absl::allocator_traits< + using AllocTraits = y_absl::allocator_traits<allocator_type>; + using SlotAlloc = typename y_absl::allocator_traits< allocator_type>::template rebind_alloc<slot_type>; - using SlotAllocTraits = typename y_absl::allocator_traits< + using SlotAllocTraits = typename y_absl::allocator_traits< allocator_type>::template rebind_traits<slot_type>; static_assert(std::is_lvalue_reference<reference>::value, @@ -734,7 +734,7 @@ class raw_hash_set { // cases. template <class T> using RequiresInsertable = typename std::enable_if< - y_absl::disjunction<std::is_convertible<T, init_type>, + y_absl::disjunction<std::is_convertible<T, init_type>, SameAsElementReference<T>>::value, int>::type; @@ -760,9 +760,9 @@ class raw_hash_set { using iterator_category = std::forward_iterator_tag; using value_type = typename raw_hash_set::value_type; using reference = - y_absl::conditional_t<PolicyTraits::constant_iterators::value, + y_absl::conditional_t<PolicyTraits::constant_iterators::value, const value_type&, value_type&>; - using pointer = y_absl::remove_reference_t<reference>*; + using pointer = y_absl::remove_reference_t<reference>*; using difference_type = typename raw_hash_set::difference_type; iterator() {} @@ -918,20 +918,20 @@ class raw_hash_set { // that accept std::initializer_list<T> and std::initializer_list<init_type>. // This is advantageous for performance. // - // // Turns {"abc", "def"} into std::initializer_list<TString>, then + // // Turns {"abc", "def"} into std::initializer_list<TString>, then // // copies the strings into the set. - // std::unordered_set<TString> s = {"abc", "def"}; + // std::unordered_set<TString> s = {"abc", "def"}; // // // Turns {"abc", "def"} into std::initializer_list<const char*>, then // // copies the strings into the set. - // y_absl::flat_hash_set<TString> s = {"abc", "def"}; + // y_absl::flat_hash_set<TString> s = {"abc", "def"}; // // The same trick is used in insert(). // // The enabler is necessary to prevent this constructor from triggering where // the copy constructor is meant to be called. // - // y_absl::flat_hash_set<int> a, b{a}; + // y_absl::flat_hash_set<int> a, b{a}; // // RequiresNotInit<T> is a workaround for gcc prior to 7.1. template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0> @@ -996,10 +996,10 @@ class raw_hash_set { std::is_nothrow_copy_constructible<hasher>::value&& std::is_nothrow_copy_constructible<key_equal>::value&& std::is_nothrow_copy_constructible<allocator_type>::value) - : ctrl_(y_absl::exchange(that.ctrl_, EmptyGroup())), - slots_(y_absl::exchange(that.slots_, nullptr)), - size_(y_absl::exchange(that.size_, 0)), - capacity_(y_absl::exchange(that.capacity_, 0)), + : ctrl_(y_absl::exchange(that.ctrl_, EmptyGroup())), + slots_(y_absl::exchange(that.slots_, nullptr)), + size_(y_absl::exchange(that.size_, 0)), + capacity_(y_absl::exchange(that.capacity_, 0)), // Hash, equality and allocator are copied instead of moved because // `that` must be left valid. If Hash is std::function<Key>, moving it // would create a nullptr functor that cannot be called. @@ -1039,7 +1039,7 @@ class raw_hash_set { } raw_hash_set& operator=(raw_hash_set&& that) noexcept( - y_absl::allocator_traits<allocator_type>::is_always_equal::value&& + y_absl::allocator_traits<allocator_type>::is_always_equal::value&& std::is_nothrow_move_assignable<hasher>::value&& std::is_nothrow_move_assignable<key_equal>::value) { // TODO(sbenza): We should only use the operations from the noexcept clause @@ -1099,7 +1099,7 @@ class raw_hash_set { // This overload kicks in when the argument is an rvalue of insertable and // decomposable type other than init_type. // - // flat_hash_map<TString, int> m; + // flat_hash_map<TString, int> m; // m.insert(std::make_pair("abc", 42)); // TODO(cheshire): A type alias T2 is introduced as a workaround for the nvcc // bug. @@ -1118,7 +1118,7 @@ class raw_hash_set { // flat_hash_set<int> s; // s.insert(n); // - // flat_hash_set<TString> s; + // flat_hash_set<TString> s; // const char* p = "hello"; // s.insert(p); // @@ -1135,7 +1135,7 @@ class raw_hash_set { // This overload kicks in when the argument is an rvalue of init_type. Its // purpose is to handle brace-init-list arguments. // - // flat_hash_map<TString, int> s; + // flat_hash_map<TString, int> s; // s.insert({"abc", 42}); std::pair<iterator, bool> insert(init_type&& value) { return emplace(std::move(value)); @@ -1204,8 +1204,8 @@ class raw_hash_set { // // For example: // - // flat_hash_map<TString, TString> m = {{"abc", "def"}}; - // // Creates no TString copies and makes no heap allocations. + // flat_hash_map<TString, TString> m = {{"abc", "def"}}; + // // Creates no TString copies and makes no heap allocations. // m.emplace("abc", "xyz"); template <class... Args, typename std::enable_if< IsDecomposable<Args...>::value, int>::type = 0> @@ -1291,12 +1291,12 @@ class raw_hash_set { // Extension API: support for heterogeneous keys. // - // std::unordered_set<TString> s; - // // Turns "abc" into TString. + // std::unordered_set<TString> s; + // // Turns "abc" into TString. // s.erase("abc"); // - // flat_hash_set<TString> s; - // // Uses "abc" directly without copying it into TString. + // flat_hash_set<TString> s; + // // Uses "abc" directly without copying it into TString. // s.erase("abc"); template <class K = key_type> size_type erase(const key_arg<K>& key) { @@ -1425,12 +1425,12 @@ class raw_hash_set { // Extension API: support for heterogeneous keys. // - // std::unordered_set<TString> s; - // // Turns "abc" into TString. + // std::unordered_set<TString> s; + // // Turns "abc" into TString. // s.count("abc"); // - // ch_set<TString> s; - // // Uses "abc" directly without copying it into TString. + // ch_set<TString> s; + // // Uses "abc" directly without copying it into TString. // s.count("abc"); template <class K = key_type> size_t count(const key_arg<K>& key) const { @@ -1545,7 +1545,7 @@ class raw_hash_set { private: template <class Container, typename Enabler> - friend struct y_absl::container_internal::hashtable_debug_internal:: + friend struct y_absl::container_internal::hashtable_debug_internal:: HashtableDebugAccess; struct FindElement { @@ -1970,7 +1970,7 @@ void EraseIf(Predicate& pred, raw_hash_set<P, H, E, A>* c) { namespace hashtable_debug_internal { template <typename Set> -struct HashtableDebugAccess<Set, y_absl::void_t<typename Set::raw_hash_set>> { +struct HashtableDebugAccess<Set, y_absl::void_t<typename Set::raw_hash_set>> { using Traits = typename Set::PolicyTraits; using Slot = typename Traits::slot_type; @@ -2029,6 +2029,6 @@ struct HashtableDebugAccess<Set, y_absl::void_t<typename Set::raw_hash_set>> { } // namespace hashtable_debug_internal } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_RAW_HASH_SET_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set/ya.make index a7b0814eed..d636929b87 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set/ya.make @@ -12,28 +12,28 @@ OWNER( LICENSE(Apache-2.0) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/absl_hashtablez_sampler - contrib/restricted/abseil-cpp-tstring/y_absl/debugging - contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace - contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize - contrib/restricted/abseil-cpp-tstring/y_absl/demangle + contrib/restricted/abseil-cpp-tstring/y_absl/debugging + contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace + contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize + contrib/restricted/abseil-cpp-tstring/y_absl/demangle contrib/restricted/abseil-cpp-tstring/y_absl/hash - contrib/restricted/abseil-cpp-tstring/y_absl/numeric + contrib/restricted/abseil-cpp-tstring/y_absl/numeric contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased - contrib/restricted/abseil-cpp-tstring/y_absl/strings + contrib/restricted/abseil-cpp-tstring/y_absl/strings contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal - contrib/restricted/abseil-cpp-tstring/y_absl/synchronization - contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal - contrib/restricted/abseil-cpp-tstring/y_absl/time - contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time - contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone - contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access + contrib/restricted/abseil-cpp-tstring/y_absl/synchronization + contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal + contrib/restricted/abseil-cpp-tstring/y_absl/time + contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time + contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone + contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access contrib/restricted/abseil-cpp-tstring/y_absl/types ) diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/test_instance_tracker.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/test_instance_tracker.h index 192f61c5bb..49dcaf5d21 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/test_instance_tracker.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/test_instance_tracker.h @@ -18,9 +18,9 @@ #include <cstdlib> #include <ostream> -#include "y_absl/types/compare.h" +#include "y_absl/types/compare.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace test_internal { @@ -99,12 +99,12 @@ class BaseCountedInstance { return value_ >= x.value_; } - y_absl::weak_ordering compare(const BaseCountedInstance& x) const { + y_absl::weak_ordering compare(const BaseCountedInstance& x) const { ++num_comparisons_; return value_ < x.value_ - ? y_absl::weak_ordering::less - : value_ == x.value_ ? y_absl::weak_ordering::equivalent - : y_absl::weak_ordering::greater; + ? y_absl::weak_ordering::less + : value_ == x.value_ ? y_absl::weak_ordering::equivalent + : y_absl::weak_ordering::greater; } int value() const { @@ -269,6 +269,6 @@ class MovableOnlyInstance : public BaseCountedInstance { } // namespace test_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/tracked.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/tracked.h index cafd451fbf..8765ee5ea6 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/tracked.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/tracked.h @@ -22,7 +22,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -78,6 +78,6 @@ class Tracked { } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_TRACKED_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h index f3258b429a..f55d6293ae 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h @@ -21,10 +21,10 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "y_absl/container/internal/hash_generator_testing.h" -#include "y_absl/container/internal/hash_policy_testing.h" +#include "y_absl/container/internal/hash_generator_testing.h" +#include "y_absl/container/internal/hash_policy_testing.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -99,7 +99,7 @@ using has_cxx14_std_apis = std::false_type; template <typename T> using expect_cxx14_apis = - y_absl::disjunction<y_absl::negation<is_std_unordered_map<T>>, + y_absl::disjunction<y_absl::negation<is_std_unordered_map<T>>, has_cxx14_std_apis>; template <typename TypeParam> @@ -149,7 +149,7 @@ using has_alloc_std_constructors = std::false_type; template <typename T> using expect_alloc_constructors = - y_absl::disjunction<y_absl::negation<is_std_unordered_map<T>>, + y_absl::disjunction<y_absl::negation<is_std_unordered_map<T>>, has_alloc_std_constructors>; template <typename TypeParam> @@ -489,6 +489,6 @@ REGISTER_TYPED_TEST_CASE_P( } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_lookup_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_lookup_test.h index f47958b2f1..251f49aea2 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_lookup_test.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_lookup_test.h @@ -17,10 +17,10 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "y_absl/container/internal/hash_generator_testing.h" -#include "y_absl/container/internal/hash_policy_testing.h" +#include "y_absl/container/internal/hash_generator_testing.h" +#include "y_absl/container/internal/hash_policy_testing.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -112,6 +112,6 @@ REGISTER_TYPED_TEST_CASE_P(LookupTest, At, OperatorBracket, Count, Find, } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_members_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_members_test.h index 080d1fe954..1c9dc8c6be 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_members_test.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_members_test.h @@ -18,9 +18,9 @@ #include <type_traits> #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -36,10 +36,10 @@ TYPED_TEST_P(MembersTest, Typedefs) { EXPECT_TRUE((std::is_same<std::pair<const typename TypeParam::key_type, typename TypeParam::mapped_type>, typename TypeParam::value_type>())); - EXPECT_TRUE((y_absl::conjunction< - y_absl::negation<std::is_signed<typename TypeParam::size_type>>, + EXPECT_TRUE((y_absl::conjunction< + y_absl::negation<std::is_signed<typename TypeParam::size_type>>, std::is_integral<typename TypeParam::size_type>>())); - EXPECT_TRUE((y_absl::conjunction< + EXPECT_TRUE((y_absl::conjunction< std::is_signed<typename TypeParam::difference_type>, std::is_integral<typename TypeParam::difference_type>>())); EXPECT_TRUE((std::is_convertible< @@ -82,6 +82,6 @@ REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd); } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h index 65f1d4a5b8..725cfdc345 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h @@ -19,10 +19,10 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "y_absl/container/internal/hash_generator_testing.h" -#include "y_absl/container/internal/hash_policy_testing.h" +#include "y_absl/container/internal/hash_generator_testing.h" +#include "y_absl/container/internal/hash_policy_testing.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -346,6 +346,6 @@ REGISTER_TYPED_TEST_SUITE_P(UniquePtrModifiersTest, TryEmplace); } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_constructor_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_constructor_test.h index 8dff59c546..1404f44916 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_constructor_test.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_constructor_test.h @@ -21,11 +21,11 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "y_absl/container/internal/hash_generator_testing.h" -#include "y_absl/container/internal/hash_policy_testing.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/container/internal/hash_generator_testing.h" +#include "y_absl/container/internal/hash_policy_testing.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -108,7 +108,7 @@ using has_cxx14_std_apis = std::false_type; template <typename T> using expect_cxx14_apis = - y_absl::disjunction<y_absl::negation<is_std_unordered_set<T>>, + y_absl::disjunction<y_absl::negation<is_std_unordered_set<T>>, has_cxx14_std_apis>; template <typename TypeParam> @@ -158,7 +158,7 @@ using has_alloc_std_constructors = std::false_type; template <typename T> using expect_alloc_constructors = - y_absl::disjunction<y_absl::negation<is_std_unordered_set<T>>, + y_absl::disjunction<y_absl::negation<is_std_unordered_set<T>>, has_alloc_std_constructors>; template <typename TypeParam> @@ -491,6 +491,6 @@ REGISTER_TYPED_TEST_CASE_P( } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_lookup_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_lookup_test.h index 6eda801538..05579173d1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_lookup_test.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_lookup_test.h @@ -17,10 +17,10 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "y_absl/container/internal/hash_generator_testing.h" -#include "y_absl/container/internal/hash_policy_testing.h" +#include "y_absl/container/internal/hash_generator_testing.h" +#include "y_absl/container/internal/hash_policy_testing.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -86,6 +86,6 @@ REGISTER_TYPED_TEST_CASE_P(LookupTest, Count, Find, EqualRange); } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_members_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_members_test.h index 9e1d20db10..ad1c88d8b2 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_members_test.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_members_test.h @@ -18,9 +18,9 @@ #include <type_traits> #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -35,10 +35,10 @@ void UseType() {} TYPED_TEST_P(MembersTest, Typedefs) { EXPECT_TRUE((std::is_same<typename TypeParam::key_type, typename TypeParam::value_type>())); - EXPECT_TRUE((y_absl::conjunction< - y_absl::negation<std::is_signed<typename TypeParam::size_type>>, + EXPECT_TRUE((y_absl::conjunction< + y_absl::negation<std::is_signed<typename TypeParam::size_type>>, std::is_integral<typename TypeParam::size_type>>())); - EXPECT_TRUE((y_absl::conjunction< + EXPECT_TRUE((y_absl::conjunction< std::is_signed<typename TypeParam::difference_type>, std::is_integral<typename TypeParam::difference_type>>())); EXPECT_TRUE((std::is_convertible< @@ -81,6 +81,6 @@ REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd); } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_modifiers_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_modifiers_test.h index d895c138d7..2f96a0197b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_modifiers_test.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_modifiers_test.h @@ -17,10 +17,10 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "y_absl/container/internal/hash_generator_testing.h" -#include "y_absl/container/internal/hash_policy_testing.h" +#include "y_absl/container/internal/hash_generator_testing.h" +#include "y_absl/container/internal/hash_policy_testing.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { @@ -216,6 +216,6 @@ REGISTER_TYPED_TEST_CASE_P(ModifiersTest, Clear, Insert, InsertHint, } // namespace container_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h index 8ff7775b99..07e26def79 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h @@ -16,7 +16,7 @@ // File: node_hash_map.h // ----------------------------------------------------------------------------- // -// An `y_absl::node_hash_map<K, V>` is an unordered associative container of +// An `y_absl::node_hash_map<K, V>` is an unordered associative container of // unique keys and associated values designed to be a more efficient replacement // for `std::unordered_map`. Like `unordered_map`, search, insertion, and // deletion of map elements can be done as an `O(1)` operation. However, @@ -40,14 +40,14 @@ #include <type_traits> #include <utility> -#include "y_absl/algorithm/container.h" -#include "y_absl/container/internal/container_memory.h" -#include "y_absl/container/internal/hash_function_defaults.h" // IWYU pragma: export -#include "y_absl/container/internal/node_hash_policy.h" -#include "y_absl/container/internal/raw_hash_map.h" // IWYU pragma: export -#include "y_absl/memory/memory.h" +#include "y_absl/algorithm/container.h" +#include "y_absl/container/internal/container_memory.h" +#include "y_absl/container/internal/hash_function_defaults.h" // IWYU pragma: export +#include "y_absl/container/internal/node_hash_policy.h" +#include "y_absl/container/internal/raw_hash_map.h" // IWYU pragma: export +#include "y_absl/memory/memory.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { template <class Key, class Value> @@ -55,10 +55,10 @@ class NodeHashMapPolicy; } // namespace container_internal // ----------------------------------------------------------------------------- -// y_absl::node_hash_map +// y_absl::node_hash_map // ----------------------------------------------------------------------------- // -// An `y_absl::node_hash_map<K, V>` is an unordered associative container which +// An `y_absl::node_hash_map<K, V>` is an unordered associative container which // has been optimized for both speed and memory footprint in most common use // cases. Its interface is similar to that of `std::unordered_map<K, V>` with // the following notable differences: @@ -70,17 +70,17 @@ class NodeHashMapPolicy; // slots (open, deleted, and empty) within the hash map. // * Returns `void` from the `erase(iterator)` overload. // -// By default, `node_hash_map` uses the `y_absl::Hash` hashing framework. -// All fundamental and Abseil types that support the `y_absl::Hash` framework have +// By default, `node_hash_map` uses the `y_absl::Hash` hashing framework. +// All fundamental and Abseil types that support the `y_absl::Hash` framework have // a compatible equality operator for comparing insertions into `node_hash_map`. -// If your type is not yet supported by the `y_absl::Hash` framework, see -// y_absl/hash/hash.h for information on extending Abseil hashing to user-defined +// If your type is not yet supported by the `y_absl::Hash` framework, see +// y_absl/hash/hash.h for information on extending Abseil hashing to user-defined // types. // // Example: // // // Create a node hash map of three strings (that map to strings) -// y_absl::node_hash_map<TString, TString> ducks = +// y_absl::node_hash_map<TString, TString> ducks = // {{"a", "huey"}, {"b", "dewey"}, {"c", "louie"}}; // // // Insert a new element into the node hash map @@ -90,18 +90,18 @@ class NodeHashMapPolicy; // ducks.rehash(0); // // // Find the element with the key "b" -// TString search_key = "b"; +// TString search_key = "b"; // auto result = ducks.find(search_key); // if (result != ducks.end()) { // std::cout << "Result: " << result->second << std::endl; // } template <class Key, class Value, - class Hash = y_absl::container_internal::hash_default_hash<Key>, - class Eq = y_absl::container_internal::hash_default_eq<Key>, + class Hash = y_absl::container_internal::hash_default_hash<Key>, + class Eq = y_absl::container_internal::hash_default_eq<Key>, class Alloc = std::allocator<std::pair<const Key, Value>>> class node_hash_map - : public y_absl::container_internal::raw_hash_map< - y_absl::container_internal::NodeHashMapPolicy<Key, Value>, Hash, Eq, + : public y_absl::container_internal::raw_hash_map< + y_absl::container_internal::NodeHashMapPolicy<Key, Value>, Hash, Eq, Alloc> { using Base = typename node_hash_map::raw_hash_map; @@ -114,38 +114,38 @@ class node_hash_map // * Default constructor // // // No allocation for the table's elements is made. - // y_absl::node_hash_map<int, TString> map1; + // y_absl::node_hash_map<int, TString> map1; // // * Initializer List constructor // - // y_absl::node_hash_map<int, TString> map2 = + // y_absl::node_hash_map<int, TString> map2 = // {{1, "huey"}, {2, "dewey"}, {3, "louie"},}; // // * Copy constructor // - // y_absl::node_hash_map<int, TString> map3(map2); + // y_absl::node_hash_map<int, TString> map3(map2); // // * Copy assignment operator // // // Hash functor and Comparator are copied as well - // y_absl::node_hash_map<int, TString> map4; + // y_absl::node_hash_map<int, TString> map4; // map4 = map3; // // * Move constructor // // // Move is guaranteed efficient - // y_absl::node_hash_map<int, TString> map5(std::move(map4)); + // y_absl::node_hash_map<int, TString> map5(std::move(map4)); // // * Move assignment operator // // // May be efficient if allocators are compatible - // y_absl::node_hash_map<int, TString> map6; + // y_absl::node_hash_map<int, TString> map6; // map6 = std::move(map5); // // * Range constructor // - // std::vector<std::pair<int, TString>> v = {{1, "a"}, {2, "b"}}; - // y_absl::node_hash_map<int, TString> map7(v.begin(), v.end()); + // std::vector<std::pair<int, TString>> v = {{1, "a"}, {2, "b"}}; + // y_absl::node_hash_map<int, TString> map7(v.begin(), v.end()); node_hash_map() {} using Base::Base; @@ -174,7 +174,7 @@ class node_hash_map // Returns the number of element slots (assigned, deleted, and empty) // available within the `node_hash_map`. // - // NOTE: this member function is particular to `y_absl::node_hash_map` and is + // NOTE: this member function is particular to `y_absl::node_hash_map` and is // not provided in the `std::unordered_map` API. using Base::capacity; @@ -535,7 +535,7 @@ namespace container_internal { template <class Key, class Value> class NodeHashMapPolicy - : public y_absl::container_internal::node_hash_policy< + : public y_absl::container_internal::node_hash_policy< std::pair<const Key, Value>&, NodeHashMapPolicy<Key, Value>> { using value_type = std::pair<const Key, Value>; @@ -546,30 +546,30 @@ class NodeHashMapPolicy template <class Allocator, class... Args> static value_type* new_element(Allocator* alloc, Args&&... args) { - using PairAlloc = typename y_absl::allocator_traits< + using PairAlloc = typename y_absl::allocator_traits< Allocator>::template rebind_alloc<value_type>; PairAlloc pair_alloc(*alloc); value_type* res = - y_absl::allocator_traits<PairAlloc>::allocate(pair_alloc, 1); - y_absl::allocator_traits<PairAlloc>::construct(pair_alloc, res, + y_absl::allocator_traits<PairAlloc>::allocate(pair_alloc, 1); + y_absl::allocator_traits<PairAlloc>::construct(pair_alloc, res, std::forward<Args>(args)...); return res; } template <class Allocator> static void delete_element(Allocator* alloc, value_type* pair) { - using PairAlloc = typename y_absl::allocator_traits< + using PairAlloc = typename y_absl::allocator_traits< Allocator>::template rebind_alloc<value_type>; PairAlloc pair_alloc(*alloc); - y_absl::allocator_traits<PairAlloc>::destroy(pair_alloc, pair); - y_absl::allocator_traits<PairAlloc>::deallocate(pair_alloc, pair, 1); + y_absl::allocator_traits<PairAlloc>::destroy(pair_alloc, pair); + y_absl::allocator_traits<PairAlloc>::deallocate(pair_alloc, pair, 1); } template <class F, class... Args> - static decltype(y_absl::container_internal::DecomposePair( + static decltype(y_absl::container_internal::DecomposePair( std::declval<F>(), std::declval<Args>()...)) apply(F&& f, Args&&... args) { - return y_absl::container_internal::DecomposePair(std::forward<F>(f), + return y_absl::container_internal::DecomposePair(std::forward<F>(f), std::forward<Args>(args)...); } @@ -584,14 +584,14 @@ class NodeHashMapPolicy namespace container_algorithm_internal { -// Specialization of trait in y_absl/algorithm/container.h +// Specialization of trait in y_absl/algorithm/container.h template <class Key, class T, class Hash, class KeyEqual, class Allocator> struct IsUnorderedContainer< - y_absl::node_hash_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {}; + y_absl::node_hash_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {}; } // namespace container_algorithm_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_NODE_HASH_MAP_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h index 2561cfb7d8..aa98bb29b8 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h @@ -16,7 +16,7 @@ // File: node_hash_set.h // ----------------------------------------------------------------------------- // -// An `y_absl::node_hash_set<T>` is an unordered associative container designed to +// An `y_absl::node_hash_set<T>` is an unordered associative container designed to // be a more efficient replacement for `std::unordered_set`. Like // `unordered_set`, search, insertion, and deletion of set elements can be done // as an `O(1)` operation. However, `node_hash_set` (and other unordered @@ -37,13 +37,13 @@ #include <type_traits> -#include "y_absl/algorithm/container.h" -#include "y_absl/container/internal/hash_function_defaults.h" // IWYU pragma: export -#include "y_absl/container/internal/node_hash_policy.h" -#include "y_absl/container/internal/raw_hash_set.h" // IWYU pragma: export -#include "y_absl/memory/memory.h" +#include "y_absl/algorithm/container.h" +#include "y_absl/container/internal/hash_function_defaults.h" // IWYU pragma: export +#include "y_absl/container/internal/node_hash_policy.h" +#include "y_absl/container/internal/raw_hash_set.h" // IWYU pragma: export +#include "y_absl/memory/memory.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace container_internal { template <typename T> @@ -51,10 +51,10 @@ struct NodeHashSetPolicy; } // namespace container_internal // ----------------------------------------------------------------------------- -// y_absl::node_hash_set +// y_absl::node_hash_set // ----------------------------------------------------------------------------- // -// An `y_absl::node_hash_set<T>` is an unordered associative container which +// An `y_absl::node_hash_set<T>` is an unordered associative container which // has been optimized for both speed and memory footprint in most common use // cases. Its interface is similar to that of `std::unordered_set<T>` with the // following notable differences: @@ -66,11 +66,11 @@ struct NodeHashSetPolicy; // slots (open, deleted, and empty) within the hash set. // * Returns `void` from the `erase(iterator)` overload. // -// By default, `node_hash_set` uses the `y_absl::Hash` hashing framework. -// All fundamental and Abseil types that support the `y_absl::Hash` framework have +// By default, `node_hash_set` uses the `y_absl::Hash` hashing framework. +// All fundamental and Abseil types that support the `y_absl::Hash` framework have // a compatible equality operator for comparing insertions into `node_hash_set`. -// If your type is not yet supported by the `y_absl::Hash` framework, see -// y_absl/hash/hash.h for information on extending Abseil hashing to user-defined +// If your type is not yet supported by the `y_absl::Hash` framework, see +// y_absl/hash/hash.h for information on extending Abseil hashing to user-defined // types. // // Example: @@ -89,12 +89,12 @@ struct NodeHashSetPolicy; // if (ducks.contains("dewey")) { // std::cout << "We found dewey!" << std::endl; // } -template <class T, class Hash = y_absl::container_internal::hash_default_hash<T>, - class Eq = y_absl::container_internal::hash_default_eq<T>, +template <class T, class Hash = y_absl::container_internal::hash_default_hash<T>, + class Eq = y_absl::container_internal::hash_default_eq<T>, class Alloc = std::allocator<T>> class node_hash_set - : public y_absl::container_internal::raw_hash_set< - y_absl::container_internal::NodeHashSetPolicy<T>, Hash, Eq, Alloc> { + : public y_absl::container_internal::raw_hash_set< + y_absl::container_internal::NodeHashSetPolicy<T>, Hash, Eq, Alloc> { using Base = typename node_hash_set::raw_hash_set; public: @@ -106,38 +106,38 @@ class node_hash_set // * Default constructor // // // No allocation for the table's elements is made. - // y_absl::node_hash_set<TString> set1; + // y_absl::node_hash_set<TString> set1; // // * Initializer List constructor // - // y_absl::node_hash_set<TString> set2 = + // y_absl::node_hash_set<TString> set2 = // {{"huey"}, {"dewey"}, {"louie"}}; // // * Copy constructor // - // y_absl::node_hash_set<TString> set3(set2); + // y_absl::node_hash_set<TString> set3(set2); // // * Copy assignment operator // // // Hash functor and Comparator are copied as well - // y_absl::node_hash_set<TString> set4; + // y_absl::node_hash_set<TString> set4; // set4 = set3; // // * Move constructor // // // Move is guaranteed efficient - // y_absl::node_hash_set<TString> set5(std::move(set4)); + // y_absl::node_hash_set<TString> set5(std::move(set4)); // // * Move assignment operator // // // May be efficient if allocators are compatible - // y_absl::node_hash_set<TString> set6; + // y_absl::node_hash_set<TString> set6; // set6 = std::move(set5); // // * Range constructor // - // std::vector<TString> v = {"a", "b"}; - // y_absl::node_hash_set<TString> set7(v.begin(), v.end()); + // std::vector<TString> v = {"a", "b"}; + // y_absl::node_hash_set<TString> set7(v.begin(), v.end()); node_hash_set() {} using Base::Base; @@ -166,7 +166,7 @@ class node_hash_set // Returns the number of element slots (assigned, deleted, and empty) // available within the `node_hash_set`. // - // NOTE: this member function is particular to `y_absl::node_hash_set` and is + // NOTE: this member function is particular to `y_absl::node_hash_set` and is // not provided in the `std::unordered_set` API. using Base::capacity; @@ -442,7 +442,7 @@ namespace container_internal { template <class T> struct NodeHashSetPolicy - : y_absl::container_internal::node_hash_policy<T&, NodeHashSetPolicy<T>> { + : y_absl::container_internal::node_hash_policy<T&, NodeHashSetPolicy<T>> { using key_type = T; using init_type = T; using constant_iterators = std::true_type; @@ -450,10 +450,10 @@ struct NodeHashSetPolicy template <class Allocator, class... Args> static T* new_element(Allocator* alloc, Args&&... args) { using ValueAlloc = - typename y_absl::allocator_traits<Allocator>::template rebind_alloc<T>; + typename y_absl::allocator_traits<Allocator>::template rebind_alloc<T>; ValueAlloc value_alloc(*alloc); - T* res = y_absl::allocator_traits<ValueAlloc>::allocate(value_alloc, 1); - y_absl::allocator_traits<ValueAlloc>::construct(value_alloc, res, + T* res = y_absl::allocator_traits<ValueAlloc>::allocate(value_alloc, 1); + y_absl::allocator_traits<ValueAlloc>::construct(value_alloc, res, std::forward<Args>(args)...); return res; } @@ -461,17 +461,17 @@ struct NodeHashSetPolicy template <class Allocator> static void delete_element(Allocator* alloc, T* elem) { using ValueAlloc = - typename y_absl::allocator_traits<Allocator>::template rebind_alloc<T>; + typename y_absl::allocator_traits<Allocator>::template rebind_alloc<T>; ValueAlloc value_alloc(*alloc); - y_absl::allocator_traits<ValueAlloc>::destroy(value_alloc, elem); - y_absl::allocator_traits<ValueAlloc>::deallocate(value_alloc, elem, 1); + y_absl::allocator_traits<ValueAlloc>::destroy(value_alloc, elem); + y_absl::allocator_traits<ValueAlloc>::deallocate(value_alloc, elem, 1); } template <class F, class... Args> - static decltype(y_absl::container_internal::DecomposeValue( + static decltype(y_absl::container_internal::DecomposeValue( std::declval<F>(), std::declval<Args>()...)) apply(F&& f, Args&&... args) { - return y_absl::container_internal::DecomposeValue( + return y_absl::container_internal::DecomposeValue( std::forward<F>(f), std::forward<Args>(args)...); } @@ -481,13 +481,13 @@ struct NodeHashSetPolicy namespace container_algorithm_internal { -// Specialization of trait in y_absl/algorithm/container.h +// Specialization of trait in y_absl/algorithm/container.h template <class Key, class Hash, class KeyEqual, class Allocator> -struct IsUnorderedContainer<y_absl::node_hash_set<Key, Hash, KeyEqual, Allocator>> +struct IsUnorderedContainer<y_absl::node_hash_set<Key, Hash, KeyEqual, Allocator>> : std::true_type {}; } // namespace container_algorithm_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_CONTAINER_NODE_HASH_SET_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc index 02bf678650..fa6e30f935 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc @@ -14,9 +14,9 @@ // limitations under the License. // -#include "y_absl/debugging/failure_signal_handler.h" +#include "y_absl/debugging/failure_signal_handler.h" -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" #ifdef _WIN32 #include <windows.h> @@ -41,12 +41,12 @@ #include <cstring> #include <ctime> -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" #include "y_absl/base/internal/errno_saver.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/sysinfo.h" -#include "y_absl/debugging/internal/examine_stack.h" -#include "y_absl/debugging/stacktrace.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/sysinfo.h" +#include "y_absl/debugging/internal/examine_stack.h" +#include "y_absl/debugging/stacktrace.h" #ifndef _WIN32 #define ABSL_HAVE_SIGACTION @@ -57,7 +57,7 @@ #endif #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN ABSL_CONST_INIT static FailureSignalHandlerOptions fsh_options; @@ -218,7 +218,7 @@ static void InstallOneFailureHandler(FailureSignalData* data, static void WriteToStderr(const char* data) { y_absl::base_internal::ErrnoSaver errno_saver; - y_absl::raw_logging_internal::SafeWriteToStderr(data, strlen(data)); + y_absl::raw_logging_internal::SafeWriteToStderr(data, strlen(data)); } static void WriteSignalMessage(int signo, int cpu, @@ -248,7 +248,7 @@ struct WriterFnStruct { void (*writerfn)(const char*); }; -// Many of the y_absl::debugging_internal::Dump* functions in +// Many of the y_absl::debugging_internal::Dump* functions in // examine_stack.h take a writer function pointer that has a void* arg // for historical reasons. failure_signal_handler_writer only takes a // data pointer. This function converts between these types. @@ -266,12 +266,12 @@ ABSL_ATTRIBUTE_NOINLINE static void WriteStackTrace( void* stack[kNumStackFrames]; int frame_sizes[kNumStackFrames]; int min_dropped_frames; - int depth = y_absl::GetStackFramesWithContext( + int depth = y_absl::GetStackFramesWithContext( stack, frame_sizes, kNumStackFrames, 1, // Do not include this function in stack trace. ucontext, &min_dropped_frames); - y_absl::debugging_internal::DumpPCAndFrameSizesAndStackTrace( - y_absl::debugging_internal::GetProgramCounter(ucontext), stack, frame_sizes, + y_absl::debugging_internal::DumpPCAndFrameSizesAndStackTrace( + y_absl::debugging_internal::GetProgramCounter(ucontext), stack, frame_sizes, depth, min_dropped_frames, symbolize_stacktrace, writerfn, writerfn_arg); } @@ -286,7 +286,7 @@ static void WriteFailureInfo(int signo, void* ucontext, int cpu, &writerfn_struct); } -// y_absl::SleepFor() can't be used here since AbslInternalSleepFor() +// y_absl::SleepFor() can't be used here since AbslInternalSleepFor() // may be overridden to do something that isn't async-signal-safe on // some platforms. static void PortableSleepForSeconds(int seconds) { @@ -311,9 +311,9 @@ static void ImmediateAbortSignalHandler(int) { } #endif -// y_absl::base_internal::GetTID() returns pid_t on most platforms, but -// returns y_absl::base_internal::pid_t on Windows. -using GetTidType = decltype(y_absl::base_internal::GetTID()); +// y_absl::base_internal::GetTID() returns pid_t on most platforms, but +// returns y_absl::base_internal::pid_t on Windows. +using GetTidType = decltype(y_absl::base_internal::GetTID()); ABSL_CONST_INIT static std::atomic<GetTidType> failed_tid(0); #ifndef ABSL_HAVE_SIGACTION @@ -323,7 +323,7 @@ static void AbslFailureSignalHandler(int signo) { static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) { #endif - const GetTidType this_tid = y_absl::base_internal::GetTID(); + const GetTidType this_tid = y_absl::base_internal::GetTID(); GetTidType previous_failed_tid = 0; if (!failed_tid.compare_exchange_strong( previous_failed_tid, static_cast<intptr_t>(this_tid), @@ -331,7 +331,7 @@ static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) { ABSL_RAW_LOG( ERROR, "Signal %d raised at PC=%p while already in AbslFailureSignalHandler()", - signo, y_absl::debugging_internal::GetProgramCounter(ucontext)); + signo, y_absl::debugging_internal::GetProgramCounter(ucontext)); if (this_tid != previous_failed_tid) { // Another thread is already in AbslFailureSignalHandler(), so wait // a bit for it to finish. If the other thread doesn't kill us, @@ -385,4 +385,4 @@ void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h index cb6db66d88..879df3c434 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h @@ -19,15 +19,15 @@ // This file configures the Abseil *failure signal handler* to capture and dump // useful debugging information (such as a stacktrace) upon program failure. // -// To use the failure signal handler, call `y_absl::InstallFailureSignalHandler()` +// To use the failure signal handler, call `y_absl::InstallFailureSignalHandler()` // very early in your program, usually in the first few lines of main(): // // int main(int argc, char** argv) { // // Initialize the symbolizer to get a human-readable stack trace -// y_absl::InitializeSymbolizer(argv[0]); +// y_absl::InitializeSymbolizer(argv[0]); // -// y_absl::FailureSignalHandlerOptions options; -// y_absl::InstallFailureSignalHandler(options); +// y_absl::FailureSignalHandlerOptions options; +// y_absl::InstallFailureSignalHandler(options); // DoSomethingInteresting(); // return 0; // } @@ -46,12 +46,12 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // FailureSignalHandlerOptions // -// Struct for holding `y_absl::InstallFailureSignalHandler()` configuration +// Struct for holding `y_absl::InstallFailureSignalHandler()` configuration // options. struct FailureSignalHandlerOptions { // If true, try to symbolize the stacktrace emitted on failure, provided that @@ -116,6 +116,6 @@ const char* FailureSignalToString(int signo); } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc index 8c7ad66c63..df217335ea 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc @@ -15,11 +15,11 @@ // base::AddressIsReadable() probes an address to see whether it is readable, // without faulting. -#include "y_absl/debugging/internal/address_is_readable.h" +#include "y_absl/debugging/internal/address_is_readable.h" #if !defined(__linux__) || defined(__ANDROID__) -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -28,7 +28,7 @@ bool AddressIsReadable(const void* /* addr */) { return true; } } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else @@ -41,9 +41,9 @@ ABSL_NAMESPACE_END #include <cstdint> #include "y_absl/base/internal/errno_saver.h" -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -134,6 +134,6 @@ bool AddressIsReadable(const void *addr) { } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h index 6bd751a7ae..279dcc640b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h @@ -17,7 +17,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -27,6 +27,6 @@ bool AddressIsReadable(const void *addr); } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc index 973360147a..0a4daa2f5c 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc @@ -17,13 +17,13 @@ // // Note that we only have partial C++11 support yet. -#include "y_absl/debugging/internal/demangle.h" +#include "y_absl/debugging/internal/demangle.h" #include <cstdint> #include <cstdio> #include <limits> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -1956,4 +1956,4 @@ bool Demangle(const char *mangled, char *out, int out_size) { } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h index ac26059915..a9b42edb45 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h @@ -55,7 +55,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -66,6 +66,6 @@ bool Demangle(const char *mangled, char *out, int out_size); } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc index 3c179a7db3..ba4bbc3855 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc @@ -15,7 +15,7 @@ // Allow dynamic symbol lookup in an in-memory Elf image. // -#include "y_absl/debugging/internal/elf_mem_image.h" +#include "y_absl/debugging/internal/elf_mem_image.h" #ifdef ABSL_HAVE_ELF_MEM_IMAGE // defined in elf_mem_image.h @@ -23,7 +23,7 @@ #include <cassert> #include <cstddef> #include "y_absl/base/config.h" -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" // From binutils/include/elf/common.h (this doesn't appear to be documented // anywhere else). @@ -38,7 +38,7 @@ #define VERSYM_VERSION 0x7fff -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -378,6 +378,6 @@ void ElfMemImage::SymbolIterator::Update(int increment) { } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_HAVE_ELF_MEM_IMAGE diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h index 24dc09f7a3..13a6b2e664 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h @@ -44,7 +44,7 @@ #define ElfW(x) __ElfN(x) #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -131,7 +131,7 @@ class ElfMemImage { } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_HAVE_ELF_MEM_IMAGE diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc index b074255bd5..c59d92b6a3 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc @@ -14,7 +14,7 @@ // limitations under the License. // -#include "y_absl/debugging/internal/examine_stack.h" +#include "y_absl/debugging/internal/examine_stack.h" #ifndef _WIN32 #include <unistd.h> @@ -27,13 +27,13 @@ #include <csignal> #include <cstdio> -#include "y_absl/base/attributes.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/macros.h" -#include "y_absl/debugging/stacktrace.h" -#include "y_absl/debugging/symbolize.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/macros.h" +#include "y_absl/debugging/stacktrace.h" +#include "y_absl/debugging/symbolize.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -134,7 +134,7 @@ static void DumpPCAndFrameSizeAndSymbol(void (*writerfn)(const char*, void*), const char* const prefix) { char tmp[1024]; const char* symbol = "(unknown)"; - if (y_absl::Symbolize(symbolize_pc, tmp, sizeof(tmp))) { + if (y_absl::Symbolize(symbolize_pc, tmp, sizeof(tmp))) { symbol = tmp; } char buf[1024]; @@ -200,4 +200,4 @@ void DumpPCAndFrameSizesAndStackTrace( } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h index ce2e8c9735..32892a1150 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h @@ -19,7 +19,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -37,6 +37,6 @@ void DumpPCAndFrameSizesAndStackTrace( } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h index a7d602a342..80137ad0eb 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h @@ -29,7 +29,7 @@ defined(__aarch64__) || defined(__riscv)) #define ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION 1 -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -43,7 +43,7 @@ int GetSignalHandlerStackConsumption(void (*signal_handler)(int)); } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc index 682f58108f..700f607488 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc @@ -14,10 +14,10 @@ #include <cstdint> #include <iostream> -#include "y_absl/base/attributes.h" -#include "y_absl/debugging/internal/address_is_readable.h" -#include "y_absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems -#include "y_absl/debugging/stacktrace.h" +#include "y_absl/base/attributes.h" +#include "y_absl/debugging/internal/address_is_readable.h" +#include "y_absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems +#include "y_absl/debugging/stacktrace.h" static const uintptr_t kUnknownFrameSize = 0; @@ -34,9 +34,9 @@ static const unsigned char* GetKernelRtSigreturnAddress() { address = reinterpret_cast<uintptr_t>(nullptr); #ifdef ABSL_HAVE_VDSO_SUPPORT - y_absl::debugging_internal::VDSOSupport vdso; + y_absl::debugging_internal::VDSOSupport vdso; if (vdso.IsPresent()) { - y_absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info; + y_absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info; auto lookup = [&](int type) { return vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_2.6.39", type, &symbol_info); @@ -96,7 +96,7 @@ static void **NextStackFrame(void **old_frame_pointer, const void *uc) { // Check that alleged frame pointer is actually readable. This is to // prevent "double fault" in case we hit the first fault due to e.g. // stack corruption. - if (!y_absl::debugging_internal::AddressIsReadable( + if (!y_absl::debugging_internal::AddressIsReadable( pre_signal_frame_pointer)) return nullptr; @@ -152,7 +152,7 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, void* prev_return_address = nullptr; while (frame_pointer && n < max_depth) { - // The y_absl::GetStackFrames routine is called when we are in some + // The y_absl::GetStackFrames routine is called when we are in some // informational context (the failure signal handler for example). // Use the non-strict unwinding rules to produce a stack trace // that is as complete as possible (even if it contains a few bogus @@ -186,7 +186,7 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, return n; } -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { @@ -194,6 +194,6 @@ bool StackTraceWorksForTest() { } } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc index fc59d0e628..b73307120e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc @@ -19,7 +19,7 @@ #include <cstdint> -#include "y_absl/debugging/stacktrace.h" +#include "y_absl/debugging/stacktrace.h" // WARNING: // This only works if all your code is in either ARM or THUMB mode. With @@ -58,7 +58,7 @@ static void **NextStackFrame(void **old_sp) { return new_sp; } -// This ensures that y_absl::GetStackTrace sets up the Link Register properly. +// This ensures that y_absl::GetStackTrace sets up the Link Register properly. #ifdef __GNUC__ void StacktraceArmDummyFunction() __attribute__((noinline)); void StacktraceArmDummyFunction() { __asm__ volatile(""); } @@ -84,7 +84,7 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, int n = 0; while (sp && n < max_depth) { - // The y_absl::GetStackFrames routine is called when we are in some + // The y_absl::GetStackFrames routine is called when we are in some // informational context (the failure signal handler for example). // Use the non-strict unwinding rules to produce a stack trace // that is as complete as possible (even if it contains a few bogus @@ -121,7 +121,7 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, return n; } -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { @@ -129,6 +129,6 @@ bool StackTraceWorksForTest() { } } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h index 56d7cbf359..7ba212ab03 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h @@ -28,7 +28,7 @@ #elif defined(_WIN32) #define ABSL_STACKTRACE_INL_HEADER \ - "y_absl/debugging/internal/stacktrace_win32-inl.inc" + "y_absl/debugging/internal/stacktrace_win32-inl.inc" #elif defined(__APPLE__) #ifdef ABSL_HAVE_THREAD_LOCAL @@ -54,7 +54,7 @@ #if __has_include(<execinfo.h>) // Note: When using glibc this may require -funwind-tables to function properly. #define ABSL_STACKTRACE_INL_HEADER \ - "y_absl/debugging/internal/stacktrace_generic-inl.inc" + "y_absl/debugging/internal/stacktrace_generic-inl.inc" #endif // __has_include(<execinfo.h>) #elif defined(__i386__) || defined(__x86_64__) #define ABSL_STACKTRACE_INL_HEADER \ @@ -81,7 +81,7 @@ // Fallback to the empty implementation. #if !defined(ABSL_STACKTRACE_INL_HEADER) #define ABSL_STACKTRACE_INL_HEADER \ - "y_absl/debugging/internal/stacktrace_unimplemented-inl.inc" + "y_absl/debugging/internal/stacktrace_unimplemented-inl.inc" #endif #endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc index 684cd0c339..fa623aa954 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc @@ -24,8 +24,8 @@ #include <atomic> #include <cstring> -#include "y_absl/debugging/stacktrace.h" -#include "y_absl/base/attributes.h" +#include "y_absl/debugging/stacktrace.h" +#include "y_absl/base/attributes.h" // Sometimes, we can try to get a stack trace from within a stack // trace, because we don't block signals inside this code (which would be too @@ -95,7 +95,7 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, return result_count; } -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { @@ -103,6 +103,6 @@ bool StackTraceWorksForTest() { } } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc index f8a7c0c2d7..1e41c4ebf2 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc @@ -31,12 +31,12 @@ #include <cstdint> #include <cstdio> -#include "y_absl/base/attributes.h" -#include "y_absl/base/optimization.h" -#include "y_absl/base/port.h" -#include "y_absl/debugging/stacktrace.h" -#include "y_absl/debugging/internal/address_is_readable.h" -#include "y_absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems +#include "y_absl/base/attributes.h" +#include "y_absl/base/optimization.h" +#include "y_absl/base/port.h" +#include "y_absl/debugging/stacktrace.h" +#include "y_absl/debugging/internal/address_is_readable.h" +#include "y_absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems // Given a stack pointer, return the saved link register value. // Note that this is the link register for a callee. @@ -101,13 +101,13 @@ static void **NextStackFrame(void **old_sp, const void *uc) { // possibly be there. static const unsigned char *kernel_sigtramp_rt64_address = nullptr; if (kernel_symbol_status == kNotInitialized) { - y_absl::debugging_internal::VDSOSupport vdso; + y_absl::debugging_internal::VDSOSupport vdso; if (vdso.IsPresent()) { - y_absl::debugging_internal::VDSOSupport::SymbolInfo + y_absl::debugging_internal::VDSOSupport::SymbolInfo sigtramp_rt64_symbol_info; if (!vdso.LookupSymbol( "__kernel_sigtramp_rt64", "LINUX_2.6.15", - y_absl::debugging_internal::VDSOSupport::kVDSOSymbolType, + y_absl::debugging_internal::VDSOSupport::kVDSOSymbolType, &sigtramp_rt64_symbol_info) || sigtramp_rt64_symbol_info.address == nullptr) { // Unexpected: VDSO is present, yet the expected symbol is missing @@ -144,7 +144,7 @@ static void **NextStackFrame(void **old_sp, const void *uc) { // Check that alleged stack pointer is actually readable. This is to // prevent a "double fault" in case we hit the first fault due to e.g. // a stack corruption. - if (y_absl::debugging_internal::AddressIsReadable(sp_before_signal)) { + if (y_absl::debugging_internal::AddressIsReadable(sp_before_signal)) { // Alleged stack pointer is readable, use it for further unwinding. new_sp = sp_before_signal; } @@ -156,7 +156,7 @@ static void **NextStackFrame(void **old_sp, const void *uc) { return new_sp; } -// This ensures that y_absl::GetStackTrace sets up the Link Register properly. +// This ensures that y_absl::GetStackTrace sets up the Link Register properly. ABSL_ATTRIBUTE_NOINLINE static void AbslStacktracePowerPCDummyFunction() { ABSL_BLOCK_TAIL_CALL_OPTIMIZATION(); } @@ -200,7 +200,7 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, // The outermost frame is set up by runtimes and it does not have a // caller frame, so it is skipped. - // The y_absl::GetStackFrames routine is called when we are in some + // The y_absl::GetStackFrames routine is called when we are in some // informational context (the failure signal handler for example). // Use the non-strict unwinding rules to produce a stack trace // that is as complete as possible (even if it contains a few @@ -240,7 +240,7 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, return n; } -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { @@ -248,6 +248,6 @@ bool StackTraceWorksForTest() { } } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc index 01a964c902..54dccaeae9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc @@ -11,7 +11,7 @@ static int UnwindImpl(void** /* result */, int* /* sizes */, return 0; } -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { @@ -19,6 +19,6 @@ bool StackTraceWorksForTest() { } } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc index 012af44b85..69bd7e3f2f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc @@ -80,7 +80,7 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, return n; } -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { @@ -88,6 +88,6 @@ bool StackTraceWorksForTest() { } } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc index 86dcce5eea..8936f8ca70 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc @@ -29,15 +29,15 @@ #include <cstdint> #include <limits> -#include "y_absl/base/macros.h" -#include "y_absl/base/port.h" -#include "y_absl/debugging/internal/address_is_readable.h" -#include "y_absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems -#include "y_absl/debugging/stacktrace.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/port.h" +#include "y_absl/debugging/internal/address_is_readable.h" +#include "y_absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems +#include "y_absl/debugging/stacktrace.h" -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" -using y_absl::debugging_internal::AddressIsReadable; +using y_absl::debugging_internal::AddressIsReadable; #if defined(__linux__) && defined(__i386__) // Count "push %reg" instructions in VDSO __kernel_vsyscall(), @@ -175,11 +175,11 @@ static void **NextStackFrame(void **old_fp, const void *uc, static const unsigned char *kernel_vsyscall_address = nullptr; if (num_push_instructions == -1) { #ifdef ABSL_HAVE_VDSO_SUPPORT - y_absl::debugging_internal::VDSOSupport vdso; + y_absl::debugging_internal::VDSOSupport vdso; if (vdso.IsPresent()) { - y_absl::debugging_internal::VDSOSupport::SymbolInfo + y_absl::debugging_internal::VDSOSupport::SymbolInfo rt_sigreturn_symbol_info; - y_absl::debugging_internal::VDSOSupport::SymbolInfo vsyscall_symbol_info; + y_absl::debugging_internal::VDSOSupport::SymbolInfo vsyscall_symbol_info; if (!vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_2.5", STT_FUNC, &rt_sigreturn_symbol_info) || !vdso.LookupSymbol("__kernel_vsyscall", "LINUX_2.5", STT_FUNC, @@ -351,7 +351,7 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, return n; } -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { @@ -359,6 +359,6 @@ bool StackTraceWorksForTest() { } } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h index c26fe4af7a..e6e2b0724a 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h @@ -35,9 +35,9 @@ #include <elf.h> #include <link.h> // For ElfW() macro. #include <functional> -#include <util/generic/string.h> - -namespace y_absl { +#include <util/generic/string.h> + +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -58,7 +58,7 @@ bool GetSectionHeaderByName(int fd, const char *name, size_t name_len, } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE @@ -74,7 +74,7 @@ ABSL_NAMESPACE_END #define ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE 1 #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -136,7 +136,7 @@ bool GetFileMappingHint(const void** start, const void** end, uint64_t* offset, } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // __cplusplus diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc index 056e983778..7905eba32f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc @@ -16,7 +16,7 @@ // // VDSOSupport -- a class representing kernel VDSO (if present). -#include "y_absl/debugging/internal/vdso_support.h" +#include "y_absl/debugging/internal/vdso_support.h" #ifdef ABSL_HAVE_VDSO_SUPPORT // defined in vdso_support.h @@ -42,9 +42,9 @@ #include <sys/auxv.h> #endif -#include "y_absl/base/dynamic_annotations.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/port.h" +#include "y_absl/base/dynamic_annotations.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/port.h" #ifndef AT_SYSINFO_EHDR #define AT_SYSINFO_EHDR 33 // for crosstoolv10 @@ -55,7 +55,7 @@ using Elf64_auxv_t = Elf64_Auxinfo; using Elf32_auxv_t = Elf32_Auxinfo; #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -186,6 +186,6 @@ int GetCPU() { } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_HAVE_VDSO_SUPPORT diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h index c6888f7d46..c0064b9fe1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h @@ -41,8 +41,8 @@ #include <atomic> -#include "y_absl/base/attributes.h" -#include "y_absl/debugging/internal/elf_mem_image.h" +#include "y_absl/base/attributes.h" +#include "y_absl/debugging/internal/elf_mem_image.h" #ifdef ABSL_HAVE_ELF_MEM_IMAGE @@ -52,7 +52,7 @@ #define ABSL_HAVE_VDSO_SUPPORT 1 #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -151,7 +151,7 @@ int GetCPU(); } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_HAVE_ELF_MEM_IMAGE diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc index 236a644812..ae5cf79fe2 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc @@ -17,11 +17,11 @@ // therefore Abseil code which depends on these functions is conditioned on the // definition of LEAK_SANITIZER. #include "y_absl/base/attributes.h" -#include "y_absl/debugging/leak_check.h" +#include "y_absl/debugging/leak_check.h" #ifndef LEAK_SANITIZER -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN bool HaveLeakSanitizer() { return false; } bool LeakCheckerIsActive() { return false; } @@ -31,7 +31,7 @@ void UnRegisterLivePointers(const void*, size_t) { } LeakCheckDisabler::LeakCheckDisabler() { } LeakCheckDisabler::~LeakCheckDisabler() { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else @@ -41,7 +41,7 @@ ABSL_NAMESPACE_END extern "C" ABSL_ATTRIBUTE_WEAK int __lsan_is_turned_off(); #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN bool HaveLeakSanitizer() { return true; } @@ -64,6 +64,6 @@ void UnRegisterLivePointers(const void* ptr, size_t size) { LeakCheckDisabler::LeakCheckDisabler() { __lsan_disable(); } LeakCheckDisabler::~LeakCheckDisabler() { __lsan_enable(); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // LEAK_SANITIZER diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h index d939637d6b..d69f08f248 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h @@ -34,7 +34,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // HaveLeakSanitizer() @@ -128,6 +128,6 @@ void RegisterLivePointers(const void* ptr, size_t size); void UnRegisterLivePointers(const void* ptr, size_t size); ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_LEAK_CHECK_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check/ya.make index a7f423e394..f22152ef8a 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check/ya.make @@ -17,7 +17,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging) SRCS( leak_check.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check_disable/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check_disable/ya.make index 269d307c17..41792f1bc6 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check_disable/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check_disable/ya.make @@ -17,7 +17,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging) SRCS( leak_check_disable.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc index 6de1f01a93..9263d6a2a8 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc @@ -31,34 +31,34 @@ // trying to use the unwinder to instrument malloc(). // // Note: if you add a new implementation here, make sure it works -// correctly when y_absl::GetStackTrace() is called with max_depth == 0. +// correctly when y_absl::GetStackTrace() is called with max_depth == 0. // Some code may do that. -#include "y_absl/debugging/stacktrace.h" +#include "y_absl/debugging/stacktrace.h" #include <atomic> -#include "y_absl/base/attributes.h" -#include "y_absl/base/port.h" -#include "y_absl/debugging/internal/stacktrace_config.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/port.h" +#include "y_absl/debugging/internal/stacktrace_config.h" #if defined(ABSL_STACKTRACE_INL_HEADER) #include ABSL_STACKTRACE_INL_HEADER #else # error Cannot calculate stack trace: will need to write for your environment -# include "y_absl/debugging/internal/stacktrace_aarch64-inl.inc" -# include "y_absl/debugging/internal/stacktrace_arm-inl.inc" +# include "y_absl/debugging/internal/stacktrace_aarch64-inl.inc" +# include "y_absl/debugging/internal/stacktrace_arm-inl.inc" # include "y_absl/debugging/internal/stacktrace_emscripten-inl.inc" -# include "y_absl/debugging/internal/stacktrace_generic-inl.inc" -# include "y_absl/debugging/internal/stacktrace_powerpc-inl.inc" +# include "y_absl/debugging/internal/stacktrace_generic-inl.inc" +# include "y_absl/debugging/internal/stacktrace_powerpc-inl.inc" # include "y_absl/debugging/internal/stacktrace_riscv-inl.inc" -# include "y_absl/debugging/internal/stacktrace_unimplemented-inl.inc" -# include "y_absl/debugging/internal/stacktrace_win32-inl.inc" -# include "y_absl/debugging/internal/stacktrace_x86-inl.inc" +# include "y_absl/debugging/internal/stacktrace_unimplemented-inl.inc" +# include "y_absl/debugging/internal/stacktrace_win32-inl.inc" +# include "y_absl/debugging/internal/stacktrace_x86-inl.inc" #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { @@ -139,4 +139,4 @@ int DefaultStackUnwinder(void** pcs, int* sizes, int depth, int skip, } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h index 10dd5a7315..cbd48b986b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h @@ -33,7 +33,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // GetStackFrames() @@ -41,7 +41,7 @@ ABSL_NAMESPACE_BEGIN // Records program counter values for up to `max_depth` frames, skipping the // most recent `skip_count` stack frames, stores their corresponding values // and sizes in `results` and `sizes` buffers, and returns the number of frames -// stored. (Note that the frame generated for the `y_absl::GetStackFrames()` +// stored. (Note that the frame generated for the `y_absl::GetStackFrames()` // routine itself is also skipped.) // // Example: @@ -51,7 +51,7 @@ ABSL_NAMESPACE_BEGIN // bar() { // void* result[10]; // int sizes[10]; -// int depth = y_absl::GetStackFrames(result, sizes, 10, 1); +// int depth = y_absl::GetStackFrames(result, sizes, 10, 1); // } // // The current stack frame would consist of three function calls: `bar()`, @@ -87,7 +87,7 @@ extern int GetStackFrames(void** result, int* sizes, int max_depth, // program counter values for up to `max_depth` frames, skipping the most recent // `skip_count` stack frames, stores their corresponding values and sizes in // `results` and `sizes` buffers, and returns the number of frames stored. (Note -// that the frame generated for the `y_absl::GetStackFramesWithContext()` routine +// that the frame generated for the `y_absl::GetStackFramesWithContext()` routine // itself is also skipped.) // // The `uc` parameter, if non-null, should be a pointer to a `ucontext_t` value @@ -111,7 +111,7 @@ extern int GetStackFramesWithContext(void** result, int* sizes, int max_depth, // Records program counter values for up to `max_depth` frames, skipping the // most recent `skip_count` stack frames, stores their corresponding values // in `results`, and returns the number of frames -// stored. Note that this function is similar to `y_absl::GetStackFrames()` +// stored. Note that this function is similar to `y_absl::GetStackFrames()` // except that it returns the stack trace only, and not stack frame sizes. // // Example: @@ -120,7 +120,7 @@ extern int GetStackFramesWithContext(void** result, int* sizes, int max_depth, // foo() { bar(); } // bar() { // void* result[10]; -// int depth = y_absl::GetStackTrace(result, 10, 1); +// int depth = y_absl::GetStackTrace(result, 10, 1); // } // // This produces: @@ -138,7 +138,7 @@ extern int GetStackTrace(void** result, int max_depth, int skip_count); // program counter values for up to `max_depth` frames, skipping the most recent // `skip_count` stack frames, stores their corresponding values in `results`, // and returns the number of frames stored. (Note that the frame generated for -// the `y_absl::GetStackFramesWithContext()` routine itself is also skipped.) +// the `y_absl::GetStackFramesWithContext()` routine itself is also skipped.) // // The `uc` parameter, if non-null, should be a pointer to a `ucontext_t` value // passed to a signal handler registered via the `sa_sigaction` field of a @@ -163,7 +163,7 @@ extern int GetStackTraceWithContext(void** result, int max_depth, // GetStack{Frames,Trace}{,WithContext}() functions above. // // The arguments passed to the unwinder function will match the -// arguments passed to `y_absl::GetStackFramesWithContext()` except that sizes +// arguments passed to `y_absl::GetStackFramesWithContext()` except that sizes // will be non-null iff the caller is interested in frame sizes. // // If unwinder is set to null, we revert to the default stack-tracing behavior. @@ -172,9 +172,9 @@ extern int GetStackTraceWithContext(void** result, int max_depth, // WARNING // ***************************************************************************** // -// y_absl::SetStackUnwinder is not suitable for general purpose use. It is +// y_absl::SetStackUnwinder is not suitable for general purpose use. It is // provided for custom runtimes. -// Some things to watch out for when calling `y_absl::SetStackUnwinder()`: +// Some things to watch out for when calling `y_absl::SetStackUnwinder()`: // // (a) The unwinder may be called from within signal handlers and // therefore must be async-signal-safe. @@ -207,7 +207,7 @@ extern void SetStackUnwinder(int (*unwinder)(void** pcs, int* sizes, // be null when called. // // The semantics are the same as the corresponding `GetStack*()` function in the -// case where `y_absl::SetStackUnwinder()` was never called. Equivalents are: +// case where `y_absl::SetStackUnwinder()` was never called. Equivalents are: // // null sizes | non-nullptr sizes // |==========================================================| @@ -226,6 +226,6 @@ namespace debugging_internal { extern bool StackTraceWorksForTest(); } // namespace debugging_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_STACKTRACE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace/ya.make index 2337a8c6c1..a56bdc8a4c 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace/ya.make @@ -12,9 +12,9 @@ OWNER( LICENSE(Apache-2.0) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity - contrib/restricted/abseil-cpp-tstring/y_absl/debugging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/debugging ) ADDINCL( @@ -23,7 +23,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging) SRCS( stacktrace.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc index f2722db9c8..88c92a19ea 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/debugging/symbolize.h" +#include "y_absl/debugging/symbolize.h" #ifdef _WIN32 #include <winapifamily.h> @@ -24,15 +24,15 @@ #endif #if defined(ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE) -#include "y_absl/debugging/symbolize_elf.inc" +#include "y_absl/debugging/symbolize_elf.inc" #elif defined(ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32) // The Windows Symbolizer only works if PDB files containing the debug info // are available to the program at runtime. -#include "y_absl/debugging/symbolize_win32.inc" +#include "y_absl/debugging/symbolize_win32.inc" #elif defined(__APPLE__) #include "y_absl/debugging/symbolize_darwin.inc" #elif defined(__EMSCRIPTEN__) #include "y_absl/debugging/symbolize_emscripten.inc" #else -#include "y_absl/debugging/symbolize_unimplemented.inc" +#include "y_absl/debugging/symbolize_unimplemented.inc" #endif diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h index f8eaff7527..2a99f65c83 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h @@ -25,7 +25,7 @@ // * Implicitly, through the installation of an Abseil failure signal handler. // (See failure_signal_handler.h for more information.) // * By calling `Symbolize()` directly on a program counter you obtain through -// `y_absl::GetStackTrace()` or `y_absl::GetStackFrames()`. (See stacktrace.h +// `y_absl::GetStackTrace()` or `y_absl::GetStackFrames()`. (See stacktrace.h // for more information. // * By calling `Symbolize()` directly on a program counter you obtain through // other means (which would be platform-dependent). @@ -38,11 +38,11 @@ // // int main(int argc, char** argv) { // // Initialize the Symbolizer before installing the failure signal handler -// y_absl::InitializeSymbolizer(argv[0]); +// y_absl::InitializeSymbolizer(argv[0]); // // // Now you may install the failure signal handler -// y_absl::FailureSignalHandlerOptions options; -// y_absl::InstallFailureSignalHandler(options); +// y_absl::FailureSignalHandlerOptions options; +// y_absl::InstallFailureSignalHandler(options); // // // Start running your main program // ... @@ -52,9 +52,9 @@ #ifndef ABSL_DEBUGGING_SYMBOLIZE_H_ #define ABSL_DEBUGGING_SYMBOLIZE_H_ -#include "y_absl/debugging/internal/symbolize.h" +#include "y_absl/debugging/internal/symbolize.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // InitializeSymbolizer() @@ -67,7 +67,7 @@ ABSL_NAMESPACE_BEGIN // Example: // // int main(int argc, char *argv[]) { -// y_absl::InitializeSymbolizer(argv[0]); +// y_absl::InitializeSymbolizer(argv[0]); // // Now you can use the symbolizer // } void InitializeSymbolizer(const char* argv0); @@ -86,7 +86,7 @@ void InitializeSymbolizer(const char* argv0); // static void DumpPCAndSymbol(void *pc) { // char tmp[1024]; // const char *symbol = "(unknown)"; -// if (y_absl::Symbolize(pc, tmp, sizeof(tmp))) { +// if (y_absl::Symbolize(pc, tmp, sizeof(tmp))) { // symbol = tmp; // } // y_absl::PrintF("%p %s\n", pc, symbol); @@ -94,6 +94,6 @@ void InitializeSymbolizer(const char* argv0); bool Symbolize(const void *pc, char *out, int out_size); ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_DEBUGGING_SYMBOLIZE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize/ya.make index f500ff06c8..58f9d70682 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize/ya.make @@ -12,14 +12,14 @@ OWNER( LICENSE(Apache-2.0) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity - contrib/restricted/abseil-cpp-tstring/y_absl/debugging - contrib/restricted/abseil-cpp-tstring/y_absl/demangle + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/debugging + contrib/restricted/abseil-cpp-tstring/y_absl/demangle contrib/restricted/abseil-cpp-tstring/y_absl/numeric contrib/restricted/abseil-cpp-tstring/y_absl/strings contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal @@ -31,7 +31,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging) SRCS( symbolize.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc index 515f825981..18297405e3 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc @@ -67,21 +67,21 @@ #include <cstdlib> #include <cstring> -#include "y_absl/base/casts.h" -#include "y_absl/base/dynamic_annotations.h" -#include "y_absl/base/internal/low_level_alloc.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/spinlock.h" -#include "y_absl/base/port.h" -#include "y_absl/debugging/internal/demangle.h" -#include "y_absl/debugging/internal/vdso_support.h" +#include "y_absl/base/casts.h" +#include "y_absl/base/dynamic_annotations.h" +#include "y_absl/base/internal/low_level_alloc.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/spinlock.h" +#include "y_absl/base/port.h" +#include "y_absl/debugging/internal/demangle.h" +#include "y_absl/debugging/internal/vdso_support.h" #include "y_absl/strings/string_view.h" #if defined(__FreeBSD__) && !defined(ElfW) #define ElfW(x) __ElfN(x) #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // Value of argv[0]. Used by MaybeInitializeObjFile(). @@ -1564,7 +1564,7 @@ bool Symbolize(const void *pc, char *out, int out_size) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl extern "C" bool YAbslInternalGetFileMappingHint(const void **start, const void **end, uint64_t *offset, diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc index 779e171dcd..4e55ed122f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc @@ -14,9 +14,9 @@ #include <cstdint> -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -37,4 +37,4 @@ void InitializeSymbolizer(const char*) {} bool Symbolize(const void *, char *, int) { return false; } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc index dacf49ea7a..81e0473f88 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc @@ -28,9 +28,9 @@ #include <algorithm> #include <cstring> -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN static HANDLE process = NULL; @@ -78,4 +78,4 @@ bool Symbolize(const void* pc, char* out, int out_size) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/ya.make index 521c9e76c0..d768f195c2 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/ya.make @@ -12,8 +12,8 @@ LICENSE(Apache-2.0) LICENSE_TEXTS(.yandex_meta/licenses.list.txt) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity ) ADDINCL( diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/demangle/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/demangle/ya.make index 04af5c3bd3..a1abc9f615 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/demangle/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/demangle/ya.make @@ -12,10 +12,10 @@ OWNER( LICENSE(Apache-2.0) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity ) ADDINCL( @@ -24,7 +24,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal) SRCS( demangle.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h index 718638dac4..6ae4c63c9e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h @@ -16,15 +16,15 @@ // File: function_ref.h // ----------------------------------------------------------------------------- // -// This header file defines the `y_absl::FunctionRef` type for holding a +// This header file defines the `y_absl::FunctionRef` type for holding a // non-owning reference to an object of any invocable type. This function // reference is typically most useful as a type-erased argument type for // accepting function types that neither take ownership nor copy the type; using // the reference type in this case avoids a copy and an allocation. Best // practices of other non-owning reference-like objects (such as -// `y_absl::string_view`) apply here. +// `y_absl::string_view`) apply here. // -// An `y_absl::FunctionRef` is similar in usage to a `std::function` but has the +// An `y_absl::FunctionRef` is similar in usage to a `std::function` but has the // following differences: // // * It doesn't own the underlying object. @@ -33,10 +33,10 @@ // * It's much faster and cheaper to construct. // * It's trivially copyable and destructable. // -// Generally, `y_absl::FunctionRef` should not be used as a return value, data +// Generally, `y_absl::FunctionRef` should not be used as a return value, data // member, or to initialize a `std::function`. Such usages will often lead to // problematic lifetime issues. Once you convert something to an -// `y_absl::FunctionRef` you cannot make a deep copy later. +// `y_absl::FunctionRef` you cannot make a deep copy later. // // This class is suitable for use wherever a "const std::function<>&" // would be used without making a copy. ForEach functions and other versions of @@ -51,10 +51,10 @@ #include <type_traits> #include "y_absl/base/attributes.h" -#include "y_absl/functional/internal/function_ref.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/functional/internal/function_ref.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // FunctionRef @@ -66,8 +66,8 @@ class FunctionRef; // FunctionRef // -// An `y_absl::FunctionRef` is a lightweight wrapper to any invokable object with -// a compatible signature. Generally, an `y_absl::FunctionRef` should only be used +// An `y_absl::FunctionRef` is a lightweight wrapper to any invokable object with +// a compatible signature. Generally, an `y_absl::FunctionRef` should only be used // as an argument type and should be preferred as an argument over a const // reference to a `std::function`. // @@ -75,15 +75,15 @@ class FunctionRef; // // // The following function takes a function callback by const reference // bool Visitor(const std::function<void(my_proto&, -// y_absl::string_view)>& callback); +// y_absl::string_view)>& callback); // // // Assuming that the function is not stored or otherwise copied, it can be -// // replaced by an `y_absl::FunctionRef`: -// bool Visitor(y_absl::FunctionRef<void(my_proto&, y_absl::string_view)> +// // replaced by an `y_absl::FunctionRef`: +// bool Visitor(y_absl::FunctionRef<void(my_proto&, y_absl::string_view)> // callback); // -// Note: the assignment operator within an `y_absl::FunctionRef` is intentionally -// deleted to prevent misuse; because the `y_absl::FunctionRef` does not own the +// Note: the assignment operator within an `y_absl::FunctionRef` is intentionally +// deleted to prevent misuse; because the `y_absl::FunctionRef` does not own the // underlying type, assignment likely indicates misuse. template <typename R, typename... Args> class FunctionRef<R(Args...)> { @@ -101,8 +101,8 @@ class FunctionRef<R(Args...)> { template <typename F, typename = EnableIfCompatible<const F&>> // NOLINTNEXTLINE(runtime/explicit) FunctionRef(const F& f ABSL_ATTRIBUTE_LIFETIME_BOUND) - : invoker_(&y_absl::functional_internal::InvokeObject<F, R, Args...>) { - y_absl::functional_internal::AssertNonNull(f); + : invoker_(&y_absl::functional_internal::InvokeObject<F, R, Args...>) { + y_absl::functional_internal::AssertNonNull(f); ptr_.obj = &f; } @@ -114,9 +114,9 @@ class FunctionRef<R(Args...)> { // functions can decay to function pointers implicitly. template < typename F, typename = EnableIfCompatible<F*>, - y_absl::functional_internal::EnableIf<y_absl::is_function<F>::value> = 0> + y_absl::functional_internal::EnableIf<y_absl::is_function<F>::value> = 0> FunctionRef(F* f) // NOLINT(runtime/explicit) - : invoker_(&y_absl::functional_internal::InvokeFunction<F*, R, Args...>) { + : invoker_(&y_absl::functional_internal::InvokeFunction<F*, R, Args...>) { assert(f != nullptr); ptr_.fun = reinterpret_cast<decltype(ptr_.fun)>(f); } @@ -132,11 +132,11 @@ class FunctionRef<R(Args...)> { } private: - y_absl::functional_internal::VoidPtr ptr_; - y_absl::functional_internal::Invoker<R, Args...> invoker_; + y_absl::functional_internal::VoidPtr ptr_; + y_absl::functional_internal::Invoker<R, Args...> invoker_; }; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_FUNCTIONAL_FUNCTION_REF_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h index 8a1193dd0f..1ba81ee96a 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h @@ -19,10 +19,10 @@ #include <functional> #include <type_traits> -#include "y_absl/base/internal/invoke.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/base/internal/invoke.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace functional_internal { @@ -43,8 +43,8 @@ union VoidPtr { template <typename T> constexpr bool PassByValue() { return !std::is_lvalue_reference<T>::value && - y_absl::is_trivially_copy_constructible<T>::value && - y_absl::is_trivially_copy_assignable< + y_absl::is_trivially_copy_constructible<T>::value && + y_absl::is_trivially_copy_assignable< typename std::remove_cv<T>::type>::value && std::is_trivially_destructible<T>::value && sizeof(T) <= 2 * sizeof(void*); @@ -101,6 +101,6 @@ using EnableIf = typename ::std::enable_if<C, int>::type; } // namespace functional_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h index cea1fa5ba5..1e93ee96d9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h @@ -19,8 +19,8 @@ // This header file defines the Abseil `hash` library and the Abseil hashing // framework. This framework consists of the following: // -// * The `y_absl::Hash` functor, which is used to invoke the hasher within the -// Abseil hashing framework. `y_absl::Hash<T>` supports most basic types and +// * The `y_absl::Hash` functor, which is used to invoke the hasher within the +// Abseil hashing framework. `y_absl::Hash<T>` supports most basic types and // a number of Abseil types out of the box. // * `AbslHashValue`, an extension point that allows you to extend types to // support Abseil hashing without requiring you to define a hashing @@ -34,7 +34,7 @@ // provides most of its utility by abstracting away the hash algorithm (and its // implementation) entirely. Instead, a type invokes the Abseil hashing // framework by simply combining its state with the state of known, hashable -// types. Hashing of that combined state is separately done by `y_absl::Hash`. +// types. Hashing of that combined state is separately done by `y_absl::Hash`. // // One should assume that a hash algorithm is chosen randomly at the start of // each process. E.g., `y_absl::Hash<int>{}(9)` in one process and @@ -68,23 +68,23 @@ // ... // }; // -// For more information, see Adding Type Support to `y_absl::Hash` below. +// For more information, see Adding Type Support to `y_absl::Hash` below. // #ifndef ABSL_HASH_HASH_H_ #define ABSL_HASH_HASH_H_ #include <tuple> -#include "y_absl/hash/internal/hash.h" +#include "y_absl/hash/internal/hash.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ----------------------------------------------------------------------------- -// `y_absl::Hash` +// `y_absl::Hash` // ----------------------------------------------------------------------------- // -// `y_absl::Hash<T>` is a convenient general-purpose hash functor for any type `T` +// `y_absl::Hash<T>` is a convenient general-purpose hash functor for any type `T` // satisfying any of the following conditions (in order): // // * T is an arithmetic or pointer type @@ -92,7 +92,7 @@ ABSL_NAMESPACE_BEGIN // hash state `H`. // - T defines a specialization of `std::hash<T>` // -// `y_absl::Hash` intrinsically supports the following types: +// `y_absl::Hash` intrinsically supports the following types: // // * All integral types (including bool) // * All enum types @@ -103,32 +103,32 @@ ABSL_NAMESPACE_BEGIN // * std::unique_ptr and std::shared_ptr // * All string-like types including: // * y_absl::Cord -// * TString +// * TString // * std::string_view (as well as any instance of std::basic_string that // uses char and std::char_traits) // * All the standard sequence containers (provided the elements are hashable) // * All the standard ordered associative containers (provided the elements are // hashable) -// * y_absl types such as the following: -// * y_absl::string_view -// * y_absl::InlinedVector -// * y_absl::FixedArray -// * y_absl::uint128 -// * y_absl::Time, y_absl::Duration, and y_absl::TimeZone +// * y_absl types such as the following: +// * y_absl::string_view +// * y_absl::InlinedVector +// * y_absl::FixedArray +// * y_absl::uint128 +// * y_absl::Time, y_absl::Duration, and y_absl::TimeZone // // Note: the list above is not meant to be exhaustive. Additional type support // may be added, in which case the above list will be updated. // // ----------------------------------------------------------------------------- -// y_absl::Hash Invocation Evaluation +// y_absl::Hash Invocation Evaluation // ----------------------------------------------------------------------------- // -// When invoked, `y_absl::Hash<T>` searches for supplied hash functions in the +// When invoked, `y_absl::Hash<T>` searches for supplied hash functions in the // following order: // // * Natively supported types out of the box (see above) // * Types for which an `AbslHashValue()` overload is provided (such as -// user-defined types). See "Adding Type Support to `y_absl::Hash`" below. +// user-defined types). See "Adding Type Support to `y_absl::Hash`" below. // * Types which define a `std::hash<T>` specialization // // The fallback to legacy hash functions exists mainly for backwards @@ -139,17 +139,17 @@ ABSL_NAMESPACE_BEGIN // The Hash State Concept, and using `HashState` for Type Erasure // ----------------------------------------------------------------------------- // -// The `y_absl::Hash` framework relies on the Concept of a "hash state." Such a +// The `y_absl::Hash` framework relies on the Concept of a "hash state." Such a // hash state is used in several places: // -// * Within existing implementations of `y_absl::Hash<T>` to store the hashed +// * Within existing implementations of `y_absl::Hash<T>` to store the hashed // state of an object. Note that it is up to the implementation how it stores // such state. A hash table, for example, may mix the state to produce an // integer value; a testing framework may simply hold a vector of that state. // * Within implementations of `AbslHashValue()` used to extend user-defined -// types. (See "Adding Type Support to y_absl::Hash" below.) +// types. (See "Adding Type Support to y_absl::Hash" below.) // * Inside a `HashState`, providing type erasure for the concept of a hash -// state, which you can use to extend the `y_absl::Hash` framework for types +// state, which you can use to extend the `y_absl::Hash` framework for types // that are otherwise difficult to extend using `AbslHashValue()`. (See the // `HashState` class below.) // @@ -188,7 +188,7 @@ ABSL_NAMESPACE_BEGIN // loop instead. // // ----------------------------------------------------------------------------- -// Adding Type Support to `y_absl::Hash` +// Adding Type Support to `y_absl::Hash` // ----------------------------------------------------------------------------- // // To add support for your user-defined type, add a proper `AbslHashValue()` @@ -210,11 +210,11 @@ ABSL_NAMESPACE_BEGIN // file and namespace as said type. The proper `AbslHashValue` implementation // for a given type will be discovered via ADL. // -// Note: unlike `std::hash', `y_absl::Hash` should never be specialized. It must +// Note: unlike `std::hash', `y_absl::Hash` should never be specialized. It must // only be extended by adding `AbslHashValue()` overloads. // template <typename T> -using Hash = y_absl::hash_internal::Hash<T>; +using Hash = y_absl::hash_internal::Hash<T>; // HashOf // @@ -250,7 +250,7 @@ size_t HashOf(const Types&... values) { // provided by the wrapped class. // // Users of this class should still define a template `AbslHashValue` function, -// but can use `y_absl::HashState::Create(&state)` to erase the type of the hash +// but can use `y_absl::HashState::Create(&state)` to erase the type of the hash // state and dispatch to their private hashing logic. // // This state can be used like any other hash state. In particular, you can call @@ -263,20 +263,20 @@ size_t HashOf(const Types&... values) { // template <typename H> // friend H AbslHashValue(H state, const Interface& value) { // state = H::combine(std::move(state), std::type_index(typeid(*this))); -// value.HashValue(y_absl::HashState::Create(&state)); +// value.HashValue(y_absl::HashState::Create(&state)); // return state; // } // private: -// virtual void HashValue(y_absl::HashState state) const = 0; +// virtual void HashValue(y_absl::HashState state) const = 0; // }; // // class Impl : Interface { // private: -// void HashValue(y_absl::HashState state) const override { -// y_absl::HashState::combine(std::move(state), v1_, v2_); +// void HashValue(y_absl::HashState state) const override { +// y_absl::HashState::combine(std::move(state), v1_, v2_); // } // int v1_; -// TString v2_; +// TString v2_; // }; class HashState : public hash_internal::HashStateBase<HashState> { public: @@ -342,6 +342,6 @@ class HashState : public hash_internal::HashStateBase<HashState> { }; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_HASH_HASH_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash_testing.h index d32e21ccd6..2f22d37039 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash_testing.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash_testing.h @@ -22,15 +22,15 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "y_absl/hash/internal/spy_hash_state.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/strings/str_cat.h" -#include "y_absl/types/variant.h" +#include "y_absl/hash/internal/spy_hash_state.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/strings/str_cat.h" +#include "y_absl/types/variant.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN -// Run the y_absl::Hash algorithm over all the elements passed in and verify that +// Run the y_absl::Hash algorithm over all the elements passed in and verify that // their hash expansion is congruent with their `==` operator. // // It is used in conjunction with EXPECT_TRUE. Failures will output information @@ -39,17 +39,17 @@ ABSL_NAMESPACE_BEGIN // Users should pass a collection of types as either an initializer list or a // container of cases. // -// EXPECT_TRUE(y_absl::VerifyTypeImplementsAbslHashCorrectly( +// EXPECT_TRUE(y_absl::VerifyTypeImplementsAbslHashCorrectly( // {v1, v2, ..., vN})); // // std::vector<MyType> cases; // // Fill cases... -// EXPECT_TRUE(y_absl::VerifyTypeImplementsAbslHashCorrectly(cases)); +// EXPECT_TRUE(y_absl::VerifyTypeImplementsAbslHashCorrectly(cases)); // // Users can pass a variety of types for testing heterogeneous lookup with // `std::make_tuple`: // -// EXPECT_TRUE(y_absl::VerifyTypeImplementsAbslHashCorrectly( +// EXPECT_TRUE(y_absl::VerifyTypeImplementsAbslHashCorrectly( // std::make_tuple(v1, v2, ..., vN))); // // @@ -63,7 +63,7 @@ ABSL_NAMESPACE_BEGIN // // Usage: // -// EXPECT_TRUE(y_absl::VerifyTypeImplementsAbslHashCorrectly( +// EXPECT_TRUE(y_absl::VerifyTypeImplementsAbslHashCorrectly( // std::make_tuple(v1, v2, ..., vN), MyCustomEq{})); // // It checks the following requirements: @@ -128,7 +128,7 @@ ABSL_NAMESPACE_BEGIN // } // friend bool operator==(Bad4 x, Bad4 y) { // // Compare two ranges for equality. C++14 code can instead use std::equal. -// return y_absl::equal(x.p, x.p + x.size, y.p, y.p + y.size); +// return y_absl::equal(x.p, x.p + x.size, y.p, y.p + y.size); // } // }; // @@ -162,8 +162,8 @@ namespace hash_internal { struct PrintVisitor { size_t index; template <typename T> - TString operator()(const T* value) const { - return y_absl::StrCat("#", index, "(", testing::PrintToString(*value), ")"); + TString operator()(const T* value) const { + return y_absl::StrCat("#", index, "(", testing::PrintToString(*value), ")"); } }; @@ -191,10 +191,10 @@ VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) { struct Info { const V& value; size_t index; - TString ToString() const { - return y_absl::visit(PrintVisitor{index}, value); + TString ToString() const { + return y_absl::visit(PrintVisitor{index}, value); } - SpyHashState expand() const { return y_absl::visit(ExpandVisitor{}, value); } + SpyHashState expand() const { return y_absl::visit(ExpandVisitor{}, value); } }; using EqClass = std::vector<Info>; @@ -205,7 +205,7 @@ VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) { for (const auto& value : values) { EqClass* c = nullptr; for (auto& eqclass : classes) { - if (y_absl::visit(EqVisitor<Eq>{equals}, value, eqclass[0].value)) { + if (y_absl::visit(EqVisitor<Eq>{equals}, value, eqclass[0].value)) { c = &eqclass; break; } @@ -297,11 +297,11 @@ struct MakeTypeSet<T, Ts...> : MakeTypeSet<Ts...>::template Insert<T>::type {}; template <typename... T> using VariantForTypes = typename MakeTypeSet< - const typename std::decay<T>::type*...>::template apply<y_absl::variant>; + const typename std::decay<T>::type*...>::template apply<y_absl::variant>; template <typename Container> struct ContainerAsVector { - using V = y_absl::variant<const typename Container::value_type*>; + using V = y_absl::variant<const typename Container::value_type*>; using Out = std::vector<V>; static Out Do(const Container& values) { @@ -317,12 +317,12 @@ struct ContainerAsVector<std::tuple<T...>> { using Out = std::vector<V>; template <size_t... I> - static Out DoImpl(const std::tuple<T...>& tuple, y_absl::index_sequence<I...>) { + static Out DoImpl(const std::tuple<T...>& tuple, y_absl::index_sequence<I...>) { return Out{&std::get<I>(tuple)...}; } static Out Do(const std::tuple<T...>& values) { - return DoImpl(values, y_absl::index_sequence_for<T...>()); + return DoImpl(values, y_absl::index_sequence_for<T...>()); } }; @@ -373,6 +373,6 @@ VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values, } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_HASH_HASH_TESTING_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc index 9416ed5c86..5f1b655e7e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc @@ -19,23 +19,23 @@ // possible hash functions, by using SIMD instructions, or by // compromising on hash quality. -#include "y_absl/hash/internal/city.h" +#include "y_absl/hash/internal/city.h" #include <string.h> // for memcpy and memset #include <algorithm> -#include "y_absl/base/config.h" -#include "y_absl/base/internal/endian.h" -#include "y_absl/base/internal/unaligned_access.h" -#include "y_absl/base/optimization.h" +#include "y_absl/base/config.h" +#include "y_absl/base/internal/endian.h" +#include "y_absl/base/internal/unaligned_access.h" +#include "y_absl/base/optimization.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace hash_internal { #ifdef ABSL_IS_BIG_ENDIAN -#define uint32_in_expected_order(x) (y_absl::gbswap_32(x)) -#define uint64_in_expected_order(x) (y_absl::gbswap_64(x)) +#define uint32_in_expected_order(x) (y_absl::gbswap_32(x)) +#define uint64_in_expected_order(x) (y_absl::gbswap_64(x)) #else #define uint32_in_expected_order(x) (x) #define uint64_in_expected_order(x) (x) @@ -171,9 +171,9 @@ uint32_t CityHash32(const char *s, size_t len) { h = Rotate32(h, 19); h = h * 5 + 0xe6546b64; g ^= b4; - g = y_absl::gbswap_32(g) * 5; + g = y_absl::gbswap_32(g) * 5; h += b4 * 5; - h = y_absl::gbswap_32(h); + h = y_absl::gbswap_32(h); f += b0; PERMUTE3(f, h, g); s += 20; @@ -286,11 +286,11 @@ static uint64_t HashLen33to64(const char *s, size_t len) { uint64_t h = Fetch64(s + len - 16) * mul; uint64_t u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9; uint64_t v = ((a + g) ^ d) + f + 1; - uint64_t w = y_absl::gbswap_64((u + v) * mul) + h; + uint64_t w = y_absl::gbswap_64((u + v) * mul) + h; uint64_t x = Rotate(e + f, 42) + c; - uint64_t y = (y_absl::gbswap_64((v + w) * mul) + g) * mul; + uint64_t y = (y_absl::gbswap_64((v + w) * mul) + g) * mul; uint64_t z = e + f + c; - a = y_absl::gbswap_64((x + z) * mul + y) + b; + a = y_absl::gbswap_64((x + z) * mul + y) + b; b = ShiftMix((z + a) * mul + d + h) * mul; return b + x; } @@ -346,4 +346,4 @@ uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0, } // namespace hash_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h index c506887906..d2b32f0068 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h @@ -52,7 +52,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace hash_internal { @@ -73,6 +73,6 @@ uint32_t CityHash32(const char *s, size_t len); } // namespace hash_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_HASH_INTERNAL_CITY_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc index f3feb09171..fe075de43a 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc @@ -12,9 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/hash/internal/hash.h" +#include "y_absl/hash/internal/hash.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace hash_internal { @@ -66,4 +66,4 @@ uint64_t MixingHashState::LowLevelHashImpl(const unsigned char* data, } // namespace hash_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h index 531ea87573..fcbe43accd 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h @@ -41,18 +41,18 @@ #include "y_absl/base/config.h" #include "y_absl/base/internal/unaligned_access.h" -#include "y_absl/base/port.h" -#include "y_absl/container/fixed_array.h" +#include "y_absl/base/port.h" +#include "y_absl/container/fixed_array.h" #include "y_absl/hash/internal/city.h" #include "y_absl/hash/internal/low_level_hash.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/numeric/int128.h" -#include "y_absl/strings/string_view.h" -#include "y_absl/types/optional.h" -#include "y_absl/types/variant.h" -#include "y_absl/utility/utility.h" - -namespace y_absl { +#include "y_absl/meta/type_traits.h" +#include "y_absl/numeric/int128.h" +#include "y_absl/strings/string_view.h" +#include "y_absl/types/optional.h" +#include "y_absl/types/variant.h" +#include "y_absl/utility/utility.h" + +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace hash_internal { @@ -120,7 +120,7 @@ class PiecewiseCombiner { // A hash state object represents an intermediate state in the computation // of an unspecified hash algorithm. `HashStateBase` provides a CRTP style // base class for hash state implementations. Developers adding type support -// for `y_absl::Hash` should not rely on any parts of the state object other than +// for `y_absl::Hash` should not rely on any parts of the state object other than // the following member functions: // // * HashStateBase::combine() @@ -352,7 +352,7 @@ H AbslHashValue(H hash_state, std::nullptr_t) { // is_hashable() // -// Trait class which returns true if T is hashable by the y_absl::Hash framework. +// Trait class which returns true if T is hashable by the y_absl::Hash framework. // Used for the AbslHashValue implementations for composite types below. template <typename T> struct is_hashable; @@ -370,7 +370,7 @@ AbslHashValue(H hash_state, const std::pair<T1, T2>& p) { // Helper function for hashing a tuple. The third argument should // be an index_sequence running from 0 to tuple_size<Tuple> - 1. template <typename H, typename Tuple, size_t... Is> -H hash_tuple(H hash_state, const Tuple& t, y_absl::index_sequence<Is...>) { +H hash_tuple(H hash_state, const Tuple& t, y_absl::index_sequence<Is...>) { return H::combine(std::move(hash_state), std::get<Is>(t)...); } @@ -381,11 +381,11 @@ template <typename H, typename... Ts> // for now. H #else // _MSC_VER -typename std::enable_if<y_absl::conjunction<is_hashable<Ts>...>::value, H>::type +typename std::enable_if<y_absl::conjunction<is_hashable<Ts>...>::value, H>::type #endif // _MSC_VER AbslHashValue(H hash_state, const std::tuple<Ts...>& t) { return hash_internal::hash_tuple(std::move(hash_state), t, - y_absl::make_index_sequence<sizeof...(Ts)>()); + y_absl::make_index_sequence<sizeof...(Ts)>()); } // ----------------------------------------------------------------------------- @@ -414,16 +414,16 @@ H AbslHashValue(H hash_state, const std::shared_ptr<T>& ptr) { // the same character sequence. These types are: // // - `y_absl::Cord` -// - `TString` (and std::basic_string<char, std::char_traits<char>, A> for +// - `TString` (and std::basic_string<char, std::char_traits<char>, A> for // any allocator A) -// - `y_absl::string_view` and `std::string_view` +// - `y_absl::string_view` and `std::string_view` // // For simplicity, we currently support only `char` strings. This support may // be broadened, if necessary, but with some caution - this overload would // misbehave in cases where the traits' `eq()` member isn't equivalent to `==` // on the underlying character type. template <typename H> -H AbslHashValue(H hash_state, y_absl::string_view str) { +H AbslHashValue(H hash_state, y_absl::string_view str) { return H::combine( H::combine_contiguous(std::move(hash_state), str.data(), str.size()), str.size()); @@ -431,7 +431,7 @@ H AbslHashValue(H hash_state, y_absl::string_view str) { // Support std::wstring, std::u16string and std::u32string. template <typename Char, typename Alloc, typename H, - typename = y_absl::enable_if_t<std::is_same<Char, wchar_t>::value || + typename = y_absl::enable_if_t<std::is_same<Char, wchar_t>::value || std::is_same<Char, char16_t>::value || std::is_same<Char, char32_t>::value>> H AbslHashValue( @@ -583,10 +583,10 @@ typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue( return H::combine(std::move(hash_state), opt.get()); } -// AbslHashValue for hashing y_absl::optional +// AbslHashValue for hashing y_absl::optional template <typename H, typename T> typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue( - H hash_state, const y_absl::optional<T>& opt) { + H hash_state, const y_absl::optional<T>& opt) { if (opt) hash_state = H::combine(std::move(hash_state), *opt); return H::combine(std::move(hash_state), opt.has_value()); } @@ -601,12 +601,12 @@ struct VariantVisitor { } }; -// AbslHashValue for hashing y_absl::variant +// AbslHashValue for hashing y_absl::variant template <typename H, typename... T> typename std::enable_if<conjunction<is_hashable<T>...>::value, H>::type -AbslHashValue(H hash_state, const y_absl::variant<T...>& v) { +AbslHashValue(H hash_state, const y_absl::variant<T...>& v) { if (!v.valueless_by_exception()) { - hash_state = y_absl::visit(VariantVisitor<H>{std::move(hash_state)}, v); + hash_state = y_absl::visit(VariantVisitor<H>{std::move(hash_state)}, v); } return H::combine(std::move(hash_state), v.index()); } @@ -689,14 +689,14 @@ struct HashSelect { struct UniquelyRepresentedProbe { template <typename H, typename T> static auto Invoke(H state, const T& value) - -> y_absl::enable_if_t<is_uniquely_represented<T>::value, H> { + -> y_absl::enable_if_t<is_uniquely_represented<T>::value, H> { return hash_internal::hash_bytes(std::move(state), value); } }; struct HashValueProbe { template <typename H, typename T> - static auto Invoke(H state, const T& value) -> y_absl::enable_if_t< + static auto Invoke(H state, const T& value) -> y_absl::enable_if_t< std::is_same<H, decltype(AbslHashValue(std::move(state), value))>::value, H> { @@ -707,7 +707,7 @@ struct HashSelect { struct LegacyHashProbe { #if ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ template <typename H, typename T> - static auto Invoke(H state, const T& value) -> y_absl::enable_if_t< + static auto Invoke(H state, const T& value) -> y_absl::enable_if_t< std::is_convertible< decltype(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>()(value)), size_t>::value, @@ -722,7 +722,7 @@ struct HashSelect { struct StdHashProbe { template <typename H, typename T> static auto Invoke(H state, const T& value) - -> y_absl::enable_if_t<type_traits_internal::IsHashable<T>::value, H> { + -> y_absl::enable_if_t<type_traits_internal::IsHashable<T>::value, H> { return hash_internal::hash_bytes(std::move(state), std::hash<T>{}(value)); } }; @@ -744,7 +744,7 @@ struct HashSelect { // Probe each implementation in order. // disjunction provides short circuiting wrt instantiation. template <typename T> - using Apply = y_absl::disjunction< // + using Apply = y_absl::disjunction< // Probe<UniquelyRepresentedProbe, T>, // Probe<HashValueProbe, T>, // Probe<LegacyHashProbe, T>, // @@ -758,12 +758,12 @@ struct is_hashable // MixingHashState class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> { - // y_absl::uint128 is not an alias or a thin wrapper around the intrinsic. + // y_absl::uint128 is not an alias or a thin wrapper around the intrinsic. // We use the intrinsic when available to improve performance. #ifdef ABSL_HAVE_INTRINSIC_INT128 using uint128 = __uint128_t; #else // ABSL_HAVE_INTRINSIC_INT128 - using uint128 = y_absl::uint128; + using uint128 = y_absl::uint128; #endif // ABSL_HAVE_INTRINSIC_INT128 static constexpr uint64_t kMul = @@ -799,13 +799,13 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> { // Otherwise we would be instantiating and calling dozens of functions for // something that is just one multiplication and a couple xor's. // The result should be the same as running the whole algorithm, but faster. - template <typename T, y_absl::enable_if_t<IntegralFastPath<T>::value, int> = 0> + template <typename T, y_absl::enable_if_t<IntegralFastPath<T>::value, int> = 0> static size_t hash(T value) { return static_cast<size_t>(Mix(Seed(), static_cast<uint64_t>(value))); } // Overload of MixingHashState::hash() - template <typename T, y_absl::enable_if_t<!IntegralFastPath<T>::value, int> = 0> + template <typename T, y_absl::enable_if_t<!IntegralFastPath<T>::value, int> = 0> static size_t hash(const T& value) { return static_cast<size_t>(combine(MixingHashState{}, value).state_); } @@ -905,7 +905,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> { using MultType = uint64_t; #else using MultType = - y_absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>; + y_absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>; #endif // We do the addition in 64-bit space to make sure the 128-bit // multiplication is fast. If we were to do it as MultType the compiler has @@ -1032,7 +1032,7 @@ struct HashImpl { template <typename T> struct Hash - : y_absl::conditional_t<is_hashable<T>::value, HashImpl<T>, PoisonedHash> {}; + : y_absl::conditional_t<is_hashable<T>::value, HashImpl<T>, PoisonedHash> {}; template <typename H> template <typename T, typename... Ts> @@ -1091,6 +1091,6 @@ H PiecewiseCombiner::finalize(H state) { } // namespace hash_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_HASH_INTERNAL_HASH_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/spy_hash_state.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/spy_hash_state.h index 0172a14f6d..520cbf904f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/spy_hash_state.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/spy_hash_state.h @@ -19,12 +19,12 @@ #include <util/generic/string.h> #include <vector> -#include "y_absl/hash/hash.h" -#include "y_absl/strings/match.h" -#include "y_absl/strings/str_format.h" -#include "y_absl/strings/str_join.h" +#include "y_absl/hash/hash.h" +#include "y_absl/strings/match.h" +#include "y_absl/strings/str_format.h" +#include "y_absl/strings/str_join.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace hash_internal { @@ -40,7 +40,7 @@ namespace hash_internal { template <typename T> class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>> { public: - SpyHashStateImpl() : error_(std::make_shared<y_absl::optional<TString>>()) { + SpyHashStateImpl() : error_(std::make_shared<y_absl::optional<TString>>()) { static_assert(std::is_void<T>::value, ""); } @@ -112,11 +112,11 @@ class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>> { static CompareResult Compare(const SpyHashStateImpl& a, const SpyHashStateImpl& b) { - const TString a_flat = y_absl::StrJoin(a.hash_representation_, ""); - const TString b_flat = y_absl::StrJoin(b.hash_representation_, ""); + const TString a_flat = y_absl::StrJoin(a.hash_representation_, ""); + const TString b_flat = y_absl::StrJoin(b.hash_representation_, ""); if (a_flat == b_flat) return CompareResult::kEqual; - if (y_absl::EndsWith(a_flat, b_flat)) return CompareResult::kBSuffixA; - if (y_absl::EndsWith(b_flat, a_flat)) return CompareResult::kASuffixB; + if (y_absl::EndsWith(a_flat, b_flat)) return CompareResult::kBSuffixA; + if (y_absl::EndsWith(b_flat, a_flat)) return CompareResult::kASuffixB; return CompareResult::kUnequal; } @@ -129,12 +129,12 @@ class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>> { size_t offset = 0; for (char c : s) { if (offset % 16 == 0) { - out << y_absl::StreamFormat("\n0x%04x: ", offset); + out << y_absl::StreamFormat("\n0x%04x: ", offset); } if (offset % 2 == 0) { out << " "; } - out << y_absl::StreamFormat("%02x", c); + out << y_absl::StreamFormat("%02x", c); ++offset; } out << "\n"; @@ -167,7 +167,7 @@ class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>> { using SpyHashStateImpl::HashStateBase::combine_contiguous; - y_absl::optional<TString> error() const { + y_absl::optional<TString> error() const { if (moved_from_) { return "Returned a moved-from instance of the hash state object."; } @@ -183,11 +183,11 @@ class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>> { // AbslHashValue directly (because the hash state type does not match). static bool direct_absl_hash_value_error_; - std::vector<TString> hash_representation_; + std::vector<TString> hash_representation_; // This is a shared_ptr because we want all instances of the particular // SpyHashState run to share the field. This way we can set the error for // use-after-move and all the copies will see it. - std::shared_ptr<y_absl::optional<TString>> error_; + std::shared_ptr<y_absl::optional<TString>> error_; bool moved_from_ = false; }; @@ -212,7 +212,7 @@ bool RunOnStartup<f>::run = (f(), true); template < typename T, typename U, // Only trigger for when (T != U), - typename = y_absl::enable_if_t<!std::is_same<T, U>::value>, + typename = y_absl::enable_if_t<!std::is_same<T, U>::value>, // This statement works in two ways: // - First, it instantiates RunOnStartup and forces the initialization of // `run`, which set the global variable. @@ -226,6 +226,6 @@ using SpyHashState = SpyHashStateImpl<void>; } // namespace hash_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h b/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h index 2287be3331..134a614b33 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h @@ -30,10 +30,10 @@ #include <type_traits> #include <utility> -#include "y_absl/base/macros.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/base/macros.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ----------------------------------------------------------------------------- @@ -57,15 +57,15 @@ ABSL_NAMESPACE_BEGIN // - or - // std::unique_ptr<X> x(NewX(1, 2)); // -// While `y_absl::WrapUnique` is useful for capturing the output of a raw -// pointer factory, prefer 'y_absl::make_unique<T>(args...)' over -// 'y_absl::WrapUnique(new T(args...))'. +// While `y_absl::WrapUnique` is useful for capturing the output of a raw +// pointer factory, prefer 'y_absl::make_unique<T>(args...)' over +// 'y_absl::WrapUnique(new T(args...))'. // // auto x = WrapUnique(new X(1, 2)); // works, but nonideal. // auto x = make_unique<X>(1, 2); // safer, standard, avoids raw 'new'. // -// Note that `y_absl::WrapUnique(p)` is valid only if `delete p` is a valid -// expression. In particular, `y_absl::WrapUnique()` cannot wrap pointers to +// Note that `y_absl::WrapUnique(p)` is valid only if `delete p` is a valid +// expression. In particular, `y_absl::WrapUnique()` cannot wrap pointers to // arrays, functions or void, and it must not be used to capture pointers // obtained from array-new expressions (even though that would compile!). template <typename T> @@ -77,7 +77,7 @@ std::unique_ptr<T> WrapUnique(T* ptr) { namespace memory_internal { -// Traits to select proper overload and return type for `y_absl::make_unique<>`. +// Traits to select proper overload and return type for `y_absl::make_unique<>`. template <typename T> struct MakeUniqueResult { using scalar = std::unique_ptr<T>; @@ -105,12 +105,12 @@ using std::make_unique; // ----------------------------------------------------------------------------- // // Creates a `std::unique_ptr<>`, while avoiding issues creating temporaries -// during the construction process. `y_absl::make_unique<>` also avoids redundant +// during the construction process. `y_absl::make_unique<>` also avoids redundant // type declarations, by avoiding the need to explicitly use the `new` operator. // -// This implementation of `y_absl::make_unique<>` is designed for C++11 code and +// This implementation of `y_absl::make_unique<>` is designed for C++11 code and // will be replaced in C++14 by the equivalent `std::make_unique<>` abstraction. -// `y_absl::make_unique<>` is designed to be 100% compatible with +// `y_absl::make_unique<>` is designed to be 100% compatible with // `std::make_unique<>` so that the eventual migration will involve a simple // rename operation. // @@ -124,7 +124,7 @@ using std::make_unique; // auto p = make_unique<X>(args...); // 'p' is a std::unique_ptr<X> // auto pa = make_unique<X[]>(5); // 'pa' is a std::unique_ptr<X[]> // -// Three overloads of `y_absl::make_unique` are required: +// Three overloads of `y_absl::make_unique` are required: // // - For non-array T: // @@ -134,7 +134,7 @@ using std::make_unique; // // - For an array of unknown bounds T[]: // -// `y_absl::make_unique<>` will allocate an array T of type U[] with +// `y_absl::make_unique<>` will allocate an array T of type U[] with // `new U[n]()` and return a `std::unique_ptr<U[]>` owning that array. // // Note that 'U[n]()' is different from 'U[n]', and elements will be @@ -145,40 +145,40 @@ using std::make_unique; // NOTE: an array of unknown bounds T[] may still be (and often will be) // initialized to have a size, and will still use this overload. E.g: // -// auto my_array = y_absl::make_unique<int[]>(10); +// auto my_array = y_absl::make_unique<int[]>(10); // // - For an array of known bounds T[N]: // -// `y_absl::make_unique<>` is deleted (like with `std::make_unique<>`) as +// `y_absl::make_unique<>` is deleted (like with `std::make_unique<>`) as // this overload is not useful. // // NOTE: an array of known bounds T[N] is not considered a useful // construction, and may cause undefined behavior in templates. E.g: // -// auto my_array = y_absl::make_unique<int[10]>(); +// auto my_array = y_absl::make_unique<int[10]>(); // // In those cases, of course, you can still use the overload above and // simply initialize it to its desired size: // -// auto my_array = y_absl::make_unique<int[]>(10); +// auto my_array = y_absl::make_unique<int[]>(10); -// `y_absl::make_unique` overload for non-array types. +// `y_absl::make_unique` overload for non-array types. template <typename T, typename... Args> typename memory_internal::MakeUniqueResult<T>::scalar make_unique( Args&&... args) { return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); } -// `y_absl::make_unique` overload for an array T[] of unknown bounds. +// `y_absl::make_unique` overload for an array T[] of unknown bounds. // The array allocation needs to use the `new T[size]` form and cannot take // element constructor arguments. The `std::unique_ptr` will manage destructing // these array elements. template <typename T> typename memory_internal::MakeUniqueResult<T>::array make_unique(size_t n) { - return std::unique_ptr<T>(new typename y_absl::remove_extent_t<T>[n]()); + return std::unique_ptr<T>(new typename y_absl::remove_extent_t<T>[n]()); } -// `y_absl::make_unique` overload for an array T[N] of known bounds. +// `y_absl::make_unique` overload for an array T[N] of known bounds. // This construction will be rejected. template <typename T, typename... Args> typename memory_internal::MakeUniqueResult<T>::invalid make_unique( @@ -189,7 +189,7 @@ typename memory_internal::MakeUniqueResult<T>::invalid make_unique( // Function Template: RawPtr() // ----------------------------------------------------------------------------- // -// Extracts the raw pointer from a pointer-like value `ptr`. `y_absl::RawPtr` is +// Extracts the raw pointer from a pointer-like value `ptr`. `y_absl::RawPtr` is // useful within templates that need to handle a complement of raw pointers, // `std::nullptr_t`, and smart pointers. template <typename T> @@ -209,8 +209,8 @@ inline std::nullptr_t RawPtr(std::nullptr_t) { return nullptr; } // // Example: // -// auto up = y_absl::make_unique<int>(10); -// auto sp = y_absl::ShareUniquePtr(std::move(up)); // shared_ptr<int> +// auto up = y_absl::make_unique<int>(10); +// auto sp = y_absl::ShareUniquePtr(std::move(up)); // shared_ptr<int> // CHECK_EQ(*sp, 10); // CHECK(up == nullptr); // @@ -237,7 +237,7 @@ std::shared_ptr<T> ShareUniquePtr(std::unique_ptr<T, D>&& ptr) { // Example: // // auto sp = std::make_shared<int>(10); -// auto wp = y_absl::WeakenPtr(sp); +// auto wp = y_absl::WeakenPtr(sp); // CHECK_EQ(sp.get(), wp.lock().get()); // sp.reset(); // CHECK(wp.lock() == nullptr); @@ -437,32 +437,32 @@ struct allocator_traits { // const_pointer: // Alloc::const_pointer if present, otherwise - // y_absl::pointer_traits<pointer>::rebind<const value_type> + // y_absl::pointer_traits<pointer>::rebind<const value_type> using const_pointer = memory_internal::ExtractOrT<memory_internal::GetConstPointer, Alloc, - typename y_absl::pointer_traits<pointer>:: + typename y_absl::pointer_traits<pointer>:: template rebind<const value_type>>; // void_pointer: // Alloc::void_pointer if present, otherwise - // y_absl::pointer_traits<pointer>::rebind<void> + // y_absl::pointer_traits<pointer>::rebind<void> using void_pointer = memory_internal::ExtractOrT< memory_internal::GetVoidPointer, Alloc, - typename y_absl::pointer_traits<pointer>::template rebind<void>>; + typename y_absl::pointer_traits<pointer>::template rebind<void>>; // const_void_pointer: // Alloc::const_void_pointer if present, otherwise - // y_absl::pointer_traits<pointer>::rebind<const void> + // y_absl::pointer_traits<pointer>::rebind<const void> using const_void_pointer = memory_internal::ExtractOrT< memory_internal::GetConstVoidPointer, Alloc, - typename y_absl::pointer_traits<pointer>::template rebind<const void>>; + typename y_absl::pointer_traits<pointer>::template rebind<const void>>; // difference_type: // Alloc::difference_type if present, otherwise - // y_absl::pointer_traits<pointer>::difference_type + // y_absl::pointer_traits<pointer>::difference_type using difference_type = memory_internal::ExtractOrT< memory_internal::GetDifferenceType, Alloc, - typename y_absl::pointer_traits<pointer>::difference_type>; + typename y_absl::pointer_traits<pointer>::difference_type>; // size_type: // Alloc::size_type if present, otherwise @@ -504,9 +504,9 @@ struct allocator_traits { using rebind_alloc = typename memory_internal::RebindAlloc<Alloc, T>::type; // rebind_traits: - // y_absl::allocator_traits<rebind_alloc<T>> + // y_absl::allocator_traits<rebind_alloc<T>> template <typename T> - using rebind_traits = y_absl::allocator_traits<rebind_alloc<T>>; + using rebind_traits = y_absl::allocator_traits<rebind_alloc<T>>; // allocate(Alloc& a, size_type n): // Calls a.allocate(n) @@ -693,6 +693,6 @@ void CopyRange(Allocator& alloc, Iterator destination, InputIterator first, } } // namespace memory_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_MEMORY_MEMORY_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h index 9275412b7b..eb9649060b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h @@ -39,7 +39,7 @@ #include <functional> #include <type_traits> -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" // MSVC constructibility traits do not detect destructor properties and so our // implementations should not use them as a source-of-truth. @@ -55,7 +55,7 @@ #define ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT alignof(std::max_align_t) #endif // defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__) -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // Defined and documented later on in this file. @@ -103,11 +103,11 @@ struct IsTriviallyMoveAssignableReference : std::false_type {}; template <class T> struct IsTriviallyMoveAssignableReference<T&> - : y_absl::is_trivially_move_assignable<T>::type {}; + : y_absl::is_trivially_move_assignable<T>::type {}; template <class T> struct IsTriviallyMoveAssignableReference<T&&> - : y_absl::is_trivially_move_assignable<T>::type {}; + : y_absl::is_trivially_move_assignable<T>::type {}; template <typename... Ts> struct VoidTImpl { @@ -211,7 +211,7 @@ struct is_move_assignable : type_traits_internal::is_detected< // This metafunction is designed to be a drop-in replacement for the C++17 // `std::void_t` metafunction. // -// NOTE: `y_absl::void_t` does not use the standard-specified implementation so +// NOTE: `y_absl::void_t` does not use the standard-specified implementation so // that it can remain compatible with gcc < 5.1. This can introduce slightly // different behavior, such as when ordering partial specializations. template <typename... Ts> @@ -492,7 +492,7 @@ template <typename T> struct is_trivially_copy_assignable : std::integral_constant< bool, __has_trivial_assign(typename std::remove_reference<T>::type) && - y_absl::is_copy_assignable<T>::value> { + y_absl::is_copy_assignable<T>::value> { #ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE private: static constexpr bool compliant = @@ -543,7 +543,7 @@ namespace type_traits_internal { // one non-deleted copy/move constructor/assignment operator, and T is trivially // destructible. Arrays of trivially copyable types are trivially copyable. // -// We expose this metafunction only for internal use within y_absl. +// We expose this metafunction only for internal use within y_absl. template <typename T> class is_trivially_copyable_impl { using ExtentsRemoved = typename std::remove_all_extents<T>::type; @@ -551,8 +551,8 @@ class is_trivially_copyable_impl { std::is_copy_constructible<ExtentsRemoved>::value || std::is_move_constructible<ExtentsRemoved>::value; static constexpr bool kIsCopyOrMoveAssignable = - y_absl::is_copy_assignable<ExtentsRemoved>::value || - y_absl::is_move_assignable<ExtentsRemoved>::value; + y_absl::is_copy_assignable<ExtentsRemoved>::value || + y_absl::is_move_assignable<ExtentsRemoved>::value; public: static constexpr bool kValue = @@ -679,7 +679,7 @@ struct IsHashable : std::false_type {}; template <typename Key> struct IsHashable< Key, - y_absl::enable_if_t<std::is_convertible< + y_absl::enable_if_t<std::is_convertible< decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())), std::size_t>::value>> : std::true_type {}; #endif // !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ @@ -705,7 +705,7 @@ struct AssertHashEnabledHelper { static_assert( std::is_copy_constructible<std::hash<Key>>::value, "std::hash<Key> must be copy constructible when it is enabled"); - static_assert(y_absl::is_copy_assignable<std::hash<Key>>::value, + static_assert(y_absl::is_copy_assignable<std::hash<Key>>::value, "std::hash<Key> must be copy assignable when it is enabled"); // is_destructible is unchecked as it's implied by each of the // is_constructible checks. @@ -735,7 +735,7 @@ namespace swap_internal { // Necessary for the traits. using std::swap; -// This declaration prevents global `swap` and `y_absl::swap` overloads from being +// This declaration prevents global `swap` and `y_absl::swap` overloads from being // considered unless ADL picks them up. void swap(); @@ -754,7 +754,7 @@ using IsNothrowSwappableImpl = typename std::enable_if<IsNoexcept::value>::type; // arguments of type `T`. template <class T> struct IsSwappable - : y_absl::type_traits_internal::is_detected<IsSwappableImpl, T> {}; + : y_absl::type_traits_internal::is_detected<IsSwappableImpl, T> {}; // IsNothrowSwappable // @@ -762,13 +762,13 @@ struct IsSwappable // arguments of type `T` and is noexcept. template <class T> struct IsNothrowSwappable - : y_absl::type_traits_internal::is_detected<IsNothrowSwappableImpl, T> {}; + : y_absl::type_traits_internal::is_detected<IsNothrowSwappableImpl, T> {}; // Swap() // // Performs the swap idiom from a namespace where valid candidates may only be // found in `std` or via ADL. -template <class T, y_absl::enable_if_t<IsSwappable<T>::value, int> = 0> +template <class T, y_absl::enable_if_t<IsSwappable<T>::value, int> = 0> void Swap(T& lhs, T& rhs) noexcept(IsNothrowSwappable<T>::value) { swap(lhs, rhs); } @@ -792,6 +792,6 @@ using swap_internal::StdSwapIsUnconstrained; } // namespace type_traits_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_META_TYPE_TRAITS_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc index 514399def4..6172372d75 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/numeric/int128.h" +#include "y_absl/numeric/int128.h" #include <stddef.h> @@ -26,7 +26,7 @@ #include "y_absl/base/optimization.h" #include "y_absl/numeric/bits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN ABSL_DLL const uint128 kuint128max = MakeUint128( @@ -156,7 +156,7 @@ uint128 operator%(uint128 lhs, uint128 rhs) { namespace { -TString Uint128ToFormattedString(uint128 v, std::ios_base::fmtflags flags) { +TString Uint128ToFormattedString(uint128 v, std::ios_base::fmtflags flags) { // Select a divisor which is the largest power of the base < 2^64. uint128 div; int div_base_log; @@ -204,7 +204,7 @@ TString Uint128ToFormattedString(uint128 v, std::ios_base::fmtflags flags) { std::ostream& operator<<(std::ostream& os, uint128 v) { std::ios_base::fmtflags flags = os.flags(); - TString rep = Uint128ToFormattedString(v, flags); + TString rep = Uint128ToFormattedString(v, flags); // Add the requisite padding. std::streamsize width = os.width(0); @@ -286,7 +286,7 @@ int128 operator%(int128 lhs, int128 rhs) { std::ostream& operator<<(std::ostream& os, int128 v) { std::ios_base::fmtflags flags = os.flags(); - TString rep; + TString rep; // Add the sign if needed. bool print_as_decimal = @@ -330,54 +330,54 @@ std::ostream& operator<<(std::ostream& os, int128 v) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl namespace std { -constexpr bool numeric_limits<y_absl::uint128>::is_specialized; -constexpr bool numeric_limits<y_absl::uint128>::is_signed; -constexpr bool numeric_limits<y_absl::uint128>::is_integer; -constexpr bool numeric_limits<y_absl::uint128>::is_exact; -constexpr bool numeric_limits<y_absl::uint128>::has_infinity; -constexpr bool numeric_limits<y_absl::uint128>::has_quiet_NaN; -constexpr bool numeric_limits<y_absl::uint128>::has_signaling_NaN; -constexpr float_denorm_style numeric_limits<y_absl::uint128>::has_denorm; -constexpr bool numeric_limits<y_absl::uint128>::has_denorm_loss; -constexpr float_round_style numeric_limits<y_absl::uint128>::round_style; -constexpr bool numeric_limits<y_absl::uint128>::is_iec559; -constexpr bool numeric_limits<y_absl::uint128>::is_bounded; -constexpr bool numeric_limits<y_absl::uint128>::is_modulo; -constexpr int numeric_limits<y_absl::uint128>::digits; -constexpr int numeric_limits<y_absl::uint128>::digits10; -constexpr int numeric_limits<y_absl::uint128>::max_digits10; -constexpr int numeric_limits<y_absl::uint128>::radix; -constexpr int numeric_limits<y_absl::uint128>::min_exponent; -constexpr int numeric_limits<y_absl::uint128>::min_exponent10; -constexpr int numeric_limits<y_absl::uint128>::max_exponent; -constexpr int numeric_limits<y_absl::uint128>::max_exponent10; -constexpr bool numeric_limits<y_absl::uint128>::traps; -constexpr bool numeric_limits<y_absl::uint128>::tinyness_before; - -constexpr bool numeric_limits<y_absl::int128>::is_specialized; -constexpr bool numeric_limits<y_absl::int128>::is_signed; -constexpr bool numeric_limits<y_absl::int128>::is_integer; -constexpr bool numeric_limits<y_absl::int128>::is_exact; -constexpr bool numeric_limits<y_absl::int128>::has_infinity; -constexpr bool numeric_limits<y_absl::int128>::has_quiet_NaN; -constexpr bool numeric_limits<y_absl::int128>::has_signaling_NaN; -constexpr float_denorm_style numeric_limits<y_absl::int128>::has_denorm; -constexpr bool numeric_limits<y_absl::int128>::has_denorm_loss; -constexpr float_round_style numeric_limits<y_absl::int128>::round_style; -constexpr bool numeric_limits<y_absl::int128>::is_iec559; -constexpr bool numeric_limits<y_absl::int128>::is_bounded; -constexpr bool numeric_limits<y_absl::int128>::is_modulo; -constexpr int numeric_limits<y_absl::int128>::digits; -constexpr int numeric_limits<y_absl::int128>::digits10; -constexpr int numeric_limits<y_absl::int128>::max_digits10; -constexpr int numeric_limits<y_absl::int128>::radix; -constexpr int numeric_limits<y_absl::int128>::min_exponent; -constexpr int numeric_limits<y_absl::int128>::min_exponent10; -constexpr int numeric_limits<y_absl::int128>::max_exponent; -constexpr int numeric_limits<y_absl::int128>::max_exponent10; -constexpr bool numeric_limits<y_absl::int128>::traps; -constexpr bool numeric_limits<y_absl::int128>::tinyness_before; +constexpr bool numeric_limits<y_absl::uint128>::is_specialized; +constexpr bool numeric_limits<y_absl::uint128>::is_signed; +constexpr bool numeric_limits<y_absl::uint128>::is_integer; +constexpr bool numeric_limits<y_absl::uint128>::is_exact; +constexpr bool numeric_limits<y_absl::uint128>::has_infinity; +constexpr bool numeric_limits<y_absl::uint128>::has_quiet_NaN; +constexpr bool numeric_limits<y_absl::uint128>::has_signaling_NaN; +constexpr float_denorm_style numeric_limits<y_absl::uint128>::has_denorm; +constexpr bool numeric_limits<y_absl::uint128>::has_denorm_loss; +constexpr float_round_style numeric_limits<y_absl::uint128>::round_style; +constexpr bool numeric_limits<y_absl::uint128>::is_iec559; +constexpr bool numeric_limits<y_absl::uint128>::is_bounded; +constexpr bool numeric_limits<y_absl::uint128>::is_modulo; +constexpr int numeric_limits<y_absl::uint128>::digits; +constexpr int numeric_limits<y_absl::uint128>::digits10; +constexpr int numeric_limits<y_absl::uint128>::max_digits10; +constexpr int numeric_limits<y_absl::uint128>::radix; +constexpr int numeric_limits<y_absl::uint128>::min_exponent; +constexpr int numeric_limits<y_absl::uint128>::min_exponent10; +constexpr int numeric_limits<y_absl::uint128>::max_exponent; +constexpr int numeric_limits<y_absl::uint128>::max_exponent10; +constexpr bool numeric_limits<y_absl::uint128>::traps; +constexpr bool numeric_limits<y_absl::uint128>::tinyness_before; + +constexpr bool numeric_limits<y_absl::int128>::is_specialized; +constexpr bool numeric_limits<y_absl::int128>::is_signed; +constexpr bool numeric_limits<y_absl::int128>::is_integer; +constexpr bool numeric_limits<y_absl::int128>::is_exact; +constexpr bool numeric_limits<y_absl::int128>::has_infinity; +constexpr bool numeric_limits<y_absl::int128>::has_quiet_NaN; +constexpr bool numeric_limits<y_absl::int128>::has_signaling_NaN; +constexpr float_denorm_style numeric_limits<y_absl::int128>::has_denorm; +constexpr bool numeric_limits<y_absl::int128>::has_denorm_loss; +constexpr float_round_style numeric_limits<y_absl::int128>::round_style; +constexpr bool numeric_limits<y_absl::int128>::is_iec559; +constexpr bool numeric_limits<y_absl::int128>::is_bounded; +constexpr bool numeric_limits<y_absl::int128>::is_modulo; +constexpr int numeric_limits<y_absl::int128>::digits; +constexpr int numeric_limits<y_absl::int128>::digits10; +constexpr int numeric_limits<y_absl::int128>::max_digits10; +constexpr int numeric_limits<y_absl::int128>::radix; +constexpr int numeric_limits<y_absl::int128>::min_exponent; +constexpr int numeric_limits<y_absl::int128>::min_exponent10; +constexpr int numeric_limits<y_absl::int128>::max_exponent; +constexpr int numeric_limits<y_absl::int128>::max_exponent10; +constexpr bool numeric_limits<y_absl::int128>::traps; +constexpr bool numeric_limits<y_absl::int128>::tinyness_before; } // namespace std diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h index 86688ad7bf..b54d614ce9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h @@ -34,9 +34,9 @@ #include <limits> #include <utility> -#include "y_absl/base/config.h" -#include "y_absl/base/macros.h" -#include "y_absl/base/port.h" +#include "y_absl/base/config.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/port.h" #if defined(_MSC_VER) // In very old versions of MSVC and when the /Zc:wchar_t flag is off, wchar_t is @@ -52,7 +52,7 @@ #define ABSL_INTERNAL_WCHAR_T wchar_t #endif // defined(_MSC_VER) -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN class int128; @@ -94,10 +94,10 @@ class int128; // // Example: // -// float y = y_absl::Uint128Max(); // Error. uint128 cannot be implicitly +// float y = y_absl::Uint128Max(); // Error. uint128 cannot be implicitly // // converted to float. // -// y_absl::uint128 v; +// y_absl::uint128 v; // uint64_t i = v; // Error // uint64_t i = static_cast<uint64_t>(v); // OK // @@ -203,7 +203,7 @@ class // // Example: // - // y_absl::uint128 big = y_absl::MakeUint128(1, 0); + // y_absl::uint128 big = y_absl::MakeUint128(1, 0); friend constexpr uint128 MakeUint128(uint64_t high, uint64_t low); // Uint128Max() @@ -211,7 +211,7 @@ class // Returns the highest value for a 128-bit unsigned integer. friend constexpr uint128 Uint128Max(); - // Support for y_absl::Hash. + // Support for y_absl::Hash. template <typename H> friend H AbslHashValue(H h, uint128 v) { return H::combine(std::move(h), Uint128High64(v), Uint128Low64(v)); @@ -237,7 +237,7 @@ class // Prefer to use the constexpr `Uint128Max()`. // -// TODO(y_absl-team) deprecate kuint128max once migration tool is released. +// TODO(y_absl-team) deprecate kuint128max once migration tool is released. ABSL_DLL extern const uint128 kuint128max; // allow uint128 to be logged @@ -251,12 +251,12 @@ constexpr uint128 Uint128Max() { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl // Specialized numeric_limits for uint128. namespace std { template <> -class numeric_limits<y_absl::uint128> { +class numeric_limits<y_absl::uint128> { public: static constexpr bool is_specialized = true; static constexpr bool is_signed = false; @@ -286,19 +286,19 @@ class numeric_limits<y_absl::uint128> { #endif // ABSL_HAVE_INTRINSIC_INT128 static constexpr bool tinyness_before = false; - static constexpr y_absl::uint128 (min)() { return 0; } - static constexpr y_absl::uint128 lowest() { return 0; } - static constexpr y_absl::uint128 (max)() { return y_absl::Uint128Max(); } - static constexpr y_absl::uint128 epsilon() { return 0; } - static constexpr y_absl::uint128 round_error() { return 0; } - static constexpr y_absl::uint128 infinity() { return 0; } - static constexpr y_absl::uint128 quiet_NaN() { return 0; } - static constexpr y_absl::uint128 signaling_NaN() { return 0; } - static constexpr y_absl::uint128 denorm_min() { return 0; } + static constexpr y_absl::uint128 (min)() { return 0; } + static constexpr y_absl::uint128 lowest() { return 0; } + static constexpr y_absl::uint128 (max)() { return y_absl::Uint128Max(); } + static constexpr y_absl::uint128 epsilon() { return 0; } + static constexpr y_absl::uint128 round_error() { return 0; } + static constexpr y_absl::uint128 infinity() { return 0; } + static constexpr y_absl::uint128 quiet_NaN() { return 0; } + static constexpr y_absl::uint128 signaling_NaN() { return 0; } + static constexpr y_absl::uint128 denorm_min() { return 0; } }; } // namespace std -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // int128 @@ -328,10 +328,10 @@ ABSL_NAMESPACE_BEGIN // // Example: // -// float y = y_absl::int128(17); // Error. int128 cannot be implicitly +// float y = y_absl::int128(17); // Error. int128 cannot be implicitly // // converted to float. // -// y_absl::int128 v; +// y_absl::int128 v; // int64_t i = v; // Error // int64_t i = static_cast<int64_t>(v); // OK // @@ -427,15 +427,15 @@ class int128 { // Constructs a `int128` numeric value from two 64-bit integers. Note that // signedness is conveyed in the upper `high` value. // - // (y_absl::int128(1) << 64) * high + low + // (y_absl::int128(1) << 64) * high + low // // Note that this factory function is the only way to construct a `int128` // from integer values greater than 2^64 or less than -2^64. // // Example: // - // y_absl::int128 big = y_absl::MakeInt128(1, 0); - // y_absl::int128 big_n = y_absl::MakeInt128(-1, 0); + // y_absl::int128 big = y_absl::MakeInt128(1, 0); + // y_absl::int128 big_n = y_absl::MakeInt128(-1, 0); friend constexpr int128 MakeInt128(int64_t high, uint64_t low); // Int128Max() @@ -448,7 +448,7 @@ class int128 { // Returns the minimum value for a 128-bit signed integer. friend constexpr int128 Int128Min(); - // Support for y_absl::Hash. + // Support for y_absl::Hash. template <typename H> friend H AbslHashValue(H h, int128 v) { return H::combine(std::move(h), Int128High64(v), Int128Low64(v)); @@ -474,7 +474,7 @@ class int128 { std::ostream& operator<<(std::ostream& os, int128 v); -// TODO(y_absl-team) add operator>>(std::istream&, int128) +// TODO(y_absl-team) add operator>>(std::istream&, int128) constexpr int128 Int128Max() { return int128((std::numeric_limits<int64_t>::max)(), @@ -486,12 +486,12 @@ constexpr int128 Int128Min() { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl // Specialized numeric_limits for int128. namespace std { template <> -class numeric_limits<y_absl::int128> { +class numeric_limits<y_absl::int128> { public: static constexpr bool is_specialized = true; static constexpr bool is_signed = true; @@ -521,22 +521,22 @@ class numeric_limits<y_absl::int128> { #endif // ABSL_HAVE_INTRINSIC_INT128 static constexpr bool tinyness_before = false; - static constexpr y_absl::int128 (min)() { return y_absl::Int128Min(); } - static constexpr y_absl::int128 lowest() { return y_absl::Int128Min(); } - static constexpr y_absl::int128 (max)() { return y_absl::Int128Max(); } - static constexpr y_absl::int128 epsilon() { return 0; } - static constexpr y_absl::int128 round_error() { return 0; } - static constexpr y_absl::int128 infinity() { return 0; } - static constexpr y_absl::int128 quiet_NaN() { return 0; } - static constexpr y_absl::int128 signaling_NaN() { return 0; } - static constexpr y_absl::int128 denorm_min() { return 0; } + static constexpr y_absl::int128 (min)() { return y_absl::Int128Min(); } + static constexpr y_absl::int128 lowest() { return y_absl::Int128Min(); } + static constexpr y_absl::int128 (max)() { return y_absl::Int128Max(); } + static constexpr y_absl::int128 epsilon() { return 0; } + static constexpr y_absl::int128 round_error() { return 0; } + static constexpr y_absl::int128 infinity() { return 0; } + static constexpr y_absl::int128 quiet_NaN() { return 0; } + static constexpr y_absl::int128 signaling_NaN() { return 0; } + static constexpr y_absl::int128 denorm_min() { return 0; } }; } // namespace std // -------------------------------------------------------------------------- // Implementation details follow // -------------------------------------------------------------------------- -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN constexpr uint128 MakeUint128(uint64_t high, uint64_t low) { @@ -1152,13 +1152,13 @@ constexpr int64_t BitCastToSigned(uint64_t v) { } // namespace int128_internal #if defined(ABSL_HAVE_INTRINSIC_INT128) -#include "y_absl/numeric/int128_have_intrinsic.inc" // IWYU pragma: export +#include "y_absl/numeric/int128_have_intrinsic.inc" // IWYU pragma: export #else // ABSL_HAVE_INTRINSIC_INT128 -#include "y_absl/numeric/int128_no_intrinsic.inc" // IWYU pragma: export +#include "y_absl/numeric/int128_no_intrinsic.inc" // IWYU pragma: export #endif // ABSL_HAVE_INTRINSIC_INT128 ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #undef ABSL_INTERNAL_WCHAR_T diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.cc index 3855e2cf8d..02f5dfd9da 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.cc @@ -21,10 +21,10 @@ #include <cmath> #include <limits> -#include "y_absl/base/attributes.h" -#include "y_absl/base/optimization.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/optimization.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace profiling_internal { @@ -90,4 +90,4 @@ void ExponentialBiased::Initialize() { } // namespace profiling_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.h b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.h index 857ae6f93f..ee7954a535 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.h @@ -20,7 +20,7 @@ #include "y_absl/base/config.h" #include "y_absl/base/macros.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace profiling_internal { @@ -125,6 +125,6 @@ inline uint64_t ExponentialBiased::NextRandom(uint64_t rnd) { } // namespace profiling_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.cc index 4b97fa10bb..39fb3660f0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.cc @@ -18,7 +18,7 @@ #include "y_absl/profiling/internal/exponential_biased.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace profiling_internal { @@ -50,4 +50,4 @@ bool PeriodicSamplerBase::SubtleConfirmSample() noexcept { } // namespace profiling_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.h b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.h index 7d14c62d34..37796a9e00 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.h @@ -19,10 +19,10 @@ #include <atomic> -#include "y_absl/base/optimization.h" +#include "y_absl/base/optimization.h" #include "y_absl/profiling/internal/exponential_biased.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace profiling_internal { @@ -206,6 +206,6 @@ std::atomic<int> PeriodicSampler<Tag, default_period>::period_(default_period); } // namespace profiling_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.cc index 45e3ea43c3..959d6c27ff 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.cc @@ -12,9 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/ascii.h" +#include "y_absl/strings/ascii.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace ascii_internal { @@ -155,19 +155,19 @@ ABSL_DLL const char kToUpper[256] = { } // namespace ascii_internal -void AsciiStrToLower(TString* s) { +void AsciiStrToLower(TString* s) { for (auto& ch : *s) { - ch = y_absl::ascii_tolower(ch); + ch = y_absl::ascii_tolower(ch); } } -void AsciiStrToUpper(TString* s) { +void AsciiStrToUpper(TString* s) { for (auto& ch : *s) { - ch = y_absl::ascii_toupper(ch); + ch = y_absl::ascii_toupper(ch); } } -void RemoveExtraAsciiWhitespace(TString* str) { +void RemoveExtraAsciiWhitespace(TString* str) { auto stripped = StripAsciiWhitespace(*str); if (stripped.empty()) { @@ -183,10 +183,10 @@ void RemoveExtraAsciiWhitespace(TString* str) { for (; input_it < input_end; ++input_it) { if (is_ws) { // Consecutive whitespace? Keep only the last. - is_ws = y_absl::ascii_isspace(*input_it); + is_ws = y_absl::ascii_isspace(*input_it); if (is_ws) --output_it; } else { - is_ws = y_absl::ascii_isspace(*input_it); + is_ws = y_absl::ascii_isspace(*input_it); } *output_it = *input_it; @@ -197,4 +197,4 @@ void RemoveExtraAsciiWhitespace(TString* str) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.h index efe3c4f38f..bc04710d8c 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.h @@ -55,11 +55,11 @@ #include <algorithm> #include <util/generic/string.h> -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" #include "y_absl/base/config.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace ascii_internal { @@ -165,12 +165,12 @@ inline char ascii_tolower(unsigned char c) { } // Converts the characters in `s` to lowercase, changing the contents of `s`. -void AsciiStrToLower(TString* s); +void AsciiStrToLower(TString* s); -// Creates a lowercase string from a given y_absl::string_view. -ABSL_MUST_USE_RESULT inline TString AsciiStrToLower(y_absl::string_view s) { - TString result(s); - y_absl::AsciiStrToLower(&result); +// Creates a lowercase string from a given y_absl::string_view. +ABSL_MUST_USE_RESULT inline TString AsciiStrToLower(y_absl::string_view s) { + TString result(s); + y_absl::AsciiStrToLower(&result); return result; } @@ -183,60 +183,60 @@ inline char ascii_toupper(unsigned char c) { } // Converts the characters in `s` to uppercase, changing the contents of `s`. -void AsciiStrToUpper(TString* s); +void AsciiStrToUpper(TString* s); -// Creates an uppercase string from a given y_absl::string_view. -ABSL_MUST_USE_RESULT inline TString AsciiStrToUpper(y_absl::string_view s) { - TString result(s); - y_absl::AsciiStrToUpper(&result); +// Creates an uppercase string from a given y_absl::string_view. +ABSL_MUST_USE_RESULT inline TString AsciiStrToUpper(y_absl::string_view s) { + TString result(s); + y_absl::AsciiStrToUpper(&result); return result; } -// Returns y_absl::string_view with whitespace stripped from the beginning of the +// Returns y_absl::string_view with whitespace stripped from the beginning of the // given string_view. -ABSL_MUST_USE_RESULT inline y_absl::string_view StripLeadingAsciiWhitespace( - y_absl::string_view str) { - auto it = std::find_if_not(str.begin(), str.end(), y_absl::ascii_isspace); +ABSL_MUST_USE_RESULT inline y_absl::string_view StripLeadingAsciiWhitespace( + y_absl::string_view str) { + auto it = std::find_if_not(str.begin(), str.end(), y_absl::ascii_isspace); return str.substr(it - str.begin()); } // Strips in place whitespace from the beginning of the given string. -inline void StripLeadingAsciiWhitespace(TString* str) { - auto it = std::find_if_not(str->cbegin(), str->cend(), y_absl::ascii_isspace); +inline void StripLeadingAsciiWhitespace(TString* str) { + auto it = std::find_if_not(str->cbegin(), str->cend(), y_absl::ascii_isspace); str->erase(str->begin(), it); } -// Returns y_absl::string_view with whitespace stripped from the end of the given +// Returns y_absl::string_view with whitespace stripped from the end of the given // string_view. -ABSL_MUST_USE_RESULT inline y_absl::string_view StripTrailingAsciiWhitespace( - y_absl::string_view str) { - auto it = std::find_if_not(str.rbegin(), str.rend(), y_absl::ascii_isspace); +ABSL_MUST_USE_RESULT inline y_absl::string_view StripTrailingAsciiWhitespace( + y_absl::string_view str) { + auto it = std::find_if_not(str.rbegin(), str.rend(), y_absl::ascii_isspace); return str.substr(0, str.rend() - it); } // Strips in place whitespace from the end of the given string -inline void StripTrailingAsciiWhitespace(TString* str) { - auto it = std::find_if_not(str->rbegin(), str->rend(), y_absl::ascii_isspace); +inline void StripTrailingAsciiWhitespace(TString* str) { + auto it = std::find_if_not(str->rbegin(), str->rend(), y_absl::ascii_isspace); str->erase(str->rend() - it); } -// Returns y_absl::string_view with whitespace stripped from both ends of the +// Returns y_absl::string_view with whitespace stripped from both ends of the // given string_view. -ABSL_MUST_USE_RESULT inline y_absl::string_view StripAsciiWhitespace( - y_absl::string_view str) { +ABSL_MUST_USE_RESULT inline y_absl::string_view StripAsciiWhitespace( + y_absl::string_view str) { return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str)); } // Strips in place whitespace from both ends of the given string -inline void StripAsciiWhitespace(TString* str) { +inline void StripAsciiWhitespace(TString* str) { StripTrailingAsciiWhitespace(str); StripLeadingAsciiWhitespace(str); } // Removes leading, trailing, and consecutive internal whitespace. -void RemoveExtraAsciiWhitespace(TString*); +void RemoveExtraAsciiWhitespace(TString*); ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_ASCII_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc index ff906ea64f..9515ca24dd 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc @@ -12,18 +12,18 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/charconv.h" +#include "y_absl/strings/charconv.h" #include <algorithm> #include <cassert> #include <cmath> #include <cstring> -#include "y_absl/base/casts.h" +#include "y_absl/base/casts.h" #include "y_absl/numeric/bits.h" -#include "y_absl/numeric/int128.h" -#include "y_absl/strings/internal/charconv_bigint.h" -#include "y_absl/strings/internal/charconv_parse.h" +#include "y_absl/numeric/int128.h" +#include "y_absl/strings/internal/charconv_bigint.h" +#include "y_absl/strings/internal/charconv_parse.h" // The macro ABSL_BIT_PACK_FLOATS is defined on x86-64, where IEEE floating // point numbers have the same endianness in memory as a bitfield struct @@ -56,7 +56,7 @@ // end result normally has the 53rd bit set. It represents subnormals by using // narrower mantissas. -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { @@ -124,7 +124,7 @@ struct FloatTraits<double> { assert(exponent == kMinNormalExponent); } dbl += mantissa; - return y_absl::bit_cast<double>(dbl); + return y_absl::bit_cast<double>(dbl); #endif // ABSL_BIT_PACK_FLOATS } }; @@ -164,7 +164,7 @@ struct FloatTraits<float> { assert(exponent == kMinNormalExponent); } flt += mantissa; - return y_absl::bit_cast<float>(flt); + return y_absl::bit_cast<float>(flt); #endif // ABSL_BIT_PACK_FLOATS } }; @@ -326,7 +326,7 @@ bool HandleEdgeCase(const strings_internal::ParsedFloat& input, bool negative, // number is stored in *value. template <typename FloatType> void EncodeResult(const CalculatedFloat& calculated, bool negative, - y_absl::from_chars_result* result, FloatType* value) { + y_absl::from_chars_result* result, FloatType* value) { if (calculated.exponent == kOverflow) { result->ec = std::errc::result_out_of_range; *value = negative ? -std::numeric_limits<FloatType>::max() @@ -432,7 +432,7 @@ bool MustRoundUp(uint64_t guess_mantissa, int guess_exponent, // better limit dynamically based on the value of parsed_decimal.exponent. // This would optimize pathological input cases only. (Sane inputs won't have // hundreds of digits of mantissa.) - y_absl::strings_internal::BigUnsigned<84> exact_mantissa; + y_absl::strings_internal::BigUnsigned<84> exact_mantissa; int exact_exponent = exact_mantissa.ReadFloatMantissa(parsed_decimal, 768); // Adjust the `guess` arguments to be halfway between A and B. @@ -446,11 +446,11 @@ bool MustRoundUp(uint64_t guess_mantissa, int guess_exponent, // // Because we are doing integer math, we can't directly deal with negative // exponents. We instead move these to the other side of the inequality. - y_absl::strings_internal::BigUnsigned<84>& lhs = exact_mantissa; + y_absl::strings_internal::BigUnsigned<84>& lhs = exact_mantissa; int comparison; if (exact_exponent >= 0) { lhs.MultiplyByFiveToTheNth(exact_exponent); - y_absl::strings_internal::BigUnsigned<84> rhs(guess_mantissa); + y_absl::strings_internal::BigUnsigned<84> rhs(guess_mantissa); // There are powers of 2 on both sides of the inequality; reduce this to // a single bit-shift. if (exact_exponent > guess_exponent) { @@ -463,8 +463,8 @@ bool MustRoundUp(uint64_t guess_mantissa, int guess_exponent, // Move the power of 5 to the other side of the equation, giving us: // lhs = exact_mantissa * 2**exact_exponent // rhs = guess_mantissa * 5**(-exact_exponent) * 2**guess_exponent - y_absl::strings_internal::BigUnsigned<84> rhs = - y_absl::strings_internal::BigUnsigned<84>::FiveToTheNth(-exact_exponent); + y_absl::strings_internal::BigUnsigned<84> rhs = + y_absl::strings_internal::BigUnsigned<84>::FiveToTheNth(-exact_exponent); rhs.MultiplyBy(guess_mantissa); if (exact_exponent > guess_exponent) { lhs.ShiftLeft(exact_exponent - guess_exponent); @@ -981,4 +981,4 @@ const int16_t kPower10ExponentTable[] = { } // namespace ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.h index a80092f504..1a115aa251 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.h @@ -19,12 +19,12 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // Workalike compatibilty version of std::chars_format from C++17. // -// This is an bitfield enumerator which can be passed to y_absl::from_chars to +// This is an bitfield enumerator which can be passed to y_absl::from_chars to // configure the string-to-float conversion. enum class chars_format { scientific = 1, @@ -76,11 +76,11 @@ struct from_chars_result { // format that strtod() accepts, except that a "0x" prefix is NOT matched. // (In particular, in `hex` mode, the input "0xff" results in the largest // matching pattern "0".) -y_absl::from_chars_result from_chars(const char* first, const char* last, +y_absl::from_chars_result from_chars(const char* first, const char* last, double& value, // NOLINT chars_format fmt = chars_format::general); -y_absl::from_chars_result from_chars(const char* first, const char* last, +y_absl::from_chars_result from_chars(const char* first, const char* last, float& value, // NOLINT chars_format fmt = chars_format::general); @@ -115,6 +115,6 @@ inline chars_format& operator^=(chars_format& lhs, chars_format rhs) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_CHARCONV_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc index 4461d83a85..8c82740608 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/escaping.h" +#include "y_absl/strings/escaping.h" #include <algorithm> #include <cassert> @@ -22,18 +22,18 @@ #include <limits> #include <util/generic/string.h> -#include "y_absl/base/internal/endian.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/unaligned_access.h" -#include "y_absl/strings/internal/char_map.h" +#include "y_absl/base/internal/endian.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/unaligned_access.h" +#include "y_absl/strings/internal/char_map.h" #include "y_absl/strings/internal/escaping.h" -#include "y_absl/strings/internal/resize_uninitialized.h" -#include "y_absl/strings/internal/utf8.h" -#include "y_absl/strings/str_cat.h" -#include "y_absl/strings/str_join.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/strings/internal/resize_uninitialized.h" +#include "y_absl/strings/internal/utf8.h" +#include "y_absl/strings/str_cat.h" +#include "y_absl/strings/str_join.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { @@ -45,7 +45,7 @@ inline bool is_octal_digit(char c) { return ('0' <= c) && (c <= '7'); } inline int hex_digit_to_int(char c) { static_assert('0' == 0x30 && 'A' == 0x41 && 'a' == 0x61, "Character set must be ASCII."); - assert(y_absl::ascii_isxdigit(c)); + assert(y_absl::ascii_isxdigit(c)); int x = static_cast<unsigned char>(c); if (x > '9') { x += 9; @@ -53,10 +53,10 @@ inline int hex_digit_to_int(char c) { return x & 0xf; } -inline bool IsSurrogate(char32_t c, y_absl::string_view src, TString* error) { +inline bool IsSurrogate(char32_t c, y_absl::string_view src, TString* error) { if (c >= 0xD800 && c <= 0xDFFF) { if (error) { - *error = y_absl::StrCat("invalid surrogate character (0xD800-DFFF): \\", + *error = y_absl::StrCat("invalid surrogate character (0xD800-DFFF): \\", src); } return true; @@ -81,8 +81,8 @@ inline bool IsSurrogate(char32_t c, y_absl::string_view src, TString* error) { // NOTE: any changes to this function must also be reflected in the older // UnescapeCEscapeSequences(). // ---------------------------------------------------------------------- -bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, - char* dest, ptrdiff_t* dest_len, TString* error) { +bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, + char* dest, ptrdiff_t* dest_len, TString* error) { char* d = dest; const char* p = source.data(); const char* end = p + source.size(); @@ -128,7 +128,7 @@ bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, if (ch > 0xff) { if (error) { *error = "Value of \\" + - TString(octal_start, p + 1 - octal_start) + + TString(octal_start, p + 1 - octal_start) + " exceeds 0xff"; } return false; @@ -149,19 +149,19 @@ bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, if (p >= last_byte) { if (error) *error = "String cannot end with \\x"; return false; - } else if (!y_absl::ascii_isxdigit(p[1])) { + } else if (!y_absl::ascii_isxdigit(p[1])) { if (error) *error = "\\x cannot be followed by a non-hex digit"; return false; } unsigned int ch = 0; const char* hex_start = p; - while (p < last_byte && y_absl::ascii_isxdigit(p[1])) + while (p < last_byte && y_absl::ascii_isxdigit(p[1])) // Arbitrarily many hex digits ch = (ch << 4) + hex_digit_to_int(*++p); if (ch > 0xFF) { if (error) { *error = "Value of \\" + - TString(hex_start, p + 1 - hex_start) + + TString(hex_start, p + 1 - hex_start) + " exceeds 0xff"; } return false; @@ -184,18 +184,18 @@ bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, if (p + 4 >= end) { if (error) { *error = "\\u must be followed by 4 hex digits: \\" + - TString(hex_start, p + 1 - hex_start); + TString(hex_start, p + 1 - hex_start); } return false; } for (int i = 0; i < 4; ++i) { // Look one char ahead. - if (y_absl::ascii_isxdigit(p[1])) { + if (y_absl::ascii_isxdigit(p[1])) { rune = (rune << 4) + hex_digit_to_int(*++p); // Advance p. } else { if (error) { *error = "\\u must be followed by 4 hex digits: \\" + - TString(hex_start, p + 1 - hex_start); + TString(hex_start, p + 1 - hex_start); } return false; } @@ -207,7 +207,7 @@ bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, d += 5; break; } - if (IsSurrogate(rune, y_absl::string_view(hex_start, 5), error)) { + if (IsSurrogate(rune, y_absl::string_view(hex_start, 5), error)) { return false; } d += strings_internal::EncodeUTF8Char(d, rune); @@ -220,20 +220,20 @@ bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, if (p + 8 >= end) { if (error) { *error = "\\U must be followed by 8 hex digits: \\" + - TString(hex_start, p + 1 - hex_start); + TString(hex_start, p + 1 - hex_start); } return false; } for (int i = 0; i < 8; ++i) { // Look one char ahead. - if (y_absl::ascii_isxdigit(p[1])) { + if (y_absl::ascii_isxdigit(p[1])) { // Don't change rune until we're sure this // is within the Unicode limit, but do advance p. uint32_t newrune = (rune << 4) + hex_digit_to_int(*++p); if (newrune > 0x10FFFF) { if (error) { *error = "Value of \\" + - TString(hex_start, p + 1 - hex_start) + + TString(hex_start, p + 1 - hex_start) + " exceeds Unicode limit (0x10FFFF)"; } return false; @@ -243,7 +243,7 @@ bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, } else { if (error) { *error = "\\U must be followed by 8 hex digits: \\" + - TString(hex_start, p + 1 - hex_start); + TString(hex_start, p + 1 - hex_start); } return false; } @@ -255,14 +255,14 @@ bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, d += 9; break; } - if (IsSurrogate(rune, y_absl::string_view(hex_start, 9), error)) { + if (IsSurrogate(rune, y_absl::string_view(hex_start, 9), error)) { return false; } d += strings_internal::EncodeUTF8Char(d, rune); break; } default: { - if (error) *error = TString("Unknown escape sequence: \\") + *p; + if (error) *error = TString("Unknown escape sequence: \\") + *p; return false; } } @@ -276,11 +276,11 @@ bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, // ---------------------------------------------------------------------- // CUnescapeInternal() // -// Same as above but uses a TString for output. 'source' and 'dest' +// Same as above but uses a TString for output. 'source' and 'dest' // may be the same. // ---------------------------------------------------------------------- -bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, - TString* dest, TString* error) { +bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, + TString* dest, TString* error) { strings_internal::STLStringResizeUninitialized(dest, source.size()); ptrdiff_t dest_size; @@ -304,11 +304,11 @@ bool CUnescapeInternal(y_absl::string_view source, bool leave_nulls_escaped, // preparing query flags. The 'Hex' version uses hexadecimal rather than // octal sequences. The 'Utf8Safe' version does not touch UTF-8 bytes. // -// Escaped chars: \n, \r, \t, ", ', \, and !y_absl::ascii_isprint(). +// Escaped chars: \n, \r, \t, ", ', \, and !y_absl::ascii_isprint(). // ---------------------------------------------------------------------- -TString CEscapeInternal(y_absl::string_view src, bool use_hex, +TString CEscapeInternal(y_absl::string_view src, bool use_hex, bool utf8_safe) { - TString dest; + TString dest; bool last_hex_escape = false; // true if last output char was \xNN. for (unsigned char c : src) { @@ -325,8 +325,8 @@ TString CEscapeInternal(y_absl::string_view src, bool use_hex, // digit then that digit must be escaped too to prevent it being // interpreted as part of the character code by C. if ((!utf8_safe || c < 0x80) && - (!y_absl::ascii_isprint(c) || - (last_hex_escape && y_absl::ascii_isxdigit(c)))) { + (!y_absl::ascii_isprint(c) || + (last_hex_escape && y_absl::ascii_isxdigit(c)))) { if (use_hex) { dest.append("\\" "x"); dest.push_back(numbers_internal::kHexChar[c / 16]); @@ -373,13 +373,13 @@ constexpr char c_escaped_len[256] = { // Calculates the length of the C-style escaped version of 'src'. // Assumes that non-printable characters are escaped using octal sequences, and // that UTF-8 bytes are not handled specially. -inline size_t CEscapedLength(y_absl::string_view src) { +inline size_t CEscapedLength(y_absl::string_view src) { size_t escaped_len = 0; for (unsigned char c : src) escaped_len += c_escaped_len[c]; return escaped_len; } -void CEscapeAndAppendInternal(y_absl::string_view src, TString* dest) { +void CEscapeAndAppendInternal(y_absl::string_view src, TString* dest) { size_t escaped_len = CEscapedLength(src); if (escaped_len == src.size()) { dest->append(src.data(), src.size()); @@ -460,7 +460,7 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest, ch = *src++; \ decode = unbase64[ch]; \ if (decode < 0) { \ - if (y_absl::ascii_isspace(ch) && szsrc >= remain) goto label; \ + if (y_absl::ascii_isspace(ch) && szsrc >= remain) goto label; \ state = 4 - remain; \ break; \ } @@ -550,7 +550,7 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest, // if the loop terminated because we read a bad character, return // now. if (decode < 0 && ch != kPad64Equals && ch != kPad64Dot && - !y_absl::ascii_isspace(ch)) + !y_absl::ascii_isspace(ch)) return false; if (ch == kPad64Equals || ch == kPad64Dot) { @@ -569,7 +569,7 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest, ch = *src++; decode = unbase64[ch]; if (decode < 0) { - if (y_absl::ascii_isspace(ch)) { + if (y_absl::ascii_isspace(ch)) { continue; } else if (ch == kPad64Equals || ch == kPad64Dot) { // back up one character; we'll read it again when we check @@ -653,7 +653,7 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest, while (szsrc > 0) { if (*src == kPad64Equals || *src == kPad64Dot) ++equals; - else if (!y_absl::ascii_isspace(*src)) + else if (!y_absl::ascii_isspace(*src)) return false; --szsrc; ++src; @@ -829,7 +829,7 @@ void HexStringToBytesInternal(const char* from, T to, ptrdiff_t num) { } // This is a templated function so that T can be either a char* or a -// TString. +// TString. template <typename T> void BytesToHexStringInternal(const unsigned char* src, T dest, ptrdiff_t num) { auto dest_ptr = &dest[0]; @@ -846,26 +846,26 @@ void BytesToHexStringInternal(const unsigned char* src, T dest, ptrdiff_t num) { // // See CUnescapeInternal() for implementation details. // ---------------------------------------------------------------------- -bool CUnescape(y_absl::string_view source, TString* dest, - TString* error) { +bool CUnescape(y_absl::string_view source, TString* dest, + TString* error) { return CUnescapeInternal(source, kUnescapeNulls, dest, error); } -TString CEscape(y_absl::string_view src) { - TString dest; +TString CEscape(y_absl::string_view src) { + TString dest; CEscapeAndAppendInternal(src, &dest); return dest; } -TString CHexEscape(y_absl::string_view src) { +TString CHexEscape(y_absl::string_view src) { return CEscapeInternal(src, true, false); } -TString Utf8SafeCEscape(y_absl::string_view src) { +TString Utf8SafeCEscape(y_absl::string_view src) { return CEscapeInternal(src, false, true); } -TString Utf8SafeCHexEscape(y_absl::string_view src) { +TString Utf8SafeCHexEscape(y_absl::string_view src) { return CEscapeInternal(src, true, true); } @@ -893,57 +893,57 @@ TString Utf8SafeCHexEscape(y_absl::string_view src) { // indicate that the text was not an integer multiple of three bytes long. // ---------------------------------------------------------------------- -bool Base64Unescape(y_absl::string_view src, TString* dest) { +bool Base64Unescape(y_absl::string_view src, TString* dest) { return Base64UnescapeInternal(src.data(), src.size(), dest, kUnBase64); } -bool WebSafeBase64Unescape(y_absl::string_view src, TString* dest) { +bool WebSafeBase64Unescape(y_absl::string_view src, TString* dest) { return Base64UnescapeInternal(src.data(), src.size(), dest, kUnWebSafeBase64); } -void Base64Escape(y_absl::string_view src, TString* dest) { +void Base64Escape(y_absl::string_view src, TString* dest) { strings_internal::Base64EscapeInternal( reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest, true, strings_internal::kBase64Chars); } -void WebSafeBase64Escape(y_absl::string_view src, TString* dest) { +void WebSafeBase64Escape(y_absl::string_view src, TString* dest) { strings_internal::Base64EscapeInternal( reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest, false, kWebSafeBase64Chars); } -TString Base64Escape(y_absl::string_view src) { - TString dest; +TString Base64Escape(y_absl::string_view src) { + TString dest; strings_internal::Base64EscapeInternal( reinterpret_cast<const unsigned char*>(src.data()), src.size(), &dest, true, strings_internal::kBase64Chars); return dest; } -TString WebSafeBase64Escape(y_absl::string_view src) { - TString dest; +TString WebSafeBase64Escape(y_absl::string_view src) { + TString dest; strings_internal::Base64EscapeInternal( reinterpret_cast<const unsigned char*>(src.data()), src.size(), &dest, false, kWebSafeBase64Chars); return dest; } -TString HexStringToBytes(y_absl::string_view from) { - TString result; +TString HexStringToBytes(y_absl::string_view from) { + TString result; const auto num = from.size() / 2; strings_internal::STLStringResizeUninitialized(&result, num); - y_absl::HexStringToBytesInternal<TString&>(from.data(), result, num); + y_absl::HexStringToBytesInternal<TString&>(from.data(), result, num); return result; } -TString BytesToHexString(y_absl::string_view from) { - TString result; +TString BytesToHexString(y_absl::string_view from) { + TString result; strings_internal::STLStringResizeUninitialized(&result, 2 * from.size()); - y_absl::BytesToHexStringInternal<TString&>( + y_absl::BytesToHexStringInternal<TString&>( reinterpret_cast<const unsigned char*>(from.data()), result, from.size()); return result; } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.h index 098fb91d36..8868b87879 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.h @@ -27,12 +27,12 @@ #include <util/generic/string.h> #include <vector> -#include "y_absl/base/macros.h" -#include "y_absl/strings/ascii.h" -#include "y_absl/strings/str_join.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/base/macros.h" +#include "y_absl/strings/ascii.h" +#include "y_absl/strings/str_join.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // CUnescape() @@ -63,16 +63,16 @@ ABSL_NAMESPACE_BEGIN // // Example: // -// TString s = "foo\\rbar\\nbaz\\t"; -// TString unescaped_s; -// if (!y_absl::CUnescape(s, &unescaped_s) { +// TString s = "foo\\rbar\\nbaz\\t"; +// TString unescaped_s; +// if (!y_absl::CUnescape(s, &unescaped_s) { // ... // } // EXPECT_EQ(unescaped_s, "foo\rbar\nbaz\t"); -bool CUnescape(y_absl::string_view source, TString* dest, TString* error); +bool CUnescape(y_absl::string_view source, TString* dest, TString* error); // Overload of `CUnescape()` with no error reporting. -inline bool CUnescape(y_absl::string_view source, TString* dest) { +inline bool CUnescape(y_absl::string_view source, TString* dest) { return CUnescape(source, dest, nullptr); } @@ -84,10 +84,10 @@ inline bool CUnescape(y_absl::string_view source, TString* dest) { // // Example: // -// TString s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n"; -// TString escaped_s = y_absl::CEscape(s); +// TString s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n"; +// TString escaped_s = y_absl::CEscape(s); // EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\010\\t\\n\\013\\014\\r\\n"); -TString CEscape(y_absl::string_view src); +TString CEscape(y_absl::string_view src); // CHexEscape() // @@ -97,10 +97,10 @@ TString CEscape(y_absl::string_view src); // // Example: // -// TString s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n"; -// TString escaped_s = y_absl::CHexEscape(s); +// TString s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n"; +// TString escaped_s = y_absl::CHexEscape(s); // EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\x08\\t\\n\\x0b\\x0c\\r\\n"); -TString CHexEscape(y_absl::string_view src); +TString CHexEscape(y_absl::string_view src); // Utf8SafeCEscape() // @@ -108,57 +108,57 @@ TString CHexEscape(y_absl::string_view src); // octal sequences, and passing through UTF-8 characters without conversion. // I.e., when encountering any bytes with their high bit set, this function // will not escape those values, whether or not they are valid UTF-8. -TString Utf8SafeCEscape(y_absl::string_view src); +TString Utf8SafeCEscape(y_absl::string_view src); // Utf8SafeCHexEscape() // // Escapes a 'src' string using C-style escape sequences, escaping bytes as // hexadecimal sequences, and passing through UTF-8 characters without // conversion. -TString Utf8SafeCHexEscape(y_absl::string_view src); +TString Utf8SafeCHexEscape(y_absl::string_view src); // Base64Unescape() // // Converts a `src` string encoded in Base64 to its binary equivalent, writing // it to a `dest` buffer, returning `true` on success. If `src` contains invalid // characters, `dest` is cleared and returns `false`. -bool Base64Unescape(y_absl::string_view src, TString* dest); +bool Base64Unescape(y_absl::string_view src, TString* dest); // WebSafeBase64Unescape() // // Converts a `src` string encoded in Base64 to its binary equivalent, writing // it to a `dest` buffer, but using '-' instead of '+', and '_' instead of '/'. // If `src` contains invalid characters, `dest` is cleared and returns `false`. -bool WebSafeBase64Unescape(y_absl::string_view src, TString* dest); +bool WebSafeBase64Unescape(y_absl::string_view src, TString* dest); // Base64Escape() // // Encodes a `src` string into a base64-encoded string, with padding characters. // This function conforms with RFC 4648 section 4 (base64). -void Base64Escape(y_absl::string_view src, TString* dest); -TString Base64Escape(y_absl::string_view src); +void Base64Escape(y_absl::string_view src, TString* dest); +TString Base64Escape(y_absl::string_view src); // WebSafeBase64Escape() // // Encodes a `src` string into a base64-like string, using '-' instead of '+' // and '_' instead of '/', and without padding. This function conforms with RFC // 4648 section 5 (base64url). -void WebSafeBase64Escape(y_absl::string_view src, TString* dest); -TString WebSafeBase64Escape(y_absl::string_view src); +void WebSafeBase64Escape(y_absl::string_view src, TString* dest); +TString WebSafeBase64Escape(y_absl::string_view src); // HexStringToBytes() // // Converts an ASCII hex string into bytes, returning binary data of length // `from.size()/2`. -TString HexStringToBytes(y_absl::string_view from); +TString HexStringToBytes(y_absl::string_view from); // BytesToHexString() // // Converts binary data into an ASCII text string, returning a string of size // `2*from.size()`. -TString BytesToHexString(y_absl::string_view from); +TString BytesToHexString(y_absl::string_view from); ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_ESCAPING_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h index b8badd7901..25428e304c 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h @@ -24,10 +24,10 @@ #include <cstdint> #include <cstring> -#include "y_absl/base/macros.h" -#include "y_absl/base/port.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/port.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -151,6 +151,6 @@ constexpr Charmap PunctCharmap() { return GraphCharmap() & ~AlnumCharmap(); } } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_CHAR_MAP_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc index f47fecbf1f..72a4fa188b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc @@ -12,13 +12,13 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/internal/charconv_bigint.h" +#include "y_absl/strings/internal/charconv_bigint.h" #include <algorithm> #include <cassert> #include <util/generic/string.h> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -336,9 +336,9 @@ void BigUnsigned<max_words>::MultiplyStep(int original_size, } template <int max_words> -TString BigUnsigned<max_words>::ToString() const { +TString BigUnsigned<max_words>::ToString() const { BigUnsigned<max_words> copy = *this; - TString result; + TString result; // Build result in reverse order while (copy.size() > 0) { int next_digit = copy.DivMod<10>(); @@ -347,7 +347,7 @@ TString BigUnsigned<max_words>::ToString() const { if (result.empty()) { result.push_back('0'); } - std::reverse(result.begin(), result.vend()); + std::reverse(result.begin(), result.vend()); return result; } @@ -356,4 +356,4 @@ template class BigUnsigned<84>; } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h index 13b1d5db44..a77aab14dd 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h @@ -21,11 +21,11 @@ #include <util/generic/string.h> #include "y_absl/base/config.h" -#include "y_absl/strings/ascii.h" -#include "y_absl/strings/internal/charconv_parse.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/strings/ascii.h" +#include "y_absl/strings/internal/charconv_parse.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -41,7 +41,7 @@ ABSL_DLL extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1]; // Large, fixed-width unsigned integer. // // Exact rounding for decimal-to-binary floating point conversion requires very -// large integer math, but a design goal of y_absl::from_chars is to avoid +// large integer math, but a design goal of y_absl::from_chars is to avoid // allocating memory. The integer precision needed for decimal-to-binary // conversions is large but bounded, so a huge fixed-width integer class // suffices. @@ -68,7 +68,7 @@ class BigUnsigned { // Constructs a BigUnsigned from the given string_view containing a decimal // value. If the input string is not a decimal integer, constructs a 0 // instead. - explicit BigUnsigned(y_absl::string_view sv) : size_(0), words_{} { + explicit BigUnsigned(y_absl::string_view sv) : size_(0), words_{} { // Check for valid input, returning a 0 otherwise. This is reasonable // behavior only because this constructor is for unit tests. if (std::find_if_not(sv.begin(), sv.end(), ascii_isdigit) != sv.end() || @@ -212,7 +212,7 @@ class BigUnsigned { // Returns this integer as a decimal string. This is not used in the decimal- // to-binary conversion; it is intended to aid in testing. - TString ToString() const; + TString ToString() const; int size() const { return size_; } const uint32_t* words() const { return words_; } @@ -418,6 +418,6 @@ extern template class BigUnsigned<84>; } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc index d13dc938ef..f0f78eb68c 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc @@ -12,16 +12,16 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/internal/charconv_parse.h" -#include "y_absl/strings/charconv.h" +#include "y_absl/strings/internal/charconv_parse.h" +#include "y_absl/strings/charconv.h" #include <cassert> #include <cstdint> #include <limits> -#include "y_absl/strings/internal/memutil.h" +#include "y_absl/strings/internal/memutil.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { @@ -501,4 +501,4 @@ template ParsedFloat ParseFloat<16>(const char* begin, const char* end, } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h index 31239d9ab4..3f942cd4cb 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h @@ -18,9 +18,9 @@ #include <cstdint> #include "y_absl/base/config.h" -#include "y_absl/strings/charconv.h" +#include "y_absl/strings/charconv.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -86,14 +86,14 @@ struct ParsedFloat { // *not* consumed. The `hex` bit from format_flags is ignored by ParseFloat. template <int base> ParsedFloat ParseFloat(const char* begin, const char* end, - y_absl::chars_format format_flags); + y_absl::chars_format format_flags); extern template ParsedFloat ParseFloat<10>(const char* begin, const char* end, - y_absl::chars_format format_flags); + y_absl::chars_format format_flags); extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end, - y_absl::chars_format format_flags); + y_absl::chars_format format_flags); } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h index c9f4351692..f145127225 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h @@ -19,15 +19,15 @@ #define ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_ #include <array> -#include "y_absl/strings/string_view.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { struct base64_testcase { - y_absl::string_view plaintext; - y_absl::string_view cyphertext; + y_absl::string_view plaintext; + y_absl::string_view cyphertext; }; inline const std::array<base64_testcase, 5>& base64_strings() { @@ -128,6 +128,6 @@ inline const std::array<base64_testcase, 5>& base64_strings() { } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc index 801181e3fc..0ba6574fdb 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc @@ -12,11 +12,11 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/internal/memutil.h" +#include "y_absl/strings/internal/memutil.h" #include <cstdlib> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -26,8 +26,8 @@ int memcasecmp(const char* s1, const char* s2, size_t len) { for (size_t i = 0; i < len; i++) { const int diff = - int{static_cast<unsigned char>(y_absl::ascii_tolower(us1[i]))} - - int{static_cast<unsigned char>(y_absl::ascii_tolower(us2[i]))}; + int{static_cast<unsigned char>(y_absl::ascii_tolower(us1[i]))} - + int{static_cast<unsigned char>(y_absl::ascii_tolower(us2[i]))}; if (diff != 0) return diff; } return 0; @@ -109,4 +109,4 @@ const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle, } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h index fb6a48ebad..ee442fe25f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h @@ -24,7 +24,7 @@ // The difference between the mem and str versions is the mem version // takes a pointer and a length, rather than a '\0'-terminated string. // The memcase* routines defined here assume the locale is "C" -// (they use y_absl::ascii_tolower instead of tolower). +// (they use y_absl::ascii_tolower instead of tolower). // // These routines are based on the BSD library. // @@ -65,10 +65,10 @@ #include <cstddef> #include <cstring> -#include "y_absl/base/port.h" // disable some warnings on Windows -#include "y_absl/strings/ascii.h" // for y_absl::ascii_tolower +#include "y_absl/base/port.h" // disable some warnings on Windows +#include "y_absl/strings/ascii.h" // for y_absl::ascii_tolower -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -98,10 +98,10 @@ const char* int_memmatch(const char* haystack, size_t haylen, for (; haystack < hayend; ++haystack) { char hay = case_sensitive ? *haystack - : y_absl::ascii_tolower(static_cast<unsigned char>(*haystack)); + : y_absl::ascii_tolower(static_cast<unsigned char>(*haystack)); char nee = case_sensitive ? *needle - : y_absl::ascii_tolower(static_cast<unsigned char>(*needle)); + : y_absl::ascii_tolower(static_cast<unsigned char>(*needle)); if (hay == nee) { if (++needle == needleend) { return haystack + 1 - neelen; @@ -143,6 +143,6 @@ const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle, } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_MEMUTIL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h index ef07171c41..12aec3ac11 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h @@ -25,12 +25,12 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { template <typename IntType> -inline bool Itoa(IntType value, int base, TString* destination) { +inline bool Itoa(IntType value, int base, TString* destination) { destination->clear(); if (base <= 1 || base > 36) { return false; @@ -179,6 +179,6 @@ inline const std::array<uint64_test_case, 34>& strtouint64_test_cases() { } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc index df891f0533..ba18857d83 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc @@ -12,9 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/internal/ostringstream.h" +#include "y_absl/strings/internal/ostringstream.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -33,4 +33,4 @@ std::streamsize OStringStream::xsputn(const char* s, std::streamsize n) { } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h index aa1d8d6658..d00cef9c23 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h @@ -20,24 +20,24 @@ #include <streambuf> #include <util/generic/string.h> -#include "y_absl/base/port.h" +#include "y_absl/base/port.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { -// The same as std::ostringstream but appends to a user-specified TString, +// The same as std::ostringstream but appends to a user-specified TString, // and is faster. It is ~70% faster to create, ~50% faster to write to, and -// completely free to extract the result TString. +// completely free to extract the result TString. // -// TString s; +// TString s; // OStringStream strm(&s); // strm << 42 << ' ' << 3.14; // appends to `s` // // The stream object doesn't have to be named. Starting from C++11 operator<< // works with rvalues of std::ostream. // -// TString s; +// TString s; // OStringStream(&s) << 42 << ' ' << 3.14; // appends to `s` // // OStringStream is faster to create than std::ostringstream but it's still @@ -46,14 +46,14 @@ namespace strings_internal { // // Creates unnecessary instances of OStringStream: slow. // -// TString s; +// TString s; // OStringStream(&s) << 42; // OStringStream(&s) << ' '; // OStringStream(&s) << 3.14; // // Creates a single instance of OStringStream and reuses it: fast. // -// TString s; +// TString s; // OStringStream strm(&s); // strm << 42; // strm << ' '; @@ -65,13 +65,13 @@ class OStringStream : private std::basic_streambuf<char>, public std::ostream { // The argument can be null, in which case you'll need to call str(p) with a // non-null argument before you can write to the stream. // - // The destructor of OStringStream doesn't use the TString. It's OK to - // destroy the TString before the stream. - explicit OStringStream(TString* s) : std::ostream(this), s_(s) {} + // The destructor of OStringStream doesn't use the TString. It's OK to + // destroy the TString before the stream. + explicit OStringStream(TString* s) : std::ostream(this), s_(s) {} - TString* str() { return s_; } - const TString* str() const { return s_; } - void str(TString* s) { s_ = s; } + TString* str() { return s_; } + const TString* str() const { return s_; } + void str(TString* s) { s_ = s; } private: using Buf = std::basic_streambuf<char>; @@ -79,11 +79,11 @@ class OStringStream : private std::basic_streambuf<char>, public std::ostream { Buf::int_type overflow(int c) override; std::streamsize xsputn(const char* s, std::streamsize n) override; - TString* s_; + TString* s_; }; } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h index b4a9b1c3db..e4d41d7e4e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h @@ -24,7 +24,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -35,6 +35,6 @@ double Pow10(int exp); } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_POW10_HELPER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h index 9ed8ca2063..14860bb237 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h @@ -22,10 +22,10 @@ #include <type_traits> #include <utility> -#include "y_absl/base/port.h" -#include "y_absl/meta/type_traits.h" // for void_t +#include "y_absl/base/port.h" +#include "y_absl/meta/type_traits.h" // for void_t -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -41,7 +41,7 @@ struct ResizeUninitializedTraits { // __resize_default_init is provided by libc++ >= 8.0 template <typename string_type> struct ResizeUninitializedTraits< - string_type, y_absl::void_t<decltype(std::declval<string_type&>() + string_type, y_absl::void_t<decltype(std::declval<string_type&>() .__resize_default_init(237))> > { using HasMember = std::true_type; static void Resize(string_type* s, size_t new_size) { @@ -49,8 +49,8 @@ struct ResizeUninitializedTraits< } }; -// Returns true if the TString implementation supports a resize where -// the new characters added to the TString are left untouched. +// Returns true if the TString implementation supports a resize where +// the new characters added to the TString are left untouched. // // (A better name might be "STLStringSupportsUninitializedResize", alluding to // the previous function.) @@ -62,7 +62,7 @@ inline constexpr bool STLStringSupportsNontrashingResize(string_type*) { // Like str->resize(new_size), except any new characters added to "*str" as a // result of resizing may be left uninitialized, rather than being filled with // '0' bytes. Typically used when code is then going to overwrite the backing -// store of the TString with known data. +// store of the TString with known data. template <typename string_type, typename = void> inline void STLStringResizeUninitialized(string_type* s, size_t new_size) { ResizeUninitializedTraits<string_type>::Resize(s, new_size); @@ -114,6 +114,6 @@ void STLStringResizeUninitializedAmortized(string_type* s, size_t new_size) { } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h index c082ae4443..db8d4635d0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h @@ -18,9 +18,9 @@ // wrappers of STL containers. // // DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including -// y_absl/strings/str_split.h. +// y_absl/strings/str_split.h. // -// IWYU pragma: private, include "y_absl/strings/str_split.h" +// IWYU pragma: private, include "y_absl/strings/str_split.h" #ifndef ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_ #define ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_ @@ -37,9 +37,9 @@ #include <unordered_set> #include <vector> -#include "y_absl/meta/type_traits.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -48,25 +48,25 @@ struct IsSpecializationImpl : std::false_type {}; template <template <typename...> class T, typename... Args> struct IsSpecializationImpl<T<Args...>, T> : std::true_type {}; template <typename C, template <typename...> class T> -using IsSpecialization = IsSpecializationImpl<y_absl::decay_t<C>, T>; +using IsSpecialization = IsSpecializationImpl<y_absl::decay_t<C>, T>; template <typename C> struct IsArrayImpl : std::false_type {}; template <template <typename, size_t> class A, typename T, size_t N> struct IsArrayImpl<A<T, N>> : std::is_same<A<T, N>, std::array<T, N>> {}; template <typename C> -using IsArray = IsArrayImpl<y_absl::decay_t<C>>; +using IsArray = IsArrayImpl<y_absl::decay_t<C>>; template <typename C> struct IsBitsetImpl : std::false_type {}; template <template <size_t> class B, size_t N> struct IsBitsetImpl<B<N>> : std::is_same<B<N>, std::bitset<N>> {}; template <typename C> -using IsBitset = IsBitsetImpl<y_absl::decay_t<C>>; +using IsBitset = IsBitsetImpl<y_absl::decay_t<C>>; template <typename C> struct IsSTLContainer - : y_absl::disjunction< + : y_absl::disjunction< IsArray<C>, IsBitset<C>, IsSpecialization<C, std::deque>, IsSpecialization<C, std::forward_list>, IsSpecialization<C, std::list>, IsSpecialization<C, std::map>, @@ -85,20 +85,20 @@ struct IsBaseOfSpecializationImpl : std::false_type {}; // template. template <typename C, template <typename, typename> class T> struct IsBaseOfSpecializationImpl< - C, T, y_absl::void_t<typename C::value_type, typename C::allocator_type>> + C, T, y_absl::void_t<typename C::value_type, typename C::allocator_type>> : std::is_base_of<C, T<typename C::value_type, typename C::allocator_type>> {}; template <typename C, template <typename, typename, typename> class T> struct IsBaseOfSpecializationImpl< C, T, - y_absl::void_t<typename C::key_type, typename C::key_compare, + y_absl::void_t<typename C::key_type, typename C::key_compare, typename C::allocator_type>> : std::is_base_of<C, T<typename C::key_type, typename C::key_compare, typename C::allocator_type>> {}; template <typename C, template <typename, typename, typename, typename> class T> struct IsBaseOfSpecializationImpl< C, T, - y_absl::void_t<typename C::key_type, typename C::mapped_type, + y_absl::void_t<typename C::key_type, typename C::mapped_type, typename C::key_compare, typename C::allocator_type>> : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type, @@ -107,7 +107,7 @@ struct IsBaseOfSpecializationImpl< template <typename C, template <typename, typename, typename, typename> class T> struct IsBaseOfSpecializationImpl< C, T, - y_absl::void_t<typename C::key_type, typename C::hasher, + y_absl::void_t<typename C::key_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>> : std::is_base_of<C, T<typename C::key_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>> { @@ -116,14 +116,14 @@ template <typename C, template <typename, typename, typename, typename, typename> class T> struct IsBaseOfSpecializationImpl< C, T, - y_absl::void_t<typename C::key_type, typename C::mapped_type, + y_absl::void_t<typename C::key_type, typename C::mapped_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>> : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>> {}; template <typename C, template <typename...> class T> -using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<y_absl::decay_t<C>, T>; +using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<y_absl::decay_t<C>, T>; template <typename C> struct IsBaseOfArrayImpl : std::false_type {}; @@ -131,18 +131,18 @@ template <template <typename, size_t> class A, typename T, size_t N> struct IsBaseOfArrayImpl<A<T, N>> : std::is_base_of<A<T, N>, std::array<T, N>> { }; template <typename C> -using IsBaseOfArray = IsBaseOfArrayImpl<y_absl::decay_t<C>>; +using IsBaseOfArray = IsBaseOfArrayImpl<y_absl::decay_t<C>>; template <typename C> struct IsBaseOfBitsetImpl : std::false_type {}; template <template <size_t> class B, size_t N> struct IsBaseOfBitsetImpl<B<N>> : std::is_base_of<B<N>, std::bitset<N>> {}; template <typename C> -using IsBaseOfBitset = IsBaseOfBitsetImpl<y_absl::decay_t<C>>; +using IsBaseOfBitset = IsBaseOfBitsetImpl<y_absl::decay_t<C>>; template <typename C> struct IsBaseOfSTLContainer - : y_absl::disjunction<IsBaseOfArray<C>, IsBaseOfBitset<C>, + : y_absl::disjunction<IsBaseOfArray<C>, IsBaseOfBitset<C>, IsBaseOfSpecialization<C, std::deque>, IsBaseOfSpecialization<C, std::forward_list>, IsBaseOfSpecialization<C, std::list>, @@ -163,20 +163,20 @@ struct IsConvertibleToSpecializationImpl : std::false_type {}; // STL template. template <typename C, template <typename, typename> class T> struct IsConvertibleToSpecializationImpl< - C, T, y_absl::void_t<typename C::value_type, typename C::allocator_type>> + C, T, y_absl::void_t<typename C::value_type, typename C::allocator_type>> : std::is_convertible< C, T<typename C::value_type, typename C::allocator_type>> {}; template <typename C, template <typename, typename, typename> class T> struct IsConvertibleToSpecializationImpl< C, T, - y_absl::void_t<typename C::key_type, typename C::key_compare, + y_absl::void_t<typename C::key_type, typename C::key_compare, typename C::allocator_type>> : std::is_convertible<C, T<typename C::key_type, typename C::key_compare, typename C::allocator_type>> {}; template <typename C, template <typename, typename, typename, typename> class T> struct IsConvertibleToSpecializationImpl< C, T, - y_absl::void_t<typename C::key_type, typename C::mapped_type, + y_absl::void_t<typename C::key_type, typename C::mapped_type, typename C::key_compare, typename C::allocator_type>> : std::is_convertible< C, T<typename C::key_type, typename C::mapped_type, @@ -184,7 +184,7 @@ struct IsConvertibleToSpecializationImpl< template <typename C, template <typename, typename, typename, typename> class T> struct IsConvertibleToSpecializationImpl< C, T, - y_absl::void_t<typename C::key_type, typename C::hasher, + y_absl::void_t<typename C::key_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>> : std::is_convertible< C, T<typename C::key_type, typename C::hasher, typename C::key_equal, @@ -193,7 +193,7 @@ template <typename C, template <typename, typename, typename, typename, typename> class T> struct IsConvertibleToSpecializationImpl< C, T, - y_absl::void_t<typename C::key_type, typename C::mapped_type, + y_absl::void_t<typename C::key_type, typename C::mapped_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>> : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type, @@ -201,7 +201,7 @@ struct IsConvertibleToSpecializationImpl< typename C::allocator_type>> {}; template <typename C, template <typename...> class T> using IsConvertibleToSpecialization = - IsConvertibleToSpecializationImpl<y_absl::decay_t<C>, T>; + IsConvertibleToSpecializationImpl<y_absl::decay_t<C>, T>; template <typename C> struct IsConvertibleToArrayImpl : std::false_type {}; @@ -209,7 +209,7 @@ template <template <typename, size_t> class A, typename T, size_t N> struct IsConvertibleToArrayImpl<A<T, N>> : std::is_convertible<A<T, N>, std::array<T, N>> {}; template <typename C> -using IsConvertibleToArray = IsConvertibleToArrayImpl<y_absl::decay_t<C>>; +using IsConvertibleToArray = IsConvertibleToArrayImpl<y_absl::decay_t<C>>; template <typename C> struct IsConvertibleToBitsetImpl : std::false_type {}; @@ -217,11 +217,11 @@ template <template <size_t> class B, size_t N> struct IsConvertibleToBitsetImpl<B<N>> : std::is_convertible<B<N>, std::bitset<N>> {}; template <typename C> -using IsConvertibleToBitset = IsConvertibleToBitsetImpl<y_absl::decay_t<C>>; +using IsConvertibleToBitset = IsConvertibleToBitsetImpl<y_absl::decay_t<C>>; template <typename C> struct IsConvertibleToSTLContainer - : y_absl::disjunction< + : y_absl::disjunction< IsConvertibleToArray<C>, IsConvertibleToBitset<C>, IsConvertibleToSpecialization<C, std::deque>, IsConvertibleToSpecialization<C, std::forward_list>, @@ -238,11 +238,11 @@ struct IsConvertibleToSTLContainer template <typename C> struct IsStrictlyBaseOfAndConvertibleToSTLContainer - : y_absl::conjunction<y_absl::negation<IsSTLContainer<C>>, + : y_absl::conjunction<y_absl::negation<IsSTLContainer<C>>, IsBaseOfSTLContainer<C>, IsConvertibleToSTLContainer<C>> {}; } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc index cc80be14e4..8d5c3b61ac 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc @@ -16,7 +16,7 @@ // POSIX spec: // http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html // -#include "y_absl/strings/internal/str_format/arg.h" +#include "y_absl/strings/internal/str_format/arg.h" #include <cassert> #include <cerrno> @@ -24,11 +24,11 @@ #include <util/generic/string.h> #include <type_traits> -#include "y_absl/base/port.h" -#include "y_absl/strings/internal/str_format/float_conversion.h" +#include "y_absl/base/port.h" +#include "y_absl/strings/internal/str_format/float_conversion.h" #include "y_absl/strings/numbers.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace str_format_internal { namespace { @@ -46,20 +46,20 @@ void ReducePadding(size_t n, size_t *capacity) { template <typename T> struct MakeUnsigned : std::make_unsigned<T> {}; template <> -struct MakeUnsigned<y_absl::int128> { - using type = y_absl::uint128; +struct MakeUnsigned<y_absl::int128> { + using type = y_absl::uint128; }; template <> -struct MakeUnsigned<y_absl::uint128> { - using type = y_absl::uint128; +struct MakeUnsigned<y_absl::uint128> { + using type = y_absl::uint128; }; template <typename T> struct IsSigned : std::is_signed<T> {}; template <> -struct IsSigned<y_absl::int128> : std::true_type {}; +struct IsSigned<y_absl::int128> : std::true_type {}; template <> -struct IsSigned<y_absl::uint128> : std::false_type {}; +struct IsSigned<y_absl::uint128> : std::false_type {}; // Integral digit printer. // Call one of the PrintAs* routines after construction once. @@ -467,12 +467,12 @@ IntegralConvertResult FormatConvertImpl(unsigned long long v, // NOLINT FormatSinkImpl *sink) { return {ConvertIntArg(v, conv, sink)}; } -IntegralConvertResult FormatConvertImpl(y_absl::int128 v, +IntegralConvertResult FormatConvertImpl(y_absl::int128 v, const FormatConversionSpecImpl conv, FormatSinkImpl *sink) { return {ConvertIntArg(v, conv, sink)}; } -IntegralConvertResult FormatConvertImpl(y_absl::uint128 v, +IntegralConvertResult FormatConvertImpl(y_absl::uint128 v, const FormatConversionSpecImpl conv, FormatSinkImpl *sink) { return {ConvertIntArg(v, conv, sink)}; @@ -485,4 +485,4 @@ ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(); } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h index 3ea87a3c30..59b7bcc727 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h @@ -27,13 +27,13 @@ #include <util/stream/str.h> #include <type_traits> -#include "y_absl/base/port.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/numeric/int128.h" -#include "y_absl/strings/internal/str_format/extension.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/base/port.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/numeric/int128.h" +#include "y_absl/strings/internal/str_format/extension.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN class Cord; @@ -261,7 +261,7 @@ struct FormatCountCaptureHelper { static ArgConvertResult<FormatConversionCharSetInternal::n> ConvertHelper( const FormatCountCapture& v, FormatConversionSpecImpl conv, FormatSinkImpl* sink) { - const y_absl::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v; + const y_absl::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v; if (conv.conversion_char() != str_format_internal::FormatConversionCharInternal::n) { @@ -515,7 +515,7 @@ class FormatArgImpl { ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(double, __VA_ARGS__); \ ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long double, __VA_ARGS__); \ ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(const char*, __VA_ARGS__); \ - ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(TString, __VA_ARGS__); \ + ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(TString, __VA_ARGS__); \ ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(string_view, __VA_ARGS__) ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern); @@ -523,6 +523,6 @@ ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern); } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc index a728a33344..211ce25dea 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc @@ -12,21 +12,21 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/internal/str_format/bind.h" +#include "y_absl/strings/internal/str_format/bind.h" #include <cerrno> #include <limits> #include <sstream> #include <util/generic/string.h> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace str_format_internal { namespace { inline bool BindFromPosition(int position, int* value, - y_absl::Span<const FormatArgImpl> pack) { + y_absl::Span<const FormatArgImpl> pack) { assert(position > 0); if (static_cast<size_t>(position) > pack.size()) { return false; @@ -37,7 +37,7 @@ inline bool BindFromPosition(int position, int* value, class ArgContext { public: - explicit ArgContext(y_absl::Span<const FormatArgImpl> pack) : pack_(pack) {} + explicit ArgContext(y_absl::Span<const FormatArgImpl> pack) : pack_(pack) {} // Fill 'bound' with the results of applying the context's argument pack // to the specified 'unbound'. We synthesize a BoundConversion by @@ -48,7 +48,7 @@ class ArgContext { bool Bind(const UnboundConversion* unbound, BoundConversion* bound); private: - y_absl::Span<const FormatArgImpl> pack_; + y_absl::Span<const FormatArgImpl> pack_; }; inline bool ArgContext::Bind(const UnboundConversion* unbound, @@ -102,7 +102,7 @@ inline bool ArgContext::Bind(const UnboundConversion* unbound, template <typename Converter> class ConverterConsumer { public: - ConverterConsumer(Converter converter, y_absl::Span<const FormatArgImpl> pack) + ConverterConsumer(Converter converter, y_absl::Span<const FormatArgImpl> pack) : converter_(converter), arg_context_(pack) {} bool Append(string_view s) { @@ -122,7 +122,7 @@ class ConverterConsumer { template <typename Converter> bool ConvertAll(const UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args, Converter converter) { + y_absl::Span<const FormatArgImpl> args, Converter converter) { if (format.has_parsed_conversion()) { return format.parsed_conversion()->ProcessFormat( ConverterConsumer<Converter>(converter, args)); @@ -172,15 +172,15 @@ class SummarizingConverter { } // namespace bool BindWithPack(const UnboundConversion* props, - y_absl::Span<const FormatArgImpl> pack, + y_absl::Span<const FormatArgImpl> pack, BoundConversion* bound) { return ArgContext(pack).Bind(props, bound); } -TString Summarize(const UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args) { +TString Summarize(const UntypedFormatSpecImpl format, + y_absl::Span<const FormatArgImpl> args) { typedef SummarizingConverter Converter; - TString out; + TString out; { // inner block to destroy sink before returning out. It ensures a last // flush. @@ -194,7 +194,7 @@ TString Summarize(const UntypedFormatSpecImpl format, bool FormatUntyped(FormatRawSinkImpl raw_sink, const UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args) { + y_absl::Span<const FormatArgImpl> args) { FormatSinkImpl sink(raw_sink); using Converter = DefaultConverter; return ConvertAll(format, args, Converter(&sink)); @@ -205,8 +205,8 @@ std::ostream& Streamable::Print(std::ostream& os) const { return os; } -TString& AppendPack(TString* out, const UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args) { +TString& AppendPack(TString* out, const UntypedFormatSpecImpl format, + y_absl::Span<const FormatArgImpl> args) { size_t orig = out->size(); if (ABSL_PREDICT_FALSE(!FormatUntyped(out, format, args))) { out->erase(orig); @@ -214,9 +214,9 @@ TString& AppendPack(TString* out, const UntypedFormatSpecImpl format, return *out; } -TString FormatPack(const UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args) { - TString out; +TString FormatPack(const UntypedFormatSpecImpl format, + y_absl::Span<const FormatArgImpl> args) { + TString out; if (ABSL_PREDICT_FALSE(!FormatUntyped(&out, format, args))) { out.clear(); } @@ -224,7 +224,7 @@ TString FormatPack(const UntypedFormatSpecImpl format, } int FprintF(std::FILE* output, const UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args) { + y_absl::Span<const FormatArgImpl> args) { FILERawSink sink(output); if (!FormatUntyped(&sink, format, args)) { errno = EINVAL; @@ -242,7 +242,7 @@ int FprintF(std::FILE* output, const UntypedFormatSpecImpl format, } int SnprintF(char* output, size_t size, const UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args) { + y_absl::Span<const FormatArgImpl> args) { BufferRawSink sink(output, size ? size - 1 : 0); if (!FormatUntyped(&sink, format, args)) { errno = EINVAL; @@ -255,4 +255,4 @@ int SnprintF(char* output, size_t size, const UntypedFormatSpecImpl format, } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h index b2e4326b5d..3966610710 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h @@ -20,13 +20,13 @@ #include <sstream> #include <util/generic/string.h> -#include "y_absl/base/port.h" -#include "y_absl/strings/internal/str_format/arg.h" -#include "y_absl/strings/internal/str_format/checker.h" -#include "y_absl/strings/internal/str_format/parser.h" -#include "y_absl/types/span.h" +#include "y_absl/base/port.h" +#include "y_absl/strings/internal/str_format/arg.h" +#include "y_absl/strings/internal/str_format/checker.h" +#include "y_absl/strings/internal/str_format/parser.h" +#include "y_absl/types/span.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN class UntypedFormatSpec; @@ -145,13 +145,13 @@ class FormatSpecTemplate class Streamable { public: Streamable(const UntypedFormatSpecImpl& format, - y_absl::Span<const FormatArgImpl> args) + y_absl::Span<const FormatArgImpl> args) : format_(format) { if (args.size() <= ABSL_ARRAYSIZE(few_args_)) { for (size_t i = 0; i < args.size(); ++i) { few_args_[i] = args[i]; } - args_ = y_absl::MakeSpan(few_args_, args.size()); + args_ = y_absl::MakeSpan(few_args_, args.size()); } else { many_args_.assign(args.begin(), args.end()); args_ = many_args_; @@ -166,7 +166,7 @@ class Streamable { private: const UntypedFormatSpecImpl& format_; - y_absl::Span<const FormatArgImpl> args_; + y_absl::Span<const FormatArgImpl> args_; // if args_.size() is 4 or less: FormatArgImpl few_args_[4] = {FormatArgImpl(0), FormatArgImpl(0), FormatArgImpl(0), FormatArgImpl(0)}; @@ -175,27 +175,27 @@ class Streamable { }; // for testing -TString Summarize(UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args); +TString Summarize(UntypedFormatSpecImpl format, + y_absl::Span<const FormatArgImpl> args); bool BindWithPack(const UnboundConversion* props, - y_absl::Span<const FormatArgImpl> pack, BoundConversion* bound); + y_absl::Span<const FormatArgImpl> pack, BoundConversion* bound); bool FormatUntyped(FormatRawSinkImpl raw_sink, UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args); + y_absl::Span<const FormatArgImpl> args); -TString& AppendPack(TString* out, UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args); +TString& AppendPack(TString* out, UntypedFormatSpecImpl format, + y_absl::Span<const FormatArgImpl> args); -TString FormatPack(const UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args); +TString FormatPack(const UntypedFormatSpecImpl format, + y_absl::Span<const FormatArgImpl> args); int FprintF(std::FILE* output, UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args); + y_absl::Span<const FormatArgImpl> args); int SnprintF(char* output, size_t size, UntypedFormatSpecImpl format, - y_absl::Span<const FormatArgImpl> args); + y_absl::Span<const FormatArgImpl> args); -// Returned by Streamed(v). Converts via '%s' to the TString created +// Returned by Streamed(v). Converts via '%s' to the TString created // by std::ostream << v. template <typename T> class StreamedWrapper { @@ -212,6 +212,6 @@ class StreamedWrapper { } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h index 8ec89dd294..7c530d2507 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h @@ -16,8 +16,8 @@ #define ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_ #include "y_absl/base/attributes.h" -#include "y_absl/strings/internal/str_format/arg.h" -#include "y_absl/strings/internal/str_format/extension.h" +#include "y_absl/strings/internal/str_format/arg.h" +#include "y_absl/strings/internal/str_format/extension.h" // Compile time check support for entry points. @@ -27,7 +27,7 @@ #endif // ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__) #endif // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace str_format_internal { @@ -328,6 +328,6 @@ constexpr bool ValidFormatImpl(string_view format) { } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc index efc93c046c..f2a4169ae7 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc @@ -13,18 +13,18 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/internal/str_format/extension.h" +#include "y_absl/strings/internal/str_format/extension.h" #include <errno.h> #include <algorithm> #include <util/generic/string.h> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace str_format_internal { TString FlagsToString(Flags v) { - TString s; + TString s; s.append(FlagsContains(v, Flags::kLeft) ? "-" : ""); s.append(FlagsContains(v, Flags::kShowPos) ? "+" : ""); s.append(FlagsContains(v, Flags::kSignCol) ? " " : ""); @@ -72,4 +72,4 @@ bool FormatSinkImpl::PutPaddedString(string_view value, int width, } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h index 02697a1324..e5de5cb6a1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h @@ -23,12 +23,12 @@ #include <ostream> #include "y_absl/base/config.h" -#include "y_absl/base/port.h" +#include "y_absl/base/port.h" #include "y_absl/meta/type_traits.h" -#include "y_absl/strings/internal/str_format/output.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/strings/internal/str_format/output.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN enum class FormatConversionChar : uint8_t; @@ -440,6 +440,6 @@ inline size_t Excess(size_t used, size_t capacity) { } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc index c56af14d5c..c49062538d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/internal/str_format/float_conversion.h" +#include "y_absl/strings/internal/str_format/float_conversion.h" #include <string.h> @@ -23,7 +23,7 @@ #include <util/generic/string.h> #include "y_absl/base/attributes.h" -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" #include "y_absl/base/optimization.h" #include "y_absl/functional/function_ref.h" #include "y_absl/meta/type_traits.h" @@ -34,7 +34,7 @@ #include "y_absl/types/optional.h" #include "y_absl/types/span.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace str_format_internal { @@ -955,7 +955,7 @@ bool FallbackToSnprintf(const Float v, const FormatConversionSpecImpl &conv, *fp = 0; assert(fp < fmt + sizeof(fmt)); } - TString space(512, '\0'); + TString space(512, '\0'); y_absl::string_view result; while (true) { int n = snprintf(&space[0], space.size(), fmt, w, p, v); @@ -1420,4 +1420,4 @@ bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv, } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h index 78c57edf1b..d93a415756 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h @@ -15,9 +15,9 @@ #ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_ #define ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_ -#include "y_absl/strings/internal/str_format/extension.h" +#include "y_absl/strings/internal/str_format/extension.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace str_format_internal { @@ -32,6 +32,6 @@ bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv, } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc index cbe31f2d94..ade3f67ef2 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc @@ -12,12 +12,12 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/internal/str_format/output.h" +#include "y_absl/strings/internal/str_format/output.h" #include <errno.h> #include <cstring> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace str_format_internal { @@ -69,4 +69,4 @@ void FILERawSink::Write(string_view v) { } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h index 5ff7c5435a..8fc46fbafa 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h @@ -25,8 +25,8 @@ #include <ostream> #include <util/generic/string.h> -#include "y_absl/base/port.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/base/port.h" +#include "y_absl/strings/string_view.h" namespace y_absl { ABSL_NAMESPACE_BEGIN @@ -67,7 +67,7 @@ class FILERawSink { }; // Provide RawSink integration with common types from the STL. -inline void AbslFormatFlush(TString* out, string_view s) { +inline void AbslFormatFlush(TString* out, string_view s) { out->append(s.data(), s.size()); } inline void AbslFormatFlush(std::ostream* out, string_view s) { @@ -91,6 +91,6 @@ auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) { } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc index 56e52a214c..af07e32fe5 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/internal/str_format/parser.h" +#include "y_absl/strings/internal/str_format/parser.h" #include <assert.h> #include <string.h> @@ -27,7 +27,7 @@ #include <util/generic/string.h> #include <unordered_set> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace str_format_internal { @@ -336,4 +336,4 @@ bool ParsedFormatBase::MatchesConversions( } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h index e8beb3c5e7..ba614bb8b4 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h @@ -28,10 +28,10 @@ #include <util/generic/string.h> #include <vector> -#include "y_absl/strings/internal/str_format/checker.h" -#include "y_absl/strings/internal/str_format/extension.h" +#include "y_absl/strings/internal/str_format/checker.h" +#include "y_absl/strings/internal/str_format/extension.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace str_format_internal { @@ -352,6 +352,6 @@ class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase { }; } // namespace str_format_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make index 2cf0a66cd3..ff8069cd0f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make @@ -12,13 +12,13 @@ LICENSE(Apache-2.0) LICENSE_TEXTS(.yandex_meta/licenses.list.txt) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity - contrib/restricted/abseil-cpp-tstring/y_absl/numeric - contrib/restricted/abseil-cpp-tstring/y_absl/strings + contrib/restricted/abseil-cpp-tstring/y_absl/base + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/numeric + contrib/restricted/abseil-cpp-tstring/y_absl/strings contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal ) diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h index 33f875c913..0a220fa33d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h @@ -24,9 +24,9 @@ // - JoinTuple() // // DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including -// y_absl/strings/str_join.h +// y_absl/strings/str_join.h // -// IWYU pragma: private, include "y_absl/strings/str_join.h" +// IWYU pragma: private, include "y_absl/strings/str_join.h" #ifndef ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_ #define ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_ @@ -38,11 +38,11 @@ #include <type_traits> #include <utility> -#include "y_absl/strings/internal/ostringstream.h" -#include "y_absl/strings/internal/resize_uninitialized.h" -#include "y_absl/strings/str_cat.h" +#include "y_absl/strings/internal/ostringstream.h" +#include "y_absl/strings/internal/resize_uninitialized.h" +#include "y_absl/strings/str_cat.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -59,11 +59,11 @@ struct AlphaNumFormatterImpl { // This template is needed in order to support passing in a dereferenced // vector<bool>::iterator template <typename T> - void operator()(TString* out, const T& t) const { + void operator()(TString* out, const T& t) const { StrAppend(out, AlphaNum(t)); } - void operator()(TString* out, const AlphaNum& t) const { + void operator()(TString* out, const AlphaNum& t) const { StrAppend(out, t); } }; @@ -80,7 +80,7 @@ class StreamFormatterImpl { // The method isn't const because it mutates state. Making it const will // render StreamFormatterImpl thread-hostile. template <typename T> - void operator()(TString* out, const T& t) { + void operator()(TString* out, const T& t) { // The stream is created lazily to avoid paying the relatively high cost // of its construction when joining an empty range. if (strm_) { @@ -101,18 +101,18 @@ class StreamFormatterImpl { template <typename F1, typename F2> class PairFormatterImpl { public: - PairFormatterImpl(F1 f1, y_absl::string_view sep, F2 f2) + PairFormatterImpl(F1 f1, y_absl::string_view sep, F2 f2) : f1_(std::move(f1)), sep_(sep), f2_(std::move(f2)) {} template <typename T> - void operator()(TString* out, const T& p) { + void operator()(TString* out, const T& p) { f1_(out, p.first); out->append(sep_); f2_(out, p.second); } template <typename T> - void operator()(TString* out, const T& p) const { + void operator()(TString* out, const T& p) const { f1_(out, p.first); out->append(sep_); f2_(out, p.second); @@ -120,7 +120,7 @@ class PairFormatterImpl { private: F1 f1_; - TString sep_; + TString sep_; F2 f2_; }; @@ -135,12 +135,12 @@ class DereferenceFormatterImpl { : f_(std::forward<Formatter>(f)) {} template <typename T> - void operator()(TString* out, const T& t) { + void operator()(TString* out, const T& t) { f_(out, *t); } template <typename T> - void operator()(TString* out, const T& t) const { + void operator()(TString* out, const T& t) const { f_(out, *t); } @@ -168,11 +168,11 @@ struct DefaultFormatter<char*> { typedef AlphaNumFormatterImpl Type; }; template <> -struct DefaultFormatter<TString> { +struct DefaultFormatter<TString> { typedef NoFormatter Type; }; template <> -struct DefaultFormatter<y_absl::string_view> { +struct DefaultFormatter<y_absl::string_view> { typedef NoFormatter Type; }; template <typename ValueType> @@ -193,10 +193,10 @@ struct DefaultFormatter<std::unique_ptr<ValueType>> // iterator range, each separated by the given separator, into an output string, // and formats each element using the provided Formatter object. template <typename Iterator, typename Formatter> -TString JoinAlgorithm(Iterator start, Iterator end, y_absl::string_view s, +TString JoinAlgorithm(Iterator start, Iterator end, y_absl::string_view s, Formatter&& f) { - TString result; - y_absl::string_view sep(""); + TString result; + y_absl::string_view sep(""); for (Iterator it = start; it != end; ++it) { result.append(sep.data(), sep.size()); f(&result, *it); @@ -208,12 +208,12 @@ TString JoinAlgorithm(Iterator start, Iterator end, y_absl::string_view s, // A joining algorithm that's optimized for a forward iterator range of // string-like objects that do not need any additional formatting. This is to // optimize the common case of joining, say, a std::vector<string> or a -// std::vector<y_absl::string_view>. +// std::vector<y_absl::string_view>. // // This is an overload of the previous JoinAlgorithm() function. Here the // Formatter argument is of type NoFormatter. Since NoFormatter is an internal // type, this overload is only invoked when strings::Join() is called with a -// range of string-like objects (e.g., TString, y_absl::string_view), and an +// range of string-like objects (e.g., TString, y_absl::string_view), and an // explicit Formatter argument was NOT specified. // // The optimization is that the needed space will be reserved in the output @@ -224,9 +224,9 @@ template <typename Iterator, typename = typename std::enable_if<std::is_convertible< typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>::value>::type> -TString JoinAlgorithm(Iterator start, Iterator end, y_absl::string_view s, +TString JoinAlgorithm(Iterator start, Iterator end, y_absl::string_view s, NoFormatter) { - TString result; + TString result; if (start != end) { // Sums size size_t result_size = start->size(); @@ -262,7 +262,7 @@ TString JoinAlgorithm(Iterator start, Iterator end, y_absl::string_view s, template <size_t I, size_t N> struct JoinTupleLoop { template <typename Tup, typename Formatter> - void operator()(TString* out, const Tup& tup, y_absl::string_view sep, + void operator()(TString* out, const Tup& tup, y_absl::string_view sep, Formatter&& fmt) { if (I > 0) out->append(sep.data(), sep.size()); fmt(out, std::get<I>(tup)); @@ -272,20 +272,20 @@ struct JoinTupleLoop { template <size_t N> struct JoinTupleLoop<N, N> { template <typename Tup, typename Formatter> - void operator()(TString*, const Tup&, y_absl::string_view, Formatter&&) {} + void operator()(TString*, const Tup&, y_absl::string_view, Formatter&&) {} }; template <typename... T, typename Formatter> -TString JoinAlgorithm(const std::tuple<T...>& tup, y_absl::string_view sep, +TString JoinAlgorithm(const std::tuple<T...>& tup, y_absl::string_view sep, Formatter&& fmt) { - TString result; + TString result; JoinTupleLoop<0, sizeof...(T)>()(&result, tup, sep, fmt); return result; } template <typename Iterator> -TString JoinRange(Iterator first, Iterator last, - y_absl::string_view separator) { +TString JoinRange(Iterator first, Iterator last, + y_absl::string_view separator) { // No formatter was explicitly given, so a default must be chosen. typedef typename std::iterator_traits<Iterator>::value_type ValueType; typedef typename DefaultFormatter<ValueType>::Type Formatter; @@ -293,7 +293,7 @@ TString JoinRange(Iterator first, Iterator last, } template <typename Range, typename Formatter> -TString JoinRange(const Range& range, y_absl::string_view separator, +TString JoinRange(const Range& range, y_absl::string_view separator, Formatter&& fmt) { using std::begin; using std::end; @@ -301,7 +301,7 @@ TString JoinRange(const Range& range, y_absl::string_view separator, } template <typename Range> -TString JoinRange(const Range& range, y_absl::string_view separator) { +TString JoinRange(const Range& range, y_absl::string_view separator) { using std::begin; using std::end; return JoinRange(begin(range), end(range), separator); @@ -309,6 +309,6 @@ TString JoinRange(const Range& range, y_absl::string_view separator) { } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h index 0f787b1bdc..237864c0ed 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h @@ -22,9 +22,9 @@ // - Splitter<> // // DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including -// y_absl/strings/str_split.h. +// y_absl/strings/str_split.h. // -// IWYU pragma: private, include "y_absl/strings/str_split.h" +// IWYU pragma: private, include "y_absl/strings/str_split.h" #ifndef ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_ #define ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_ @@ -37,20 +37,20 @@ #include <utility> #include <vector> -#include "y_absl/base/macros.h" -#include "y_absl/base/port.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/port.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/strings/string_view.h" #ifdef _GLIBCXX_DEBUG -#include "y_absl/strings/internal/stl_type_traits.h" +#include "y_absl/strings/internal/stl_type_traits.h" #endif // _GLIBCXX_DEBUG -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { -// This class is implicitly constructible from everything that y_absl::string_view +// This class is implicitly constructible from everything that y_absl::string_view // is implicitly constructible from, except for rvalue strings. This means it // can be used as a function parameter in places where passing a temporary // string might cause memory lifetime issues. @@ -59,19 +59,19 @@ class ConvertibleToStringView { ConvertibleToStringView(const char* s) // NOLINT(runtime/explicit) : value_(s) {} ConvertibleToStringView(char* s) : value_(s) {} // NOLINT(runtime/explicit) - ConvertibleToStringView(y_absl::string_view s) // NOLINT(runtime/explicit) + ConvertibleToStringView(y_absl::string_view s) // NOLINT(runtime/explicit) : value_(s) {} - ConvertibleToStringView(const TString& s) // NOLINT(runtime/explicit) + ConvertibleToStringView(const TString& s) // NOLINT(runtime/explicit) : value_(s) {} // Disable conversion from rvalue strings. ConvertibleToStringView(TString&& s) = delete; ConvertibleToStringView(const TString&& s) = delete; - y_absl::string_view value() const { return value_; } + y_absl::string_view value() const { return value_; } private: - y_absl::string_view value_; + y_absl::string_view value_; }; // An iterator that enumerates the parts of a string from a Splitter. The text @@ -84,7 +84,7 @@ template <typename Splitter> class SplitIterator { public: using iterator_category = std::input_iterator_tag; - using value_type = y_absl::string_view; + using value_type = y_absl::string_view; using difference_type = ptrdiff_t; using pointer = const value_type*; using reference = const value_type&; @@ -97,14 +97,14 @@ class SplitIterator { delimiter_(splitter->delimiter()), predicate_(splitter->predicate()) { // Hack to maintain backward compatibility. This one block makes it so an - // empty y_absl::string_view whose .data() happens to be nullptr behaves - // *differently* from an otherwise empty y_absl::string_view whose .data() is + // empty y_absl::string_view whose .data() happens to be nullptr behaves + // *differently* from an otherwise empty y_absl::string_view whose .data() is // not nullptr. This is an undesirable difference in general, but this // behavior is maintained to avoid breaking existing code that happens to // depend on this old behavior/bug. Perhaps it will be fixed one day. The // difference in behavior is as follows: - // Split(y_absl::string_view(""), '-'); // {""} - // Split(y_absl::string_view(), '-'); // {} + // Split(y_absl::string_view(""), '-'); // {""} + // Split(y_absl::string_view(), '-'); // {} if (splitter_->text().data() == nullptr) { state_ = kEndState; pos_ = splitter_->text().size(); @@ -129,8 +129,8 @@ class SplitIterator { state_ = kEndState; return *this; } - const y_absl::string_view text = splitter_->text(); - const y_absl::string_view d = delimiter_.Find(text, pos_); + const y_absl::string_view text = splitter_->text(); + const y_absl::string_view d = delimiter_.Find(text, pos_); if (d.data() == text.data() + text.size()) state_ = kLastState; curr_ = text.substr(pos_, d.data() - (text.data() + pos_)); pos_ += curr_.size() + d.size(); @@ -155,7 +155,7 @@ class SplitIterator { private: size_t pos_; State state_; - y_absl::string_view curr_; + y_absl::string_view curr_; const Splitter* splitter_; typename Splitter::DelimiterType delimiter_; typename Splitter::PredicateType predicate_; @@ -165,21 +165,21 @@ class SplitIterator { template <typename T, typename = void> struct HasMappedType : std::false_type {}; template <typename T> -struct HasMappedType<T, y_absl::void_t<typename T::mapped_type>> +struct HasMappedType<T, y_absl::void_t<typename T::mapped_type>> : std::true_type {}; // HasValueType<T>::value is true iff there exists a type T::value_type. template <typename T, typename = void> struct HasValueType : std::false_type {}; template <typename T> -struct HasValueType<T, y_absl::void_t<typename T::value_type>> : std::true_type { +struct HasValueType<T, y_absl::void_t<typename T::value_type>> : std::true_type { }; // HasConstIterator<T>::value is true iff there exists a type T::const_iterator. template <typename T, typename = void> struct HasConstIterator : std::false_type {}; template <typename T> -struct HasConstIterator<T, y_absl::void_t<typename T::const_iterator>> +struct HasConstIterator<T, y_absl::void_t<typename T::const_iterator>> : std::true_type {}; // HasEmplace<T>::value is true iff there exists a method T::emplace(). @@ -213,13 +213,13 @@ struct SplitterIsConvertibleToImpl : std::false_type {}; template <typename C> struct SplitterIsConvertibleToImpl<C, true, false> - : std::is_constructible<typename C::value_type, y_absl::string_view> {}; + : std::is_constructible<typename C::value_type, y_absl::string_view> {}; template <typename C> struct SplitterIsConvertibleToImpl<C, true, true> - : y_absl::conjunction< - std::is_constructible<typename C::key_type, y_absl::string_view>, - std::is_constructible<typename C::mapped_type, y_absl::string_view>> {}; + : y_absl::conjunction< + std::is_constructible<typename C::key_type, y_absl::string_view>, + std::is_constructible<typename C::mapped_type, y_absl::string_view>> {}; template <typename C> struct SplitterIsConvertibleTo @@ -234,7 +234,7 @@ struct SplitterIsConvertibleTo HasMappedType<C>::value> { }; -// This class implements the range that is returned by y_absl::StrSplit(). This +// This class implements the range that is returned by y_absl::StrSplit(). This // class has templated conversion operators that allow it to be implicitly // converted to a variety of types that the caller may have specified on the // left-hand side of an assignment. @@ -245,11 +245,11 @@ struct SplitterIsConvertibleTo // within a range-for loop. // // Output containers can be collections of any type that is constructible from -// an y_absl::string_view. +// an y_absl::string_view. // // An Predicate functor may be supplied. This predicate will be used to filter // the split strings: only strings for which the predicate returns true will be -// kept. A Predicate object is any unary functor that takes an y_absl::string_view +// kept. A Predicate object is any unary functor that takes an y_absl::string_view // and returns bool. // // The StringType parameter can be either string_view or string, depending on @@ -272,7 +272,7 @@ class Splitter { const Delimiter& delimiter() const { return delimiter_; } const Predicate& predicate() const { return predicate_; } - // Range functions that iterate the split substrings as y_absl::string_view + // Range functions that iterate the split substrings as y_absl::string_view // objects. These methods enable a Splitter to be used in a range-based for // loop. const_iterator begin() const { return {const_iterator::kInitState, this}; } @@ -294,7 +294,7 @@ class Splitter { // corresponding value. template <typename First, typename Second> operator std::pair<First, Second>() const { // NOLINT(runtime/explicit) - y_absl::string_view first, second; + y_absl::string_view first, second; auto it = begin(); if (it != end()) { first = *it; @@ -325,24 +325,24 @@ class Splitter { } }; - // Partial specialization for a std::vector<y_absl::string_view>. + // Partial specialization for a std::vector<y_absl::string_view>. // // Optimized for the common case of splitting to a - // std::vector<y_absl::string_view>. In this case we first split the results to - // a small array of y_absl::string_view on the stack, to reduce reallocations. + // std::vector<y_absl::string_view>. In this case we first split the results to + // a small array of y_absl::string_view on the stack, to reduce reallocations. template <typename A> - struct ConvertToContainer<std::vector<y_absl::string_view, A>, - y_absl::string_view, false> { - std::vector<y_absl::string_view, A> operator()( + struct ConvertToContainer<std::vector<y_absl::string_view, A>, + y_absl::string_view, false> { + std::vector<y_absl::string_view, A> operator()( const Splitter& splitter) const { struct raw_view { const char* data; size_t size; - operator y_absl::string_view() const { // NOLINT(runtime/explicit) + operator y_absl::string_view() const { // NOLINT(runtime/explicit) return {data, size}; } }; - std::vector<y_absl::string_view, A> v; + std::vector<y_absl::string_view, A> v; std::array<raw_view, 16> ar; for (auto it = splitter.begin(); !it.at_end();) { size_t index = 0; @@ -357,17 +357,17 @@ class Splitter { } }; - // Partial specialization for a std::vector<TString>. + // Partial specialization for a std::vector<TString>. // - // Optimized for the common case of splitting to a std::vector<TString>. - // In this case we first split the results to a std::vector<y_absl::string_view> - // so the returned std::vector<TString> can have space reserved to avoid - // TString moves. + // Optimized for the common case of splitting to a std::vector<TString>. + // In this case we first split the results to a std::vector<y_absl::string_view> + // so the returned std::vector<TString> can have space reserved to avoid + // TString moves. template <typename A> - struct ConvertToContainer<std::vector<TString, A>, TString, false> { - std::vector<TString, A> operator()(const Splitter& splitter) const { - const std::vector<y_absl::string_view> v = splitter; - return std::vector<TString, A>(v.begin(), v.end()); + struct ConvertToContainer<std::vector<TString, A>, TString, false> { + std::vector<TString, A> operator()(const Splitter& splitter) const { + const std::vector<y_absl::string_view> v = splitter; + return std::vector<TString, A>(v.begin(), v.end()); } }; @@ -425,6 +425,6 @@ class Splitter { } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc index a33b67d1a8..06b1cae79d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc @@ -14,9 +14,9 @@ // UTF8 utilities, implemented to reduce dependencies. -#include "y_absl/strings/internal/utf8.h" +#include "y_absl/strings/internal/utf8.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -50,4 +50,4 @@ size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) { } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h index e51e407a5a..1b2d6abd51 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h @@ -22,7 +22,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { @@ -45,6 +45,6 @@ size_t EncodeUTF8Char(char *buffer, char32_t utf8_char); } // namespace strings_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_INTERNAL_UTF8_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc index c84ac9ce47..3197bdf432 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc @@ -12,19 +12,19 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/match.h" +#include "y_absl/strings/match.h" -#include "y_absl/strings/internal/memutil.h" +#include "y_absl/strings/internal/memutil.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN bool EqualsIgnoreCase(y_absl::string_view piece1, y_absl::string_view piece2) noexcept { return (piece1.size() == piece2.size() && - 0 == y_absl::strings_internal::memcasecmp(piece1.data(), piece2.data(), + 0 == y_absl::strings_internal::memcasecmp(piece1.data(), piece2.data(), piece1.size())); - // memcasecmp uses y_absl::ascii_tolower(). + // memcasecmp uses y_absl::ascii_tolower(). } bool StartsWithIgnoreCase(y_absl::string_view text, @@ -40,4 +40,4 @@ bool EndsWithIgnoreCase(y_absl::string_view text, } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.h index 133eae9c63..4709abc93f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.h @@ -18,26 +18,26 @@ // ----------------------------------------------------------------------------- // // This file contains simple utilities for performing string matching checks. -// All of these function parameters are specified as `y_absl::string_view`, -// meaning that these functions can accept `TString`, `y_absl::string_view` or +// All of these function parameters are specified as `y_absl::string_view`, +// meaning that these functions can accept `TString`, `y_absl::string_view` or // NUL-terminated C-style strings. // // Examples: -// TString s = "foo"; -// y_absl::string_view sv = "f"; -// assert(y_absl::StrContains(s, sv)); +// TString s = "foo"; +// y_absl::string_view sv = "f"; +// assert(y_absl::StrContains(s, sv)); // // Note: The order of parameters in these functions is designed to mimic the // order an equivalent member function would exhibit; -// e.g. `s.Contains(x)` ==> `y_absl::StrContains(s, x). +// e.g. `s.Contains(x)` ==> `y_absl::StrContains(s, x). #ifndef ABSL_STRINGS_MATCH_H_ #define ABSL_STRINGS_MATCH_H_ #include <cstring> -#include "y_absl/strings/string_view.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // StrContains() @@ -95,6 +95,6 @@ bool EndsWithIgnoreCase(y_absl::string_view text, y_absl::string_view suffix) noexcept; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_MATCH_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc index 30db79a678..528d044fa6 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc @@ -15,7 +15,7 @@ // This file contains string processing functions related to // numeric values. -#include "y_absl/strings/numbers.h" +#include "y_absl/strings/numbers.h" #include <algorithm> #include <cassert> @@ -31,19 +31,19 @@ #include <utility> #include "y_absl/base/attributes.h" -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" #include "y_absl/numeric/bits.h" -#include "y_absl/strings/ascii.h" -#include "y_absl/strings/charconv.h" -#include "y_absl/strings/escaping.h" -#include "y_absl/strings/internal/memutil.h" -#include "y_absl/strings/match.h" -#include "y_absl/strings/str_cat.h" - -namespace y_absl { +#include "y_absl/strings/ascii.h" +#include "y_absl/strings/charconv.h" +#include "y_absl/strings/escaping.h" +#include "y_absl/strings/internal/memutil.h" +#include "y_absl/strings/match.h" +#include "y_absl/strings/str_cat.h" + +namespace y_absl { ABSL_NAMESPACE_BEGIN -bool SimpleAtof(y_absl::string_view str, float* out) { +bool SimpleAtof(y_absl::string_view str, float* out) { *out = 0.0; str = StripAsciiWhitespace(str); // std::from_chars doesn't accept an initial +, but SimpleAtof does, so if one @@ -54,7 +54,7 @@ bool SimpleAtof(y_absl::string_view str, float* out) { return false; } } - auto result = y_absl::from_chars(str.data(), str.data() + str.size(), *out); + auto result = y_absl::from_chars(str.data(), str.data() + str.size(), *out); if (result.ec == std::errc::invalid_argument) { return false; } @@ -74,7 +74,7 @@ bool SimpleAtof(y_absl::string_view str, float* out) { return true; } -bool SimpleAtod(y_absl::string_view str, double* out) { +bool SimpleAtod(y_absl::string_view str, double* out) { *out = 0.0; str = StripAsciiWhitespace(str); // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one @@ -85,7 +85,7 @@ bool SimpleAtod(y_absl::string_view str, double* out) { return false; } } - auto result = y_absl::from_chars(str.data(), str.data() + str.size(), *out); + auto result = y_absl::from_chars(str.data(), str.data() + str.size(), *out); if (result.ec == std::errc::invalid_argument) { return false; } @@ -105,7 +105,7 @@ bool SimpleAtod(y_absl::string_view str, double* out) { return true; } -bool SimpleAtob(y_absl::string_view str, bool* out) { +bool SimpleAtob(y_absl::string_view str, bool* out) { ABSL_RAW_CHECK(out != nullptr, "Output pointer must not be nullptr."); if (EqualsIgnoreCase(str, "true") || EqualsIgnoreCase(str, "t") || EqualsIgnoreCase(str, "yes") || EqualsIgnoreCase(str, "y") || @@ -630,7 +630,7 @@ static const int8_t kAsciiToInt[256] = { 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36}; // Parse the sign and optional hex or oct prefix in text. -inline bool safe_parse_sign_and_base(y_absl::string_view* text /*inout*/, +inline bool safe_parse_sign_and_base(y_absl::string_view* text /*inout*/, int* base_ptr /*inout*/, bool* negative_ptr /*output*/) { if (text->data() == nullptr) { @@ -642,10 +642,10 @@ inline bool safe_parse_sign_and_base(y_absl::string_view* text /*inout*/, int base = *base_ptr; // Consume whitespace. - while (start < end && y_absl::ascii_isspace(start[0])) { + while (start < end && y_absl::ascii_isspace(start[0])) { ++start; } - while (start < end && y_absl::ascii_isspace(end[-1])) { + while (start < end && y_absl::ascii_isspace(end[-1])) { --end; } if (start >= end) { @@ -694,7 +694,7 @@ inline bool safe_parse_sign_and_base(y_absl::string_view* text /*inout*/, } else { return false; } - *text = y_absl::string_view(start, end - start); + *text = y_absl::string_view(start, end - start); *base_ptr = base; return true; } @@ -914,7 +914,7 @@ const IntType LookupTables<IntType>::kVminOverBase[] = #undef X_OVER_BASE_INITIALIZER template <typename IntType> -inline bool safe_parse_positive_int(y_absl::string_view text, int base, +inline bool safe_parse_positive_int(y_absl::string_view text, int base, IntType* value_p) { IntType value = 0; const IntType vmax = std::numeric_limits<IntType>::max(); @@ -950,7 +950,7 @@ inline bool safe_parse_positive_int(y_absl::string_view text, int base, } template <typename IntType> -inline bool safe_parse_negative_int(y_absl::string_view text, int base, +inline bool safe_parse_negative_int(y_absl::string_view text, int base, IntType* value_p) { IntType value = 0; const IntType vmin = std::numeric_limits<IntType>::min(); @@ -995,7 +995,7 @@ inline bool safe_parse_negative_int(y_absl::string_view text, int base, // Input format based on POSIX.1-2008 strtol // http://pubs.opengroup.org/onlinepubs/9699919799/functions/strtol.html template <typename IntType> -inline bool safe_int_internal(y_absl::string_view text, IntType* value_p, +inline bool safe_int_internal(y_absl::string_view text, IntType* value_p, int base) { *value_p = 0; bool negative; @@ -1010,7 +1010,7 @@ inline bool safe_int_internal(y_absl::string_view text, IntType* value_p, } template <typename IntType> -inline bool safe_uint_internal(y_absl::string_view text, IntType* value_p, +inline bool safe_uint_internal(y_absl::string_view text, IntType* value_p, int base) { *value_p = 0; bool negative; @@ -1064,11 +1064,11 @@ ABSL_CONST_INIT ABSL_DLL const char two_ASCII_digits[100][2] = { {'9', '0'}, {'9', '1'}, {'9', '2'}, {'9', '3'}, {'9', '4'}, {'9', '5'}, {'9', '6'}, {'9', '7'}, {'9', '8'}, {'9', '9'}}; -bool safe_strto32_base(y_absl::string_view text, int32_t* value, int base) { +bool safe_strto32_base(y_absl::string_view text, int32_t* value, int base) { return safe_int_internal<int32_t>(text, value, base); } -bool safe_strto64_base(y_absl::string_view text, int64_t* value, int base) { +bool safe_strto64_base(y_absl::string_view text, int64_t* value, int base) { return safe_int_internal<int64_t>(text, value, base); } @@ -1076,18 +1076,18 @@ bool safe_strto128_base(y_absl::string_view text, int128* value, int base) { return safe_int_internal<y_absl::int128>(text, value, base); } -bool safe_strtou32_base(y_absl::string_view text, uint32_t* value, int base) { +bool safe_strtou32_base(y_absl::string_view text, uint32_t* value, int base) { return safe_uint_internal<uint32_t>(text, value, base); } -bool safe_strtou64_base(y_absl::string_view text, uint64_t* value, int base) { +bool safe_strtou64_base(y_absl::string_view text, uint64_t* value, int base) { return safe_uint_internal<uint64_t>(text, value, base); } -bool safe_strtou128_base(y_absl::string_view text, uint128* value, int base) { - return safe_uint_internal<y_absl::uint128>(text, value, base); +bool safe_strtou128_base(y_absl::string_view text, uint128* value, int base) { + return safe_uint_internal<y_absl::uint128>(text, value, base); } } // namespace numbers_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h index b1832e8f3c..ce181d8eb1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h @@ -23,11 +23,11 @@ #ifndef ABSL_STRINGS_NUMBERS_H_ #define ABSL_STRINGS_NUMBERS_H_ -#if defined(__SSE4_2__) && !defined(__CUDACC__) -#define _Y__SSE4_2__ -#endif - -#ifdef _Y__SSE4_2__ +#if defined(__SSE4_2__) && !defined(__CUDACC__) +#define _Y__SSE4_2__ +#endif + +#ifdef _Y__SSE4_2__ #ifdef _MSC_VER #include <intrin.h> #else @@ -44,21 +44,21 @@ #include <type_traits> #include "y_absl/base/config.h" -#ifdef _Y__SSE4_2__ +#ifdef _Y__SSE4_2__ // TODO(jorg): Remove this when we figure out the right way // to swap bytes on SSE 4.2 that works with the compilers // we claim to support. Also, add tests for the compiler // that doesn't support the Intel _bswap64 intrinsic but // does support all the SSE 4.2 intrinsics -#include "y_absl/base/internal/endian.h" +#include "y_absl/base/internal/endian.h" #endif -#include "y_absl/base/macros.h" -#include "y_absl/base/port.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/port.h" #include "y_absl/numeric/bits.h" -#include "y_absl/numeric/int128.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/numeric/int128.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // SimpleAtoi() @@ -70,7 +70,7 @@ ABSL_NAMESPACE_BEGIN // encountered, this function returns `false`, leaving `out` in an unspecified // state. template <typename int_type> -ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out); +ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out); // SimpleAtof() // @@ -81,7 +81,7 @@ ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out); // allowed formats for `str`, except SimpleAtof() is locale-independent and will // always use the "C" locale. If any errors are encountered, this function // returns `false`, leaving `out` in an unspecified state. -ABSL_MUST_USE_RESULT bool SimpleAtof(y_absl::string_view str, float* out); +ABSL_MUST_USE_RESULT bool SimpleAtof(y_absl::string_view str, float* out); // SimpleAtod() // @@ -92,7 +92,7 @@ ABSL_MUST_USE_RESULT bool SimpleAtof(y_absl::string_view str, float* out); // allowed formats for `str`, except SimpleAtod is locale-independent and will // always use the "C" locale. If any errors are encountered, this function // returns `false`, leaving `out` in an unspecified state. -ABSL_MUST_USE_RESULT bool SimpleAtod(y_absl::string_view str, double* out); +ABSL_MUST_USE_RESULT bool SimpleAtod(y_absl::string_view str, double* out); // SimpleAtob() // @@ -102,7 +102,7 @@ ABSL_MUST_USE_RESULT bool SimpleAtod(y_absl::string_view str, double* out); // are interpreted as boolean `false`: "false", "f", "no", "n", "0". If any // errors are encountered, this function returns `false`, leaving `out` in an // unspecified state. -ABSL_MUST_USE_RESULT bool SimpleAtob(y_absl::string_view str, bool* out); +ABSL_MUST_USE_RESULT bool SimpleAtob(y_absl::string_view str, bool* out); // SimpleHexAtoi() // @@ -124,11 +124,11 @@ ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(y_absl::string_view str, y_absl::uint128* out); ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl // End of public API. Implementation details follow. -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace numbers_internal { @@ -152,13 +152,13 @@ inline void PutTwoDigits(size_t i, char* buf) { // safe_strto?() functions for implementing SimpleAtoi() -bool safe_strto32_base(y_absl::string_view text, int32_t* value, int base); -bool safe_strto64_base(y_absl::string_view text, int64_t* value, int base); +bool safe_strto32_base(y_absl::string_view text, int32_t* value, int base); +bool safe_strto64_base(y_absl::string_view text, int64_t* value, int base); bool safe_strto128_base(y_absl::string_view text, y_absl::int128* value, int base); -bool safe_strtou32_base(y_absl::string_view text, uint32_t* value, int base); -bool safe_strtou64_base(y_absl::string_view text, uint64_t* value, int base); -bool safe_strtou128_base(y_absl::string_view text, y_absl::uint128* value, +bool safe_strtou32_base(y_absl::string_view text, uint32_t* value, int base); +bool safe_strtou64_base(y_absl::string_view text, uint64_t* value, int base); +bool safe_strtou128_base(y_absl::string_view text, y_absl::uint128* value, int base); static const int kFastToBufferSize = 32; @@ -207,7 +207,7 @@ char* FastIntToBuffer(int_type i, char* buffer) { // Implementation of SimpleAtoi, generalized to support arbitrary base (used // with base different from 10 elsewhere in Abseil implementation). template <typename int_type> -ABSL_MUST_USE_RESULT bool safe_strtoi_base(y_absl::string_view s, int_type* out, +ABSL_MUST_USE_RESULT bool safe_strtoi_base(y_absl::string_view s, int_type* out, int base) { static_assert(sizeof(*out) == 4 || sizeof(*out) == 8, "SimpleAtoi works only with 32-bit or 64-bit integers."); @@ -248,8 +248,8 @@ ABSL_MUST_USE_RESULT bool safe_strtoi_base(y_absl::string_view s, int_type* out, // Returns the number of non-pad digits of the output (it can never be zero // since 0 has one digit). inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out) { -#ifdef _Y__SSE4_2__ - uint64_t be = y_absl::big_endian::FromHost64(val); +#ifdef _Y__SSE4_2__ + uint64_t be = y_absl::big_endian::FromHost64(val); const auto kNibbleMask = _mm_set1_epi8(0xf); const auto kHexDigits = _mm_setr_epi8('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'); @@ -262,7 +262,7 @@ inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out) { #else for (int i = 0; i < 8; ++i) { auto byte = (val >> (56 - 8 * i)) & 0xFF; - auto* hex = &y_absl::numbers_internal::kHexTable[byte * 2]; + auto* hex = &y_absl::numbers_internal::kHexTable[byte * 2]; std::memcpy(out + 2 * i, hex, 2); } #endif @@ -273,17 +273,17 @@ inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out) { } // namespace numbers_internal template <typename int_type> -ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out) { +ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out) { return numbers_internal::safe_strtoi_base(str, out, 10); } -ABSL_MUST_USE_RESULT inline bool SimpleAtoi(y_absl::string_view str, +ABSL_MUST_USE_RESULT inline bool SimpleAtoi(y_absl::string_view str, y_absl::int128* out) { return numbers_internal::safe_strto128_base(str, out, 10); } ABSL_MUST_USE_RESULT inline bool SimpleAtoi(y_absl::string_view str, - y_absl::uint128* out) { + y_absl::uint128* out) { return numbers_internal::safe_strtou128_base(str, out, 10); } @@ -303,6 +303,6 @@ ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(y_absl::string_view str, } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_NUMBERS_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc index f29ba3c877..9e11702eae 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/str_cat.h" +#include "y_absl/strings/str_cat.h" #include <assert.h> @@ -20,11 +20,11 @@ #include <cstdint> #include <cstring> -#include "y_absl/strings/ascii.h" -#include "y_absl/strings/internal/resize_uninitialized.h" -#include "y_absl/strings/numbers.h" +#include "y_absl/strings/ascii.h" +#include "y_absl/strings/internal/resize_uninitialized.h" +#include "y_absl/strings/numbers.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN AlphaNum::AlphaNum(Hex hex) { @@ -32,16 +32,16 @@ AlphaNum::AlphaNum(Hex hex) { "This function only works when output buffer >= 32 bytes long"); char* const end = &digits_[numbers_internal::kFastToBufferSize]; auto real_width = - y_absl::numbers_internal::FastHexToBufferZeroPad16(hex.value, end - 16); + y_absl::numbers_internal::FastHexToBufferZeroPad16(hex.value, end - 16); if (real_width >= hex.width) { - piece_ = y_absl::string_view(end - real_width, real_width); + piece_ = y_absl::string_view(end - real_width, real_width); } else { // Pad first 16 chars because FastHexToBufferZeroPad16 pads only to 16 and // max pad width can be up to 20. std::memset(end - 32, hex.fill, 16); // Patch up everything else up to the real_width. std::memset(end - real_width - 16, hex.fill, 16); - piece_ = y_absl::string_view(end - hex.width, hex.width); + piece_ = y_absl::string_view(end - hex.width, hex.width); } } @@ -73,7 +73,7 @@ AlphaNum::AlphaNum(Dec dec) { if (add_sign_again) *--writer = '-'; } - piece_ = y_absl::string_view(writer, end - writer); + piece_ = y_absl::string_view(writer, end - writer); } // ---------------------------------------------------------------------- @@ -95,9 +95,9 @@ static char* Append(char* out, const AlphaNum& x) { return after; } -TString StrCat(const AlphaNum& a, const AlphaNum& b) { - TString result; - y_absl::strings_internal::STLStringResizeUninitialized(&result, +TString StrCat(const AlphaNum& a, const AlphaNum& b) { + TString result; + y_absl::strings_internal::STLStringResizeUninitialized(&result, a.size() + b.size()); char* const begin = &result[0]; char* out = begin; @@ -107,8 +107,8 @@ TString StrCat(const AlphaNum& a, const AlphaNum& b) { return result; } -TString StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) { - TString result; +TString StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) { + TString result; strings_internal::STLStringResizeUninitialized( &result, a.size() + b.size() + c.size()); char* const begin = &result[0]; @@ -120,9 +120,9 @@ TString StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) { return result; } -TString StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, +TString StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d) { - TString result; + TString result; strings_internal::STLStringResizeUninitialized( &result, a.size() + b.size() + c.size() + d.size()); char* const begin = &result[0]; @@ -138,8 +138,8 @@ TString StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, namespace strings_internal { // Do not call directly - these are not part of the public API. -TString CatPieces(std::initializer_list<y_absl::string_view> pieces) { - TString result; +TString CatPieces(std::initializer_list<y_absl::string_view> pieces) { + TString result; size_t total_size = 0; for (const y_absl::string_view& piece : pieces) total_size += piece.size(); strings_internal::STLStringResizeUninitialized(&result, total_size); @@ -157,7 +157,7 @@ TString CatPieces(std::initializer_list<y_absl::string_view> pieces) { return result; } -// It's possible to call StrAppend with an y_absl::string_view that is itself a +// It's possible to call StrAppend with an y_absl::string_view that is itself a // fragment of the string we're appending to. However the results of this are // random. Therefore, check for this in debug mode. Use unsigned math so we // only have to do one comparison. Note, there's an exception case: appending an @@ -166,8 +166,8 @@ TString CatPieces(std::initializer_list<y_absl::string_view> pieces) { assert(((src).size() == 0) || \ (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size()))) -void AppendPieces(TString* dest, - std::initializer_list<y_absl::string_view> pieces) { +void AppendPieces(TString* dest, + std::initializer_list<y_absl::string_view> pieces) { size_t old_size = dest->size(); size_t total_size = old_size; for (const y_absl::string_view& piece : pieces) { @@ -190,15 +190,15 @@ void AppendPieces(TString* dest, } // namespace strings_internal -void StrAppend(TString* dest, const AlphaNum& a) { +void StrAppend(TString* dest, const AlphaNum& a) { ASSERT_NO_OVERLAP(*dest, a); dest->append(a.data(), a.size()); } -void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b) { +void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b) { ASSERT_NO_OVERLAP(*dest, a); ASSERT_NO_OVERLAP(*dest, b); - TString::size_type old_size = dest->size(); + TString::size_type old_size = dest->size(); strings_internal::STLStringResizeUninitializedAmortized( dest, old_size + a.size() + b.size()); char* const begin = &(*dest)[0]; @@ -208,12 +208,12 @@ void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b) { assert(out == begin + dest->size()); } -void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, +void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) { ASSERT_NO_OVERLAP(*dest, a); ASSERT_NO_OVERLAP(*dest, b); ASSERT_NO_OVERLAP(*dest, c); - TString::size_type old_size = dest->size(); + TString::size_type old_size = dest->size(); strings_internal::STLStringResizeUninitializedAmortized( dest, old_size + a.size() + b.size() + c.size()); char* const begin = &(*dest)[0]; @@ -224,13 +224,13 @@ void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, assert(out == begin + dest->size()); } -void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, +void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d) { ASSERT_NO_OVERLAP(*dest, a); ASSERT_NO_OVERLAP(*dest, b); ASSERT_NO_OVERLAP(*dest, c); ASSERT_NO_OVERLAP(*dest, d); - TString::size_type old_size = dest->size(); + TString::size_type old_size = dest->size(); strings_internal::STLStringResizeUninitializedAmortized( dest, old_size + a.size() + b.size() + c.size() + d.size()); char* const begin = &(*dest)[0]; @@ -243,4 +243,4 @@ void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h index a214ac0ba6..a77c9ae906 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h @@ -28,7 +28,7 @@ // to your function, your callers will automagically convert bools, integers, // and floating point values to strings for you. // -// NOTE: Use of `AlphaNum` outside of the //y_absl/strings package is unsupported +// NOTE: Use of `AlphaNum` outside of the //y_absl/strings package is unsupported // except for the specific case of function parameters of type `AlphaNum` or // `const AlphaNum &`. In particular, instantiating `AlphaNum` directly as a // stack variable is not supported. @@ -59,17 +59,17 @@ #include <type_traits> #include <vector> -#include "y_absl/base/port.h" -#include "y_absl/strings/numbers.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/base/port.h" +#include "y_absl/strings/numbers.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { // AlphaNumBuffer allows a way to pass a string to StrCat without having to do // memory allocation. It is simply a pair of a fixed-size character array, and -// a size. Please don't use outside of y_absl, yet. +// a size. Please don't use outside of y_absl, yet. template <size_t max_size> struct AlphaNumBuffer { std::array<char, max_size> data; @@ -138,40 +138,40 @@ struct Hex { template <typename Int> explicit Hex( - Int v, PadSpec spec = y_absl::kNoPad, + Int v, PadSpec spec = y_absl::kNoPad, typename std::enable_if<sizeof(Int) == 1 && !std::is_pointer<Int>::value>::type* = nullptr) : Hex(spec, static_cast<uint8_t>(v)) {} template <typename Int> explicit Hex( - Int v, PadSpec spec = y_absl::kNoPad, + Int v, PadSpec spec = y_absl::kNoPad, typename std::enable_if<sizeof(Int) == 2 && !std::is_pointer<Int>::value>::type* = nullptr) : Hex(spec, static_cast<uint16_t>(v)) {} template <typename Int> explicit Hex( - Int v, PadSpec spec = y_absl::kNoPad, + Int v, PadSpec spec = y_absl::kNoPad, typename std::enable_if<sizeof(Int) == 4 && !std::is_pointer<Int>::value>::type* = nullptr) : Hex(spec, static_cast<uint32_t>(v)) {} template <typename Int> explicit Hex( - Int v, PadSpec spec = y_absl::kNoPad, + Int v, PadSpec spec = y_absl::kNoPad, typename std::enable_if<sizeof(Int) == 8 && !std::is_pointer<Int>::value>::type* = nullptr) : Hex(spec, static_cast<uint64_t>(v)) {} template <typename Pointee> - explicit Hex(Pointee* v, PadSpec spec = y_absl::kNoPad) + explicit Hex(Pointee* v, PadSpec spec = y_absl::kNoPad) : Hex(spec, reinterpret_cast<uintptr_t>(v)) {} private: Hex(PadSpec spec, uint64_t v) : value(v), - width(spec == y_absl::kNoPad + width(spec == y_absl::kNoPad ? 1 - : spec >= y_absl::kSpacePad2 ? spec - y_absl::kSpacePad2 + 2 - : spec - y_absl::kZeroPad2 + 2), - fill(spec >= y_absl::kSpacePad2 ? ' ' : '0') {} + : spec >= y_absl::kSpacePad2 ? spec - y_absl::kSpacePad2 + 2 + : spec - y_absl::kZeroPad2 + 2), + fill(spec >= y_absl::kSpacePad2 ? ' ' : '0') {} }; // ----------------------------------------------------------------------------- @@ -188,15 +188,15 @@ struct Dec { bool neg; template <typename Int> - explicit Dec(Int v, PadSpec spec = y_absl::kNoPad, + explicit Dec(Int v, PadSpec spec = y_absl::kNoPad, typename std::enable_if<(sizeof(Int) <= 8)>::type* = nullptr) : value(v >= 0 ? static_cast<uint64_t>(v) : uint64_t{0} - static_cast<uint64_t>(v)), - width(spec == y_absl::kNoPad + width(spec == y_absl::kNoPad ? 1 - : spec >= y_absl::kSpacePad2 ? spec - y_absl::kSpacePad2 + 2 - : spec - y_absl::kZeroPad2 + 2), - fill(spec >= y_absl::kSpacePad2 ? ' ' : '0'), + : spec >= y_absl::kSpacePad2 ? spec - y_absl::kSpacePad2 + 2 + : spec - y_absl::kZeroPad2 + 2), + fill(spec >= y_absl::kSpacePad2 ? ' ' : '0'), neg(v < 0) {} }; @@ -246,25 +246,25 @@ class AlphaNum { : piece_(&buf.data[0], buf.size) {} AlphaNum(const char* c_str) : piece_(c_str) {} // NOLINT(runtime/explicit) - AlphaNum(y_absl::string_view pc) : piece_(pc) {} // NOLINT(runtime/explicit) + AlphaNum(y_absl::string_view pc) : piece_(pc) {} // NOLINT(runtime/explicit) template <typename Allocator> AlphaNum( // NOLINT(runtime/explicit) const std::basic_string<char, std::char_traits<char>, Allocator>& str) : piece_(str) {} - AlphaNum(const TString& str) - : piece_(str.data(), str.size()) {} - + AlphaNum(const TString& str) + : piece_(str.data(), str.size()) {} + // Use string literals ":" instead of character literals ':'. AlphaNum(char c) = delete; // NOLINT(runtime/explicit) AlphaNum(const AlphaNum&) = delete; AlphaNum& operator=(const AlphaNum&) = delete; - y_absl::string_view::size_type size() const { return piece_.size(); } + y_absl::string_view::size_type size() const { return piece_.size(); } const char* data() const { return piece_.data(); } - y_absl::string_view Piece() const { return piece_; } + y_absl::string_view Piece() const { return piece_; } // Normal enums are already handled by the integer formatters. // This overload matches only scoped enums. @@ -286,7 +286,7 @@ class AlphaNum { AlphaNum(T e) : AlphaNum(static_cast<bool>(e)) {} // NOLINT(runtime/explicit) private: - y_absl::string_view piece_; + y_absl::string_view piece_; char digits_[numbers_internal::kFastToBufferSize]; }; @@ -321,27 +321,27 @@ class AlphaNum { namespace strings_internal { // Do not call directly - this is not part of the public API. -TString CatPieces(std::initializer_list<y_absl::string_view> pieces); -void AppendPieces(TString* dest, - std::initializer_list<y_absl::string_view> pieces); +TString CatPieces(std::initializer_list<y_absl::string_view> pieces); +void AppendPieces(TString* dest, + std::initializer_list<y_absl::string_view> pieces); } // namespace strings_internal -ABSL_MUST_USE_RESULT inline TString StrCat() { return TString(); } +ABSL_MUST_USE_RESULT inline TString StrCat() { return TString(); } -ABSL_MUST_USE_RESULT inline TString StrCat(const AlphaNum& a) { - return TString(a.data(), a.size()); +ABSL_MUST_USE_RESULT inline TString StrCat(const AlphaNum& a) { + return TString(a.data(), a.size()); } -ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b); -ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b, +ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b); +ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c); -ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b, +ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d); // Support 5 or more arguments template <typename... AV> -ABSL_MUST_USE_RESULT inline TString StrCat( +ABSL_MUST_USE_RESULT inline TString StrCat( const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d, const AlphaNum& e, const AV&... args) { return strings_internal::CatPieces( @@ -361,32 +361,32 @@ ABSL_MUST_USE_RESULT inline TString StrCat( // not try to check each of its input arguments to be sure that they are not // a subset of the string being appended to. That is, while this will work: // -// TString s = "foo"; +// TString s = "foo"; // s += s; // // This output is undefined: // -// TString s = "foo"; +// TString s = "foo"; // StrAppend(&s, s); // -// This output is undefined as well, since `y_absl::string_view` does not own its +// This output is undefined as well, since `y_absl::string_view` does not own its // data: // -// TString s = "foobar"; -// y_absl::string_view p = s; +// TString s = "foobar"; +// y_absl::string_view p = s; // StrAppend(&s, p); -inline void StrAppend(TString*) {} -void StrAppend(TString* dest, const AlphaNum& a); -void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b); -void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, +inline void StrAppend(TString*) {} +void StrAppend(TString* dest, const AlphaNum& a); +void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b); +void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, const AlphaNum& c); -void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, +void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d); // Support 5 or more arguments template <typename... AV> -inline void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, +inline void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d, const AlphaNum& e, const AV&... args) { strings_internal::AppendPieces( @@ -406,6 +406,6 @@ SixDigits(double d) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_STR_CAT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h index ba6e332450..4079f38fb4 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h @@ -25,17 +25,17 @@ // // Example: // -// TString s = y_absl::StrFormat( +// TString s = y_absl::StrFormat( // "%s %s You have $%d!", "Hello", name, dollars); // // The library consists of the following basic utilities: // -// * `y_absl::StrFormat()`, a type-safe replacement for `std::sprintf()`, to +// * `y_absl::StrFormat()`, a type-safe replacement for `std::sprintf()`, to // write a format string to a `string` value. -// * `y_absl::StrAppendFormat()` to append a format string to a `string` -// * `y_absl::StreamFormat()` to more efficiently write a format string to a +// * `y_absl::StrAppendFormat()` to append a format string to a `string` +// * `y_absl::StreamFormat()` to more efficiently write a format string to a // stream, such as`std::cout`. -// * `y_absl::PrintF()`, `y_absl::FPrintF()` and `y_absl::SNPrintF()` as +// * `y_absl::PrintF()`, `y_absl::FPrintF()` and `y_absl::SNPrintF()` as // replacements for `std::printf()`, `std::fprintf()` and `std::snprintf()`. // // Note: a version of `std::sprintf()` is not supported as it is @@ -73,13 +73,13 @@ #include <cstdio> #include <util/generic/string.h> -#include "y_absl/strings/internal/str_format/arg.h" // IWYU pragma: export -#include "y_absl/strings/internal/str_format/bind.h" // IWYU pragma: export -#include "y_absl/strings/internal/str_format/checker.h" // IWYU pragma: export -#include "y_absl/strings/internal/str_format/extension.h" // IWYU pragma: export -#include "y_absl/strings/internal/str_format/parser.h" // IWYU pragma: export +#include "y_absl/strings/internal/str_format/arg.h" // IWYU pragma: export +#include "y_absl/strings/internal/str_format/bind.h" // IWYU pragma: export +#include "y_absl/strings/internal/str_format/checker.h" // IWYU pragma: export +#include "y_absl/strings/internal/str_format/extension.h" // IWYU pragma: export +#include "y_absl/strings/internal/str_format/parser.h" // IWYU pragma: export -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // UntypedFormatSpec @@ -90,9 +90,9 @@ ABSL_NAMESPACE_BEGIN // // Example: // -// y_absl::UntypedFormatSpec format("%d"); -// TString out; -// CHECK(y_absl::FormatUntyped(&out, format, {y_absl::FormatArg(1)})); +// y_absl::UntypedFormatSpec format("%d"); +// TString out; +// CHECK(y_absl::FormatUntyped(&out, format, {y_absl::FormatArg(1)})); class UntypedFormatSpec { public: UntypedFormatSpec() = delete; @@ -118,7 +118,7 @@ class UntypedFormatSpec { // // Example: // -// y_absl::StrFormat("%s", y_absl::FormatStreamed(obj)); +// y_absl::StrFormat("%s", y_absl::FormatStreamed(obj)); template <typename T> str_format_internal::StreamedWrapper<T> FormatStreamed(const T& v) { return str_format_internal::StreamedWrapper<T>(v); @@ -137,8 +137,8 @@ str_format_internal::StreamedWrapper<T> FormatStreamed(const T& v) { // Example: // // int n = 0; -// TString s = y_absl::StrFormat("%s%d%n", "hello", 123, -// y_absl::FormatCountCapture(&n)); +// TString s = y_absl::StrFormat("%s%d%n", "hello", 123, +// y_absl::FormatCountCapture(&n)); // EXPECT_EQ(8, n); class FormatCountCapture { public: @@ -171,7 +171,7 @@ class FormatCountCapture { // For a `FormatSpec` to be valid at compile-time, it must be provided as // either: // -// * A `constexpr` literal or `y_absl::string_view`, which is how it most often +// * A `constexpr` literal or `y_absl::string_view`, which is how it most often // used. // * A `ParsedFormat` instantiation, which ensures the format string is // valid before use. (See below.) @@ -179,16 +179,16 @@ class FormatCountCapture { // Example: // // // Provided as a string literal. -// y_absl::StrFormat("Welcome to %s, Number %d!", "The Village", 6); +// y_absl::StrFormat("Welcome to %s, Number %d!", "The Village", 6); // -// // Provided as a constexpr y_absl::string_view. -// constexpr y_absl::string_view formatString = "Welcome to %s, Number %d!"; -// y_absl::StrFormat(formatString, "The Village", 6); +// // Provided as a constexpr y_absl::string_view. +// constexpr y_absl::string_view formatString = "Welcome to %s, Number %d!"; +// y_absl::StrFormat(formatString, "The Village", 6); // // // Provided as a pre-compiled ParsedFormat object. // // Note that this example is useful only for illustration purposes. -// y_absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!"); -// y_absl::StrFormat(formatString, "TheVillage", 6); +// y_absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!"); +// y_absl::StrFormat(formatString, "TheVillage", 6); // // A format string generally follows the POSIX syntax as used within the POSIX // `printf` specification. @@ -210,7 +210,7 @@ class FormatCountCapture { // * `p` for pointer address values // * `n` for the special case of writing out the number of characters // written to this point. The resulting value must be captured within an -// `y_absl::FormatCountCapture` type. +// `y_absl::FormatCountCapture` type. // // Implementation-defined behavior: // * A null pointer provided to "%s" or "%p" is output as "(nil)". @@ -224,7 +224,7 @@ class FormatCountCapture { // "%c", 'a' -> "a" // "%c", 32 -> " " // "%s", "C" -> "C" -// "%s", TString("C++") -> "C++" +// "%s", TString("C++") -> "C++" // "%d", -10 -> "-10" // "%o", 10 -> "12" // "%x", 16 -> "10" @@ -235,8 +235,8 @@ class FormatCountCapture { // "%p", (void*)&value -> "0x7ffdeb6ad2a4" // // int n = 0; -// TString s = y_absl::StrFormat( -// "%s%d%n", "hello", 123, y_absl::FormatCountCapture(&n)); +// TString s = y_absl::StrFormat( +// "%s%d%n", "hello", 123, y_absl::FormatCountCapture(&n)); // EXPECT_EQ(8, n); // // The `FormatSpec` intrinsically supports all of these fundamental C++ types: @@ -248,7 +248,7 @@ class FormatCountCapture { // // However, in the `str_format` library, a format conversion specifies a broader // C++ conceptual category instead of an exact type. For example, `%s` binds to -// any string-like argument, so `TString`, `y_absl::string_view`, and +// any string-like argument, so `TString`, `y_absl::string_view`, and // `const char*` are all accepted. Likewise, `%d` accepts any integer-like // argument, etc. @@ -271,13 +271,13 @@ using FormatSpec = str_format_internal::FormatSpecTemplate< // Example: // // // Verified at compile time. -// y_absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!"); -// y_absl::StrFormat(formatString, "TheVillage", 6); +// y_absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!"); +// y_absl::StrFormat(formatString, "TheVillage", 6); // // // Verified at runtime. -// auto format_runtime = y_absl::ParsedFormat<'d'>::New(format_string); +// auto format_runtime = y_absl::ParsedFormat<'d'>::New(format_string); // if (format_runtime) { -// value = y_absl::StrFormat(*format_runtime, i); +// value = y_absl::StrFormat(*format_runtime, i); // } else { // ... error case ... // } @@ -329,13 +329,13 @@ using ParsedFormat = str_format_internal::ExtendedParsedFormat< // // Example: // -// TString s = y_absl::StrFormat( +// TString s = y_absl::StrFormat( // "Welcome to %s, Number %d!", "The Village", 6); // EXPECT_EQ("Welcome to The Village, Number 6!", s); // // Returns an empty string in case of error. template <typename... Args> -ABSL_MUST_USE_RESULT TString StrFormat(const FormatSpec<Args...>& format, +ABSL_MUST_USE_RESULT TString StrFormat(const FormatSpec<Args...>& format, const Args&... args) { return str_format_internal::FormatPack( str_format_internal::UntypedFormatSpecImpl::Extract(format), @@ -350,10 +350,10 @@ ABSL_MUST_USE_RESULT TString StrFormat(const FormatSpec<Args...>& format, // // Example: // -// TString orig("For example PI is approximately "); +// TString orig("For example PI is approximately "); // std::cout << StrAppendFormat(&orig, "%12.6f", 3.14); template <typename... Args> -TString& StrAppendFormat(TString* dst, +TString& StrAppendFormat(TString* dst, const FormatSpec<Args...>& format, const Args&... args) { return str_format_internal::AppendPack( @@ -365,7 +365,7 @@ TString& StrAppendFormat(TString* dst, // // Writes to an output stream given a format string and zero or more arguments, // generally in a manner that is more efficient than streaming the result of -// `y_absl:: StrFormat()`. The returned object must be streamed before the full +// `y_absl:: StrFormat()`. The returned object must be streamed before the full // expression ends. // // Example: @@ -383,12 +383,12 @@ ABSL_MUST_USE_RESULT str_format_internal::Streamable StreamFormat( // // Writes to stdout given a format string and zero or more arguments. This // function is functionally equivalent to `std::printf()` (and type-safe); -// prefer `y_absl::PrintF()` over `std::printf()`. +// prefer `y_absl::PrintF()` over `std::printf()`. // // Example: // // std::string_view s = "Ulaanbaatar"; -// y_absl::PrintF("The capital of Mongolia is %s", s); +// y_absl::PrintF("The capital of Mongolia is %s", s); // // Outputs: "The capital of Mongolia is Ulaanbaatar" // @@ -403,12 +403,12 @@ int PrintF(const FormatSpec<Args...>& format, const Args&... args) { // // Writes to a file given a format string and zero or more arguments. This // function is functionally equivalent to `std::fprintf()` (and type-safe); -// prefer `y_absl::FPrintF()` over `std::fprintf()`. +// prefer `y_absl::FPrintF()` over `std::fprintf()`. // // Example: // // std::string_view s = "Ulaanbaatar"; -// y_absl::FPrintF(stdout, "The capital of Mongolia is %s", s); +// y_absl::FPrintF(stdout, "The capital of Mongolia is %s", s); // // Outputs: "The capital of Mongolia is Ulaanbaatar" // @@ -424,9 +424,9 @@ int FPrintF(std::FILE* output, const FormatSpec<Args...>& format, // // Writes to a sized buffer given a format string and zero or more arguments. // This function is functionally equivalent to `std::snprintf()` (and -// type-safe); prefer `y_absl::SNPrintF()` over `std::snprintf()`. +// type-safe); prefer `y_absl::SNPrintF()` over `std::snprintf()`. // -// In particular, a successful call to `y_absl::SNPrintF()` writes at most `size` +// In particular, a successful call to `y_absl::SNPrintF()` writes at most `size` // bytes of the formatted output to `output`, including a NUL-terminator, and // returns the number of bytes that would have been written if truncation did // not occur. In the event of an error, a negative value is returned and `errno` @@ -436,7 +436,7 @@ int FPrintF(std::FILE* output, const FormatSpec<Args...>& format, // // std::string_view s = "Ulaanbaatar"; // char output[128]; -// y_absl::SNPrintF(output, sizeof(output), +// y_absl::SNPrintF(output, sizeof(output), // "The capital of Mongolia is %s", s); // // Post-condition: output == "The capital of Mongolia is Ulaanbaatar" @@ -487,7 +487,7 @@ class FormatRawSink { // Format() // // Writes a formatted string to an arbitrary sink object (implementing the -// `y_absl::FormatRawSink` interface), using a format string and zero or more +// `y_absl::FormatRawSink` interface), using a format string and zero or more // additional arguments. // // By default, `TString`, `std::ostream`, and `y_absl::Cord` are supported as @@ -522,7 +522,7 @@ using FormatArg = str_format_internal::FormatArgImpl; // FormatUntyped() // // Writes a formatted string to an arbitrary sink object (implementing the -// `y_absl::FormatRawSink` interface), using an `UntypedFormatSpec` and zero or +// `y_absl::FormatRawSink` interface), using an `UntypedFormatSpec` and zero or // more additional arguments. // // This function acts as the most generic formatting function in the @@ -533,26 +533,26 @@ using FormatArg = str_format_internal::FormatArgImpl; // On failure, this function returns `false` and the state of the sink is // unspecified. // -// The arguments are provided in an `y_absl::Span<const y_absl::FormatArg>`. -// Each `y_absl::FormatArg` object binds to a single argument and keeps a +// The arguments are provided in an `y_absl::Span<const y_absl::FormatArg>`. +// Each `y_absl::FormatArg` object binds to a single argument and keeps a // reference to it. The values used to create the `FormatArg` objects must // outlive this function call. // // Example: // -// std::optional<TString> FormatDynamic( -// const TString& in_format, -// const vector<TString>& in_args) { -// TString out; -// std::vector<y_absl::FormatArg> args; +// std::optional<TString> FormatDynamic( +// const TString& in_format, +// const vector<TString>& in_args) { +// TString out; +// std::vector<y_absl::FormatArg> args; // for (const auto& v : in_args) { // // It is important that 'v' is a reference to the objects in in_args. // // The values we pass to FormatArg must outlive the call to // // FormatUntyped. // args.emplace_back(v); // } -// y_absl::UntypedFormatSpec format(in_format); -// if (!y_absl::FormatUntyped(&out, format, args)) { +// y_absl::UntypedFormatSpec format(in_format); +// if (!y_absl::FormatUntyped(&out, format, args)) { // return std::nullopt; // } // return std::move(out); @@ -560,7 +560,7 @@ using FormatArg = str_format_internal::FormatArgImpl; // ABSL_MUST_USE_RESULT inline bool FormatUntyped( FormatRawSink raw_sink, const UntypedFormatSpec& format, - y_absl::Span<const FormatArg> args) { + y_absl::Span<const FormatArg> args) { return str_format_internal::FormatUntyped( str_format_internal::FormatRawSinkImpl::Extract(raw_sink), str_format_internal::UntypedFormatSpecImpl::Extract(format), args); @@ -807,6 +807,6 @@ struct FormatConvertResult { }; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_STR_FORMAT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h index 41d3205da7..46a0323c6e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h @@ -18,30 +18,30 @@ // ----------------------------------------------------------------------------- // // This header file contains functions for joining a range of elements and -// returning the result as a TString. StrJoin operations are specified by +// returning the result as a TString. StrJoin operations are specified by // passing a range, a separator string to use between the elements joined, and // an optional Formatter responsible for converting each argument in the range // to a string. If omitted, a default `AlphaNumFormatter()` is called on the -// elements to be joined, using the same formatting that `y_absl::StrCat()` uses. +// elements to be joined, using the same formatting that `y_absl::StrCat()` uses. // This package defines a number of default formatters, and you can define your // own implementations. // // Ranges are specified by passing a container with `std::begin()` and // `std::end()` iterators, container-specific `begin()` and `end()` iterators, a // brace-initialized `std::initializer_list`, or a `std::tuple` of heterogeneous -// objects. The separator string is specified as an `y_absl::string_view`. +// objects. The separator string is specified as an `y_absl::string_view`. // -// Because the default formatter uses the `y_absl::AlphaNum` class, -// `y_absl::StrJoin()`, like `y_absl::StrCat()`, will work out-of-the-box on +// Because the default formatter uses the `y_absl::AlphaNum` class, +// `y_absl::StrJoin()`, like `y_absl::StrCat()`, will work out-of-the-box on // collections of strings, ints, floats, doubles, etc. // // Example: // -// std::vector<TString> v = {"foo", "bar", "baz"}; -// TString s = y_absl::StrJoin(v, "-"); +// std::vector<TString> v = {"foo", "bar", "baz"}; +// TString s = y_absl::StrJoin(v, "-"); // EXPECT_EQ("foo-bar-baz", s); // -// See comments on the `y_absl::StrJoin()` function for more examples. +// See comments on the `y_absl::StrJoin()` function for more examples. #ifndef ABSL_STRINGS_STR_JOIN_H_ #define ABSL_STRINGS_STR_JOIN_H_ @@ -55,11 +55,11 @@ #include <type_traits> #include <utility> -#include "y_absl/base/macros.h" -#include "y_absl/strings/internal/str_join_internal.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/base/macros.h" +#include "y_absl/strings/internal/str_join_internal.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ----------------------------------------------------------------------------- @@ -67,25 +67,25 @@ ABSL_NAMESPACE_BEGIN // ----------------------------------------------------------------------------- // // A Formatter is a function object that is responsible for formatting its -// argument as a string and appending it to a given output TString. +// argument as a string and appending it to a given output TString. // Formatters may be implemented as function objects, lambdas, or normal -// functions. You may provide your own Formatter to enable `y_absl::StrJoin()` to +// functions. You may provide your own Formatter to enable `y_absl::StrJoin()` to // work with arbitrary types. // // The following is an example of a custom Formatter that simply uses -// `std::to_string()` to format an integer as a TString. +// `std::to_string()` to format an integer as a TString. // // struct MyFormatter { -// void operator()(TString* out, int i) const { +// void operator()(TString* out, int i) const { // out->append(std::to_string(i)); // } // }; // // You would use the above formatter by passing an instance of it as the final -// argument to `y_absl::StrJoin()`: +// argument to `y_absl::StrJoin()`: // // std::vector<int> v = {1, 2, 3, 4}; -// TString s = y_absl::StrJoin(v, "-", MyFormatter()); +// TString s = y_absl::StrJoin(v, "-", MyFormatter()); // EXPECT_EQ("1-2-3-4", s); // // The following standard formatters are provided within this file: @@ -97,7 +97,7 @@ ABSL_NAMESPACE_BEGIN // AlphaNumFormatter() // -// Default formatter used if none is specified. Uses `y_absl::AlphaNum` to convert +// Default formatter used if none is specified. Uses `y_absl::AlphaNum` to convert // numeric arguments to strings. inline strings_internal::AlphaNumFormatterImpl AlphaNumFormatter() { return strings_internal::AlphaNumFormatterImpl(); @@ -110,14 +110,14 @@ inline strings_internal::StreamFormatterImpl StreamFormatter() { return strings_internal::StreamFormatterImpl(); } -// Function Template: PairFormatter(Formatter, y_absl::string_view, Formatter) +// Function Template: PairFormatter(Formatter, y_absl::string_view, Formatter) // // Formats a `std::pair` by putting a given separator between the pair's // `.first` and `.second` members. This formatter allows you to specify // custom Formatters for both the first and second member of each pair. template <typename FirstFormatter, typename SecondFormatter> inline strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter> -PairFormatter(FirstFormatter f1, y_absl::string_view sep, SecondFormatter f2) { +PairFormatter(FirstFormatter f1, y_absl::string_view sep, SecondFormatter f2) { return strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>( std::move(f1), sep, std::move(f2)); } @@ -127,7 +127,7 @@ PairFormatter(FirstFormatter f1, y_absl::string_view sep, SecondFormatter f2) { inline strings_internal::PairFormatterImpl< strings_internal::AlphaNumFormatterImpl, strings_internal::AlphaNumFormatterImpl> -PairFormatter(y_absl::string_view sep) { +PairFormatter(y_absl::string_view sep) { return PairFormatter(AlphaNumFormatter(), sep, AlphaNumFormatter()); } @@ -157,8 +157,8 @@ DereferenceFormatter() { // StrJoin() // ----------------------------------------------------------------------------- // -// Joins a range of elements and returns the result as a TString. -// `y_absl::StrJoin()` takes a range, a separator string to use between the +// Joins a range of elements and returns the result as a TString. +// `y_absl::StrJoin()` takes a range, a separator string to use between the // elements joined, and an optional Formatter responsible for converting each // argument in the range to a string. // @@ -167,23 +167,23 @@ DereferenceFormatter() { // // Example 1: // // Joins a collection of strings. This pattern also works with a collection -// // of `y_absl::string_view` or even `const char*`. -// std::vector<TString> v = {"foo", "bar", "baz"}; -// TString s = y_absl::StrJoin(v, "-"); +// // of `y_absl::string_view` or even `const char*`. +// std::vector<TString> v = {"foo", "bar", "baz"}; +// TString s = y_absl::StrJoin(v, "-"); // EXPECT_EQ("foo-bar-baz", s); // // Example 2: // // Joins the values in the given `std::initializer_list<>` specified using // // brace initialization. This pattern also works with an initializer_list -// // of ints or `y_absl::string_view` -- any `AlphaNum`-compatible type. -// TString s = y_absl::StrJoin({"foo", "bar", "baz"}, "-"); +// // of ints or `y_absl::string_view` -- any `AlphaNum`-compatible type. +// TString s = y_absl::StrJoin({"foo", "bar", "baz"}, "-"); // EXPECT_EQ("foo-bar-baz", s); // // Example 3: // // Joins a collection of ints. This pattern also works with floats, // // doubles, int64s -- any `StrCat()`-compatible type. // std::vector<int> v = {1, 2, 3, -4}; -// TString s = y_absl::StrJoin(v, "-"); +// TString s = y_absl::StrJoin(v, "-"); // EXPECT_EQ("1-2-3--4", s); // // Example 4: @@ -194,7 +194,7 @@ DereferenceFormatter() { // // `std::vector<int*>`. // int x = 1, y = 2, z = 3; // std::vector<int*> v = {&x, &y, &z}; -// TString s = y_absl::StrJoin(v, "-"); +// TString s = y_absl::StrJoin(v, "-"); // EXPECT_EQ("1-2-3", s); // // Example 5: @@ -203,91 +203,91 @@ DereferenceFormatter() { // v.emplace_back(new int(1)); // v.emplace_back(new int(2)); // v.emplace_back(new int(3)); -// TString s = y_absl::StrJoin(v, "-"); +// TString s = y_absl::StrJoin(v, "-"); // EXPECT_EQ("1-2-3", s); // // Example 6: // // Joins a `std::map`, with each key-value pair separated by an equals // // sign. This pattern would also work with, say, a // // `std::vector<std::pair<>>`. -// std::map<TString, int> m = { +// std::map<TString, int> m = { // std::make_pair("a", 1), // std::make_pair("b", 2), // std::make_pair("c", 3)}; -// TString s = y_absl::StrJoin(m, ",", y_absl::PairFormatter("=")); +// TString s = y_absl::StrJoin(m, ",", y_absl::PairFormatter("=")); // EXPECT_EQ("a=1,b=2,c=3", s); // // Example 7: -// // These examples show how `y_absl::StrJoin()` handles a few common edge +// // These examples show how `y_absl::StrJoin()` handles a few common edge // // cases: -// std::vector<TString> v_empty; -// EXPECT_EQ("", y_absl::StrJoin(v_empty, "-")); +// std::vector<TString> v_empty; +// EXPECT_EQ("", y_absl::StrJoin(v_empty, "-")); // -// std::vector<TString> v_one_item = {"foo"}; -// EXPECT_EQ("foo", y_absl::StrJoin(v_one_item, "-")); +// std::vector<TString> v_one_item = {"foo"}; +// EXPECT_EQ("foo", y_absl::StrJoin(v_one_item, "-")); // -// std::vector<TString> v_empty_string = {""}; -// EXPECT_EQ("", y_absl::StrJoin(v_empty_string, "-")); +// std::vector<TString> v_empty_string = {""}; +// EXPECT_EQ("", y_absl::StrJoin(v_empty_string, "-")); // -// std::vector<TString> v_one_item_empty_string = {"a", ""}; -// EXPECT_EQ("a-", y_absl::StrJoin(v_one_item_empty_string, "-")); +// std::vector<TString> v_one_item_empty_string = {"a", ""}; +// EXPECT_EQ("a-", y_absl::StrJoin(v_one_item_empty_string, "-")); // -// std::vector<TString> v_two_empty_string = {"", ""}; -// EXPECT_EQ("-", y_absl::StrJoin(v_two_empty_string, "-")); +// std::vector<TString> v_two_empty_string = {"", ""}; +// EXPECT_EQ("-", y_absl::StrJoin(v_two_empty_string, "-")); // // Example 8: // // Joins a `std::tuple<T...>` of heterogeneous types, converting each to -// // a TString using the `y_absl::AlphaNum` class. -// TString s = y_absl::StrJoin(std::make_tuple(123, "abc", 0.456), "-"); +// // a TString using the `y_absl::AlphaNum` class. +// TString s = y_absl::StrJoin(std::make_tuple(123, "abc", 0.456), "-"); // EXPECT_EQ("123-abc-0.456", s); template <typename Iterator, typename Formatter> -TString StrJoin(Iterator start, Iterator end, y_absl::string_view sep, +TString StrJoin(Iterator start, Iterator end, y_absl::string_view sep, Formatter&& fmt) { return strings_internal::JoinAlgorithm(start, end, sep, fmt); } template <typename Range, typename Formatter> -TString StrJoin(const Range& range, y_absl::string_view separator, +TString StrJoin(const Range& range, y_absl::string_view separator, Formatter&& fmt) { return strings_internal::JoinRange(range, separator, fmt); } template <typename T, typename Formatter> -TString StrJoin(std::initializer_list<T> il, y_absl::string_view separator, +TString StrJoin(std::initializer_list<T> il, y_absl::string_view separator, Formatter&& fmt) { return strings_internal::JoinRange(il, separator, fmt); } template <typename... T, typename Formatter> -TString StrJoin(const std::tuple<T...>& value, y_absl::string_view separator, +TString StrJoin(const std::tuple<T...>& value, y_absl::string_view separator, Formatter&& fmt) { return strings_internal::JoinAlgorithm(value, separator, fmt); } template <typename Iterator> -TString StrJoin(Iterator start, Iterator end, y_absl::string_view separator) { +TString StrJoin(Iterator start, Iterator end, y_absl::string_view separator) { return strings_internal::JoinRange(start, end, separator); } template <typename Range> -TString StrJoin(const Range& range, y_absl::string_view separator) { +TString StrJoin(const Range& range, y_absl::string_view separator) { return strings_internal::JoinRange(range, separator); } template <typename T> -TString StrJoin(std::initializer_list<T> il, - y_absl::string_view separator) { +TString StrJoin(std::initializer_list<T> il, + y_absl::string_view separator) { return strings_internal::JoinRange(il, separator); } template <typename... T> -TString StrJoin(const std::tuple<T...>& value, - y_absl::string_view separator) { +TString StrJoin(const std::tuple<T...>& value, + y_absl::string_view separator) { return strings_internal::JoinAlgorithm(value, separator, AlphaNumFormatter()); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_STR_JOIN_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.cc index e6e3c9eba8..77b78c6c16 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.cc @@ -12,24 +12,24 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/str_replace.h" +#include "y_absl/strings/str_replace.h" -#include "y_absl/strings/str_cat.h" +#include "y_absl/strings/str_cat.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace strings_internal { using FixedMapping = - std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>>; + std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>>; -// Applies the ViableSubstitutions in subs_ptr to the y_absl::string_view s, and +// Applies the ViableSubstitutions in subs_ptr to the y_absl::string_view s, and // stores the result in *result_ptr. Returns the number of substitutions that // occurred. int ApplySubstitutions( - y_absl::string_view s, + y_absl::string_view s, std::vector<strings_internal::ViableSubstitution>* subs_ptr, - TString* result_ptr) { + TString* result_ptr) { auto& subs = *subs_ptr; int substitutions = 0; size_t pos = 0; @@ -68,15 +68,15 @@ int ApplySubstitutions( // Note that we implement them here, rather than in the header, so that they // aren't inlined. -TString StrReplaceAll(y_absl::string_view s, +TString StrReplaceAll(y_absl::string_view s, strings_internal::FixedMapping replacements) { return StrReplaceAll<strings_internal::FixedMapping>(s, replacements); } int StrReplaceAll(strings_internal::FixedMapping replacements, - TString* target) { + TString* target) { return StrReplaceAll<strings_internal::FixedMapping>(replacements, target); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h index c9019646d7..42c85616a0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h @@ -17,7 +17,7 @@ // File: str_replace.h // ----------------------------------------------------------------------------- // -// This file defines `y_absl::StrReplaceAll()`, a general-purpose string +// This file defines `y_absl::StrReplaceAll()`, a general-purpose string // replacement function designed for large, arbitrary text substitutions, // especially on strings which you are receiving from some other system for // further processing (e.g. processing regular expressions, escaping HTML @@ -25,11 +25,11 @@ // one substitution is being performed, or when substitution is rare. // // If the string being modified is known at compile-time, and the substitutions -// vary, `y_absl::Substitute()` may be a better choice. +// vary, `y_absl::Substitute()` may be a better choice. // // Example: // -// TString html_escaped = y_absl::StrReplaceAll(user_input, { +// TString html_escaped = y_absl::StrReplaceAll(user_input, { // {"&", "&"}, // {"<", "<"}, // {">", ">"}, @@ -42,10 +42,10 @@ #include <utility> #include <vector> -#include "y_absl/base/attributes.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/base/attributes.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // StrReplaceAll() @@ -59,15 +59,15 @@ ABSL_NAMESPACE_BEGIN // // Example: // -// TString s = y_absl::StrReplaceAll( +// TString s = y_absl::StrReplaceAll( // "$who bought $count #Noun. Thanks $who!", -// {{"$count", y_absl::StrCat(5)}, +// {{"$count", y_absl::StrCat(5)}, // {"$who", "Bob"}, // {"#Noun", "Apples"}}); // EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s); -ABSL_MUST_USE_RESULT TString StrReplaceAll( - y_absl::string_view s, - std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>> +ABSL_MUST_USE_RESULT TString StrReplaceAll( + y_absl::string_view s, + std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>> replacements); // Overload of `StrReplaceAll()` to accept a container of key/value replacement @@ -76,25 +76,25 @@ ABSL_MUST_USE_RESULT TString StrReplaceAll( // // Examples: // -// std::map<const y_absl::string_view, const y_absl::string_view> replacements; +// std::map<const y_absl::string_view, const y_absl::string_view> replacements; // replacements["$who"] = "Bob"; // replacements["$count"] = "5"; // replacements["#Noun"] = "Apples"; -// TString s = y_absl::StrReplaceAll( +// TString s = y_absl::StrReplaceAll( // "$who bought $count #Noun. Thanks $who!", // replacements); // EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s); // // // A std::vector of std::pair elements can be more efficient. -// std::vector<std::pair<const y_absl::string_view, TString>> replacements; +// std::vector<std::pair<const y_absl::string_view, TString>> replacements; // replacements.push_back({"&", "&"}); // replacements.push_back({"<", "<"}); // replacements.push_back({">", ">"}); -// TString s = y_absl::StrReplaceAll("if (ptr < &foo)", +// TString s = y_absl::StrReplaceAll("if (ptr < &foo)", // replacements); // EXPECT_EQ("if (ptr < &foo)", s); template <typename StrToStrMapping> -TString StrReplaceAll(y_absl::string_view s, +TString StrReplaceAll(y_absl::string_view s, const StrToStrMapping& replacements); // Overload of `StrReplaceAll()` to replace character sequences within a given @@ -103,17 +103,17 @@ TString StrReplaceAll(y_absl::string_view s, // // Example: // -// TString s = TString("$who bought $count #Noun. Thanks $who!"); +// TString s = TString("$who bought $count #Noun. Thanks $who!"); // int count; -// count = y_absl::StrReplaceAll({{"$count", y_absl::StrCat(5)}, +// count = y_absl::StrReplaceAll({{"$count", y_absl::StrCat(5)}, // {"$who", "Bob"}, // {"#Noun", "Apples"}}, &s); // EXPECT_EQ(count, 4); // EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s); int StrReplaceAll( - std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>> + std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>> replacements, - TString* target); + TString* target); // Overload of `StrReplaceAll()` to replace patterns within a given output // string *in place* with replacements provided within a container of key/value @@ -121,25 +121,25 @@ int StrReplaceAll( // // Example: // -// TString s = TString("if (ptr < &foo)"); -// int count = y_absl::StrReplaceAll({{"&", "&"}, +// TString s = TString("if (ptr < &foo)"); +// int count = y_absl::StrReplaceAll({{"&", "&"}, // {"<", "<"}, // {">", ">"}}, &s); // EXPECT_EQ(count, 2); // EXPECT_EQ("if (ptr < &foo)", s); template <typename StrToStrMapping> -int StrReplaceAll(const StrToStrMapping& replacements, TString* target); +int StrReplaceAll(const StrToStrMapping& replacements, TString* target); // Implementation details only, past this point. namespace strings_internal { struct ViableSubstitution { - y_absl::string_view old; - y_absl::string_view replacement; + y_absl::string_view old; + y_absl::string_view replacement; size_t offset; - ViableSubstitution(y_absl::string_view old_str, - y_absl::string_view replacement_str, size_t offset_val) + ViableSubstitution(y_absl::string_view old_str, + y_absl::string_view replacement_str, size_t offset_val) : old(old_str), replacement(replacement_str), offset(offset_val) {} // One substitution occurs "before" another (takes priority) if either @@ -156,13 +156,13 @@ struct ViableSubstitution { // overhead of such a queue isn't worth it. template <typename StrToStrMapping> std::vector<ViableSubstitution> FindSubstitutions( - y_absl::string_view s, const StrToStrMapping& replacements) { + y_absl::string_view s, const StrToStrMapping& replacements) { std::vector<ViableSubstitution> subs; subs.reserve(replacements.size()); for (const auto& rep : replacements) { using std::get; - y_absl::string_view old(get<0>(rep)); + y_absl::string_view old(get<0>(rep)); size_t pos = s.find(old); if (pos == s.npos) continue; @@ -184,28 +184,28 @@ std::vector<ViableSubstitution> FindSubstitutions( return subs; } -int ApplySubstitutions(y_absl::string_view s, +int ApplySubstitutions(y_absl::string_view s, std::vector<ViableSubstitution>* subs_ptr, - TString* result_ptr); + TString* result_ptr); } // namespace strings_internal template <typename StrToStrMapping> -TString StrReplaceAll(y_absl::string_view s, +TString StrReplaceAll(y_absl::string_view s, const StrToStrMapping& replacements) { auto subs = strings_internal::FindSubstitutions(s, replacements); - TString result; + TString result; result.reserve(s.size()); strings_internal::ApplySubstitutions(s, &subs, &result); return result; } template <typename StrToStrMapping> -int StrReplaceAll(const StrToStrMapping& replacements, TString* target) { +int StrReplaceAll(const StrToStrMapping& replacements, TString* target) { auto subs = strings_internal::FindSubstitutions(*target, replacements); if (subs.empty()) return 0; - TString result; + TString result; result.reserve(target->size()); int substitutions = strings_internal::ApplySubstitutions(*target, &subs, &result); @@ -214,6 +214,6 @@ int StrReplaceAll(const StrToStrMapping& replacements, TString* target) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_STR_REPLACE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc index bf37503357..5f9193e6ba 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/str_split.h" +#include "y_absl/strings/str_split.h" #include <algorithm> #include <cassert> @@ -23,10 +23,10 @@ #include <limits> #include <memory> -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/strings/ascii.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/strings/ascii.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { @@ -35,44 +35,44 @@ namespace { // shared between the ByString and ByAnyChar delimiters. The FindPolicy // template parameter allows each delimiter to customize the actual find // function to use and the length of the found delimiter. For example, the -// Literal delimiter will ultimately use y_absl::string_view::find(), and the -// AnyOf delimiter will use y_absl::string_view::find_first_of(). +// Literal delimiter will ultimately use y_absl::string_view::find(), and the +// AnyOf delimiter will use y_absl::string_view::find_first_of(). template <typename FindPolicy> -y_absl::string_view GenericFind(y_absl::string_view text, - y_absl::string_view delimiter, size_t pos, +y_absl::string_view GenericFind(y_absl::string_view text, + y_absl::string_view delimiter, size_t pos, FindPolicy find_policy) { if (delimiter.empty() && text.length() > 0) { // Special case for empty string delimiters: always return a zero-length - // y_absl::string_view referring to the item at position 1 past pos. - return y_absl::string_view(text.data() + pos + 1, 0); + // y_absl::string_view referring to the item at position 1 past pos. + return y_absl::string_view(text.data() + pos + 1, 0); } - size_t found_pos = y_absl::string_view::npos; - y_absl::string_view found(text.data() + text.size(), + size_t found_pos = y_absl::string_view::npos; + y_absl::string_view found(text.data() + text.size(), 0); // By default, not found found_pos = find_policy.Find(text, delimiter, pos); - if (found_pos != y_absl::string_view::npos) { - found = y_absl::string_view(text.data() + found_pos, + if (found_pos != y_absl::string_view::npos) { + found = y_absl::string_view(text.data() + found_pos, find_policy.Length(delimiter)); } return found; } -// Finds using y_absl::string_view::find(), therefore the length of the found +// Finds using y_absl::string_view::find(), therefore the length of the found // delimiter is delimiter.length(). struct LiteralPolicy { - size_t Find(y_absl::string_view text, y_absl::string_view delimiter, size_t pos) { + size_t Find(y_absl::string_view text, y_absl::string_view delimiter, size_t pos) { return text.find(delimiter, pos); } - size_t Length(y_absl::string_view delimiter) { return delimiter.length(); } + size_t Length(y_absl::string_view delimiter) { return delimiter.length(); } }; -// Finds using y_absl::string_view::find_first_of(), therefore the length of the +// Finds using y_absl::string_view::find_first_of(), therefore the length of the // found delimiter is 1. struct AnyOfPolicy { - size_t Find(y_absl::string_view text, y_absl::string_view delimiter, size_t pos) { + size_t Find(y_absl::string_view text, y_absl::string_view delimiter, size_t pos) { return text.find_first_of(delimiter, pos); } - size_t Length(y_absl::string_view /* delimiter */) { return 1; } + size_t Length(y_absl::string_view /* delimiter */) { return 1; } }; } // namespace @@ -81,15 +81,15 @@ struct AnyOfPolicy { // ByString // -ByString::ByString(y_absl::string_view sp) : delimiter_(sp) {} +ByString::ByString(y_absl::string_view sp) : delimiter_(sp) {} -y_absl::string_view ByString::Find(y_absl::string_view text, size_t pos) const { +y_absl::string_view ByString::Find(y_absl::string_view text, size_t pos) const { if (delimiter_.length() == 1) { // Much faster to call find on a single character than on an - // y_absl::string_view. + // y_absl::string_view. size_t found_pos = text.find(delimiter_[0], pos); - if (found_pos == y_absl::string_view::npos) - return y_absl::string_view(text.data() + text.size(), 0); + if (found_pos == y_absl::string_view::npos) + return y_absl::string_view(text.data() + text.size(), 0); return text.substr(found_pos, 1); } return GenericFind(text, delimiter_, pos, LiteralPolicy()); @@ -99,10 +99,10 @@ y_absl::string_view ByString::Find(y_absl::string_view text, size_t pos) const { // ByChar // -y_absl::string_view ByChar::Find(y_absl::string_view text, size_t pos) const { +y_absl::string_view ByChar::Find(y_absl::string_view text, size_t pos) const { size_t found_pos = text.find(c_, pos); - if (found_pos == y_absl::string_view::npos) - return y_absl::string_view(text.data() + text.size(), 0); + if (found_pos == y_absl::string_view::npos) + return y_absl::string_view(text.data() + text.size(), 0); return text.substr(found_pos, 1); } @@ -110,9 +110,9 @@ y_absl::string_view ByChar::Find(y_absl::string_view text, size_t pos) const { // ByAnyChar // -ByAnyChar::ByAnyChar(y_absl::string_view sp) : delimiters_(sp) {} +ByAnyChar::ByAnyChar(y_absl::string_view sp) : delimiters_(sp) {} -y_absl::string_view ByAnyChar::Find(y_absl::string_view text, size_t pos) const { +y_absl::string_view ByAnyChar::Find(y_absl::string_view text, size_t pos) const { return GenericFind(text, delimiters_, pos, AnyOfPolicy()); } @@ -123,17 +123,17 @@ ByLength::ByLength(ptrdiff_t length) : length_(length) { ABSL_RAW_CHECK(length > 0, ""); } -y_absl::string_view ByLength::Find(y_absl::string_view text, +y_absl::string_view ByLength::Find(y_absl::string_view text, size_t pos) const { pos = std::min(pos, text.size()); // truncate `pos` - y_absl::string_view substr = text.substr(pos); + y_absl::string_view substr = text.substr(pos); // If the string is shorter than the chunk size we say we // "can't find the delimiter" so this will be the last chunk. if (substr.length() <= static_cast<size_t>(length_)) - return y_absl::string_view(text.data() + text.size(), 0); + return y_absl::string_view(text.data() + text.size(), 0); - return y_absl::string_view(substr.data() + length_, 0); + return y_absl::string_view(substr.data() + length_, 0); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h index 22176e418d..d32d54813e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h @@ -27,7 +27,7 @@ // // // Splits the given string on commas. Returns the results in a // // vector of strings. -// std::vector<TString> v = y_absl::StrSplit("a,b,c", ','); +// std::vector<TString> v = y_absl::StrSplit("a,b,c", ','); // // Can also use "," // // v[0] == "a", v[1] == "b", v[2] == "c" // @@ -43,13 +43,13 @@ #include <utility> #include <vector> -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" #include "y_absl/base/macros.h" -#include "y_absl/strings/internal/str_split_internal.h" -#include "y_absl/strings/string_view.h" -#include "y_absl/strings/strip.h" +#include "y_absl/strings/internal/str_split_internal.h" +#include "y_absl/strings/string_view.h" +#include "y_absl/strings/strip.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN //------------------------------------------------------------------------------ @@ -58,12 +58,12 @@ ABSL_NAMESPACE_BEGIN // // `StrSplit()` uses delimiters to define the boundaries between elements in the // provided input. Several `Delimiter` types are defined below. If a string -// (`const char*`, `TString`, or `y_absl::string_view`) is passed in place of +// (`const char*`, `TString`, or `y_absl::string_view`) is passed in place of // an explicit `Delimiter` object, `StrSplit()` treats it the same way as if it // were passed a `ByString` delimiter. // // A `Delimiter` is an object with a `Find()` function that knows how to find -// the first occurrence of itself in a given `y_absl::string_view`. +// the first occurrence of itself in a given `y_absl::string_view`. // // The following `Delimiter` types are available for use within `StrSplit()`: // @@ -75,16 +75,16 @@ ABSL_NAMESPACE_BEGIN // // A Delimiter's `Find()` member function will be passed an input `text` that is // to be split and a position (`pos`) to begin searching for the next delimiter -// in `text`. The returned y_absl::string_view should refer to the next occurrence -// (after `pos`) of the represented delimiter; this returned y_absl::string_view +// in `text`. The returned y_absl::string_view should refer to the next occurrence +// (after `pos`) of the represented delimiter; this returned y_absl::string_view // represents the next location where the input `text` should be broken. // -// The returned y_absl::string_view may be zero-length if the Delimiter does not +// The returned y_absl::string_view may be zero-length if the Delimiter does not // represent a part of the string (e.g., a fixed-length delimiter). If no -// delimiter is found in the input `text`, a zero-length y_absl::string_view +// delimiter is found in the input `text`, a zero-length y_absl::string_view // referring to `text.end()` should be returned (e.g., // `text.substr(text.size())`). It is important that the returned -// y_absl::string_view always be within the bounds of the input `text` given as an +// y_absl::string_view always be within the bounds of the input `text` given as an // argument--it must not refer to a string that is physically located outside of // the given string. // @@ -95,9 +95,9 @@ ABSL_NAMESPACE_BEGIN // struct SimpleDelimiter { // const char c_; // explicit SimpleDelimiter(char c) : c_(c) {} -// y_absl::string_view Find(y_absl::string_view text, size_t pos) { +// y_absl::string_view Find(y_absl::string_view text, size_t pos) { // auto found = text.find(c_, pos); -// if (found == y_absl::string_view::npos) +// if (found == y_absl::string_view::npos) // return text.substr(text.size()); // // return text.substr(found, 1); @@ -112,22 +112,22 @@ ABSL_NAMESPACE_BEGIN // // Example: // -// // Because a string literal is converted to an `y_absl::ByString`, +// // Because a string literal is converted to an `y_absl::ByString`, // // the following two splits are equivalent. // -// std::vector<TString> v1 = y_absl::StrSplit("a, b, c", ", "); +// std::vector<TString> v1 = y_absl::StrSplit("a, b, c", ", "); // -// using y_absl::ByString; -// std::vector<TString> v2 = y_absl::StrSplit("a, b, c", +// using y_absl::ByString; +// std::vector<TString> v2 = y_absl::StrSplit("a, b, c", // ByString(", ")); // // v[0] == "a", v[1] == "b", v[2] == "c" class ByString { public: - explicit ByString(y_absl::string_view sp); - y_absl::string_view Find(y_absl::string_view text, size_t pos) const; + explicit ByString(y_absl::string_view sp); + y_absl::string_view Find(y_absl::string_view text, size_t pos) const; private: - const TString delimiter_; + const TString delimiter_; }; // ByChar @@ -137,26 +137,26 @@ class ByString { // // Example: // -// // Because a char literal is converted to a y_absl::ByChar, +// // Because a char literal is converted to a y_absl::ByChar, // // the following two splits are equivalent. -// std::vector<TString> v1 = y_absl::StrSplit("a,b,c", ','); -// using y_absl::ByChar; -// std::vector<TString> v2 = y_absl::StrSplit("a,b,c", ByChar(',')); +// std::vector<TString> v1 = y_absl::StrSplit("a,b,c", ','); +// using y_absl::ByChar; +// std::vector<TString> v2 = y_absl::StrSplit("a,b,c", ByChar(',')); // // v[0] == "a", v[1] == "b", v[2] == "c" // // `ByChar` is also the default delimiter if a single character is given // as the delimiter to `StrSplit()`. For example, the following calls are // equivalent: // -// std::vector<TString> v = y_absl::StrSplit("a-b", '-'); +// std::vector<TString> v = y_absl::StrSplit("a-b", '-'); // -// using y_absl::ByChar; -// std::vector<TString> v = y_absl::StrSplit("a-b", ByChar('-')); +// using y_absl::ByChar; +// std::vector<TString> v = y_absl::StrSplit("a-b", ByChar('-')); // class ByChar { public: explicit ByChar(char c) : c_(c) {} - y_absl::string_view Find(y_absl::string_view text, size_t pos) const; + y_absl::string_view Find(y_absl::string_view text, size_t pos) const; private: char c_; @@ -172,8 +172,8 @@ class ByChar { // // Example: // -// using y_absl::ByAnyChar; -// std::vector<TString> v = y_absl::StrSplit("a,b=c", ByAnyChar(",=")); +// using y_absl::ByAnyChar; +// std::vector<TString> v = y_absl::StrSplit("a,b=c", ByAnyChar(",=")); // // v[0] == "a", v[1] == "b", v[2] == "c" // // If `ByAnyChar` is given the empty string, it behaves exactly like @@ -181,11 +181,11 @@ class ByChar { // class ByAnyChar { public: - explicit ByAnyChar(y_absl::string_view sp); - y_absl::string_view Find(y_absl::string_view text, size_t pos) const; + explicit ByAnyChar(y_absl::string_view sp); + y_absl::string_view Find(y_absl::string_view text, size_t pos) const; private: - const TString delimiters_; + const TString delimiters_; }; // ByLength @@ -198,22 +198,22 @@ class ByAnyChar { // // Example: // -// using y_absl::ByLength; -// std::vector<TString> v = y_absl::StrSplit("123456789", ByLength(3)); +// using y_absl::ByLength; +// std::vector<TString> v = y_absl::StrSplit("123456789", ByLength(3)); // // v[0] == "123", v[1] == "456", v[2] == "789" // // Note that the string does not have to be a multiple of the fixed split // length. In such a case, the last substring will be shorter. // -// using y_absl::ByLength; -// std::vector<TString> v = y_absl::StrSplit("12345", ByLength(2)); +// using y_absl::ByLength; +// std::vector<TString> v = y_absl::StrSplit("12345", ByLength(2)); // // // v[0] == "12", v[1] == "34", v[2] == "5" class ByLength { public: explicit ByLength(ptrdiff_t length); - y_absl::string_view Find(y_absl::string_view text, size_t pos) const; + y_absl::string_view Find(y_absl::string_view text, size_t pos) const; private: const ptrdiff_t length_; @@ -225,7 +225,7 @@ namespace strings_internal { // for a particular Delimiter type. The base case simply exposes type Delimiter // itself as the delimiter's Type. However, there are specializations for // string-like objects that map them to the ByString delimiter object. -// This allows functions like y_absl::StrSplit() and y_absl::MaxSplits() to accept +// This allows functions like y_absl::StrSplit() and y_absl::MaxSplits() to accept // string-like objects (e.g., ',') as delimiter arguments but they will be // treated as if a ByString delimiter was given. template <typename Delimiter> @@ -246,11 +246,11 @@ struct SelectDelimiter<const char*> { using type = ByString; }; template <> -struct SelectDelimiter<y_absl::string_view> { +struct SelectDelimiter<y_absl::string_view> { using type = ByString; }; template <> -struct SelectDelimiter<TString> { +struct SelectDelimiter<TString> { using type = ByString; }; @@ -260,9 +260,9 @@ class MaxSplitsImpl { public: MaxSplitsImpl(Delimiter delimiter, int limit) : delimiter_(delimiter), limit_(limit), count_(0) {} - y_absl::string_view Find(y_absl::string_view text, size_t pos) { + y_absl::string_view Find(y_absl::string_view text, size_t pos) { if (count_++ == limit_) { - return y_absl::string_view(text.data() + text.size(), + return y_absl::string_view(text.data() + text.size(), 0); // No more matches. } return delimiter_.Find(text, pos); @@ -284,8 +284,8 @@ class MaxSplitsImpl { // The collection will contain at most `limit` + 1 elements. // Example: // -// using y_absl::MaxSplits; -// std::vector<TString> v = y_absl::StrSplit("a,b,c", MaxSplits(',', 1)); +// using y_absl::MaxSplits; +// std::vector<TString> v = y_absl::StrSplit("a,b,c", MaxSplits(',', 1)); // // // v[0] == "a", v[1] == "b,c" template <typename Delimiter> @@ -307,7 +307,7 @@ MaxSplits(Delimiter delimiter, int limit) { // as an optional third argument to the `StrSplit()` function. // // Predicates are unary functions (or functors) that take a single -// `y_absl::string_view` argument and return a bool indicating whether the +// `y_absl::string_view` argument and return a bool indicating whether the // argument should be included (`true`) or excluded (`false`). // // Predicates are useful when filtering out empty substrings. By default, empty @@ -323,21 +323,21 @@ MaxSplits(Delimiter delimiter, int limit) { // // Example: // -// std::vector<TString> v = y_absl::StrSplit(" a , ,,b,", ',', AllowEmpty()); +// std::vector<TString> v = y_absl::StrSplit(" a , ,,b,", ',', AllowEmpty()); // // // v[0] == " a ", v[1] == " ", v[2] == "", v[3] = "b", v[4] == "" struct AllowEmpty { - bool operator()(y_absl::string_view) const { return true; } + bool operator()(y_absl::string_view) const { return true; } }; // SkipEmpty() // -// Returns `false` if the given `y_absl::string_view` is empty, indicating that +// Returns `false` if the given `y_absl::string_view` is empty, indicating that // `StrSplit()` should omit the empty string. // // Example: // -// std::vector<TString> v = y_absl::StrSplit(",a,,b,", ',', SkipEmpty()); +// std::vector<TString> v = y_absl::StrSplit(",a,,b,", ',', SkipEmpty()); // // // v[0] == "a", v[1] == "b" // @@ -345,26 +345,26 @@ struct AllowEmpty { // to be empty. To skip such whitespace as well, use the `SkipWhitespace()` // predicate. struct SkipEmpty { - bool operator()(y_absl::string_view sp) const { return !sp.empty(); } + bool operator()(y_absl::string_view sp) const { return !sp.empty(); } }; // SkipWhitespace() // -// Returns `false` if the given `y_absl::string_view` is empty *or* contains only +// Returns `false` if the given `y_absl::string_view` is empty *or* contains only // whitespace, indicating that `StrSplit()` should omit the string. // // Example: // -// std::vector<TString> v = y_absl::StrSplit(" a , ,,b,", +// std::vector<TString> v = y_absl::StrSplit(" a , ,,b,", // ',', SkipWhitespace()); // // v[0] == " a ", v[1] == "b" // // // SkipEmpty() would return whitespace elements -// std::vector<TString> v = y_absl::StrSplit(" a , ,,b,", ',', SkipEmpty()); +// std::vector<TString> v = y_absl::StrSplit(" a , ,,b,", ',', SkipEmpty()); // // v[0] == " a ", v[1] == " ", v[2] == "b" struct SkipWhitespace { - bool operator()(y_absl::string_view sp) const { - sp = y_absl::StripAsciiWhitespace(sp); + bool operator()(y_absl::string_view sp) const { + sp = y_absl::StripAsciiWhitespace(sp); return !sp.empty(); } }; @@ -389,15 +389,15 @@ using EnableSplitIfString = // // Example: // -// std::vector<TString> v = y_absl::StrSplit("a,b,c,d", ','); +// std::vector<TString> v = y_absl::StrSplit("a,b,c,d", ','); // // v[0] == "a", v[1] == "b", v[2] == "c", v[3] == "d" // // You can also provide an explicit `Delimiter` object: // // Example: // -// using y_absl::ByAnyChar; -// std::vector<TString> v = y_absl::StrSplit("a,b=c", ByAnyChar(",=")); +// using y_absl::ByAnyChar; +// std::vector<TString> v = y_absl::StrSplit("a,b=c", ByAnyChar(",=")); // // v[0] == "a", v[1] == "b", v[2] == "c" // // See above for more information on delimiters. @@ -408,7 +408,7 @@ using EnableSplitIfString = // // Example: // -// std::vector<TString> v = y_absl::StrSplit(" a , ,,b,", +// std::vector<TString> v = y_absl::StrSplit(" a , ,,b,", // ',', SkipWhitespace()); // // v[0] == " a ", v[1] == "b" // @@ -420,9 +420,9 @@ using EnableSplitIfString = // // The `StrSplit()` function adapts the returned collection to the collection // specified by the caller (e.g. `std::vector` above). The returned collections -// may contain `TString`, `y_absl::string_view` (in which case the original +// may contain `TString`, `y_absl::string_view` (in which case the original // string being split must ensure that it outlives the collection), or any -// object that can be explicitly created from an `y_absl::string_view`. This +// object that can be explicitly created from an `y_absl::string_view`. This // behavior works for: // // 1) All standard STL containers including `std::vector`, `std::list`, @@ -431,19 +431,19 @@ using EnableSplitIfString = // // Example: // -// // The results are returned as `y_absl::string_view` objects. Note that we +// // The results are returned as `y_absl::string_view` objects. Note that we // // have to ensure that the input string outlives any results. -// std::vector<y_absl::string_view> v = y_absl::StrSplit("a,b,c", ','); +// std::vector<y_absl::string_view> v = y_absl::StrSplit("a,b,c", ','); // -// // Stores results in a std::set<TString>, which also performs +// // Stores results in a std::set<TString>, which also performs // // de-duplication and orders the elements in ascending order. -// std::set<TString> a = y_absl::StrSplit("b,a,c,a,b", ','); +// std::set<TString> a = y_absl::StrSplit("b,a,c,a,b", ','); // // v[0] == "a", v[1] == "b", v[2] = "c" // // // `StrSplit()` can be used within a range-based for loop, in which case -// // each element will be of type `y_absl::string_view`. -// std::vector<TString> v; -// for (const auto sv : y_absl::StrSplit("a,b,c", ',')) { +// // each element will be of type `y_absl::string_view`. +// std::vector<TString> v; +// for (const auto sv : y_absl::StrSplit("a,b,c", ',')) { // if (sv != "b") v.emplace_back(sv); // } // // v[0] == "a", v[1] == "c" @@ -453,7 +453,7 @@ using EnableSplitIfString = // // resulting from the split will be stored as a key to the 1st element. If // // an odd number of elements are resolved, the last element is paired with // // a default-constructed value (e.g., empty string). -// std::map<TString, TString> m = y_absl::StrSplit("a,b,c", ','); +// std::map<TString, TString> m = y_absl::StrSplit("a,b,c", ','); // // m["a"] == "b", m["c"] == "" // last component value equals "" // // Splitting to `std::pair` is an interesting case because it can hold only two @@ -467,7 +467,7 @@ using EnableSplitIfString = // Example: // // // Stores first two split strings as the members in a std::pair. -// std::pair<TString, TString> p = y_absl::StrSplit("a,b,c", ','); +// std::pair<TString, TString> p = y_absl::StrSplit("a,b,c", ','); // // p.first == "a", p.second == "b" // "c" is omitted. // // The `StrSplit()` function can be used multiple times to perform more @@ -477,9 +477,9 @@ using EnableSplitIfString = // // // The input string "a=b=c,d=e,f=,g" becomes // // { "a" => "b=c", "d" => "e", "f" => "", "g" => "" } -// std::map<TString, TString> m; -// for (y_absl::string_view sp : y_absl::StrSplit("a=b=c,d=e,f=,g", ',')) { -// m.insert(y_absl::StrSplit(sp, y_absl::MaxSplits('=', 1))); +// std::map<TString, TString> m; +// for (y_absl::string_view sp : y_absl::StrSplit("a=b=c,d=e,f=,g", ',')) { +// m.insert(y_absl::StrSplit(sp, y_absl::MaxSplits('=', 1))); // } // EXPECT_EQ("b=c", m.find("a")->second); // EXPECT_EQ("e", m.find("d")->second); @@ -489,8 +489,8 @@ using EnableSplitIfString = // WARNING: Due to a legacy bug that is maintained for backward compatibility, // splitting the following empty string_views produces different results: // -// y_absl::StrSplit(y_absl::string_view(""), '-'); // {""} -// y_absl::StrSplit(y_absl::string_view(), '-'); // {}, but should be {""} +// y_absl::StrSplit(y_absl::string_view(""), '-'); // {""} +// y_absl::StrSplit(y_absl::string_view(), '-'); // {}, but should be {""} // // Try not to depend on this distinction because the bug may one day be fixed. template <typename Delimiter> @@ -543,6 +543,6 @@ StrSplit(StringType&& text, Delimiter d, Predicate p) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_STR_SPLIT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.cc index aa7fcc318b..9893c7ab99 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/string_view.h" +#include "y_absl/strings/string_view.h" #ifndef ABSL_USES_STD_STRING_VIEW @@ -21,9 +21,9 @@ #include <cstring> #include <ostream> -#include "y_absl/strings/internal/memutil.h" +#include "y_absl/strings/internal/memutil.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { @@ -225,6 +225,6 @@ ABSL_STRING_VIEW_SELECTANY constexpr string_view::size_type string_view::kMaxSize; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_USES_STD_STRING_VIEW diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h index d1369e2d08..c3906fe1c5 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h @@ -17,12 +17,12 @@ // File: string_view.h // ----------------------------------------------------------------------------- // -// This file contains the definition of the `y_absl::string_view` class. A +// This file contains the definition of the `y_absl::string_view` class. A // `string_view` points to a contiguous span of characters, often part or all of -// another `TString`, double-quoted string literal, character array, or even +// another `TString`, double-quoted string literal, character array, or even // another `string_view`. // -// This `y_absl::string_view` abstraction is designed to be a drop-in +// This `y_absl::string_view` abstraction is designed to be a drop-in // replacement for the C++17 `std::string_view` abstraction. #ifndef ABSL_STRINGS_STRING_VIEW_H_ #define ABSL_STRINGS_STRING_VIEW_H_ @@ -37,7 +37,7 @@ #include <util/generic/string.h> #include "y_absl/base/attributes.h" -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" #include "y_absl/base/internal/throw_delegate.h" #include "y_absl/base/macros.h" #include "y_absl/base/optimization.h" @@ -47,16 +47,16 @@ #include <string_view> // IWYU pragma: export -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN using string_view = std::string_view; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else // ABSL_USES_STD_STRING_VIEW -#error "std::string_view should be used in all configurations" - +#error "std::string_view should be used in all configurations" + #if ABSL_HAVE_BUILTIN(__builtin_memcmp) || \ (defined(__GNUC__) && !defined(__clang__)) #define ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp @@ -70,29 +70,29 @@ ABSL_NAMESPACE_END #define ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN -// y_absl::string_view +// y_absl::string_view // // A `string_view` provides a lightweight view into the string data provided by -// a `TString`, double-quoted string literal, character array, or even +// a `TString`, double-quoted string literal, character array, or even // another `string_view`. A `string_view` does *not* own the string to which it // points, and that data cannot be modified through the view. // // You can use `string_view` as a function or method parameter anywhere a // parameter can receive a double-quoted string literal, `const char*`, -// `TString`, or another `y_absl::string_view` argument with no need to copy +// `TString`, or another `y_absl::string_view` argument with no need to copy // the string data. Systematic use of `string_view` within function arguments // reduces data copies and `strlen()` calls. // // Because of its small size, prefer passing `string_view` by value: // -// void MyFunction(y_absl::string_view arg); +// void MyFunction(y_absl::string_view arg); // // If circumstances require, you may also pass one by const reference: // -// void MyFunction(const y_absl::string_view& arg); // not preferred +// void MyFunction(const y_absl::string_view& arg); // not preferred // // Passing by value generates slightly smaller code for many architectures. // @@ -105,11 +105,11 @@ ABSL_NAMESPACE_BEGIN // temporary value: // // // BAD use of string_view: lifetime problem -// y_absl::string_view sv = obj.ReturnAString(); +// y_absl::string_view sv = obj.ReturnAString(); // // // GOOD use of string_view: str outlives sv -// TString str = obj.ReturnAString(); -// y_absl::string_view sv = str; +// TString str = obj.ReturnAString(); +// y_absl::string_view sv = str; // // Due to lifetime issues, a `string_view` is sometimes a poor choice for a // return value and usually a poor choice for a data member. If you do use a @@ -117,7 +117,7 @@ ABSL_NAMESPACE_BEGIN // pointed to by the `string_view` outlives the `string_view`. // // A `string_view` may represent a whole string or just part of a string. For -// example, when splitting a string, `std::vector<y_absl::string_view>` is a +// example, when splitting a string, `std::vector<y_absl::string_view>` is a // natural data type for the output. // // For another example, a Cord is a non-contiguous, potentially very @@ -136,7 +136,7 @@ ABSL_NAMESPACE_BEGIN // You may create a null `string_view` in two ways: // // y_absl::string_view sv; -// y_absl::string_view sv(nullptr, 0); +// y_absl::string_view sv(nullptr, 0); // // For the above, `sv.data() == nullptr`, `sv.length() == 0`, and // `sv.empty() == true`. Also, if you create a `string_view` with a non-null @@ -154,17 +154,17 @@ ABSL_NAMESPACE_BEGIN // // const char* nullcp = nullptr; // // string_view.size() will return 0 in all cases. -// y_absl::string_view(); -// y_absl::string_view(nullcp, 0); -// y_absl::string_view(""); -// y_absl::string_view("", 0); -// y_absl::string_view("abcdef", 0); -// y_absl::string_view("abcdef" + 6, 0); +// y_absl::string_view(); +// y_absl::string_view(nullcp, 0); +// y_absl::string_view(""); +// y_absl::string_view("", 0); +// y_absl::string_view("abcdef", 0); +// y_absl::string_view("abcdef" + 6, 0); // // All empty `string_view` objects whether null or not, are equal: // -// y_absl::string_view() == y_absl::string_view("", 0) -// y_absl::string_view(nullptr, 0) == y_absl::string_view("abcdef"+6, 0) +// y_absl::string_view() == y_absl::string_view("", 0) +// y_absl::string_view(nullptr, 0) == y_absl::string_view("abcdef"+6, 0) class string_view { public: using traits_type = std::char_traits<char>; @@ -198,7 +198,7 @@ class string_view { : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {} // Implicit constructor of a `string_view` from NUL-terminated `str`. When - // accepting possibly null strings, use `y_absl::NullSafeStringView(str)` + // accepting possibly null strings, use `y_absl::NullSafeStringView(str)` // instead (see below). // The length check is skipped since it is unnecessary and causes code bloat. constexpr string_view(const char* str) // NOLINT(runtime/explicit) @@ -309,7 +309,7 @@ class string_view { return ABSL_PREDICT_TRUE(i < size()) ? ptr_[i] : ((void)base_internal::ThrowStdOutOfRange( - "y_absl::string_view::at"), + "y_absl::string_view::at"), ptr_[i]); } @@ -381,7 +381,7 @@ class string_view { // into `buf`. size_type copy(char* buf, size_type n, size_type pos = 0) const { if (ABSL_PREDICT_FALSE(pos > length_)) { - base_internal::ThrowStdOutOfRange("y_absl::string_view::copy"); + base_internal::ThrowStdOutOfRange("y_absl::string_view::copy"); } size_type rlen = (std::min)(length_ - pos, n); if (rlen > 0) { @@ -420,13 +420,13 @@ class string_view { } // Overload of `string_view::compare()` for comparing a substring of the - // 'string_view` and another `y_absl::string_view`. + // 'string_view` and another `y_absl::string_view`. constexpr int compare(size_type pos1, size_type count1, string_view v) const { return substr(pos1, count1).compare(v); } // Overload of `string_view::compare()` for comparing a substring of the - // `string_view` and a substring of another `y_absl::string_view`. + // `string_view` and a substring of another `y_absl::string_view`. constexpr int compare(size_type pos1, size_type count1, string_view v, size_type pos2, size_type count2) const { return substr(pos1, count1).compare(v.substr(pos2, count2)); @@ -677,14 +677,14 @@ constexpr bool operator>=(string_view x, string_view y) noexcept { std::ostream& operator<<(std::ostream& o, string_view piece); ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #undef ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR #undef ABSL_INTERNAL_STRING_VIEW_MEMCMP #endif // ABSL_USES_STD_STRING_VIEW -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ClippedSubstr() @@ -699,14 +699,14 @@ inline string_view ClippedSubstr(string_view s, size_t pos, // NullSafeStringView() // -// Creates an `y_absl::string_view` from a pointer `p` even if it's null-valued. -// This function should be used where an `y_absl::string_view` can be created from +// Creates an `y_absl::string_view` from a pointer `p` even if it's null-valued. +// This function should be used where an `y_absl::string_view` can be created from // a possibly-null pointer. constexpr string_view NullSafeStringView(const char* p) { return p ? string_view(p) : string_view(); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_STRING_VIEW_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/strip.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/strip.h index 32558b3809..3164ff1ebc 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/strip.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/strip.h @@ -24,12 +24,12 @@ #include <cstddef> #include <util/generic/string.h> -#include "y_absl/base/macros.h" -#include "y_absl/strings/ascii.h" -#include "y_absl/strings/match.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/base/macros.h" +#include "y_absl/strings/ascii.h" +#include "y_absl/strings/match.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ConsumePrefix() @@ -39,11 +39,11 @@ ABSL_NAMESPACE_BEGIN // // Example: // -// y_absl::string_view input("abc"); -// EXPECT_TRUE(y_absl::ConsumePrefix(&input, "a")); +// y_absl::string_view input("abc"); +// EXPECT_TRUE(y_absl::ConsumePrefix(&input, "a")); // EXPECT_EQ(input, "bc"); -inline bool ConsumePrefix(y_absl::string_view* str, y_absl::string_view expected) { - if (!y_absl::StartsWith(*str, expected)) return false; +inline bool ConsumePrefix(y_absl::string_view* str, y_absl::string_view expected) { + if (!y_absl::StartsWith(*str, expected)) return false; str->remove_prefix(expected.size()); return true; } @@ -54,11 +54,11 @@ inline bool ConsumePrefix(y_absl::string_view* str, y_absl::string_view expected // // Example: // -// y_absl::string_view input("abcdef"); -// EXPECT_TRUE(y_absl::ConsumeSuffix(&input, "def")); +// y_absl::string_view input("abcdef"); +// EXPECT_TRUE(y_absl::ConsumeSuffix(&input, "def")); // EXPECT_EQ(input, "abc"); -inline bool ConsumeSuffix(y_absl::string_view* str, y_absl::string_view expected) { - if (!y_absl::EndsWith(*str, expected)) return false; +inline bool ConsumeSuffix(y_absl::string_view* str, y_absl::string_view expected) { + if (!y_absl::EndsWith(*str, expected)) return false; str->remove_suffix(expected.size()); return true; } @@ -68,9 +68,9 @@ inline bool ConsumeSuffix(y_absl::string_view* str, y_absl::string_view expected // Returns a view into the input string 'str' with the given 'prefix' removed, // but leaving the original string intact. If the prefix does not match at the // start of the string, returns the original string instead. -ABSL_MUST_USE_RESULT inline y_absl::string_view StripPrefix( - y_absl::string_view str, y_absl::string_view prefix) { - if (y_absl::StartsWith(str, prefix)) str.remove_prefix(prefix.size()); +ABSL_MUST_USE_RESULT inline y_absl::string_view StripPrefix( + y_absl::string_view str, y_absl::string_view prefix) { + if (y_absl::StartsWith(str, prefix)) str.remove_prefix(prefix.size()); return str; } @@ -79,13 +79,13 @@ ABSL_MUST_USE_RESULT inline y_absl::string_view StripPrefix( // Returns a view into the input string 'str' with the given 'suffix' removed, // but leaving the original string intact. If the suffix does not match at the // end of the string, returns the original string instead. -ABSL_MUST_USE_RESULT inline y_absl::string_view StripSuffix( - y_absl::string_view str, y_absl::string_view suffix) { - if (y_absl::EndsWith(str, suffix)) str.remove_suffix(suffix.size()); +ABSL_MUST_USE_RESULT inline y_absl::string_view StripSuffix( + y_absl::string_view str, y_absl::string_view suffix) { + if (y_absl::EndsWith(str, suffix)) str.remove_suffix(suffix.size()); return str; } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_STRIP_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc index ad6f1d1e75..177fba8cbe 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc @@ -12,22 +12,22 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/strings/substitute.h" +#include "y_absl/strings/substitute.h" #include <algorithm> -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/strings/ascii.h" -#include "y_absl/strings/escaping.h" -#include "y_absl/strings/internal/resize_uninitialized.h" -#include "y_absl/strings/string_view.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/strings/ascii.h" +#include "y_absl/strings/escaping.h" +#include "y_absl/strings/internal/resize_uninitialized.h" +#include "y_absl/strings/string_view.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace substitute_internal { -void SubstituteAndAppendArray(TString* output, y_absl::string_view format, - const y_absl::string_view* args_array, +void SubstituteAndAppendArray(TString* output, y_absl::string_view format, + const y_absl::string_view* args_array, size_t num_args) { // Determine total size needed. size_t size = 0; @@ -37,10 +37,10 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format, #ifndef NDEBUG ABSL_RAW_LOG(FATAL, "Invalid y_absl::Substitute() format string: \"%s\".", - y_absl::CEscape(format).c_str()); + y_absl::CEscape(format).c_str()); #endif return; - } else if (y_absl::ascii_isdigit(format[i + 1])) { + } else if (y_absl::ascii_isdigit(format[i + 1])) { int index = format[i + 1] - '0'; if (static_cast<size_t>(index) >= num_args) { #ifndef NDEBUG @@ -49,7 +49,7 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format, "Invalid y_absl::Substitute() format string: asked for \"$" "%d\", but only %d args were given. Full format string was: " "\"%s\".", - index, static_cast<int>(num_args), y_absl::CEscape(format).c_str()); + index, static_cast<int>(num_args), y_absl::CEscape(format).c_str()); #endif return; } @@ -62,7 +62,7 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format, #ifndef NDEBUG ABSL_RAW_LOG(FATAL, "Invalid y_absl::Substitute() format string: \"%s\".", - y_absl::CEscape(format).c_str()); + y_absl::CEscape(format).c_str()); #endif return; } @@ -80,8 +80,8 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format, char* target = &(*output)[original_size]; for (size_t i = 0; i < format.size(); i++) { if (format[i] == '$') { - if (y_absl::ascii_isdigit(format[i + 1])) { - const y_absl::string_view src = args_array[format[i + 1] - '0']; + if (y_absl::ascii_isdigit(format[i + 1])) { + const y_absl::string_view src = args_array[format[i + 1] - '0']; target = std::copy(src.begin(), src.end(), target); ++i; // Skip next char. } else if (format[i + 1] == '$') { @@ -105,12 +105,12 @@ Arg::Arg(const void* value) { char* ptr = scratch_ + sizeof(scratch_); uintptr_t num = reinterpret_cast<uintptr_t>(value); do { - *--ptr = y_absl::numbers_internal::kHexChar[num & 0xf]; + *--ptr = y_absl::numbers_internal::kHexChar[num & 0xf]; num >>= 4; } while (num != 0); *--ptr = 'x'; *--ptr = '0'; - piece_ = y_absl::string_view(ptr, scratch_ + sizeof(scratch_) - ptr); + piece_ = y_absl::string_view(ptr, scratch_ + sizeof(scratch_) - ptr); } } @@ -120,7 +120,7 @@ Arg::Arg(Hex hex) { char* writer = end; uint64_t value = hex.value; do { - *--writer = y_absl::numbers_internal::kHexChar[value & 0xF]; + *--writer = y_absl::numbers_internal::kHexChar[value & 0xF]; value >>= 4; } while (value != 0); @@ -132,7 +132,7 @@ Arg::Arg(Hex hex) { beg = writer; } - piece_ = y_absl::string_view(beg, end - beg); + piece_ = y_absl::string_view(beg, end - beg); } // TODO(jorg): Don't duplicate so much code between here and str_cat.cc @@ -164,9 +164,9 @@ Arg::Arg(Dec dec) { if (add_sign_again) *--writer = '-'; } - piece_ = y_absl::string_view(writer, end - writer); + piece_ = y_absl::string_view(writer, end - writer); } } // namespace substitute_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h index f92369d2e2..c31191fbda 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h @@ -39,17 +39,17 @@ // output. // // Example 1: -// TString s = Substitute("$1 purchased $0 $2 for $$10. Thanks $1!", +// TString s = Substitute("$1 purchased $0 $2 for $$10. Thanks $1!", // 5, "Bob", "Apples"); // EXPECT_EQ("Bob purchased 5 Apples for $10. Thanks Bob!", s); // // Example 2: -// TString s = "Hi. "; +// TString s = "Hi. "; // SubstituteAndAppend(&s, "My name is $0 and I am $1 years old.", "Bob", 5); // EXPECT_EQ("Hi. My name is Bob and I am 5 years old.", s); // // Supported types: -// * y_absl::string_view, TString, const char* (null is equivalent to "") +// * y_absl::string_view, TString, const char* (null is equivalent to "") // * int32_t, int64_t, uint32_t, uint64_t // * float, double // * bool (Printed as "true" or "false") @@ -75,24 +75,24 @@ #include <type_traits> #include <vector> -#include "y_absl/base/macros.h" -#include "y_absl/base/port.h" -#include "y_absl/strings/ascii.h" -#include "y_absl/strings/escaping.h" -#include "y_absl/strings/numbers.h" -#include "y_absl/strings/str_cat.h" -#include "y_absl/strings/str_split.h" -#include "y_absl/strings/string_view.h" -#include "y_absl/strings/strip.h" - -namespace y_absl { +#include "y_absl/base/macros.h" +#include "y_absl/base/port.h" +#include "y_absl/strings/ascii.h" +#include "y_absl/strings/escaping.h" +#include "y_absl/strings/numbers.h" +#include "y_absl/strings/str_cat.h" +#include "y_absl/strings/str_split.h" +#include "y_absl/strings/string_view.h" +#include "y_absl/strings/strip.h" + +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace substitute_internal { // Arg // -// This class provides an argument type for `y_absl::Substitute()` and -// `y_absl::SubstituteAndAppend()`. `Arg` handles implicit conversion of various +// This class provides an argument type for `y_absl::Substitute()` and +// `y_absl::SubstituteAndAppend()`. `Arg` handles implicit conversion of various // types to a string. (`Arg` is very similar to the `AlphaNum` class in // `StrCat()`.) // @@ -103,16 +103,16 @@ class Arg { // // Explicitly overload `const char*` so the compiler doesn't cast to `bool`. Arg(const char* value) // NOLINT(runtime/explicit) - : piece_(y_absl::NullSafeStringView(value)) {} + : piece_(y_absl::NullSafeStringView(value)) {} template <typename Allocator> Arg( // NOLINT const std::basic_string<char, std::char_traits<char>, Allocator>& value) noexcept : piece_(value) {} - Arg(y_absl::string_view value) // NOLINT(runtime/explicit) + Arg(y_absl::string_view value) // NOLINT(runtime/explicit) : piece_(value) {} - Arg(const TString& s) - : piece_(s.data(), s.size()) {} + Arg(const TString& s) + : piece_(s.data(), s.size()) {} // Overloads for primitives // @@ -164,7 +164,7 @@ class Arg { // vector<bool>::reference and const_reference require special help to // convert to `AlphaNum` because it requires two user defined conversions. template <typename T, - y_absl::enable_if_t< + y_absl::enable_if_t< std::is_class<T>::value && (std::is_same<T, std::vector<bool>::reference>::value || std::is_same<T, std::vector<bool>::const_reference>::value)>* = @@ -179,17 +179,17 @@ class Arg { Arg(const Arg&) = delete; Arg& operator=(const Arg&) = delete; - y_absl::string_view piece() const { return piece_; } + y_absl::string_view piece() const { return piece_; } private: - y_absl::string_view piece_; + y_absl::string_view piece_; char scratch_[numbers_internal::kFastToBufferSize]; }; // Internal helper function. Don't call this from outside this implementation. // This interface may change without notice. -void SubstituteAndAppendArray(TString* output, y_absl::string_view format, - const y_absl::string_view* args_array, +void SubstituteAndAppendArray(TString* output, y_absl::string_view format, + const y_absl::string_view* args_array, size_t num_args); #if defined(ABSL_BAD_CALL_IF) @@ -234,76 +234,76 @@ constexpr int PlaceholderBitmask(const char* format) { // // Example: // template <typename... Args> -// void VarMsg(TString* boilerplate, y_absl::string_view format, +// void VarMsg(TString* boilerplate, y_absl::string_view format, // const Args&... args) { -// y_absl::SubstituteAndAppend(boilerplate, format, args...); +// y_absl::SubstituteAndAppend(boilerplate, format, args...); // } // -inline void SubstituteAndAppend(TString* output, y_absl::string_view format) { +inline void SubstituteAndAppend(TString* output, y_absl::string_view format) { substitute_internal::SubstituteAndAppendArray(output, format, nullptr, 0); } -inline void SubstituteAndAppend(TString* output, y_absl::string_view format, +inline void SubstituteAndAppend(TString* output, y_absl::string_view format, const substitute_internal::Arg& a0) { - const y_absl::string_view args[] = {a0.piece()}; + const y_absl::string_view args[] = {a0.piece()}; substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args)); } -inline void SubstituteAndAppend(TString* output, y_absl::string_view format, +inline void SubstituteAndAppend(TString* output, y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1) { - const y_absl::string_view args[] = {a0.piece(), a1.piece()}; + const y_absl::string_view args[] = {a0.piece(), a1.piece()}; substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args)); } -inline void SubstituteAndAppend(TString* output, y_absl::string_view format, +inline void SubstituteAndAppend(TString* output, y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2) { - const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece()}; + const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece()}; substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args)); } -inline void SubstituteAndAppend(TString* output, y_absl::string_view format, +inline void SubstituteAndAppend(TString* output, y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3) { - const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), + const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece()}; substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args)); } -inline void SubstituteAndAppend(TString* output, y_absl::string_view format, +inline void SubstituteAndAppend(TString* output, y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4) { - const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), + const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece()}; substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args)); } -inline void SubstituteAndAppend(TString* output, y_absl::string_view format, +inline void SubstituteAndAppend(TString* output, y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5) { - const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), + const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(), a5.piece()}; substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args)); } -inline void SubstituteAndAppend(TString* output, y_absl::string_view format, +inline void SubstituteAndAppend(TString* output, y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, @@ -311,7 +311,7 @@ inline void SubstituteAndAppend(TString* output, y_absl::string_view format, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6) { - const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), + const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(), a5.piece(), a6.piece()}; substitute_internal::SubstituteAndAppendArray(output, format, args, @@ -319,12 +319,12 @@ inline void SubstituteAndAppend(TString* output, y_absl::string_view format, } inline void SubstituteAndAppend( - TString* output, y_absl::string_view format, + TString* output, y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7) { - const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), + const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(), a5.piece(), a6.piece(), a7.piece()}; substitute_internal::SubstituteAndAppendArray(output, format, args, @@ -332,13 +332,13 @@ inline void SubstituteAndAppend( } inline void SubstituteAndAppend( - TString* output, y_absl::string_view format, + TString* output, y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8) { - const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), + const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(), a5.piece(), a6.piece(), a7.piece(), a8.piece()}; substitute_internal::SubstituteAndAppendArray(output, format, args, @@ -346,13 +346,13 @@ inline void SubstituteAndAppend( } inline void SubstituteAndAppend( - TString* output, y_absl::string_view format, + TString* output, y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8, const substitute_internal::Arg& a9) { - const y_absl::string_view args[] = { + const y_absl::string_view args[] = { a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(), a5.piece(), a6.piece(), a7.piece(), a8.piece(), a9.piece()}; substitute_internal::SubstituteAndAppendArray(output, format, args, @@ -362,14 +362,14 @@ inline void SubstituteAndAppend( #if defined(ABSL_BAD_CALL_IF) // This body of functions catches cases where the number of placeholders // doesn't match the number of data arguments. -void SubstituteAndAppend(TString* output, const char* format) +void SubstituteAndAppend(TString* output, const char* format) ABSL_BAD_CALL_IF( substitute_internal::PlaceholderBitmask(format) != 0, "There were no substitution arguments " "but this format string either has a $[0-9] in it or contains " "an unescaped $ character (use $$ instead)"); -void SubstituteAndAppend(TString* output, const char* format, +void SubstituteAndAppend(TString* output, const char* format, const substitute_internal::Arg& a0) ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1, "There was 1 substitution argument given, but " @@ -377,7 +377,7 @@ void SubstituteAndAppend(TString* output, const char* format, "one of $1-$9, or contains an unescaped $ character (use " "$$ instead)"); -void SubstituteAndAppend(TString* output, const char* format, +void SubstituteAndAppend(TString* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1) ABSL_BAD_CALL_IF( @@ -386,7 +386,7 @@ void SubstituteAndAppend(TString* output, const char* format, "missing its $0/$1, contains one of $2-$9, or contains an " "unescaped $ character (use $$ instead)"); -void SubstituteAndAppend(TString* output, const char* format, +void SubstituteAndAppend(TString* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2) @@ -396,7 +396,7 @@ void SubstituteAndAppend(TString* output, const char* format, "this format string is missing its $0/$1/$2, contains one of " "$3-$9, or contains an unescaped $ character (use $$ instead)"); -void SubstituteAndAppend(TString* output, const char* format, +void SubstituteAndAppend(TString* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, @@ -407,7 +407,7 @@ void SubstituteAndAppend(TString* output, const char* format, "this format string is missing its $0-$3, contains one of " "$4-$9, or contains an unescaped $ character (use $$ instead)"); -void SubstituteAndAppend(TString* output, const char* format, +void SubstituteAndAppend(TString* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, @@ -419,7 +419,7 @@ void SubstituteAndAppend(TString* output, const char* format, "this format string is missing its $0-$4, contains one of " "$5-$9, or contains an unescaped $ character (use $$ instead)"); -void SubstituteAndAppend(TString* output, const char* format, +void SubstituteAndAppend(TString* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, @@ -433,7 +433,7 @@ void SubstituteAndAppend(TString* output, const char* format, "$6-$9, or contains an unescaped $ character (use $$ instead)"); void SubstituteAndAppend( - TString* output, const char* format, const substitute_internal::Arg& a0, + TString* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6) @@ -444,7 +444,7 @@ void SubstituteAndAppend( "$7-$9, or contains an unescaped $ character (use $$ instead)"); void SubstituteAndAppend( - TString* output, const char* format, const substitute_internal::Arg& a0, + TString* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, @@ -456,7 +456,7 @@ void SubstituteAndAppend( "$8-$9, or contains an unescaped $ character (use $$ instead)"); void SubstituteAndAppend( - TString* output, const char* format, const substitute_internal::Arg& a0, + TString* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, @@ -468,7 +468,7 @@ void SubstituteAndAppend( "contains an unescaped $ character (use $$ instead)"); void SubstituteAndAppend( - TString* output, const char* format, const substitute_internal::Arg& a0, + TString* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, @@ -494,106 +494,106 @@ void SubstituteAndAppend( // // Example: // template <typename... Args> -// void VarMsg(y_absl::string_view format, const Args&... args) { -// TString s = y_absl::Substitute(format, args...); +// void VarMsg(y_absl::string_view format, const Args&... args) { +// TString s = y_absl::Substitute(format, args...); -ABSL_MUST_USE_RESULT inline TString Substitute(y_absl::string_view format) { - TString result; +ABSL_MUST_USE_RESULT inline TString Substitute(y_absl::string_view format) { + TString result; SubstituteAndAppend(&result, format); return result; } -ABSL_MUST_USE_RESULT inline TString Substitute( - y_absl::string_view format, const substitute_internal::Arg& a0) { - TString result; +ABSL_MUST_USE_RESULT inline TString Substitute( + y_absl::string_view format, const substitute_internal::Arg& a0) { + TString result; SubstituteAndAppend(&result, format, a0); return result; } -ABSL_MUST_USE_RESULT inline TString Substitute( - y_absl::string_view format, const substitute_internal::Arg& a0, +ABSL_MUST_USE_RESULT inline TString Substitute( + y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1) { - TString result; + TString result; SubstituteAndAppend(&result, format, a0, a1); return result; } -ABSL_MUST_USE_RESULT inline TString Substitute( - y_absl::string_view format, const substitute_internal::Arg& a0, +ABSL_MUST_USE_RESULT inline TString Substitute( + y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2) { - TString result; + TString result; SubstituteAndAppend(&result, format, a0, a1, a2); return result; } -ABSL_MUST_USE_RESULT inline TString Substitute( - y_absl::string_view format, const substitute_internal::Arg& a0, +ABSL_MUST_USE_RESULT inline TString Substitute( + y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3) { - TString result; + TString result; SubstituteAndAppend(&result, format, a0, a1, a2, a3); return result; } -ABSL_MUST_USE_RESULT inline TString Substitute( - y_absl::string_view format, const substitute_internal::Arg& a0, +ABSL_MUST_USE_RESULT inline TString Substitute( + y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4) { - TString result; + TString result; SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4); return result; } -ABSL_MUST_USE_RESULT inline TString Substitute( - y_absl::string_view format, const substitute_internal::Arg& a0, +ABSL_MUST_USE_RESULT inline TString Substitute( + y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5) { - TString result; + TString result; SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5); return result; } -ABSL_MUST_USE_RESULT inline TString Substitute( - y_absl::string_view format, const substitute_internal::Arg& a0, +ABSL_MUST_USE_RESULT inline TString Substitute( + y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6) { - TString result; + TString result; SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6); return result; } -ABSL_MUST_USE_RESULT inline TString Substitute( - y_absl::string_view format, const substitute_internal::Arg& a0, +ABSL_MUST_USE_RESULT inline TString Substitute( + y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7) { - TString result; + TString result; SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7); return result; } -ABSL_MUST_USE_RESULT inline TString Substitute( - y_absl::string_view format, const substitute_internal::Arg& a0, +ABSL_MUST_USE_RESULT inline TString Substitute( + y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8) { - TString result; + TString result; SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8); return result; } -ABSL_MUST_USE_RESULT inline TString Substitute( - y_absl::string_view format, const substitute_internal::Arg& a0, +ABSL_MUST_USE_RESULT inline TString Substitute( + y_absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8, const substitute_internal::Arg& a9) { - TString result; + TString result; SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); return result; } @@ -601,20 +601,20 @@ ABSL_MUST_USE_RESULT inline TString Substitute( #if defined(ABSL_BAD_CALL_IF) // This body of functions catches cases where the number of placeholders // doesn't match the number of data arguments. -TString Substitute(const char* format) +TString Substitute(const char* format) ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 0, "There were no substitution arguments " "but this format string either has a $[0-9] in it or " "contains an unescaped $ character (use $$ instead)"); -TString Substitute(const char* format, const substitute_internal::Arg& a0) +TString Substitute(const char* format, const substitute_internal::Arg& a0) ABSL_BAD_CALL_IF( substitute_internal::PlaceholderBitmask(format) != 1, "There was 1 substitution argument given, but " "this format string is missing its $0, contains one of $1-$9, " "or contains an unescaped $ character (use $$ instead)"); -TString Substitute(const char* format, const substitute_internal::Arg& a0, +TString Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1) ABSL_BAD_CALL_IF( substitute_internal::PlaceholderBitmask(format) != 3, @@ -622,7 +622,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0, "this format string is missing its $0/$1, contains one of " "$2-$9, or contains an unescaped $ character (use $$ instead)"); -TString Substitute(const char* format, const substitute_internal::Arg& a0, +TString Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2) ABSL_BAD_CALL_IF( @@ -631,7 +631,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0, "this format string is missing its $0/$1/$2, contains one of " "$3-$9, or contains an unescaped $ character (use $$ instead)"); -TString Substitute(const char* format, const substitute_internal::Arg& a0, +TString Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3) @@ -641,7 +641,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0, "this format string is missing its $0-$3, contains one of " "$4-$9, or contains an unescaped $ character (use $$ instead)"); -TString Substitute(const char* format, const substitute_internal::Arg& a0, +TString Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, @@ -652,7 +652,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0, "this format string is missing its $0-$4, contains one of " "$5-$9, or contains an unescaped $ character (use $$ instead)"); -TString Substitute(const char* format, const substitute_internal::Arg& a0, +TString Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, @@ -664,7 +664,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0, "this format string is missing its $0-$5, contains one of " "$6-$9, or contains an unescaped $ character (use $$ instead)"); -TString Substitute(const char* format, const substitute_internal::Arg& a0, +TString Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, @@ -677,7 +677,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0, "this format string is missing its $0-$6, contains one of " "$7-$9, or contains an unescaped $ character (use $$ instead)"); -TString Substitute(const char* format, const substitute_internal::Arg& a0, +TString Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, @@ -691,7 +691,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0, "this format string is missing its $0-$7, contains one of " "$8-$9, or contains an unescaped $ character (use $$ instead)"); -TString Substitute( +TString Substitute( const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, @@ -703,7 +703,7 @@ TString Substitute( "this format string is missing its $0-$8, contains a $9, or " "contains an unescaped $ character (use $$ instead)"); -TString Substitute( +TString Substitute( const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, @@ -718,6 +718,6 @@ TString Substitute( #endif // ABSL_BAD_CALL_IF ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_STRINGS_SUBSTITUTE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ya.make index 33ccf33bac..77c5a47dc9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ya.make @@ -12,12 +12,12 @@ LICENSE(Apache-2.0) LICENSE_TEXTS(.yandex_meta/licenses.list.txt) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity - contrib/restricted/abseil-cpp-tstring/y_absl/numeric + contrib/restricted/abseil-cpp-tstring/y_absl/base + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/numeric contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal ) diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.cc index c510ec9442..b03f0ff559 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.cc @@ -12,12 +12,12 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/synchronization/barrier.h" +#include "y_absl/synchronization/barrier.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/synchronization/mutex.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/synchronization/mutex.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // Return whether int *arg is zero. @@ -49,4 +49,4 @@ bool Barrier::Block() { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.h index 0802f05a69..527bd42be0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.h @@ -19,10 +19,10 @@ #ifndef ABSL_SYNCHRONIZATION_BARRIER_H_ #define ABSL_SYNCHRONIZATION_BARRIER_H_ -#include "y_absl/base/thread_annotations.h" -#include "y_absl/synchronization/mutex.h" +#include "y_absl/base/thread_annotations.h" +#include "y_absl/synchronization/mutex.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // Barrier @@ -75,5 +75,5 @@ class Barrier { }; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_SYNCHRONIZATION_BARRIER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.cc index 79e51b5b0d..056185e51e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.cc @@ -12,13 +12,13 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/synchronization/blocking_counter.h" +#include "y_absl/synchronization/blocking_counter.h" #include <atomic> -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { @@ -64,4 +64,4 @@ void BlockingCounter::Wait() { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.h index 279382959a..a1644903e3 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.h @@ -22,10 +22,10 @@ #include <atomic> -#include "y_absl/base/thread_annotations.h" -#include "y_absl/synchronization/mutex.h" +#include "y_absl/base/thread_annotations.h" +#include "y_absl/synchronization/mutex.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // BlockingCounter @@ -96,6 +96,6 @@ class BlockingCounter { }; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc index b710b6e2a1..3c5764eeb9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc @@ -16,17 +16,17 @@ #include <new> // This file is a no-op if the required LowLevelAlloc support is missing. -#include "y_absl/base/internal/low_level_alloc.h" +#include "y_absl/base/internal/low_level_alloc.h" #ifndef ABSL_LOW_LEVEL_ALLOC_MISSING #include <string.h> -#include "y_absl/base/attributes.h" -#include "y_absl/base/internal/spinlock.h" -#include "y_absl/base/internal/thread_identity.h" -#include "y_absl/synchronization/internal/per_thread_sem.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/internal/spinlock.h" +#include "y_absl/base/internal/thread_identity.h" +#include "y_absl/synchronization/internal/per_thread_sem.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace synchronization_internal { @@ -135,6 +135,6 @@ base_internal::ThreadIdentity* CreateThreadIdentity() { } // namespace synchronization_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_LOW_LEVEL_ALLOC_MISSING diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.h index 8264f55fb1..d93209f424 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.h @@ -20,15 +20,15 @@ // This file is separate from thread_identity.h because creating a new // ThreadIdentity requires slightly higher level libraries (per_thread_sem // and low_level_alloc) than accessing an existing one. This separation allows -// us to have a smaller //y_absl/base:base. +// us to have a smaller //y_absl/base:base. #ifndef ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_ #define ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_ -#include "y_absl/base/internal/thread_identity.h" -#include "y_absl/base/port.h" +#include "y_absl/base/internal/thread_identity.h" +#include "y_absl/base/port.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace synchronization_internal { @@ -55,6 +55,6 @@ inline base_internal::ThreadIdentity* GetOrCreateCurrentThreadIdentity() { } // namespace synchronization_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc index 00fb2bd754..d8987c1a98 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc @@ -28,23 +28,23 @@ // (2) When a new edge (x->y) is inserted, do nothing if rank[x] < rank[y]. // (3) Otherwise: adjust ranks in the neighborhood of x and y. -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" // This file is a no-op if the required LowLevelAlloc support is missing. -#include "y_absl/base/internal/low_level_alloc.h" +#include "y_absl/base/internal/low_level_alloc.h" #ifndef ABSL_LOW_LEVEL_ALLOC_MISSING -#include "y_absl/synchronization/internal/graphcycles.h" +#include "y_absl/synchronization/internal/graphcycles.h" #include <algorithm> #include <array> #include <limits> -#include "y_absl/base/internal/hide_ptr.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/spinlock.h" +#include "y_absl/base/internal/hide_ptr.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/spinlock.h" // Do not use STL. This module does not use standard memory allocation. -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace synchronization_internal { @@ -693,6 +693,6 @@ int GraphCycles::GetStackTrace(GraphId id, void*** ptr) { } // namespace synchronization_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_LOW_LEVEL_ALLOC_MISSING diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.h index f7ca16bc61..eaf130bc29 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.h @@ -42,7 +42,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace synchronization_internal { @@ -136,6 +136,6 @@ class GraphCycles { } // namespace synchronization_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h index 5640066a4e..ee4078702d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h @@ -14,13 +14,13 @@ // // An optional absolute timeout, with nanosecond granularity, -// compatible with y_absl::Time. Suitable for in-register +// compatible with y_absl::Time. Suitable for in-register // parameter-passing (e.g. syscalls.) -// Constructible from a y_absl::Time (for a timeout to be respected) or {} +// Constructible from a y_absl::Time (for a timeout to be respected) or {} // (for "no timeout".) // This is a private low-level API for use by a handful of low-level // components that are friends of this class. Higher-level components -// should build APIs based on y_absl::Time and y_absl::Duration. +// should build APIs based on y_absl::Time and y_absl::Duration. #ifndef ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_ #define ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_ @@ -30,11 +30,11 @@ #include <algorithm> #include <limits> -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/time/clock.h" -#include "y_absl/time/time.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/time/clock.h" +#include "y_absl/time/time.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace synchronization_internal { @@ -46,7 +46,7 @@ class KernelTimeout { // A timeout that should expire at <t>. Any value, in the full // InfinitePast() to InfiniteFuture() range, is valid here and will be // respected. - explicit KernelTimeout(y_absl::Time t) : ns_(MakeNs(t)) {} + explicit KernelTimeout(y_absl::Time t) : ns_(MakeNs(t)) {} // No timeout. KernelTimeout() : ns_(0) {} @@ -54,7 +54,7 @@ class KernelTimeout { static KernelTimeout Never() { return {}; } // We explicitly do not support other custom formats: timespec, int64_t nanos. - // Unify on this and y_absl::Time, please. + // Unify on this and y_absl::Time, please. bool has_timeout() const { return ns_ != 0; } @@ -69,10 +69,10 @@ class KernelTimeout { // timeout. int64_t ns_; - static int64_t MakeNs(y_absl::Time t) { + static int64_t MakeNs(y_absl::Time t) { // optimization--InfiniteFuture is common "no timeout" value // and cheaper to compare than convert. - if (t == y_absl::InfiniteFuture()) return 0; + if (t == y_absl::InfiniteFuture()) return 0; int64_t x = ToUnixNanos(t); // A timeout that lands exactly on the epoch (x=0) needs to be respected, @@ -102,10 +102,10 @@ class KernelTimeout { if (!has_timeout()) { return kInfinite; } - // The use of y_absl::Now() to convert from absolute time to - // relative time means that y_absl::Now() cannot use anything that + // The use of y_absl::Now() to convert from absolute time to + // relative time means that y_absl::Now() cannot use anything that // depends on KernelTimeout (for example, Mutex) on Windows. - int64_t now = ToUnixNanos(y_absl::Now()); + int64_t now = ToUnixNanos(y_absl::Now()); if (ns_ >= now) { // Round up so that Now() + ms_from_now >= ns_. constexpr uint64_t max_nanos = @@ -151,6 +151,6 @@ inline struct timespec KernelTimeout::MakeAbsTimespec() { } // namespace synchronization_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc index af152bf63a..3e40e812a9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc @@ -13,18 +13,18 @@ // limitations under the License. // This file is a no-op if the required LowLevelAlloc support is missing. -#include "y_absl/base/internal/low_level_alloc.h" +#include "y_absl/base/internal/low_level_alloc.h" #ifndef ABSL_LOW_LEVEL_ALLOC_MISSING -#include "y_absl/synchronization/internal/per_thread_sem.h" +#include "y_absl/synchronization/internal/per_thread_sem.h" #include <atomic> -#include "y_absl/base/attributes.h" -#include "y_absl/base/internal/thread_identity.h" -#include "y_absl/synchronization/internal/waiter.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/internal/thread_identity.h" +#include "y_absl/synchronization/internal/waiter.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace synchronization_internal { @@ -64,20 +64,20 @@ void PerThreadSem::Tick(base_internal::ThreadIdentity *identity) { } // namespace synchronization_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl extern "C" { ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)( - y_absl::base_internal::ThreadIdentity *identity) { - y_absl::synchronization_internal::Waiter::GetWaiter(identity)->Post(); + y_absl::base_internal::ThreadIdentity *identity) { + y_absl::synchronization_internal::Waiter::GetWaiter(identity)->Post(); } ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)( - y_absl::synchronization_internal::KernelTimeout t) { + y_absl::synchronization_internal::KernelTimeout t) { bool timeout = false; - y_absl::base_internal::ThreadIdentity *identity; - identity = y_absl::synchronization_internal::GetOrCreateCurrentThreadIdentity(); + y_absl::base_internal::ThreadIdentity *identity; + identity = y_absl::synchronization_internal::GetOrCreateCurrentThreadIdentity(); // Ensure wait_start != 0. int ticker = identity->ticker.load(std::memory_order_relaxed); @@ -90,7 +90,7 @@ ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)( } timeout = - !y_absl::synchronization_internal::Waiter::GetWaiter(identity)->Wait(t); + !y_absl::synchronization_internal::Waiter::GetWaiter(identity)->Wait(t); if (identity->blocked_count_ptr != nullptr) { identity->blocked_count_ptr->fetch_sub(1, std::memory_order_relaxed); diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h index 1a747d4da9..2fc39ca130 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h @@ -27,11 +27,11 @@ #include <atomic> -#include "y_absl/base/internal/thread_identity.h" -#include "y_absl/synchronization/internal/create_thread_identity.h" -#include "y_absl/synchronization/internal/kernel_timeout.h" +#include "y_absl/base/internal/thread_identity.h" +#include "y_absl/synchronization/internal/create_thread_identity.h" +#include "y_absl/synchronization/internal/kernel_timeout.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN class Mutex; @@ -80,14 +80,14 @@ class PerThreadSem { // Permitted callers. friend class PerThreadSemTest; - friend class y_absl::Mutex; - friend y_absl::base_internal::ThreadIdentity* CreateThreadIdentity(); + friend class y_absl::Mutex; + friend y_absl::base_internal::ThreadIdentity* CreateThreadIdentity(); friend void ReclaimThreadIdentity(void* v); }; } // namespace synchronization_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl // In some build configurations we pass --detect-odr-violations to the // gold linker. This causes it to flag weak symbol overrides as ODR @@ -97,18 +97,18 @@ ABSL_NAMESPACE_END // check. extern "C" { void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)( - y_absl::base_internal::ThreadIdentity* identity); + y_absl::base_internal::ThreadIdentity* identity); bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)( - y_absl::synchronization_internal::KernelTimeout t); + y_absl::synchronization_internal::KernelTimeout t); } // extern "C" -void y_absl::synchronization_internal::PerThreadSem::Post( - y_absl::base_internal::ThreadIdentity* identity) { +void y_absl::synchronization_internal::PerThreadSem::Post( + y_absl::base_internal::ThreadIdentity* identity) { ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity); } -bool y_absl::synchronization_internal::PerThreadSem::Wait( - y_absl::synchronization_internal::KernelTimeout t) { +bool y_absl::synchronization_internal::PerThreadSem::Wait( + y_absl::synchronization_internal::KernelTimeout t) { return ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(t); } diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/thread_pool.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/thread_pool.h index 3901ca7da3..8b8912d494 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/thread_pool.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/thread_pool.h @@ -22,10 +22,10 @@ #include <thread> // NOLINT(build/c++11) #include <vector> -#include "y_absl/base/thread_annotations.h" -#include "y_absl/synchronization/mutex.h" +#include "y_absl/base/thread_annotations.h" +#include "y_absl/synchronization/mutex.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace synchronization_internal { @@ -43,7 +43,7 @@ class ThreadPool { ~ThreadPool() { { - y_absl::MutexLock l(&mu_); + y_absl::MutexLock l(&mu_); for (size_t i = 0; i < threads_.size(); i++) { queue_.push(nullptr); // Shutdown signal. } @@ -56,7 +56,7 @@ class ThreadPool { // Schedule a function to be run on a ThreadPool thread immediately. void Schedule(std::function<void()> func) { assert(func != nullptr); - y_absl::MutexLock l(&mu_); + y_absl::MutexLock l(&mu_); queue_.push(std::move(func)); } @@ -69,8 +69,8 @@ class ThreadPool { while (true) { std::function<void()> func; { - y_absl::MutexLock l(&mu_); - mu_.Await(y_absl::Condition(this, &ThreadPool::WorkAvailable)); + y_absl::MutexLock l(&mu_); + mu_.Await(y_absl::Condition(this, &ThreadPool::WorkAvailable)); func = std::move(queue_.front()); queue_.pop(); } @@ -81,13 +81,13 @@ class ThreadPool { } } - y_absl::Mutex mu_; + y_absl::Mutex mu_; std::queue<std::function<void()>> queue_ ABSL_GUARDED_BY(mu_); std::vector<std::thread> threads_; }; } // namespace synchronization_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc index da4629d20d..573ce9c6c5 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc @@ -12,9 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/synchronization/internal/waiter.h" +#include "y_absl/synchronization/internal/waiter.h" -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" #ifdef _WIN32 #include <windows.h> @@ -43,13 +43,13 @@ #include <new> #include <type_traits> -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/thread_identity.h" -#include "y_absl/base/optimization.h" -#include "y_absl/synchronization/internal/kernel_timeout.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/thread_identity.h" +#include "y_absl/base/optimization.h" +#include "y_absl/synchronization/internal/kernel_timeout.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace synchronization_internal { @@ -425,4 +425,4 @@ void Waiter::InternalCondVarPoke() { } // namespace synchronization_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h index 8065171c31..e6fede411f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h @@ -16,7 +16,7 @@ #ifndef ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_ #define ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_ -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" #ifdef _WIN32 #include <sdkddkver.h> @@ -35,9 +35,9 @@ #include <atomic> #include <cstdint> -#include "y_absl/base/internal/thread_identity.h" +#include "y_absl/base/internal/thread_identity.h" #include "y_absl/synchronization/internal/futex.h" -#include "y_absl/synchronization/internal/kernel_timeout.h" +#include "y_absl/synchronization/internal/kernel_timeout.h" // May be chosen at compile time via -DABSL_FORCE_WAITER_MODE=<index> #define ABSL_WAITER_MODE_FUTEX 0 @@ -57,7 +57,7 @@ #define ABSL_WAITER_MODE ABSL_WAITER_MODE_CONDVAR #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace synchronization_internal { @@ -150,6 +150,6 @@ class Waiter { } // namespace synchronization_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/ya.make index 8d1461a559..167e710a78 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/ya.make @@ -12,11 +12,11 @@ LICENSE(Apache-2.0) LICENSE_TEXTS(.yandex_meta/licenses.list.txt) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity ) ADDINCL( diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc index 6de2ac8bad..babe5c4ada 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/synchronization/mutex.h" +#include "y_absl/synchronization/mutex.h" #ifdef _WIN32 #include <windows.h> @@ -38,36 +38,36 @@ #include <cinttypes> #include <thread> // NOLINT(build/c++11) -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" #include "y_absl/base/call_once.h" -#include "y_absl/base/config.h" -#include "y_absl/base/dynamic_annotations.h" -#include "y_absl/base/internal/atomic_hook.h" -#include "y_absl/base/internal/cycleclock.h" -#include "y_absl/base/internal/hide_ptr.h" -#include "y_absl/base/internal/low_level_alloc.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/base/internal/spinlock.h" -#include "y_absl/base/internal/sysinfo.h" -#include "y_absl/base/internal/thread_identity.h" +#include "y_absl/base/config.h" +#include "y_absl/base/dynamic_annotations.h" +#include "y_absl/base/internal/atomic_hook.h" +#include "y_absl/base/internal/cycleclock.h" +#include "y_absl/base/internal/hide_ptr.h" +#include "y_absl/base/internal/low_level_alloc.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/spinlock.h" +#include "y_absl/base/internal/sysinfo.h" +#include "y_absl/base/internal/thread_identity.h" #include "y_absl/base/internal/tsan_mutex_interface.h" -#include "y_absl/base/port.h" -#include "y_absl/debugging/stacktrace.h" -#include "y_absl/debugging/symbolize.h" -#include "y_absl/synchronization/internal/graphcycles.h" -#include "y_absl/synchronization/internal/per_thread_sem.h" -#include "y_absl/time/time.h" - -using y_absl::base_internal::CurrentThreadIdentityIfPresent; -using y_absl::base_internal::PerThreadSynch; +#include "y_absl/base/port.h" +#include "y_absl/debugging/stacktrace.h" +#include "y_absl/debugging/symbolize.h" +#include "y_absl/synchronization/internal/graphcycles.h" +#include "y_absl/synchronization/internal/per_thread_sem.h" +#include "y_absl/time/time.h" + +using y_absl::base_internal::CurrentThreadIdentityIfPresent; +using y_absl::base_internal::PerThreadSynch; using y_absl::base_internal::SchedulingGuard; -using y_absl::base_internal::ThreadIdentity; -using y_absl::synchronization_internal::GetOrCreateCurrentThreadIdentity; -using y_absl::synchronization_internal::GraphCycles; -using y_absl::synchronization_internal::GraphId; -using y_absl::synchronization_internal::InvalidGraphId; -using y_absl::synchronization_internal::KernelTimeout; -using y_absl::synchronization_internal::PerThreadSem; +using y_absl::base_internal::ThreadIdentity; +using y_absl::synchronization_internal::GetOrCreateCurrentThreadIdentity; +using y_absl::synchronization_internal::GraphCycles; +using y_absl::synchronization_internal::GraphId; +using y_absl::synchronization_internal::InvalidGraphId; +using y_absl::synchronization_internal::KernelTimeout; +using y_absl::synchronization_internal::PerThreadSem; extern "C" { ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)() { @@ -75,7 +75,7 @@ ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)() { } } // extern "C" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { @@ -101,7 +101,7 @@ ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES cond_var_tracer; ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES y_absl::base_internal::AtomicHook< bool (*)(const void *pc, char *out, int out_size)> - symbolizer(y_absl::Symbolize); + symbolizer(y_absl::Symbolize); } // namespace @@ -176,7 +176,7 @@ int MutexDelay(int32_t c, int mode) { c++; } else { // Then wait. - y_absl::SleepFor(y_absl::Microseconds(10)); + y_absl::SleepFor(y_absl::Microseconds(10)); c = 0; } ABSL_TSAN_MUTEX_POST_DIVERT(nullptr, 0); @@ -424,7 +424,7 @@ static void PostSynchEvent(void *obj, int ev) { // or it explicitly says to log if (e == nullptr || e->log) { void *pcs[40]; - int n = y_absl::GetStackTrace(pcs, ABSL_ARRAYSIZE(pcs), 1); + int n = y_absl::GetStackTrace(pcs, ABSL_ARRAYSIZE(pcs), 1); // A buffer with enough space for the ASCII for all the PCs, even on a // 64-bit machine. char buffer[ABSL_ARRAYSIZE(pcs) * 24]; @@ -605,13 +605,13 @@ void Mutex::InternalAttemptToUseMutexInFatalSignalHandler() { // Return the current time plus the timeout. Use the same clock as // PerThreadSem::Wait() for consistency. Unfortunately, we don't have // such a choice when a deadline is given directly. -static y_absl::Time DeadlineFromTimeout(y_absl::Duration timeout) { +static y_absl::Time DeadlineFromTimeout(y_absl::Duration timeout) { #ifndef _WIN32 struct timeval tv; gettimeofday(&tv, nullptr); - return y_absl::TimeFromTimeval(tv) + timeout; + return y_absl::TimeFromTimeval(tv) + timeout; #else - return y_absl::Now() + timeout; + return y_absl::Now() + timeout; #endif } @@ -1290,7 +1290,7 @@ static char *StackString(void **pcs, int n, char *buf, int maxlen, static char *CurrentStackString(char *buf, int maxlen, bool symbolize) { void *pcs[40]; - return StackString(pcs, y_absl::GetStackTrace(pcs, ABSL_ARRAYSIZE(pcs), 2), buf, + return StackString(pcs, y_absl::GetStackTrace(pcs, ABSL_ARRAYSIZE(pcs), 2), buf, maxlen, symbolize); } @@ -1315,7 +1315,7 @@ struct ScopedDeadlockReportBuffers { // Helper to pass to GraphCycles::UpdateStackTrace. int GetStack(void** stack, int max_depth) { - return y_absl::GetStackTrace(stack, max_depth, 3); + return y_absl::GetStackTrace(stack, max_depth, 3); } } // anonymous namespace @@ -1329,7 +1329,7 @@ static GraphId DeadlockCheck(Mutex *mu) { SynchLocksHeld *all_locks = Synch_GetAllLocks(); - y_absl::base_internal::SpinLockHolder lock(&deadlock_graph_mu); + y_absl::base_internal::SpinLockHolder lock(&deadlock_graph_mu); const GraphId mu_id = GetGraphIdLocked(mu); if (all_locks->n == 0) { @@ -1508,11 +1508,11 @@ void Mutex::LockWhen(const Condition &cond) { ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0); } -bool Mutex::LockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout) { +bool Mutex::LockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout) { return LockWhenWithDeadline(cond, DeadlineFromTimeout(timeout)); } -bool Mutex::LockWhenWithDeadline(const Condition &cond, y_absl::Time deadline) { +bool Mutex::LockWhenWithDeadline(const Condition &cond, y_absl::Time deadline) { ABSL_TSAN_MUTEX_PRE_LOCK(this, 0); GraphId id = DebugOnlyDeadlockCheck(this); bool res = LockSlowWithDeadline(kExclusive, &cond, @@ -1531,12 +1531,12 @@ void Mutex::ReaderLockWhen(const Condition &cond) { } bool Mutex::ReaderLockWhenWithTimeout(const Condition &cond, - y_absl::Duration timeout) { + y_absl::Duration timeout) { return ReaderLockWhenWithDeadline(cond, DeadlineFromTimeout(timeout)); } bool Mutex::ReaderLockWhenWithDeadline(const Condition &cond, - y_absl::Time deadline) { + y_absl::Time deadline) { ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock); GraphId id = DebugOnlyDeadlockCheck(this); bool res = LockSlowWithDeadline(kShared, &cond, KernelTimeout(deadline), 0); @@ -1556,11 +1556,11 @@ void Mutex::Await(const Condition &cond) { } } -bool Mutex::AwaitWithTimeout(const Condition &cond, y_absl::Duration timeout) { +bool Mutex::AwaitWithTimeout(const Condition &cond, y_absl::Duration timeout) { return AwaitWithDeadline(cond, DeadlineFromTimeout(timeout)); } -bool Mutex::AwaitWithDeadline(const Condition &cond, y_absl::Time deadline) { +bool Mutex::AwaitWithDeadline(const Condition &cond, y_absl::Time deadline) { if (cond.Eval()) { // condition already true; nothing to do if (kDebugMode) { this->AssertReaderHeld(); @@ -2582,11 +2582,11 @@ bool CondVar::WaitCommon(Mutex *mutex, KernelTimeout t) { return rc; } -bool CondVar::WaitWithTimeout(Mutex *mu, y_absl::Duration timeout) { +bool CondVar::WaitWithTimeout(Mutex *mu, y_absl::Duration timeout) { return WaitWithDeadline(mu, DeadlineFromTimeout(timeout)); } -bool CondVar::WaitWithDeadline(Mutex *mu, y_absl::Time deadline) { +bool CondVar::WaitWithDeadline(Mutex *mu, y_absl::Time deadline) { return WaitCommon(mu, KernelTimeout(deadline)); } @@ -2748,4 +2748,4 @@ bool Condition::GuaranteedEqual(const Condition *a, const Condition *b) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h index 298b014313..0762a852df 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h @@ -62,18 +62,18 @@ #include <cstdint> #include <util/generic/string.h> -#include "y_absl/base/const_init.h" -#include "y_absl/base/internal/identity.h" -#include "y_absl/base/internal/low_level_alloc.h" -#include "y_absl/base/internal/thread_identity.h" -#include "y_absl/base/internal/tsan_mutex_interface.h" -#include "y_absl/base/port.h" -#include "y_absl/base/thread_annotations.h" -#include "y_absl/synchronization/internal/kernel_timeout.h" -#include "y_absl/synchronization/internal/per_thread_sem.h" -#include "y_absl/time/time.h" - -namespace y_absl { +#include "y_absl/base/const_init.h" +#include "y_absl/base/internal/identity.h" +#include "y_absl/base/internal/low_level_alloc.h" +#include "y_absl/base/internal/thread_identity.h" +#include "y_absl/base/internal/tsan_mutex_interface.h" +#include "y_absl/base/port.h" +#include "y_absl/base/thread_annotations.h" +#include "y_absl/synchronization/internal/kernel_timeout.h" +#include "y_absl/synchronization/internal/per_thread_sem.h" +#include "y_absl/time/time.h" + +namespace y_absl { ABSL_NAMESPACE_BEGIN class Condition; @@ -135,12 +135,12 @@ class ABSL_LOCKABLE Mutex { // // To create `Mutex` instances with static storage duration // (e.g. a namespace-scoped or global variable), see - // `Mutex::Mutex(y_absl::kConstInit)` below instead. + // `Mutex::Mutex(y_absl::kConstInit)` below instead. Mutex(); // Creates a mutex with static storage duration. A global variable // constructed this way avoids the lifetime issues that can occur on program - // startup and shutdown. (See y_absl/base/const_init.h.) + // startup and shutdown. (See y_absl/base/const_init.h.) // // For Mutexes allocated on the heap and stack, instead use the default // constructor, which can interact more fully with the thread sanitizer. @@ -149,7 +149,7 @@ class ABSL_LOCKABLE Mutex { // namespace foo { // ABSL_CONST_INIT y_absl::Mutex mu(y_absl::kConstInit); // } - explicit constexpr Mutex(y_absl::ConstInitType); + explicit constexpr Mutex(y_absl::ConstInitType); ~Mutex(); @@ -337,9 +337,9 @@ class ABSL_LOCKABLE Mutex { // Negative timeouts are equivalent to a zero timeout. // // This method requires that this thread holds this `Mutex` in some mode. - bool AwaitWithTimeout(const Condition &cond, y_absl::Duration timeout); + bool AwaitWithTimeout(const Condition &cond, y_absl::Duration timeout); - bool AwaitWithDeadline(const Condition &cond, y_absl::Time deadline); + bool AwaitWithDeadline(const Condition &cond, y_absl::Time deadline); // Mutex::LockWhenWithTimeout() // Mutex::ReaderLockWhenWithTimeout() @@ -352,11 +352,11 @@ class ABSL_LOCKABLE Mutex { // `true` on return. // // Negative timeouts are equivalent to a zero timeout. - bool LockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout) + bool LockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout) ABSL_EXCLUSIVE_LOCK_FUNCTION(); - bool ReaderLockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout) + bool ReaderLockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout) ABSL_SHARED_LOCK_FUNCTION(); - bool WriterLockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout) + bool WriterLockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout) ABSL_EXCLUSIVE_LOCK_FUNCTION() { return this->LockWhenWithTimeout(cond, timeout); } @@ -372,11 +372,11 @@ class ABSL_LOCKABLE Mutex { // on return. // // Deadlines in the past are equivalent to an immediate deadline. - bool LockWhenWithDeadline(const Condition &cond, y_absl::Time deadline) + bool LockWhenWithDeadline(const Condition &cond, y_absl::Time deadline) ABSL_EXCLUSIVE_LOCK_FUNCTION(); - bool ReaderLockWhenWithDeadline(const Condition &cond, y_absl::Time deadline) + bool ReaderLockWhenWithDeadline(const Condition &cond, y_absl::Time deadline) ABSL_SHARED_LOCK_FUNCTION(); - bool WriterLockWhenWithDeadline(const Condition &cond, y_absl::Time deadline) + bool WriterLockWhenWithDeadline(const Condition &cond, y_absl::Time deadline) ABSL_EXCLUSIVE_LOCK_FUNCTION() { return this->LockWhenWithDeadline(cond, deadline); } @@ -675,16 +675,16 @@ class Condition { // `Condition(object, &Class::Method)` constructs a `Condition` that evaluates // `object->Method()`. // - // Implementation Note: `y_absl::internal::identity` is used to allow methods to + // Implementation Note: `y_absl::internal::identity` is used to allow methods to // come from base classes. A simpler signature like // `Condition(T*, bool (T::*)())` does not suffice. template<typename T> - Condition(T *object, bool (y_absl::internal::identity<T>::type::* method)()); + Condition(T *object, bool (y_absl::internal::identity<T>::type::* method)()); // Same as above, for const members template<typename T> Condition(const T *object, - bool (y_absl::internal::identity<T>::type::* method)() const); + bool (y_absl::internal::identity<T>::type::* method)() const); // A Condition that returns the value of `*cond` explicit Condition(const bool *cond); @@ -817,7 +817,7 @@ class CondVar { // to return `true` or `false`. // // Requires and ensures that the current thread holds the `Mutex`. - bool WaitWithTimeout(Mutex *mu, y_absl::Duration timeout); + bool WaitWithTimeout(Mutex *mu, y_absl::Duration timeout); // CondVar::WaitWithDeadline() // @@ -834,7 +834,7 @@ class CondVar { // to return `true` or `false`. // // Requires and ensures that the current thread holds the `Mutex`. - bool WaitWithDeadline(Mutex *mu, y_absl::Time deadline); + bool WaitWithDeadline(Mutex *mu, y_absl::Time deadline); // CondVar::Signal() // @@ -935,7 +935,7 @@ inline Mutex::Mutex() : mu_(0) { ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static); } -inline constexpr Mutex::Mutex(y_absl::ConstInitType) : mu_(0) {} +inline constexpr Mutex::Mutex(y_absl::ConstInitType) : mu_(0) {} inline CondVar::CondVar() : cv_(0) {} @@ -966,7 +966,7 @@ inline Condition::Condition(bool (*func)(T *), T *arg) template <typename T> inline Condition::Condition(T *object, - bool (y_absl::internal::identity<T>::type::*method)()) + bool (y_absl::internal::identity<T>::type::*method)()) : eval_(&CastAndCallMethod<T>), function_(nullptr), method_(reinterpret_cast<InternalMethodType>(method)), @@ -974,7 +974,7 @@ inline Condition::Condition(T *object, template <typename T> inline Condition::Condition(const T *object, - bool (y_absl::internal::identity<T>::type::*method)() + bool (y_absl::internal::identity<T>::type::*method)() const) : eval_(&CastAndCallMethod<T>), function_(nullptr), @@ -984,7 +984,7 @@ inline Condition::Condition(const T *object, // Register a hook for profiling support. // // The function pointer registered here will be called whenever a mutex is -// contended. The callback is given the y_absl/base/cycleclock.h timestamp when +// contended. The callback is given the y_absl/base/cycleclock.h timestamp when // waiting began. // // Calls to this function do not race or block, but there is no ordering @@ -998,7 +998,7 @@ void RegisterMutexProfiler(void (*fn)(int64_t wait_timestamp)); // The function pointer registered here will be called whenever a mutex is // contended. The callback is given an opaque handle to the contended mutex, // an event name, and the number of wait cycles (as measured by -// //y_absl/base/internal/cycleclock.h, and which may not be real +// //y_absl/base/internal/cycleclock.h, and which may not be real // "cycle" counts.) // // The only event name currently sent is "slow release". @@ -1032,10 +1032,10 @@ void RegisterCondVarTracer(void (*fn)(const char *msg, const void *cv)); // // This has the same memory ordering concerns as RegisterMutexProfiler() above. // -// DEPRECATED: The default symbolizer function is y_absl::Symbolize() and the +// DEPRECATED: The default symbolizer function is y_absl::Symbolize() and the // ability to register a different hook for symbolizing stack traces will be // removed on or after 2023-05-01. -ABSL_DEPRECATED("y_absl::RegisterSymbolizer() is deprecated and will be removed " +ABSL_DEPRECATED("y_absl::RegisterSymbolizer() is deprecated and will be removed " "on or after 2023-05-01") void RegisterSymbolizer(bool (*fn)(const void *pc, char *out, int out_size)); @@ -1067,7 +1067,7 @@ enum class OnDeadlockCycle { void SetMutexDeadlockDetectionMode(OnDeadlockCycle mode); ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl // In some build configurations we pass --detect-odr-violations to the // gold linker. This causes it to flag weak symbol overrides as ODR diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.cc index ac1873d017..0b5c5a5e48 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.cc @@ -12,16 +12,16 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/synchronization/notification.h" +#include "y_absl/synchronization/notification.h" #include <atomic> -#include "y_absl/base/attributes.h" -#include "y_absl/base/internal/raw_logging.h" -#include "y_absl/synchronization/mutex.h" -#include "y_absl/time/time.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/synchronization/mutex.h" +#include "y_absl/time/time.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN void Notification::Notify() { @@ -54,7 +54,7 @@ void Notification::WaitForNotification() const { } bool Notification::WaitForNotificationWithTimeout( - y_absl::Duration timeout) const { + y_absl::Duration timeout) const { bool notified = HasBeenNotifiedInternal(&this->notified_yet_); if (!notified) { notified = this->mutex_.LockWhenWithTimeout( @@ -64,7 +64,7 @@ bool Notification::WaitForNotificationWithTimeout( return notified; } -bool Notification::WaitForNotificationWithDeadline(y_absl::Time deadline) const { +bool Notification::WaitForNotificationWithDeadline(y_absl::Time deadline) const { bool notified = HasBeenNotifiedInternal(&this->notified_yet_); if (!notified) { notified = this->mutex_.LockWhenWithDeadline( @@ -75,4 +75,4 @@ bool Notification::WaitForNotificationWithDeadline(y_absl::Time deadline) const } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.h index fb6aca8e36..eea7090f18 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.h @@ -52,11 +52,11 @@ #include <atomic> -#include "y_absl/base/macros.h" -#include "y_absl/synchronization/mutex.h" -#include "y_absl/time/time.h" +#include "y_absl/base/macros.h" +#include "y_absl/synchronization/mutex.h" +#include "y_absl/time/time.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ----------------------------------------------------------------------------- @@ -90,14 +90,14 @@ class Notification { // Blocks until either the notification's "notified" state is `true` (which // may occur immediately) or the timeout has elapsed, returning the value of // its "notified" state in either case. - bool WaitForNotificationWithTimeout(y_absl::Duration timeout) const; + bool WaitForNotificationWithTimeout(y_absl::Duration timeout) const; // Notification::WaitForNotificationWithDeadline() // // Blocks until either the notification's "notified" state is `true` (which // may occur immediately) or the deadline has expired, returning the value of // its "notified" state in either case. - bool WaitForNotificationWithDeadline(y_absl::Time deadline) const; + bool WaitForNotificationWithDeadline(y_absl::Time deadline) const; // Notification::Notify() // @@ -118,6 +118,6 @@ class Notification { }; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_SYNCHRONIZATION_NOTIFICATION_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/ya.make index 0d62753029..860fd01b0f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/ya.make @@ -12,23 +12,23 @@ LICENSE(Apache-2.0) LICENSE_TEXTS(.yandex_meta/licenses.list.txt) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity - contrib/restricted/abseil-cpp-tstring/y_absl/debugging - contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace - contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize - contrib/restricted/abseil-cpp-tstring/y_absl/demangle - contrib/restricted/abseil-cpp-tstring/y_absl/numeric - contrib/restricted/abseil-cpp-tstring/y_absl/strings + contrib/restricted/abseil-cpp-tstring/y_absl/base + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/debugging + contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace + contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize + contrib/restricted/abseil-cpp-tstring/y_absl/demangle + contrib/restricted/abseil-cpp-tstring/y_absl/numeric + contrib/restricted/abseil-cpp-tstring/y_absl/strings contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal - contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal - contrib/restricted/abseil-cpp-tstring/y_absl/time - contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time - contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone + contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal + contrib/restricted/abseil-cpp-tstring/y_absl/time + contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time + contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone ) ADDINCL( diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc index 8ebe6264d9..f24bac91e8 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc @@ -12,29 +12,29 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/time/civil_time.h" +#include "y_absl/time/civil_time.h" #include <cstdlib> #include <util/generic/string.h> -#include "y_absl/strings/str_cat.h" -#include "y_absl/time/time.h" +#include "y_absl/strings/str_cat.h" +#include "y_absl/time/time.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { -// Since a civil time has a larger year range than y_absl::Time (64-bit years vs +// Since a civil time has a larger year range than y_absl::Time (64-bit years vs // 64-bit seconds, respectively) we normalize years to roughly +/- 400 years // around the year 2400, which will produce an equivalent year in a range that -// y_absl::Time can handle. +// y_absl::Time can handle. inline civil_year_t NormalizeYear(civil_year_t year) { return 2400 + year % 400; } // Formats the given CivilSecond according to the given format. -TString FormatYearAnd(string_view fmt, CivilSecond cs) { +TString FormatYearAnd(string_view fmt, CivilSecond cs) { const CivilSecond ncs(NormalizeYear(cs.year()), cs.month(), cs.day(), cs.hour(), cs.minute(), cs.second()); const TimeZone utc = UTCTimeZone(); @@ -43,17 +43,17 @@ TString FormatYearAnd(string_view fmt, CivilSecond cs) { template <typename CivilT> bool ParseYearAnd(string_view fmt, string_view s, CivilT* c) { - // Civil times support a larger year range than y_absl::Time, so we need to - // parse the year separately, normalize it, then use y_absl::ParseTime on the + // Civil times support a larger year range than y_absl::Time, so we need to + // parse the year separately, normalize it, then use y_absl::ParseTime on the // normalized string. - const TString ss = TString(s); // TODO(y_absl-team): Avoid conversion. + const TString ss = TString(s); // TODO(y_absl-team): Avoid conversion. const char* const np = ss.c_str(); char* endp; errno = 0; const civil_year_t y = std::strtoll(np, &endp, 10); // NOLINT(runtime/deprecated_fn) if (endp == np || errno == ERANGE) return false; - const TString norm = StrCat(NormalizeYear(y), endp); + const TString norm = StrCat(NormalizeYear(y), endp); const TimeZone utc = UTCTimeZone(); Time t; @@ -95,18 +95,18 @@ bool ParseLenient(string_view s, CivilT* c) { } } // namespace -TString FormatCivilTime(CivilSecond c) { +TString FormatCivilTime(CivilSecond c) { return FormatYearAnd("-%m-%d%ET%H:%M:%S", c); } -TString FormatCivilTime(CivilMinute c) { +TString FormatCivilTime(CivilMinute c) { return FormatYearAnd("-%m-%d%ET%H:%M", c); } -TString FormatCivilTime(CivilHour c) { +TString FormatCivilTime(CivilHour c) { return FormatYearAnd("-%m-%d%ET%H", c); } -TString FormatCivilTime(CivilDay c) { return FormatYearAnd("-%m-%d", c); } -TString FormatCivilTime(CivilMonth c) { return FormatYearAnd("-%m", c); } -TString FormatCivilTime(CivilYear c) { return FormatYearAnd("", c); } +TString FormatCivilTime(CivilDay c) { return FormatYearAnd("-%m-%d", c); } +TString FormatCivilTime(CivilMonth c) { return FormatYearAnd("-%m", c); } +TString FormatCivilTime(CivilYear c) { return FormatYearAnd("", c); } bool ParseCivilTime(string_view s, CivilSecond* c) { return ParseYearAnd("-%m-%d%ET%H:%M:%S", s, c); @@ -170,4 +170,4 @@ std::ostream& operator<<(std::ostream& os, CivilSecond s) { } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.h index df6b4381b3..64fb6da494 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.h @@ -20,7 +20,7 @@ // The term "civil time" refers to the legally recognized human-scale time // that is represented by the six fields `YYYY-MM-DD hh:mm:ss`. A "date" // is perhaps the most common example of a civil time (represented here as -// an `y_absl::CivilDay`). +// an `y_absl::CivilDay`). // // Modern-day civil time follows the Gregorian Calendar and is a // time-zone-independent concept: a civil time of "2015-06-01 12:00:00", for @@ -45,37 +45,37 @@ // arithmetic on civil-time objects, while avoiding complications like // daylight-saving time (DST): // -// * `y_absl::CivilSecond` -// * `y_absl::CivilMinute` -// * `y_absl::CivilHour` -// * `y_absl::CivilDay` -// * `y_absl::CivilMonth` -// * `y_absl::CivilYear` +// * `y_absl::CivilSecond` +// * `y_absl::CivilMinute` +// * `y_absl::CivilHour` +// * `y_absl::CivilDay` +// * `y_absl::CivilMonth` +// * `y_absl::CivilYear` // // Example: // // // Construct a civil-time object for a specific day -// const y_absl::CivilDay cd(1969, 07, 20); +// const y_absl::CivilDay cd(1969, 07, 20); // // // Construct a civil-time object for a specific second -// const y_absl::CivilSecond cd(2018, 8, 1, 12, 0, 1); +// const y_absl::CivilSecond cd(2018, 8, 1, 12, 0, 1); // // Note: In C++14 and later, this library is usable in a constexpr context. // // Example: // // // Valid in C++14 -// constexpr y_absl::CivilDay cd(1969, 07, 20); +// constexpr y_absl::CivilDay cd(1969, 07, 20); #ifndef ABSL_TIME_CIVIL_TIME_H_ #define ABSL_TIME_CIVIL_TIME_H_ #include <util/generic/string.h> -#include "y_absl/strings/string_view.h" -#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" +#include "y_absl/strings/string_view.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { @@ -108,24 +108,24 @@ struct year_tag : month_tag, cctz::detail::year_tag {}; // // Examples: // -// y_absl::CivilDay default_value; // 1970-01-01 00:00:00 +// y_absl::CivilDay default_value; // 1970-01-01 00:00:00 // -// y_absl::CivilDay a(2015, 2, 3); // 2015-02-03 00:00:00 -// y_absl::CivilDay b(2015, 2, 3, 4, 5, 6); // 2015-02-03 00:00:00 -// y_absl::CivilDay c(2015); // 2015-01-01 00:00:00 +// y_absl::CivilDay a(2015, 2, 3); // 2015-02-03 00:00:00 +// y_absl::CivilDay b(2015, 2, 3, 4, 5, 6); // 2015-02-03 00:00:00 +// y_absl::CivilDay c(2015); // 2015-01-01 00:00:00 // -// y_absl::CivilSecond ss(2015, 2, 3, 4, 5, 6); // 2015-02-03 04:05:06 -// y_absl::CivilMinute mm(ss); // 2015-02-03 04:05:00 -// y_absl::CivilHour hh(mm); // 2015-02-03 04:00:00 -// y_absl::CivilDay d(hh); // 2015-02-03 00:00:00 -// y_absl::CivilMonth m(d); // 2015-02-01 00:00:00 -// y_absl::CivilYear y(m); // 2015-01-01 00:00:00 +// y_absl::CivilSecond ss(2015, 2, 3, 4, 5, 6); // 2015-02-03 04:05:06 +// y_absl::CivilMinute mm(ss); // 2015-02-03 04:05:00 +// y_absl::CivilHour hh(mm); // 2015-02-03 04:00:00 +// y_absl::CivilDay d(hh); // 2015-02-03 00:00:00 +// y_absl::CivilMonth m(d); // 2015-02-01 00:00:00 +// y_absl::CivilYear y(m); // 2015-01-01 00:00:00 // -// m = y_absl::CivilMonth(y); // 2015-01-01 00:00:00 -// d = y_absl::CivilDay(m); // 2015-01-01 00:00:00 -// hh = y_absl::CivilHour(d); // 2015-01-01 00:00:00 -// mm = y_absl::CivilMinute(hh); // 2015-01-01 00:00:00 -// ss = y_absl::CivilSecond(mm); // 2015-01-01 00:00:00 +// m = y_absl::CivilMonth(y); // 2015-01-01 00:00:00 +// d = y_absl::CivilDay(m); // 2015-01-01 00:00:00 +// hh = y_absl::CivilHour(d); // 2015-01-01 00:00:00 +// mm = y_absl::CivilMinute(hh); // 2015-01-01 00:00:00 +// ss = y_absl::CivilSecond(mm); // 2015-01-01 00:00:00 // // Each civil-time class is aligned to the civil-time field indicated in the // class's name after normalization. Alignment is performed by setting all the @@ -135,20 +135,20 @@ struct year_tag : month_tag, cctz::detail::year_tag {}; // string format used here is not important; it's just a shorthand way of // showing the six YMDHMS fields.) // -// y_absl::CivilSecond : 2015-11-22 12:34:56 -// y_absl::CivilMinute : 2015-11-22 12:34:00 -// y_absl::CivilHour : 2015-11-22 12:00:00 -// y_absl::CivilDay : 2015-11-22 00:00:00 -// y_absl::CivilMonth : 2015-11-01 00:00:00 -// y_absl::CivilYear : 2015-01-01 00:00:00 +// y_absl::CivilSecond : 2015-11-22 12:34:56 +// y_absl::CivilMinute : 2015-11-22 12:34:00 +// y_absl::CivilHour : 2015-11-22 12:00:00 +// y_absl::CivilDay : 2015-11-22 00:00:00 +// y_absl::CivilMonth : 2015-11-01 00:00:00 +// y_absl::CivilYear : 2015-01-01 00:00:00 // // Each civil-time type performs arithmetic on the field to which it is -// aligned. This means that adding 1 to an y_absl::CivilDay increments the day -// field (normalizing as necessary), and subtracting 7 from an y_absl::CivilMonth +// aligned. This means that adding 1 to an y_absl::CivilDay increments the day +// field (normalizing as necessary), and subtracting 7 from an y_absl::CivilMonth // operates on the month field (normalizing as necessary). All arithmetic // produces a valid civil time. Difference requires two similarly aligned // civil-time objects and returns the scalar answer in units of the objects' -// alignment. For example, the difference between two y_absl::CivilHour objects +// alignment. For example, the difference between two y_absl::CivilHour objects // will give an answer in units of civil hours. // // ALIGNMENT CONVERSION @@ -156,24 +156,24 @@ struct year_tag : month_tag, cctz::detail::year_tag {}; // The alignment of a civil-time object cannot change, but the object may be // used to construct a new object with a different alignment. This is referred // to as "realigning". When realigning to a type with the same or more -// precision (e.g., y_absl::CivilDay -> y_absl::CivilSecond), the conversion may be +// precision (e.g., y_absl::CivilDay -> y_absl::CivilSecond), the conversion may be // performed implicitly since no information is lost. However, if information // could be discarded (e.g., CivilSecond -> CivilDay), the conversion must // be explicit at the call site. // // Examples: // -// void UseDay(y_absl::CivilDay day); +// void UseDay(y_absl::CivilDay day); // -// y_absl::CivilSecond cs; +// y_absl::CivilSecond cs; // UseDay(cs); // Won't compile because data may be discarded -// UseDay(y_absl::CivilDay(cs)); // OK: explicit conversion +// UseDay(y_absl::CivilDay(cs)); // OK: explicit conversion // -// y_absl::CivilDay cd; +// y_absl::CivilDay cd; // UseDay(cd); // OK: no conversion needed // -// y_absl::CivilMonth cm; -// UseDay(cm); // OK: implicit conversion to y_absl::CivilDay +// y_absl::CivilMonth cm; +// UseDay(cm); // OK: implicit conversion to y_absl::CivilDay // // NORMALIZATION // @@ -187,11 +187,11 @@ struct year_tag : month_tag, cctz::detail::year_tag {}; // Examples: // // // Out-of-range; normalized to 2016-11-01 -// y_absl::CivilDay d(2016, 10, 32); +// y_absl::CivilDay d(2016, 10, 32); // // Out-of-range, negative: normalized to 2016-10-30T23 -// y_absl::CivilHour h1(2016, 10, 31, -1); +// y_absl::CivilHour h1(2016, 10, 31, -1); // // Normalization is cumulative: normalized to 2016-10-30T23 -// y_absl::CivilHour h2(2016, 10, 32, -25); +// y_absl::CivilHour h2(2016, 10, 32, -25); // // Note: If normalization is undesired, you can signal an error by comparing // the constructor arguments to the normalized values returned by the YMDHMS @@ -205,17 +205,17 @@ struct year_tag : month_tag, cctz::detail::year_tag {}; // // Examples: // -// y_absl::CivilDay feb_3(2015, 2, 3); // 2015-02-03 00:00:00 -// y_absl::CivilDay mar_4(2015, 3, 4); // 2015-03-04 00:00:00 +// y_absl::CivilDay feb_3(2015, 2, 3); // 2015-02-03 00:00:00 +// y_absl::CivilDay mar_4(2015, 3, 4); // 2015-03-04 00:00:00 // // feb_3 < mar_4 -// // y_absl::CivilYear(feb_3) == y_absl::CivilYear(mar_4) +// // y_absl::CivilYear(feb_3) == y_absl::CivilYear(mar_4) // -// y_absl::CivilSecond feb_3_noon(2015, 2, 3, 12, 0, 0); // 2015-02-03 12:00:00 +// y_absl::CivilSecond feb_3_noon(2015, 2, 3, 12, 0, 0); // 2015-02-03 12:00:00 // // feb_3 < feb_3_noon -// // feb_3 == y_absl::CivilDay(feb_3_noon) +// // feb_3 == y_absl::CivilDay(feb_3_noon) // // // Iterates all the days of February 2015. -// for (y_absl::CivilDay d(2015, 2, 1); d < y_absl::CivilMonth(2015, 3); ++d) { +// for (y_absl::CivilDay d(2015, 2, 1); d < y_absl::CivilMonth(2015, 3); ++d) { // // ... // } // @@ -228,13 +228,13 @@ struct year_tag : month_tag, cctz::detail::year_tag {}; // // Example: // -// y_absl::CivilDay a(2015, 2, 3); +// y_absl::CivilDay a(2015, 2, 3); // ++a; // 2015-02-04 00:00:00 // --a; // 2015-02-03 00:00:00 -// y_absl::CivilDay b = a + 1; // 2015-02-04 00:00:00 -// y_absl::CivilDay c = 1 + b; // 2015-02-05 00:00:00 +// y_absl::CivilDay b = a + 1; // 2015-02-04 00:00:00 +// y_absl::CivilDay c = 1 + b; // 2015-02-05 00:00:00 // int n = c - a; // n = 2 (civil days) -// int m = c - y_absl::CivilMonth(c); // Won't compile: different types. +// int m = c - y_absl::CivilMonth(c); // Won't compile: different types. // // ACCESSORS // @@ -253,7 +253,7 @@ struct year_tag : month_tag, cctz::detail::year_tag {}; // // Example: // -// y_absl::CivilDay d(2015, 6, 28); +// y_absl::CivilDay d(2015, 6, 28); // // d.year() == 2015 // // d.month() == 6 // // d.day() == 28 @@ -300,23 +300,23 @@ struct year_tag : month_tag, cctz::detail::year_tag {}; // // Example: // -// const y_absl::CivilDay d(2015, 1, 31); +// const y_absl::CivilDay d(2015, 1, 31); // // // Answer 1: // // Add 1 to the month field in the constructor, and rely on normalization. -// const auto normalized = y_absl::CivilDay(d.year(), d.month() + 1, d.day()); +// const auto normalized = y_absl::CivilDay(d.year(), d.month() + 1, d.day()); // // normalized == 2015-03-03 (aka Feb 31) // // // Answer 2: // // Add 1 to month field, capping to the end of next month. -// const auto next_month = y_absl::CivilMonth(d) + 1; -// const auto last_day_of_next_month = y_absl::CivilDay(next_month + 1) - 1; +// const auto next_month = y_absl::CivilMonth(d) + 1; +// const auto last_day_of_next_month = y_absl::CivilDay(next_month + 1) - 1; // const auto capped = std::min(normalized, last_day_of_next_month); // // capped == 2015-02-28 // // // Answer 3: // // Signal an error if the normalized answer is not in next month. -// if (y_absl::CivilMonth(normalized) != next_month) { +// if (y_absl::CivilMonth(normalized) != next_month) { // // error, month overflow // } // @@ -340,9 +340,9 @@ using CivilYear = // // Example: // -// y_absl::CivilSecond cs = ...; -// y_absl::civil_year_t y = cs.year(); -// cs = y_absl::CivilSecond(y, 1, 1, 0, 0, 0); // CivilSecond(CivilYear(cs)) +// y_absl::CivilSecond cs = ...; +// y_absl::civil_year_t y = cs.year(); +// cs = y_absl::CivilSecond(y, 1, 1, 0, 0, 0); // CivilSecond(CivilYear(cs)) // using civil_year_t = time_internal::cctz::year_t; @@ -355,7 +355,7 @@ using civil_year_t = time_internal::cctz::year_t; // // Example: // -// y_absl::civil_diff_t n_sec = cs1 - cs2; // cs1 == cs2 + n_sec; +// y_absl::civil_diff_t n_sec = cs1 - cs2; // cs1 == cs2 + n_sec; // using civil_diff_t = time_internal::cctz::diff_t; @@ -365,18 +365,18 @@ using civil_diff_t = time_internal::cctz::diff_t; // The Weekday enum class represents the civil-time concept of a "weekday" with // members for all days of the week. // -// y_absl::Weekday wd = y_absl::Weekday::thursday; +// y_absl::Weekday wd = y_absl::Weekday::thursday; // using Weekday = time_internal::cctz::weekday; // GetWeekday() // -// Returns the y_absl::Weekday for the given (realigned) civil-time value. +// Returns the y_absl::Weekday for the given (realigned) civil-time value. // // Example: // -// y_absl::CivilDay a(2015, 8, 13); -// y_absl::Weekday wd = y_absl::GetWeekday(a); // wd == y_absl::Weekday::thursday +// y_absl::CivilDay a(2015, 8, 13); +// y_absl::Weekday wd = y_absl::GetWeekday(a); // wd == y_absl::Weekday::thursday // inline Weekday GetWeekday(CivilSecond cs) { return time_internal::cctz::get_weekday(cs); @@ -385,8 +385,8 @@ inline Weekday GetWeekday(CivilSecond cs) { // NextWeekday() // PrevWeekday() // -// Returns the y_absl::CivilDay that strictly follows or precedes a given -// y_absl::CivilDay, and that falls on the given y_absl::Weekday. +// Returns the y_absl::CivilDay that strictly follows or precedes a given +// y_absl::CivilDay, and that falls on the given y_absl::Weekday. // // Example, given the following month: // @@ -399,18 +399,18 @@ inline Weekday GetWeekday(CivilSecond cs) { // 23 24 25 26 27 28 29 // 30 31 // -// y_absl::CivilDay a(2015, 8, 13); -// // y_absl::GetWeekday(a) == y_absl::Weekday::thursday -// y_absl::CivilDay b = y_absl::NextWeekday(a, y_absl::Weekday::thursday); +// y_absl::CivilDay a(2015, 8, 13); +// // y_absl::GetWeekday(a) == y_absl::Weekday::thursday +// y_absl::CivilDay b = y_absl::NextWeekday(a, y_absl::Weekday::thursday); // // b = 2015-08-20 -// y_absl::CivilDay c = y_absl::PrevWeekday(a, y_absl::Weekday::thursday); +// y_absl::CivilDay c = y_absl::PrevWeekday(a, y_absl::Weekday::thursday); // // c = 2015-08-06 // -// y_absl::CivilDay d = ... +// y_absl::CivilDay d = ... // // Gets the following Thursday if d is not already Thursday -// y_absl::CivilDay thurs1 = y_absl::NextWeekday(d - 1, y_absl::Weekday::thursday); +// y_absl::CivilDay thurs1 = y_absl::NextWeekday(d - 1, y_absl::Weekday::thursday); // // Gets the previous Thursday if d is not already Thursday -// y_absl::CivilDay thurs2 = y_absl::PrevWeekday(d + 1, y_absl::Weekday::thursday); +// y_absl::CivilDay thurs2 = y_absl::PrevWeekday(d + 1, y_absl::Weekday::thursday); // inline CivilDay NextWeekday(CivilDay cd, Weekday wd) { return CivilDay(time_internal::cctz::next_weekday(cd, wd)); @@ -425,10 +425,10 @@ inline CivilDay PrevWeekday(CivilDay cd, Weekday wd) { // // Example: // -// y_absl::CivilDay a(2015, 1, 1); -// int yd_jan_1 = y_absl::GetYearDay(a); // yd_jan_1 = 1 -// y_absl::CivilDay b(2015, 12, 31); -// int yd_dec_31 = y_absl::GetYearDay(b); // yd_dec_31 = 365 +// y_absl::CivilDay a(2015, 1, 1); +// int yd_jan_1 = y_absl::GetYearDay(a); // yd_jan_1 = 1 +// y_absl::CivilDay b(2015, 12, 31); +// int yd_dec_31 = y_absl::GetYearDay(b); // yd_dec_31 = 365 // inline int GetYearDay(CivilSecond cs) { return time_internal::cctz::get_yearday(cs); @@ -450,19 +450,19 @@ inline int GetYearDay(CivilSecond cs) { // // Example: // -// y_absl::CivilDay d = y_absl::CivilDay(1969, 7, 20); -// TString day_string = y_absl::FormatCivilTime(d); // "1969-07-20" +// y_absl::CivilDay d = y_absl::CivilDay(1969, 7, 20); +// TString day_string = y_absl::FormatCivilTime(d); // "1969-07-20" // -TString FormatCivilTime(CivilSecond c); -TString FormatCivilTime(CivilMinute c); -TString FormatCivilTime(CivilHour c); -TString FormatCivilTime(CivilDay c); -TString FormatCivilTime(CivilMonth c); -TString FormatCivilTime(CivilYear c); +TString FormatCivilTime(CivilSecond c); +TString FormatCivilTime(CivilMinute c); +TString FormatCivilTime(CivilHour c); +TString FormatCivilTime(CivilDay c); +TString FormatCivilTime(CivilMonth c); +TString FormatCivilTime(CivilYear c); -// y_absl::ParseCivilTime() +// y_absl::ParseCivilTime() // -// Parses a civil-time value from the specified `y_absl::string_view` into the +// Parses a civil-time value from the specified `y_absl::string_view` into the // passed output parameter. Returns `true` upon successful parsing. // // The expected form of the input string is as follows: @@ -478,38 +478,38 @@ TString FormatCivilTime(CivilYear c); // // Example: // -// y_absl::CivilDay d; -// bool ok = y_absl::ParseCivilTime("2018-01-02", &d); // OK +// y_absl::CivilDay d; +// bool ok = y_absl::ParseCivilTime("2018-01-02", &d); // OK // // Note that parsing will fail if the string's format does not match the // expected type exactly. `ParseLenientCivilTime()` below is more lenient. // -bool ParseCivilTime(y_absl::string_view s, CivilSecond* c); -bool ParseCivilTime(y_absl::string_view s, CivilMinute* c); -bool ParseCivilTime(y_absl::string_view s, CivilHour* c); -bool ParseCivilTime(y_absl::string_view s, CivilDay* c); -bool ParseCivilTime(y_absl::string_view s, CivilMonth* c); -bool ParseCivilTime(y_absl::string_view s, CivilYear* c); +bool ParseCivilTime(y_absl::string_view s, CivilSecond* c); +bool ParseCivilTime(y_absl::string_view s, CivilMinute* c); +bool ParseCivilTime(y_absl::string_view s, CivilHour* c); +bool ParseCivilTime(y_absl::string_view s, CivilDay* c); +bool ParseCivilTime(y_absl::string_view s, CivilMonth* c); +bool ParseCivilTime(y_absl::string_view s, CivilYear* c); // ParseLenientCivilTime() // -// Parses any of the formats accepted by `y_absl::ParseCivilTime()`, but is more +// Parses any of the formats accepted by `y_absl::ParseCivilTime()`, but is more // lenient if the format of the string does not exactly match the associated // type. // // Example: // -// y_absl::CivilDay d; -// bool ok = y_absl::ParseLenientCivilTime("1969-07-20", &d); // OK -// ok = y_absl::ParseLenientCivilTime("1969-07-20T10", &d); // OK: T10 floored -// ok = y_absl::ParseLenientCivilTime("1969-07", &d); // OK: day defaults to 1 -// -bool ParseLenientCivilTime(y_absl::string_view s, CivilSecond* c); -bool ParseLenientCivilTime(y_absl::string_view s, CivilMinute* c); -bool ParseLenientCivilTime(y_absl::string_view s, CivilHour* c); -bool ParseLenientCivilTime(y_absl::string_view s, CivilDay* c); -bool ParseLenientCivilTime(y_absl::string_view s, CivilMonth* c); -bool ParseLenientCivilTime(y_absl::string_view s, CivilYear* c); +// y_absl::CivilDay d; +// bool ok = y_absl::ParseLenientCivilTime("1969-07-20", &d); // OK +// ok = y_absl::ParseLenientCivilTime("1969-07-20T10", &d); // OK: T10 floored +// ok = y_absl::ParseLenientCivilTime("1969-07", &d); // OK: day defaults to 1 +// +bool ParseLenientCivilTime(y_absl::string_view s, CivilSecond* c); +bool ParseLenientCivilTime(y_absl::string_view s, CivilMinute* c); +bool ParseLenientCivilTime(y_absl::string_view s, CivilHour* c); +bool ParseLenientCivilTime(y_absl::string_view s, CivilDay* c); +bool ParseLenientCivilTime(y_absl::string_view s, CivilMonth* c); +bool ParseLenientCivilTime(y_absl::string_view s, CivilYear* c); namespace time_internal { // For functions found via ADL on civil-time tags. @@ -520,7 +520,7 @@ namespace time_internal { // For functions found via ADL on civil-time tags. // // Example: // -// y_absl::CivilDay d = y_absl::CivilDay(1969, 7, 20); +// y_absl::CivilDay d = y_absl::CivilDay(1969, 7, 20); // std::cout << "Date is: " << d << "\n"; // std::ostream& operator<<(std::ostream& os, CivilYear y); @@ -533,6 +533,6 @@ std::ostream& operator<<(std::ostream& os, CivilSecond s); } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_CIVIL_TIME_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time/ya.make index 53f09bb8c4..919773f619 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time/ya.make @@ -17,7 +17,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src) SRCS( civil_time_detail.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc index 0a309960f4..dcc12b5633 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc @@ -12,9 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/time/clock.h" +#include "y_absl/time/clock.h" -#include "y_absl/base/attributes.h" +#include "y_absl/base/attributes.h" #include "y_absl/base/optimization.h" #ifdef _WIN32 @@ -28,25 +28,25 @@ #include <ctime> #include <limits> -#include "y_absl/base/internal/spinlock.h" -#include "y_absl/base/internal/unscaledcycleclock.h" -#include "y_absl/base/macros.h" -#include "y_absl/base/port.h" -#include "y_absl/base/thread_annotations.h" +#include "y_absl/base/internal/spinlock.h" +#include "y_absl/base/internal/unscaledcycleclock.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/port.h" +#include "y_absl/base/thread_annotations.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN Time Now() { // TODO(bww): Get a timespec instead so we don't have to divide. - int64_t n = y_absl::GetCurrentTimeNanos(); + int64_t n = y_absl::GetCurrentTimeNanos(); if (n >= 0) { return time_internal::FromUnixDuration( time_internal::MakeDuration(n / 1000000000, n % 1000000000 * 4)); } - return time_internal::FromUnixDuration(y_absl::Nanoseconds(n)); + return time_internal::FromUnixDuration(y_absl::Nanoseconds(n)); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl // Decide if we should use the fast GetCurrentTimeNanos() algorithm // based on the cyclecounter, otherwise just get the time directly @@ -61,32 +61,32 @@ ABSL_NAMESPACE_END #endif #if defined(__APPLE__) || defined(_WIN32) -#include "y_absl/time/internal/get_current_time_chrono.inc" +#include "y_absl/time/internal/get_current_time_chrono.inc" #else -#include "y_absl/time/internal/get_current_time_posix.inc" +#include "y_absl/time/internal/get_current_time_posix.inc" #endif // Allows override by test. #ifndef GET_CURRENT_TIME_NANOS_FROM_SYSTEM #define GET_CURRENT_TIME_NANOS_FROM_SYSTEM() \ - ::y_absl::time_internal::GetCurrentTimeNanosFromSystem() + ::y_absl::time_internal::GetCurrentTimeNanosFromSystem() #endif #if !ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else // Use the cyclecounter-based implementation below. // Allows override by test. #ifndef GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW #define GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW() \ - ::y_absl::time_internal::UnscaledCycleClockWrapperForGetCurrentTime::Now() + ::y_absl::time_internal::UnscaledCycleClockWrapperForGetCurrentTime::Now() #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { // This is a friend wrapper around UnscaledCycleClock::Now() @@ -392,7 +392,7 @@ static uint64_t UpdateLastSample( // into the fast path. That causes lots of register spills and reloads that // are unnecessary unless the slow path is taken. // -// TODO(y_absl-team): Remove this attribute when our compiler is smart enough +// TODO(y_absl-team): Remove this attribute when our compiler is smart enough // to do the right thing. ABSL_ATTRIBUTE_NOINLINE static int64_t GetCurrentTimeNanosSlowPath() @@ -536,31 +536,31 @@ static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns, return estimated_base_ns; } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { // Returns the maximum duration that SleepOnce() can sleep for. -constexpr y_absl::Duration MaxSleep() { +constexpr y_absl::Duration MaxSleep() { #ifdef _WIN32 // Windows Sleep() takes unsigned long argument in milliseconds. - return y_absl::Milliseconds( + return y_absl::Milliseconds( std::numeric_limits<unsigned long>::max()); // NOLINT(runtime/int) #else - return y_absl::Seconds(std::numeric_limits<time_t>::max()); + return y_absl::Seconds(std::numeric_limits<time_t>::max()); #endif } // Sleeps for the given duration. // REQUIRES: to_sleep <= MaxSleep(). -void SleepOnce(y_absl::Duration to_sleep) { +void SleepOnce(y_absl::Duration to_sleep) { #ifdef _WIN32 - Sleep(to_sleep / y_absl::Milliseconds(1)); + Sleep(to_sleep / y_absl::Milliseconds(1)); #else - struct timespec sleep_time = y_absl::ToTimespec(to_sleep); + struct timespec sleep_time = y_absl::ToTimespec(to_sleep); while (nanosleep(&sleep_time, &sleep_time) != 0 && errno == EINTR) { // Ignore signals and wait for the full interval to elapse. } @@ -569,15 +569,15 @@ void SleepOnce(y_absl::Duration to_sleep) { } // namespace ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl extern "C" { ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)( y_absl::Duration duration) { - while (duration > y_absl::ZeroDuration()) { - y_absl::Duration to_sleep = std::min(duration, y_absl::MaxSleep()); - y_absl::SleepOnce(to_sleep); + while (duration > y_absl::ZeroDuration()) { + y_absl::Duration to_sleep = std::min(duration, y_absl::MaxSleep()); + y_absl::SleepOnce(to_sleep); duration -= to_sleep; } } diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h index 7967899b4e..178b96d828 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h @@ -22,36 +22,36 @@ #ifndef ABSL_TIME_CLOCK_H_ #define ABSL_TIME_CLOCK_H_ -#include "y_absl/base/macros.h" -#include "y_absl/time/time.h" +#include "y_absl/base/macros.h" +#include "y_absl/time/time.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // Now() // -// Returns the current time, expressed as an `y_absl::Time` absolute time value. -y_absl::Time Now(); +// Returns the current time, expressed as an `y_absl::Time` absolute time value. +y_absl::Time Now(); // GetCurrentTimeNanos() // // Returns the current time, expressed as a count of nanoseconds since the Unix -// Epoch (https://en.wikipedia.org/wiki/Unix_time). Prefer `y_absl::Now()` instead +// Epoch (https://en.wikipedia.org/wiki/Unix_time). Prefer `y_absl::Now()` instead // for all but the most performance-sensitive cases (i.e. when you are calling // this function hundreds of thousands of times per second). int64_t GetCurrentTimeNanos(); // SleepFor() // -// Sleeps for the specified duration, expressed as an `y_absl::Duration`. +// Sleeps for the specified duration, expressed as an `y_absl::Duration`. // // Notes: // * Signal interruptions will not reduce the sleep duration. // * Returns immediately when passed a nonpositive duration. -void SleepFor(y_absl::Duration duration); +void SleepFor(y_absl::Duration duration); ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl // ----------------------------------------------------------------------------- // Implementation Details @@ -67,7 +67,7 @@ extern "C" { void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(y_absl::Duration duration); } // extern "C" -inline void y_absl::SleepFor(y_absl::Duration duration) { +inline void y_absl::SleepFor(y_absl::Duration duration) { ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(duration); } diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc index 5fad39923d..d4914556e6 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc @@ -12,13 +12,13 @@ // See the License for the specific language governing permissions and // limitations under the License. -// The implementation of the y_absl::Duration class, which is declared in -// //y_absl/time.h. This class behaves like a numeric type; it has no public +// The implementation of the y_absl::Duration class, which is declared in +// //y_absl/time.h. This class behaves like a numeric type; it has no public // methods and is used only through the operators defined here. // // Implementation notes: // -// An y_absl::Duration is represented as +// An y_absl::Duration is represented as // // rep_hi_ : (int64_t) Whole seconds // rep_lo_ : (uint32_t) Fractions of a second @@ -66,14 +66,14 @@ #include <limits> #include <util/generic/string.h> -#include "y_absl/base/casts.h" +#include "y_absl/base/casts.h" #include "y_absl/base/macros.h" -#include "y_absl/numeric/int128.h" +#include "y_absl/numeric/int128.h" #include "y_absl/strings/string_view.h" #include "y_absl/strings/strip.h" -#include "y_absl/time/time.h" +#include "y_absl/time/time.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { @@ -189,9 +189,9 @@ inline Duration MakeDurationFromU128(uint128 u128, bool is_neg) { // bits, and a two's complement representation." So, we can convert to // and from the corresponding uint64_t value using a bit cast. inline uint64_t EncodeTwosComp(int64_t v) { - return y_absl::bit_cast<uint64_t>(v); + return y_absl::bit_cast<uint64_t>(v); } -inline int64_t DecodeTwosComp(uint64_t v) { return y_absl::bit_cast<int64_t>(v); } +inline int64_t DecodeTwosComp(uint64_t v) { return y_absl::bit_cast<int64_t>(v); } // Note: The overflow detection in this function is done using greater/less *or // equal* because kint64max/min is too large to be represented exactly in a @@ -508,12 +508,12 @@ Duration Trunc(Duration d, Duration unit) { } Duration Floor(const Duration d, const Duration unit) { - const y_absl::Duration td = Trunc(d, unit); + const y_absl::Duration td = Trunc(d, unit); return td <= d ? td : td - AbsDuration(unit); } Duration Ceil(const Duration d, const Duration unit) { - const y_absl::Duration td = Trunc(d, unit); + const y_absl::Duration td = Trunc(d, unit); return td >= d ? td : td + AbsDuration(unit); } @@ -723,7 +723,7 @@ ABSL_CONST_INIT const DisplayUnit kDisplayMin = {"m", -1, 0.0}; // prec ignored ABSL_CONST_INIT const DisplayUnit kDisplayHour = {"h", -1, 0.0}; // prec ignored -void AppendNumberUnit(TString* out, int64_t n, DisplayUnit unit) { +void AppendNumberUnit(TString* out, int64_t n, DisplayUnit unit) { char buf[sizeof("2562047788015216")]; // hours in max duration char* const ep = buf + sizeof(buf); char* bp = Format64(ep, 0, n); @@ -735,7 +735,7 @@ void AppendNumberUnit(TString* out, int64_t n, DisplayUnit unit) { // Note: unit.prec is limited to double's digits10 value (typically 15) so it // always fits in buf[]. -void AppendNumberUnit(TString* out, double n, DisplayUnit unit) { +void AppendNumberUnit(TString* out, double n, DisplayUnit unit) { constexpr int kBufferSize = std::numeric_limits<double>::digits10; const int prec = std::min(kBufferSize, unit.prec); char buf[kBufferSize]; // also large enough to hold integer part @@ -765,14 +765,14 @@ void AppendNumberUnit(TString* out, double n, DisplayUnit unit) { // (milli-, micro-, or nanoseconds) to ensure that the leading digit // is non-zero. // Unlike Go, we format the zero duration as 0, with no unit. -TString FormatDuration(Duration d) { +TString FormatDuration(Duration d) { const Duration min_duration = Seconds(kint64min); if (d == min_duration) { // Avoid needing to negate kint64min by directly returning what the // following code should produce in that case. return "-2562047788015215h30m8s"; } - TString s; + TString s; if (d < ZeroDuration()) { s.append("-"); d = -d; @@ -939,16 +939,16 @@ bool ParseDuration(y_absl::string_view dur_sv, Duration* d) { return true; } -bool AbslParseFlag(y_absl::string_view text, Duration* dst, TString*) { +bool AbslParseFlag(y_absl::string_view text, Duration* dst, TString*) { return ParseDuration(text, dst); } -TString AbslUnparseFlag(Duration d) { return FormatDuration(d); } -bool ParseFlag(const TString& text, Duration* dst, TString* ) { +TString AbslUnparseFlag(Duration d) { return FormatDuration(d); } +bool ParseFlag(const TString& text, Duration* dst, TString* ) { return ParseDuration(text, dst); } -TString UnparseFlag(Duration d) { return FormatDuration(d); } +TString UnparseFlag(Duration d) { return FormatDuration(d); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc index 002e84c12e..c75e4ec21a 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc @@ -19,12 +19,12 @@ #include "y_absl/strings/match.h" #include "y_absl/strings/string_view.h" -#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" -#include "y_absl/time/time.h" +#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" +#include "y_absl/time/time.h" -namespace cctz = y_absl::time_internal::cctz; +namespace cctz = y_absl::time_internal::cctz; -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN ABSL_DLL extern const char RFC3339_full[] = "%Y-%m-%d%ET%H:%M:%E*S%Ez"; @@ -51,7 +51,7 @@ inline cctz::time_point<cctz::seconds> unix_epoch() { // Splits a Time into seconds and femtoseconds, which can be used with CCTZ. // Requires that 't' is finite. See duration.cc for details about rep_hi and // rep_lo. -cctz_parts Split(y_absl::Time t) { +cctz_parts Split(y_absl::Time t) { const auto d = time_internal::ToUnixDuration(t); const int64_t rep_hi = time_internal::GetRepHi(d); const int64_t rep_lo = time_internal::GetRepLo(d); @@ -62,7 +62,7 @@ cctz_parts Split(y_absl::Time t) { // Joins the given seconds and femtoseconds into a Time. See duration.cc for // details about rep_hi and rep_lo. -y_absl::Time Join(const cctz_parts& parts) { +y_absl::Time Join(const cctz_parts& parts) { const int64_t rep_hi = (parts.sec - unix_epoch()).count(); const uint32_t rep_lo = parts.fem.count() / (1000 * 1000 / 4); const auto d = time_internal::MakeDuration(rep_hi, rep_lo); @@ -72,7 +72,7 @@ y_absl::Time Join(const cctz_parts& parts) { } // namespace TString FormatTime(y_absl::string_view format, y_absl::Time t, - y_absl::TimeZone tz) { + y_absl::TimeZone tz) { if (t == y_absl::InfiniteFuture()) return TString(kInfiniteFutureStr); if (t == y_absl::InfinitePast()) return TString(kInfinitePastStr); const auto parts = Split(t); @@ -80,23 +80,23 @@ TString FormatTime(y_absl::string_view format, y_absl::Time t, cctz::time_zone(tz)); } -TString FormatTime(y_absl::Time t, y_absl::TimeZone tz) { +TString FormatTime(y_absl::Time t, y_absl::TimeZone tz) { return FormatTime(RFC3339_full, t, tz); } -TString FormatTime(y_absl::Time t) { - return y_absl::FormatTime(RFC3339_full, t, y_absl::LocalTimeZone()); +TString FormatTime(y_absl::Time t) { + return y_absl::FormatTime(RFC3339_full, t, y_absl::LocalTimeZone()); } bool ParseTime(y_absl::string_view format, y_absl::string_view input, - y_absl::Time* time, TString* err) { - return y_absl::ParseTime(format, input, y_absl::UTCTimeZone(), time, err); + y_absl::Time* time, TString* err) { + return y_absl::ParseTime(format, input, y_absl::UTCTimeZone(), time, err); } // If the input string does not contain an explicit UTC offset, interpret // the fields with respect to the given TimeZone. bool ParseTime(y_absl::string_view format, y_absl::string_view input, - y_absl::TimeZone tz, y_absl::Time* time, TString* err) { + y_absl::TimeZone tz, y_absl::Time* time, TString* err) { auto strip_leading_space = [](y_absl::string_view* sv) { while (!sv->empty()) { if (!std::isspace(sv->front())) return; @@ -127,7 +127,7 @@ bool ParseTime(y_absl::string_view format, y_absl::string_view input, } } - TString error; + TString error; cctz_parts parts; const bool b = cctz::detail::parse(TString(format), TString(input), @@ -140,21 +140,21 @@ bool ParseTime(y_absl::string_view format, y_absl::string_view input, return b; } -// Functions required to support y_absl::Time flags. -bool AbslParseFlag(y_absl::string_view text, y_absl::Time* t, TString* error) { +// Functions required to support y_absl::Time flags. +bool AbslParseFlag(y_absl::string_view text, y_absl::Time* t, TString* error) { return y_absl::ParseTime(RFC3339_full, text, y_absl::UTCTimeZone(), t, error); } -TString AbslUnparseFlag(y_absl::Time t) { - return y_absl::FormatTime(RFC3339_full, t, y_absl::UTCTimeZone()); +TString AbslUnparseFlag(y_absl::Time t) { + return y_absl::FormatTime(RFC3339_full, t, y_absl::UTCTimeZone()); } -bool ParseFlag(const TString& text, y_absl::Time* t, TString* error) { - return y_absl::ParseTime(RFC3339_full, text, y_absl::UTCTimeZone(), t, error); +bool ParseFlag(const TString& text, y_absl::Time* t, TString* error) { + return y_absl::ParseTime(RFC3339_full, text, y_absl::UTCTimeZone(), t, error); } -TString UnparseFlag(y_absl::Time t) { - return y_absl::FormatTime(RFC3339_full, t, y_absl::UTCTimeZone()); +TString UnparseFlag(y_absl::Time t) { + return y_absl::FormatTime(RFC3339_full, t, y_absl::UTCTimeZone()); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time.h index 1920bb56d4..be60a54dbe 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time.h @@ -16,9 +16,9 @@ #define ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_ #include "y_absl/base/config.h" -#include "y_absl/time/internal/cctz/include/cctz/civil_time_detail.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time_detail.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -327,6 +327,6 @@ using detail::get_yearday; } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h index 4ae30f24e8..0e71a7cd33 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h @@ -33,7 +33,7 @@ #define CONSTEXPR_M #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -619,7 +619,7 @@ std::ostream& operator<<(std::ostream& os, weekday wd); } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #undef CONSTEXPR_M #undef CONSTEXPR_F diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h index b61238b716..524654df4b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h @@ -27,9 +27,9 @@ #include <utility> #include "y_absl/base/config.h" -#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -71,7 +71,7 @@ class time_zone { time_zone(const time_zone&) = default; time_zone& operator=(const time_zone&) = default; - TString name() const; + TString name() const; // An absolute_lookup represents the civil time (cctz::civil_second) within // this time_zone at the given absolute time (time_point). There are @@ -203,8 +203,8 @@ class time_zone { // empty when unavailable. // // Note: These functions are for informational or testing purposes only. - TString version() const; // empty when unknown - TString description() const; + TString version() const; // empty when unknown + TString description() const; // Relational operators. friend bool operator==(time_zone lhs, time_zone rhs) { @@ -228,7 +228,7 @@ class time_zone { // Loads the named time zone. May perform I/O on the initial load. // If the name is invalid, or some other kind of error occurs, returns // false and "*tz" is set to the UTC time zone. -bool load_time_zone(const TString& name, time_zone* tz); +bool load_time_zone(const TString& name, time_zone* tz); // Returns a time_zone representing UTC. Cannot fail. time_zone utc_time_zone(); @@ -265,10 +265,10 @@ inline time_point<seconds> convert(const civil_second& cs, namespace detail { using femtoseconds = std::chrono::duration<std::int_fast64_t, std::femto>; -TString format(const TString&, const time_point<seconds>&, +TString format(const TString&, const time_point<seconds>&, const femtoseconds&, const time_zone&); -bool parse(const TString&, const TString&, const time_zone&, - time_point<seconds>*, femtoseconds*, TString* err = nullptr); +bool parse(const TString&, const TString&, const time_zone&, + time_point<seconds>*, femtoseconds*, TString* err = nullptr); template <typename Rep, std::intmax_t Denom> bool join_seconds( const time_point<seconds>& sec, const femtoseconds& fs, @@ -312,10 +312,10 @@ bool join_seconds(const time_point<seconds>& sec, const femtoseconds&, // cctz::time_zone lax; // if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... } // auto tp = cctz::convert(cctz::civil_second(2013, 1, 2, 3, 4, 5), lax); -// TString f = cctz::format("%H:%M:%S", tp, lax); // "03:04:05" +// TString f = cctz::format("%H:%M:%S", tp, lax); // "03:04:05" // f = cctz::format("%H:%M:%E3S", tp, lax); // "03:04:05.000" template <typename D> -inline TString format(const TString& fmt, const time_point<D>& tp, +inline TString format(const TString& fmt, const time_point<D>& tp, const time_zone& tz) { const auto p = detail::split_seconds(tp); const auto n = std::chrono::duration_cast<detail::femtoseconds>(p.second); @@ -369,7 +369,7 @@ inline TString format(const TString& fmt, const time_point<D>& tp, // ... // } template <typename D> -inline bool parse(const TString& fmt, const TString& input, +inline bool parse(const TString& fmt, const TString& input, const time_zone& tz, time_point<D>* tpp) { time_point<seconds> sec; detail::femtoseconds fs; @@ -454,6 +454,6 @@ inline bool join_seconds(const time_point<seconds>& sec, const femtoseconds&, } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h index a332809c1d..fd6dc4bbb0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h @@ -18,11 +18,11 @@ #include <cstddef> #include <functional> #include <memory> -#include <util/generic/string.h> - +#include <util/generic/string.h> + #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -38,15 +38,15 @@ class ZoneInfoSource { // Until the zoneinfo data supports versioning information, we provide // a way for a ZoneInfoSource to indicate it out-of-band. The default // implementation returns an empty string. - virtual TString Version() const; + virtual TString Version() const; }; } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz_extension { @@ -55,8 +55,8 @@ namespace cctz_extension { // given the name of a time zone and a fallback factory. Returns null // when the data for the named zone cannot be found. using ZoneInfoSourceFactory = - std::unique_ptr<y_absl::time_internal::cctz::ZoneInfoSource> (*)( - const TString&, + std::unique_ptr<y_absl::time_internal::cctz::ZoneInfoSource> (*)( + const TString&, const std::function<std::unique_ptr< y_absl::time_internal::cctz::ZoneInfoSource>(const TString&)>&); @@ -69,9 +69,9 @@ using ZoneInfoSourceFactory = // namespace cctz_extension { // namespace { // std::unique_ptr<cctz::ZoneInfoSource> CustomFactory( -// const TString& name, +// const TString& name, // const std::function<std::unique_ptr<cctz::ZoneInfoSource>( -// const TString& name)>& fallback_factory) { +// const TString& name)>& fallback_factory) { // if (auto zip = my_factory(name)) return zip; // if (auto zip = fallback_factory(name)) return zip; // if (auto zip = my_other_factory(name)) return zip; @@ -97,6 +97,6 @@ extern ZoneInfoSourceFactory zone_info_source_factory; } // namespace cctz_extension } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/civil_time_detail.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/civil_time_detail.cc index d7e1efceb7..61dbfc96ab 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/civil_time_detail.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/civil_time_detail.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/time/internal/cctz/include/cctz/civil_time_detail.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time_detail.h" #include <iomanip> #include <ostream> @@ -20,7 +20,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -91,4 +91,4 @@ std::ostream& operator<<(std::ostream& os, weekday wd) { } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.cc index 064abe41a8..3a22cbea1d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.cc @@ -22,7 +22,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -52,7 +52,7 @@ int Parse02d(const char* p) { } // namespace -bool FixedOffsetFromName(const TString& name, seconds* offset) { +bool FixedOffsetFromName(const TString& name, seconds* offset) { if (name == "UTC" || name == "UTC0") { *offset = seconds::zero(); return true; @@ -81,7 +81,7 @@ bool FixedOffsetFromName(const TString& name, seconds* offset) { return true; } -TString FixedOffsetToName(const seconds& offset) { +TString FixedOffsetToName(const seconds& offset) { if (offset == seconds::zero()) return "UTC"; if (offset < std::chrono::hours(-24) || offset > std::chrono::hours(24)) { // We don't support fixed-offset zones more than 24 hours @@ -117,8 +117,8 @@ TString FixedOffsetToName(const seconds& offset) { return buf; } -TString FixedOffsetToAbbr(const seconds& offset) { - TString abbr = FixedOffsetToName(offset); +TString FixedOffsetToAbbr(const seconds& offset) { + TString abbr = FixedOffsetToName(offset); const std::size_t prefix_len = sizeof(kFixedZonePrefix) - 1; if (abbr.size() == prefix_len + 9) { // <prefix>+99:99:99 abbr.erase(0, prefix_len); // +99:99:99 @@ -137,4 +137,4 @@ TString FixedOffsetToAbbr(const seconds& offset) { } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.h index b5b6011d68..39b24e5a32 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.h @@ -18,9 +18,9 @@ #include <util/generic/string.h> #include "y_absl/base/config.h" -#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" +#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -40,13 +40,13 @@ namespace cctz { // Note: FixedOffsetFromName() fails on syntax errors or when the parsed // offset exceeds 24 hours. FixedOffsetToName() and FixedOffsetToAbbr() // both produce "UTC" when the argument offset exceeds 24 hours. -bool FixedOffsetFromName(const TString& name, seconds* offset); -TString FixedOffsetToName(const seconds& offset); -TString FixedOffsetToAbbr(const seconds& offset); +bool FixedOffsetFromName(const TString& name, seconds* offset); +TString FixedOffsetToName(const seconds& offset); +TString FixedOffsetToAbbr(const seconds& offset); } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc index 757507aee5..2f9597018b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc @@ -25,7 +25,7 @@ #endif #include "y_absl/base/config.h" -#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" +#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" // Include time.h directly since, by C++ standards, ctime doesn't have to // declare strptime. @@ -45,10 +45,10 @@ #include <sstream> #endif -#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" #include "time_zone_if.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -212,7 +212,7 @@ char* FormatOffset(char* ep, int offset, const char* mode) { } // Formats a std::tm using strftime(3). -void FormatTM(TString* out, const TString& fmt, const std::tm& tm) { +void FormatTM(TString* out, const TString& fmt, const std::tm& tm) { // strftime(3) returns the number of characters placed in the output // array (which may be 0 characters). It also returns 0 to indicate // an error, like the array wasn't large enough. To accommodate this, @@ -330,9 +330,9 @@ const std::int_fast64_t kExp10[kDigits10_64 + 1] = { // not support the tm_gmtoff and tm_zone extensions to std::tm. // // Requires that zero() <= fs < seconds(1). -TString format(const TString& format, const time_point<seconds>& tp, +TString format(const TString& format, const time_point<seconds>& tp, const detail::femtoseconds& fs, const time_zone& tz) { - TString result; + TString result; result.reserve(format.size()); // A reasonable guess for the result size. const time_zone::absolute_lookup al = tz.lookup(tp); const std::tm tm = ToTM(al); @@ -384,7 +384,7 @@ TString format(const TString& format, const time_point<seconds>& tp, // Simple specifiers that we handle ourselves. if (strchr("YmdeUuWwHMSzZs%", *cur)) { if (cur - 1 != pending) { - FormatTM(&result, TString(pending, cur - 1), tm); + FormatTM(&result, TString(pending, cur - 1), tm); } switch (*cur) { case 'Y': @@ -455,7 +455,7 @@ TString format(const TString& format, const time_point<seconds>& tp, if (*(cur + 1) == 'z') { // Formats %:z. if (cur - 1 != pending) { - FormatTM(&result, TString(pending, cur - 1), tm); + FormatTM(&result, TString(pending, cur - 1), tm); } bp = FormatOffset(ep, al.offset, ":"); result.append(bp, static_cast<std::size_t>(ep - bp)); @@ -466,7 +466,7 @@ TString format(const TString& format, const time_point<seconds>& tp, if (*(cur + 2) == 'z') { // Formats %::z. if (cur - 1 != pending) { - FormatTM(&result, TString(pending, cur - 1), tm); + FormatTM(&result, TString(pending, cur - 1), tm); } bp = FormatOffset(ep, al.offset, ":*"); result.append(bp, static_cast<std::size_t>(ep - bp)); @@ -477,7 +477,7 @@ TString format(const TString& format, const time_point<seconds>& tp, if (*(cur + 3) == 'z') { // Formats %:::z. if (cur - 1 != pending) { - FormatTM(&result, TString(pending, cur - 1), tm); + FormatTM(&result, TString(pending, cur - 1), tm); } bp = FormatOffset(ep, al.offset, ":*:"); result.append(bp, static_cast<std::size_t>(ep - bp)); @@ -502,7 +502,7 @@ TString format(const TString& format, const time_point<seconds>& tp, } else if (*cur == 'z') { // Formats %Ez. if (cur - 2 != pending) { - FormatTM(&result, TString(pending, cur - 2), tm); + FormatTM(&result, TString(pending, cur - 2), tm); } bp = FormatOffset(ep, al.offset, ":"); result.append(bp, static_cast<std::size_t>(ep - bp)); @@ -510,7 +510,7 @@ TString format(const TString& format, const time_point<seconds>& tp, } else if (*cur == '*' && cur + 1 != end && *(cur + 1) == 'z') { // Formats %E*z. if (cur - 2 != pending) { - FormatTM(&result, TString(pending, cur - 2), tm); + FormatTM(&result, TString(pending, cur - 2), tm); } bp = FormatOffset(ep, al.offset, ":*"); result.append(bp, static_cast<std::size_t>(ep - bp)); @@ -519,7 +519,7 @@ TString format(const TString& format, const time_point<seconds>& tp, (*(cur + 1) == 'S' || *(cur + 1) == 'f')) { // Formats %E*S or %E*F. if (cur - 2 != pending) { - FormatTM(&result, TString(pending, cur - 2), tm); + FormatTM(&result, TString(pending, cur - 2), tm); } char* cp = ep; bp = Format64(cp, 15, fs.count()); @@ -538,7 +538,7 @@ TString format(const TString& format, const time_point<seconds>& tp, } else if (*cur == '4' && cur + 1 != end && *(cur + 1) == 'Y') { // Formats %E4Y. if (cur - 2 != pending) { - FormatTM(&result, TString(pending, cur - 2), tm); + FormatTM(&result, TString(pending, cur - 2), tm); } bp = Format64(ep, 4, al.cs.year()); result.append(bp, static_cast<std::size_t>(ep - bp)); @@ -550,7 +550,7 @@ TString format(const TString& format, const time_point<seconds>& tp, if (*np == 'S' || *np == 'f') { // Formats %E#S or %E#f. if (cur - 2 != pending) { - FormatTM(&result, TString(pending, cur - 2), tm); + FormatTM(&result, TString(pending, cur - 2), tm); } bp = ep; if (n > 0) { @@ -570,7 +570,7 @@ TString format(const TString& format, const time_point<seconds>& tp, // Formats any remaining data. if (end != pending) { - FormatTM(&result, TString(pending, end), tm); + FormatTM(&result, TString(pending, end), tm); } return result; @@ -611,7 +611,7 @@ const char* ParseOffset(const char* dp, const char* mode, int* offset) { return dp; } -const char* ParseZone(const char* dp, TString* zone) { +const char* ParseZone(const char* dp, TString* zone) { zone->clear(); if (dp != nullptr) { while (*dp != '\0' && !std::isspace(*dp)) zone->push_back(*dp++); @@ -689,9 +689,9 @@ bool FromWeek(int week_num, weekday week_start, year_t* year, std::tm* tm) { // // We also handle the %z specifier to accommodate platforms that do not // support the tm_gmtoff extension to std::tm. %Z is parsed but ignored. -bool parse(const TString& format, const TString& input, +bool parse(const TString& format, const TString& input, const time_zone& tz, time_point<seconds>* sec, - detail::femtoseconds* fs, TString* err) { + detail::femtoseconds* fs, TString* err) { // The unparsed input. const char* data = input.c_str(); // NUL terminated @@ -717,7 +717,7 @@ bool parse(const TString& format, const TString& input, auto subseconds = detail::femtoseconds::zero(); bool saw_offset = false; int offset = 0; // No offset from passed tz. - TString zone = "UTC"; + TString zone = "UTC"; const char* fmt = format.c_str(); // NUL terminated bool twelve_hour = false; @@ -908,7 +908,7 @@ bool parse(const TString& format, const TString& input, // Parses the current specifier. const char* orig_data = data; - TString spec(percent, static_cast<std::size_t>(fmt - percent)); + TString spec(percent, static_cast<std::size_t>(fmt - percent)); data = ParseTM(data, spec.c_str(), &tm); // If we successfully parsed %p we need to remember whether the result @@ -916,7 +916,7 @@ bool parse(const TString& format, const TString& input, // So reparse the input with a known AM hour, and check if it is shifted // to a PM hour. if (spec == "%p" && data != nullptr) { - TString test_input = "1"; + TString test_input = "1"; test_input.append(orig_data, static_cast<std::size_t>(data - orig_data)); const char* test_data = test_input.c_str(); std::tm tmp{}; @@ -1026,4 +1026,4 @@ bool parse(const TString& format, const TString& input, } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.cc index cbd9d6f9e0..2fe6d23c71 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.cc @@ -18,12 +18,12 @@ #include "time_zone_info.h" #include "time_zone_libc.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { -std::unique_ptr<TimeZoneIf> TimeZoneIf::Load(const TString& name) { +std::unique_ptr<TimeZoneIf> TimeZoneIf::Load(const TString& name) { // Support "libc:localtime" and "libc:*" to access the legacy // localtime and UTC support respectively from the C library. if (name.compare(0, 5, "libc:") == 0) { @@ -42,4 +42,4 @@ TimeZoneIf::~TimeZoneIf() {} } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.h index 5350c94c4f..10312badc2 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.h @@ -21,10 +21,10 @@ #include <util/generic/string.h> #include "y_absl/base/config.h" -#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" -#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" +#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -34,7 +34,7 @@ namespace cctz { class TimeZoneIf { public: // A factory function for TimeZoneIf implementations. - static std::unique_ptr<TimeZoneIf> Load(const TString& name); + static std::unique_ptr<TimeZoneIf> Load(const TString& name); virtual ~TimeZoneIf(); @@ -47,8 +47,8 @@ class TimeZoneIf { virtual bool PrevTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const = 0; - virtual TString Version() const = 0; - virtual TString Description() const = 0; + virtual TString Version() const = 0; + virtual TString Description() const = 0; protected: TimeZoneIf() {} @@ -72,6 +72,6 @@ inline time_point<seconds> FromUnixSeconds(std::int_fast64_t t) { } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc index e9a17011ad..3810defe3c 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc @@ -24,7 +24,7 @@ #include "y_absl/base/config.h" #include "time_zone_fixed.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -33,7 +33,7 @@ namespace { // time_zone::Impls are linked into a map to support fast lookup by name. using TimeZoneImplByName = - std::unordered_map<TString, const time_zone::Impl*>; + std::unordered_map<TString, const time_zone::Impl*>; TimeZoneImplByName* time_zone_map = nullptr; // Mutual exclusion for time_zone_map. @@ -48,7 +48,7 @@ std::mutex& TimeZoneMutex() { time_zone time_zone::Impl::UTC() { return time_zone(UTCImpl()); } -bool time_zone::Impl::LoadTimeZone(const TString& name, time_zone* tz) { +bool time_zone::Impl::LoadTimeZone(const TString& name, time_zone* tz) { const Impl* const utc_impl = UTCImpl(); // Check for UTC (which is never a key in time_zone_map). @@ -110,4 +110,4 @@ const time_zone::Impl* time_zone::Impl::UTCImpl() { } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h index 06f4234ced..c014ab41df 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h @@ -19,12 +19,12 @@ #include <util/generic/string.h> #include "y_absl/base/config.h" -#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" -#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" +#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" #include "time_zone_if.h" #include "time_zone_info.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -37,14 +37,14 @@ class time_zone::Impl { // Load a named time zone. Returns false if the name is invalid, or if // some other kind of error occurs. Note that loading "UTC" never fails. - static bool LoadTimeZone(const TString& name, time_zone* tz); + static bool LoadTimeZone(const TString& name, time_zone* tz); // Clears the map of cached time zones. Primarily for use in benchmarks // that gauge the performance of loading/parsing the time-zone data. static void ClearTimeZoneMapTestOnly(); // The primary key is the time-zone ID (e.g., "America/New_York"). - const TString& Name() const { + const TString& Name() const { // TODO: It would nice if the zoneinfo data included the zone name. return name_; } @@ -72,22 +72,22 @@ class time_zone::Impl { } // Returns an implementation-defined version string for this time zone. - TString Version() const { return zone_->Version(); } + TString Version() const { return zone_->Version(); } // Returns an implementation-defined description of this time zone. - TString Description() const { return zone_->Description(); } + TString Description() const { return zone_->Description(); } private: - explicit Impl(const TString& name); + explicit Impl(const TString& name); static const Impl* UTCImpl(); - const TString name_; + const TString name_; std::unique_ptr<TimeZoneIf> zone_; }; } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc index a63cbdaa0c..72f7bdc3ca 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc @@ -47,11 +47,11 @@ #include <utility> #include "y_absl/base/config.h" -#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" #include "time_zone_fixed.h" #include "time_zone_posix.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -595,7 +595,7 @@ inline FilePtr FOpen(const char* path, const char* mode) { // A stdio(3)-backed implementation of ZoneInfoSource. class FileZoneInfoSource : public ZoneInfoSource { public: - static std::unique_ptr<ZoneInfoSource> Open(const TString& name); + static std::unique_ptr<ZoneInfoSource> Open(const TString& name); std::size_t Read(void* ptr, std::size_t size) override { size = std::min(size, len_); @@ -609,9 +609,9 @@ class FileZoneInfoSource : public ZoneInfoSource { if (rc == 0) len_ -= offset; return rc; } - TString Version() const override { + TString Version() const override { // TODO: It would nice if the zoneinfo data included the tzdb version. - return TString(); + return TString(); } protected: @@ -625,12 +625,12 @@ class FileZoneInfoSource : public ZoneInfoSource { }; std::unique_ptr<ZoneInfoSource> FileZoneInfoSource::Open( - const TString& name) { + const TString& name) { // Use of the "file:" prefix is intended for testing purposes only. const std::size_t pos = (name.compare(0, 5, "file:") == 0) ? 5 : 0; // Map the time-zone name to a path name. - TString path; + TString path; if (pos == name.size() || name[pos] != '/') { const char* tzdir = "/usr/share/zoneinfo"; char* tzdir_env = nullptr; @@ -646,7 +646,7 @@ std::unique_ptr<ZoneInfoSource> FileZoneInfoSource::Open( free(tzdir_env); #endif } - path.append(name, pos, TString::npos); + path.append(name, pos, TString::npos); // Open the zoneinfo file. auto fp = FOpen(path.c_str(), "rb"); @@ -656,18 +656,18 @@ std::unique_ptr<ZoneInfoSource> FileZoneInfoSource::Open( class AndroidZoneInfoSource : public FileZoneInfoSource { public: - static std::unique_ptr<ZoneInfoSource> Open(const TString& name); - TString Version() const override { return version_; } + static std::unique_ptr<ZoneInfoSource> Open(const TString& name); + TString Version() const override { return version_; } private: explicit AndroidZoneInfoSource(FilePtr fp, std::size_t len, TString version) : FileZoneInfoSource(std::move(fp), len), version_(std::move(version)) {} - TString version_; + TString version_; }; std::unique_ptr<ZoneInfoSource> AndroidZoneInfoSource::Open( - const TString& name) { + const TString& name) { // Use of the "file:" prefix is intended for testing purposes only. const std::size_t pos = (name.compare(0, 5, "file:") == 0) ? 5 : 0; @@ -774,7 +774,7 @@ std::unique_ptr<ZoneInfoSource> FuchsiaZoneInfoSource::Open( } // namespace -bool TimeZoneInfo::Load(const TString& name) { +bool TimeZoneInfo::Load(const TString& name) { // We can ensure that the loading of UTC or any other fixed-offset // zone never fails because the simple, fixed-offset state can be // internally generated. Note that this depends on our choice to not @@ -812,7 +812,7 @@ time_zone::absolute_lookup TimeZoneInfo::LocalTime(std::int_fast64_t unix_time, // Note: (unix_time - tr.unix_time) will never overflow as we // have ensured that there is always a "nearby" transition. return {tr.civil_sec + (unix_time - tr.unix_time), // TODO: Optimize. - tt.utc_offset, tt.is_dst, &*abbreviations_.begin() + tt.abbr_index}; + tt.utc_offset, tt.is_dst, &*abbreviations_.begin() + tt.abbr_index}; } // MakeTime() translation with a conversion-preserving +N * 400-year shift. @@ -952,12 +952,12 @@ time_zone::civil_lookup TimeZoneInfo::MakeTime(const civil_second& cs) const { TString TimeZoneInfo::Version() const { return version_; } -TString TimeZoneInfo::Description() const { +TString TimeZoneInfo::Description() const { std::ostringstream oss; oss << "#trans=" << transitions_.size(); oss << " #types=" << transition_types_.size(); oss << " spec='" << future_spec_ << "'"; - return oss.str().c_str(); + return oss.str().c_str(); } bool TimeZoneInfo::NextTransition(const time_point<seconds>& tp, @@ -1024,4 +1024,4 @@ bool TimeZoneInfo::PrevTransition(const time_point<seconds>& tp, } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h index 9963f8228e..e55fd51847 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h @@ -22,13 +22,13 @@ #include <vector> #include "y_absl/base/config.h" -#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" -#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" -#include "y_absl/time/internal/cctz/include/cctz/zone_info_source.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" +#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" +#include "y_absl/time/internal/cctz/include/cctz/zone_info_source.h" #include "time_zone_if.h" #include "tzfile.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -69,7 +69,7 @@ class TimeZoneInfo : public TimeZoneIf { TimeZoneInfo& operator=(const TimeZoneInfo&) = delete; // Loads the zoneinfo for the given name, returning true if successful. - bool Load(const TString& name); + bool Load(const TString& name); // TimeZoneIf implementations. time_zone::absolute_lookup BreakTime( @@ -79,8 +79,8 @@ class TimeZoneInfo : public TimeZoneIf { time_zone::civil_transition* trans) const override; bool PrevTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const override; - TString Version() const override; - TString Description() const override; + TString Version() const override; + TString Description() const override; private: struct Header { // counts of: @@ -115,10 +115,10 @@ class TimeZoneInfo : public TimeZoneIf { std::vector<Transition> transitions_; // ordered by unix_time and civil_sec std::vector<TransitionType> transition_types_; // distinct transition types std::uint_fast8_t default_transition_type_; // for before first transition - TString abbreviations_; // all the NUL-terminated abbreviations + TString abbreviations_; // all the NUL-terminated abbreviations - TString version_; // the tzdata version if available - TString future_spec_; // for after the last zic transition + TString version_; // the tzdata version if available + TString future_spec_; // for after the last zic transition bool extended_; // future_spec_ was used to generate transitions year_t last_year_; // the final year of the generated transitions @@ -132,6 +132,6 @@ class TimeZoneInfo : public TimeZoneIf { } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc index eec20c9dce..a73832fc29 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc @@ -24,8 +24,8 @@ #include <utility> #include "y_absl/base/config.h" -#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" -#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" +#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" #if defined(_AIX) extern "C" { @@ -33,7 +33,7 @@ extern long altzone; } #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -183,7 +183,7 @@ std::time_t find_trans(std::time_t lo, std::time_t hi, int offset) { } // namespace -TimeZoneLibC::TimeZoneLibC(const TString& name) +TimeZoneLibC::TimeZoneLibC(const TString& name) : local_(name == "localtime") {} time_zone::absolute_lookup TimeZoneLibC::BreakTime( @@ -301,15 +301,15 @@ bool TimeZoneLibC::PrevTransition(const time_point<seconds>&, return false; } -TString TimeZoneLibC::Version() const { - return TString(); // unknown +TString TimeZoneLibC::Version() const { + return TString(); // unknown } -TString TimeZoneLibC::Description() const { +TString TimeZoneLibC::Description() const { return local_ ? "localtime" : "UTC"; } } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.h index a883c41c0c..fc926fecf7 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.h @@ -20,7 +20,7 @@ #include "y_absl/base/config.h" #include "time_zone_if.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -30,7 +30,7 @@ namespace cctz { // TODO: Add support for fixed offsets from UTC. class TimeZoneLibC : public TimeZoneIf { public: - explicit TimeZoneLibC(const TString& name); + explicit TimeZoneLibC(const TString& name); // TimeZoneIf implementations. time_zone::absolute_lookup BreakTime( @@ -40,8 +40,8 @@ class TimeZoneLibC : public TimeZoneIf { time_zone::civil_transition* trans) const override; bool PrevTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const override; - TString Version() const override; - TString Description() const override; + TString Version() const override; + TString Description() const override; private: const bool local_; // localtime or UTC @@ -50,6 +50,6 @@ class TimeZoneLibC : public TimeZoneIf { } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_lookup.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_lookup.cc index 4703076697..92c9208d6d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_lookup.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_lookup.cc @@ -13,7 +13,7 @@ // limitations under the License. #include "y_absl/base/config.h" -#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" +#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" #if defined(__ANDROID__) #include <sys/system_properties.h> @@ -42,7 +42,7 @@ #include "time_zone_fixed.h" #include "time_zone_impl.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -99,7 +99,7 @@ bool time_zone::prev_transition(const time_point<seconds>& tp, TString time_zone::version() const { return effective_impl().Version(); } -TString time_zone::description() const { +TString time_zone::description() const { return effective_impl().Description(); } @@ -112,7 +112,7 @@ const time_zone::Impl& time_zone::effective_impl() const { return *impl_; } -bool load_time_zone(const TString& name, time_zone* tz) { +bool load_time_zone(const TString& name, time_zone* tz) { return time_zone::Impl::LoadTimeZone(name, tz); } @@ -216,7 +216,7 @@ time_zone local_time_zone() { if (localtime_env) zone = localtime_env; } - const TString name = zone; + const TString name = zone; #if defined(_MSC_VER) free(localtime_env); free(tz_env); @@ -233,4 +233,4 @@ time_zone local_time_zone() { } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.cc index 764d0567fd..4096503915 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.cc @@ -21,7 +21,7 @@ #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -48,7 +48,7 @@ const char* ParseInt(const char* p, int min, int max, int* vp) { } // abbr = <.*?> | [^-+,\d]{3,} -const char* ParseAbbr(const char* p, TString* abbr) { +const char* ParseAbbr(const char* p, TString* abbr) { const char* op = p; if (*p == '<') { // special zoneinfo <...> form while (*++p != '>') { @@ -133,7 +133,7 @@ const char* ParseDateTime(const char* p, PosixTransition* res) { } // namespace // spec = std offset [ dst [ offset ] , datetime , datetime ] -bool ParsePosixSpec(const TString& spec, PosixTimeZone* res) { +bool ParsePosixSpec(const TString& spec, PosixTimeZone* res) { const char* p = spec.c_str(); if (*p == ':') return false; @@ -156,4 +156,4 @@ bool ParsePosixSpec(const TString& spec, PosixTimeZone* res) { } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.h index 3885eee12f..e9de2b77ad 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.h @@ -53,11 +53,11 @@ #define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_ #include <cstdint> -#include <util/generic/string.h> - +#include <util/generic/string.h> + #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { @@ -109,10 +109,10 @@ struct PosixTransition { // are not ordered---in the southern hemisphere the transition to end // daylight time occurs first in any particular year. struct PosixTimeZone { - TString std_abbr; + TString std_abbr; std::int_fast32_t std_offset; - TString dst_abbr; + TString dst_abbr; std::int_fast32_t dst_offset; PosixTransition dst_start; PosixTransition dst_end; @@ -122,11 +122,11 @@ struct PosixTimeZone { // filling in any missing values (DST offset, or start/end transition times) // with the standard-defined defaults. Returns false if the specification // could not be parsed (although some fields of *res may have been altered). -bool ParsePosixSpec(const TString& spec, PosixTimeZone* res); +bool ParsePosixSpec(const TString& spec, PosixTimeZone* res); } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/zone_info_source.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/zone_info_source.cc index b20d04e2b1..be58c20fb3 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/zone_info_source.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/zone_info_source.cc @@ -12,25 +12,25 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/time/internal/cctz/include/cctz/zone_info_source.h" +#include "y_absl/time/internal/cctz/include/cctz/zone_info_source.h" #include "y_absl/base/config.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz { // Defined out-of-line to avoid emitting a weak vtable in all TUs. ZoneInfoSource::~ZoneInfoSource() {} -TString ZoneInfoSource::Version() const { return TString(); } +TString ZoneInfoSource::Version() const { return TString(); } } // namespace cctz } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { namespace cctz_extension { @@ -39,8 +39,8 @@ namespace { // A default for cctz_extension::zone_info_source_factory, which simply // defers to the fallback factory. -std::unique_ptr<y_absl::time_internal::cctz::ZoneInfoSource> DefaultFactory( - const TString& name, +std::unique_ptr<y_absl::time_internal::cctz::ZoneInfoSource> DefaultFactory( + const TString& name, const std::function< std::unique_ptr<y_absl::time_internal::cctz::ZoneInfoSource>( const TString& name)>& fallback_factory) { @@ -112,4 +112,4 @@ ZoneInfoSourceFactory zone_info_source_factory = DefaultFactory; } // namespace cctz_extension } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_chrono.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_chrono.inc index f6525376b4..ef28e97e5a 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_chrono.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_chrono.inc @@ -15,7 +15,7 @@ #include <chrono> #include <cstdint> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { @@ -28,4 +28,4 @@ static int64_t GetCurrentTimeNanosFromSystem() { } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_posix.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_posix.inc index ecd4b661a4..1068fea026 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_posix.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_posix.inc @@ -1,12 +1,12 @@ -#include "y_absl/time/clock.h" +#include "y_absl/time/clock.h" #include <sys/time.h> #include <ctime> #include <cstdint> -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/internal/raw_logging.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { @@ -21,4 +21,4 @@ static int64_t GetCurrentTimeNanosFromSystem() { } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/test_util.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/test_util.h index 6c463ed4d8..22b991b836 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/test_util.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/test_util.h @@ -17,17 +17,17 @@ #include <util/generic/string.h> -#include "y_absl/time/time.h" +#include "y_absl/time/time.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace time_internal { // Loads the named timezone, but dies on any failure. -y_absl::TimeZone LoadTimeZone(const TString& name); +y_absl::TimeZone LoadTimeZone(const TString& name); } // namespace time_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_INTERNAL_TEST_UTIL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc index 7c77ca339b..441638b256 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc @@ -12,26 +12,26 @@ // See the License for the specific language governing permissions and // limitations under the License. -// The implementation of the y_absl::Time class, which is declared in -// //y_absl/time.h. +// The implementation of the y_absl::Time class, which is declared in +// //y_absl/time.h. // -// The representation for an y_absl::Time is an y_absl::Duration offset from the +// The representation for an y_absl::Time is an y_absl::Duration offset from the // epoch. We use the traditional Unix epoch (1970-01-01 00:00:00 +0000) // for convenience, but this is not exposed in the API and could be changed. // // NOTE: To keep type verbosity to a minimum, the following variable naming // conventions are used throughout this file. // -// tz: An y_absl::TimeZone -// ci: An y_absl::TimeZone::CivilInfo -// ti: An y_absl::TimeZone::TimeInfo -// cd: An y_absl::CivilDay or a cctz::civil_day -// cs: An y_absl::CivilSecond or a cctz::civil_second -// bd: An y_absl::Time::Breakdown +// tz: An y_absl::TimeZone +// ci: An y_absl::TimeZone::CivilInfo +// ti: An y_absl::TimeZone::TimeInfo +// cd: An y_absl::CivilDay or a cctz::civil_day +// cs: An y_absl::CivilSecond or a cctz::civil_second +// bd: An y_absl::Time::Breakdown // cl: A cctz::time_zone::civil_lookup // al: A cctz::time_zone::absolute_lookup -#include "y_absl/time/time.h" +#include "y_absl/time/time.h" #if defined(_MSC_VER) #include <winsock2.h> // for timeval @@ -41,12 +41,12 @@ #include <ctime> #include <limits> -#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" -#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" +#include "y_absl/time/internal/cctz/include/cctz/civil_time.h" +#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" -namespace cctz = y_absl::time_internal::cctz; +namespace cctz = y_absl::time_internal::cctz; -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace { @@ -57,24 +57,24 @@ inline cctz::time_point<cctz::seconds> unix_epoch() { } // Floors d to the next unit boundary closer to negative infinity. -inline int64_t FloorToUnit(y_absl::Duration d, y_absl::Duration unit) { - y_absl::Duration rem; - int64_t q = y_absl::IDivDuration(d, unit, &rem); +inline int64_t FloorToUnit(y_absl::Duration d, y_absl::Duration unit) { + y_absl::Duration rem; + int64_t q = y_absl::IDivDuration(d, unit, &rem); return (q > 0 || rem >= ZeroDuration() || q == std::numeric_limits<int64_t>::min()) ? q : q - 1; } -inline y_absl::Time::Breakdown InfiniteFutureBreakdown() { - y_absl::Time::Breakdown bd; +inline y_absl::Time::Breakdown InfiniteFutureBreakdown() { + y_absl::Time::Breakdown bd; bd.year = std::numeric_limits<int64_t>::max(); bd.month = 12; bd.day = 31; bd.hour = 23; bd.minute = 59; bd.second = 59; - bd.subsecond = y_absl::InfiniteDuration(); + bd.subsecond = y_absl::InfiniteDuration(); bd.weekday = 4; bd.yearday = 365; bd.offset = 0; @@ -83,7 +83,7 @@ inline y_absl::Time::Breakdown InfiniteFutureBreakdown() { return bd; } -inline y_absl::Time::Breakdown InfinitePastBreakdown() { +inline y_absl::Time::Breakdown InfinitePastBreakdown() { Time::Breakdown bd; bd.year = std::numeric_limits<int64_t>::min(); bd.month = 1; @@ -91,7 +91,7 @@ inline y_absl::Time::Breakdown InfinitePastBreakdown() { bd.hour = 0; bd.minute = 0; bd.second = 0; - bd.subsecond = -y_absl::InfiniteDuration(); + bd.subsecond = -y_absl::InfiniteDuration(); bd.weekday = 7; bd.yearday = 1; bd.offset = 0; @@ -100,7 +100,7 @@ inline y_absl::Time::Breakdown InfinitePastBreakdown() { return bd; } -inline y_absl::TimeZone::CivilInfo InfiniteFutureCivilInfo() { +inline y_absl::TimeZone::CivilInfo InfiniteFutureCivilInfo() { TimeZone::CivilInfo ci; ci.cs = CivilSecond::max(); ci.subsecond = InfiniteDuration(); @@ -110,7 +110,7 @@ inline y_absl::TimeZone::CivilInfo InfiniteFutureCivilInfo() { return ci; } -inline y_absl::TimeZone::CivilInfo InfinitePastCivilInfo() { +inline y_absl::TimeZone::CivilInfo InfinitePastCivilInfo() { TimeZone::CivilInfo ci; ci.cs = CivilSecond::min(); ci.subsecond = -InfiniteDuration(); @@ -120,18 +120,18 @@ inline y_absl::TimeZone::CivilInfo InfinitePastCivilInfo() { return ci; } -inline y_absl::TimeConversion InfiniteFutureTimeConversion() { - y_absl::TimeConversion tc; - tc.pre = tc.trans = tc.post = y_absl::InfiniteFuture(); - tc.kind = y_absl::TimeConversion::UNIQUE; +inline y_absl::TimeConversion InfiniteFutureTimeConversion() { + y_absl::TimeConversion tc; + tc.pre = tc.trans = tc.post = y_absl::InfiniteFuture(); + tc.kind = y_absl::TimeConversion::UNIQUE; tc.normalized = true; return tc; } inline TimeConversion InfinitePastTimeConversion() { - y_absl::TimeConversion tc; - tc.pre = tc.trans = tc.post = y_absl::InfinitePast(); - tc.kind = y_absl::TimeConversion::UNIQUE; + y_absl::TimeConversion tc; + tc.pre = tc.trans = tc.post = y_absl::InfinitePast(); + tc.kind = y_absl::TimeConversion::UNIQUE; tc.normalized = true; return tc; } @@ -148,14 +148,14 @@ Time MakeTimeWithOverflow(const cctz::time_point<cctz::seconds>& sec, const auto al = tz.lookup(max); if (cs > al.cs) { if (normalized) *normalized = true; - return y_absl::InfiniteFuture(); + return y_absl::InfiniteFuture(); } } if (sec == min) { const auto al = tz.lookup(min); if (cs < al.cs) { if (normalized) *normalized = true; - return y_absl::InfinitePast(); + return y_absl::InfinitePast(); } } const auto hi = (sec - unix_epoch()).count(); @@ -203,16 +203,16 @@ bool FindTransition(const cctz::time_zone& tz, // Time // -y_absl::Time::Breakdown Time::In(y_absl::TimeZone tz) const { - if (*this == y_absl::InfiniteFuture()) return InfiniteFutureBreakdown(); - if (*this == y_absl::InfinitePast()) return InfinitePastBreakdown(); +y_absl::Time::Breakdown Time::In(y_absl::TimeZone tz) const { + if (*this == y_absl::InfiniteFuture()) return InfiniteFutureBreakdown(); + if (*this == y_absl::InfinitePast()) return InfinitePastBreakdown(); const auto tp = unix_epoch() + cctz::seconds(time_internal::GetRepHi(rep_)); const auto al = cctz::time_zone(tz).lookup(tp); const auto cs = al.cs; const auto cd = cctz::civil_day(cs); - y_absl::Time::Breakdown bd; + y_absl::Time::Breakdown bd; bd.year = cs.year(); bd.month = cs.month(); bd.day = cs.day(); @@ -232,12 +232,12 @@ y_absl::Time::Breakdown Time::In(y_absl::TimeZone tz) const { // Conversions from/to other time types. // -y_absl::Time FromUDate(double udate) { - return time_internal::FromUnixDuration(y_absl::Milliseconds(udate)); +y_absl::Time FromUDate(double udate) { + return time_internal::FromUnixDuration(y_absl::Milliseconds(udate)); } -y_absl::Time FromUniversal(int64_t universal) { - return y_absl::UniversalEpoch() + 100 * y_absl::Nanoseconds(universal); +y_absl::Time FromUniversal(int64_t universal) { + return y_absl::UniversalEpoch() + 100 * y_absl::Nanoseconds(universal); } int64_t ToUnixNanos(Time t) { @@ -247,7 +247,7 @@ int64_t ToUnixNanos(Time t) { 1000 * 1000 * 1000) + (time_internal::GetRepLo(time_internal::ToUnixDuration(t)) / 4); } - return FloorToUnit(time_internal::ToUnixDuration(t), y_absl::Nanoseconds(1)); + return FloorToUnit(time_internal::ToUnixDuration(t), y_absl::Nanoseconds(1)); } int64_t ToUnixMicros(Time t) { @@ -257,7 +257,7 @@ int64_t ToUnixMicros(Time t) { 1000 * 1000) + (time_internal::GetRepLo(time_internal::ToUnixDuration(t)) / 4000); } - return FloorToUnit(time_internal::ToUnixDuration(t), y_absl::Microseconds(1)); + return FloorToUnit(time_internal::ToUnixDuration(t), y_absl::Microseconds(1)); } int64_t ToUnixMillis(Time t) { @@ -267,35 +267,35 @@ int64_t ToUnixMillis(Time t) { (time_internal::GetRepLo(time_internal::ToUnixDuration(t)) / (4000 * 1000)); } - return FloorToUnit(time_internal::ToUnixDuration(t), y_absl::Milliseconds(1)); + return FloorToUnit(time_internal::ToUnixDuration(t), y_absl::Milliseconds(1)); } int64_t ToUnixSeconds(Time t) { return time_internal::GetRepHi(time_internal::ToUnixDuration(t)); } -time_t ToTimeT(Time t) { return y_absl::ToTimespec(t).tv_sec; } +time_t ToTimeT(Time t) { return y_absl::ToTimespec(t).tv_sec; } double ToUDate(Time t) { - return y_absl::FDivDuration(time_internal::ToUnixDuration(t), - y_absl::Milliseconds(1)); + return y_absl::FDivDuration(time_internal::ToUnixDuration(t), + y_absl::Milliseconds(1)); } -int64_t ToUniversal(y_absl::Time t) { - return y_absl::FloorToUnit(t - y_absl::UniversalEpoch(), y_absl::Nanoseconds(100)); +int64_t ToUniversal(y_absl::Time t) { + return y_absl::FloorToUnit(t - y_absl::UniversalEpoch(), y_absl::Nanoseconds(100)); } -y_absl::Time TimeFromTimespec(timespec ts) { - return time_internal::FromUnixDuration(y_absl::DurationFromTimespec(ts)); +y_absl::Time TimeFromTimespec(timespec ts) { + return time_internal::FromUnixDuration(y_absl::DurationFromTimespec(ts)); } -y_absl::Time TimeFromTimeval(timeval tv) { - return time_internal::FromUnixDuration(y_absl::DurationFromTimeval(tv)); +y_absl::Time TimeFromTimeval(timeval tv) { + return time_internal::FromUnixDuration(y_absl::DurationFromTimeval(tv)); } timespec ToTimespec(Time t) { timespec ts; - y_absl::Duration d = time_internal::ToUnixDuration(t); + y_absl::Duration d = time_internal::ToUnixDuration(t); if (!time_internal::IsInfiniteDuration(d)) { ts.tv_sec = time_internal::GetRepHi(d); if (ts.tv_sec == time_internal::GetRepHi(d)) { // no time_t narrowing @@ -303,7 +303,7 @@ timespec ToTimespec(Time t) { return ts; } } - if (d >= y_absl::ZeroDuration()) { + if (d >= y_absl::ZeroDuration()) { ts.tv_sec = std::numeric_limits<time_t>::max(); ts.tv_nsec = 1000 * 1000 * 1000 - 1; } else { @@ -315,7 +315,7 @@ timespec ToTimespec(Time t) { timeval ToTimeval(Time t) { timeval tv; - timespec ts = y_absl::ToTimespec(t); + timespec ts = y_absl::ToTimespec(t); tv.tv_sec = ts.tv_sec; if (tv.tv_sec != ts.tv_sec) { // narrowing if (ts.tv_sec < 0) { @@ -336,7 +336,7 @@ Time FromChrono(const std::chrono::system_clock::time_point& tp) { tp - std::chrono::system_clock::from_time_t(0))); } -std::chrono::system_clock::time_point ToChronoTime(y_absl::Time t) { +std::chrono::system_clock::time_point ToChronoTime(y_absl::Time t) { using D = std::chrono::system_clock::duration; auto d = time_internal::ToUnixDuration(t); if (d < ZeroDuration()) d = Floor(d, FromChrono(D{1})); @@ -348,9 +348,9 @@ std::chrono::system_clock::time_point ToChronoTime(y_absl::Time t) { // TimeZone // -y_absl::TimeZone::CivilInfo TimeZone::At(Time t) const { - if (t == y_absl::InfiniteFuture()) return InfiniteFutureCivilInfo(); - if (t == y_absl::InfinitePast()) return InfinitePastCivilInfo(); +y_absl::TimeZone::CivilInfo TimeZone::At(Time t) const { + if (t == y_absl::InfiniteFuture()) return InfiniteFutureCivilInfo(); + if (t == y_absl::InfinitePast()) return InfinitePastCivilInfo(); const auto ud = time_internal::ToUnixDuration(t); const auto tp = unix_epoch() + cctz::seconds(time_internal::GetRepHi(ud)); @@ -365,7 +365,7 @@ y_absl::TimeZone::CivilInfo TimeZone::At(Time t) const { return ci; } -y_absl::TimeZone::TimeInfo TimeZone::At(CivilSecond ct) const { +y_absl::TimeZone::TimeInfo TimeZone::At(CivilSecond ct) const { const cctz::civil_second cs(ct); const auto cl = cz_.lookup(cs); @@ -399,7 +399,7 @@ bool TimeZone::PrevTransition(Time t, CivilTransition* trans) const { // Conversions involving time zones. // -y_absl::TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour, +y_absl::TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour, int min, int sec, TimeZone tz) { // Avoids years that are too extreme for CivilSecond to normalize. if (year > 300000000000) return InfiniteFutureTimeConversion(); @@ -431,7 +431,7 @@ y_absl::TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour, return tc; } -y_absl::Time FromTM(const struct tm& tm, y_absl::TimeZone tz) { +y_absl::Time FromTM(const struct tm& tm, y_absl::TimeZone tz) { civil_year_t tm_year = tm.tm_year; // Avoids years that are too extreme for CivilSecond to normalize. if (tm_year > 300000000000ll) return InfiniteFuture(); @@ -446,7 +446,7 @@ y_absl::Time FromTM(const struct tm& tm, y_absl::TimeZone tz) { return tm.tm_isdst == 0 ? ti.post : ti.pre; } -struct tm ToTM(y_absl::Time t, y_absl::TimeZone tz) { +struct tm ToTM(y_absl::Time t, y_absl::TimeZone tz) { struct tm tm = {}; const auto ci = tz.At(t); @@ -497,4 +497,4 @@ struct tm ToTM(y_absl::Time t, y_absl::TimeZone tz) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h index 2494c3e619..16150ad3b6 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h @@ -20,15 +20,15 @@ // in time, durations of time, and formatting and parsing time within a given // time zone. The following abstractions are defined: // -// * `y_absl::Time` defines an absolute, specific instance in time -// * `y_absl::Duration` defines a signed, fixed-length span of time -// * `y_absl::TimeZone` defines geopolitical time zone regions (as collected +// * `y_absl::Time` defines an absolute, specific instance in time +// * `y_absl::Duration` defines a signed, fixed-length span of time +// * `y_absl::TimeZone` defines geopolitical time zone regions (as collected // within the IANA Time Zone database (https://www.iana.org/time-zones)). // // Note: Absolute times are distinct from civil times, which refer to the // human-scale time commonly represented by `YYYY-MM-DD hh:mm:ss`. The mapping // between absolute and civil times can be specified by use of time zones -// (`y_absl::TimeZone` within this API). That is: +// (`y_absl::TimeZone` within this API). That is: // // Civil Time = F(Absolute Time, Time Zone) // Absolute Time = G(Civil Time, Time Zone) @@ -38,24 +38,24 @@ // // Example: // -// y_absl::TimeZone nyc; +// y_absl::TimeZone nyc; // // LoadTimeZone() may fail so it's always better to check for success. -// if (!y_absl::LoadTimeZone("America/New_York", &nyc)) { +// if (!y_absl::LoadTimeZone("America/New_York", &nyc)) { // // handle error case // } // // // My flight leaves NYC on Jan 2, 2017 at 03:04:05 -// y_absl::CivilSecond cs(2017, 1, 2, 3, 4, 5); -// y_absl::Time takeoff = y_absl::FromCivil(cs, nyc); +// y_absl::CivilSecond cs(2017, 1, 2, 3, 4, 5); +// y_absl::Time takeoff = y_absl::FromCivil(cs, nyc); // -// y_absl::Duration flight_duration = y_absl::Hours(21) + y_absl::Minutes(35); -// y_absl::Time landing = takeoff + flight_duration; +// y_absl::Duration flight_duration = y_absl::Hours(21) + y_absl::Minutes(35); +// y_absl::Time landing = takeoff + flight_duration; // -// y_absl::TimeZone syd; -// if (!y_absl::LoadTimeZone("Australia/Sydney", &syd)) { +// y_absl::TimeZone syd; +// if (!y_absl::LoadTimeZone("Australia/Sydney", &syd)) { // // handle error case // } -// TString s = y_absl::FormatTime( +// TString s = y_absl::FormatTime( // "My flight will land in Sydney on %Y-%m-%d at %H:%M:%S", // landing, syd); @@ -83,12 +83,12 @@ struct timeval; #include <type_traits> #include <utility> -#include "y_absl/base/macros.h" -#include "y_absl/strings/string_view.h" -#include "y_absl/time/civil_time.h" -#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" +#include "y_absl/base/macros.h" +#include "y_absl/strings/string_view.h" +#include "y_absl/time/civil_time.h" +#include "y_absl/time/internal/cctz/include/cctz/time_zone.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN class Duration; // Defined below @@ -120,9 +120,9 @@ using EnableIfFloat = // Duration // -// The `y_absl::Duration` class represents a signed, fixed-length span of time. +// The `y_absl::Duration` class represents a signed, fixed-length span of time. // A `Duration` is generated using a unit-specific factory function, or is -// the result of subtracting one `y_absl::Time` from another. Durations behave +// the result of subtracting one `y_absl::Time` from another. Durations behave // like unit-safe integers and they support all the natural integer-like // arithmetic operations. Arithmetic overflows and saturates at +/- infinity. // `Duration` should be passed by value rather than const reference. @@ -133,23 +133,23 @@ using EnableIfFloat = // // Examples: // -// constexpr y_absl::Duration ten_ns = y_absl::Nanoseconds(10); -// constexpr y_absl::Duration min = y_absl::Minutes(1); -// constexpr y_absl::Duration hour = y_absl::Hours(1); -// y_absl::Duration dur = 60 * min; // dur == hour -// y_absl::Duration half_sec = y_absl::Milliseconds(500); -// y_absl::Duration quarter_sec = 0.25 * y_absl::Seconds(1); +// constexpr y_absl::Duration ten_ns = y_absl::Nanoseconds(10); +// constexpr y_absl::Duration min = y_absl::Minutes(1); +// constexpr y_absl::Duration hour = y_absl::Hours(1); +// y_absl::Duration dur = 60 * min; // dur == hour +// y_absl::Duration half_sec = y_absl::Milliseconds(500); +// y_absl::Duration quarter_sec = 0.25 * y_absl::Seconds(1); // // `Duration` values can be easily converted to an integral number of units // using the division operator. // // Example: // -// constexpr y_absl::Duration dur = y_absl::Milliseconds(1500); -// int64_t ns = dur / y_absl::Nanoseconds(1); // ns == 1500000000 -// int64_t ms = dur / y_absl::Milliseconds(1); // ms == 1500 -// int64_t sec = dur / y_absl::Seconds(1); // sec == 1 (subseconds truncated) -// int64_t min = dur / y_absl::Minutes(1); // min == 0 +// constexpr y_absl::Duration dur = y_absl::Milliseconds(1500); +// int64_t ns = dur / y_absl::Nanoseconds(1); // ns == 1500000000 +// int64_t ms = dur / y_absl::Milliseconds(1); // ms == 1500 +// int64_t sec = dur / y_absl::Seconds(1); // sec == 1 (subseconds truncated) +// int64_t min = dur / y_absl::Minutes(1); // min == 0 // // See the `IDivDuration()` and `FDivDuration()` functions below for details on // how to access the fractional parts of the quotient. @@ -272,15 +272,15 @@ inline Duration operator%(Duration lhs, Duration rhs) { return lhs %= rhs; } // // Example: // -// constexpr y_absl::Duration a = -// y_absl::Seconds(std::numeric_limits<int64_t>::max()); // big -// constexpr y_absl::Duration b = y_absl::Nanoseconds(1); // small +// constexpr y_absl::Duration a = +// y_absl::Seconds(std::numeric_limits<int64_t>::max()); // big +// constexpr y_absl::Duration b = y_absl::Nanoseconds(1); // small // -// y_absl::Duration rem = a % b; -// // rem == y_absl::ZeroDuration() +// y_absl::Duration rem = a % b; +// // rem == y_absl::ZeroDuration() // // // Here, q would overflow int64_t, so rem accounts for the difference. -// int64_t q = y_absl::IDivDuration(a, b, &rem); +// int64_t q = y_absl::IDivDuration(a, b, &rem); // // q == std::numeric_limits<int64_t>::max(), rem == a - b * q inline int64_t IDivDuration(Duration num, Duration den, Duration* rem) { return time_internal::IDivDuration(true, num, den, @@ -297,7 +297,7 @@ inline int64_t IDivDuration(Duration num, Duration den, Duration* rem) { // // Example: // -// double d = y_absl::FDivDuration(y_absl::Milliseconds(1500), y_absl::Seconds(1)); +// double d = y_absl::FDivDuration(y_absl::Milliseconds(1500), y_absl::Seconds(1)); // // d == 1.5 double FDivDuration(Duration num, Duration den); @@ -320,8 +320,8 @@ inline Duration AbsDuration(Duration d) { // // Example: // -// y_absl::Duration d = y_absl::Nanoseconds(123456789); -// y_absl::Duration a = y_absl::Trunc(d, y_absl::Microseconds(1)); // 123456us +// y_absl::Duration d = y_absl::Nanoseconds(123456789); +// y_absl::Duration a = y_absl::Trunc(d, y_absl::Microseconds(1)); // 123456us Duration Trunc(Duration d, Duration unit); // Floor() @@ -331,8 +331,8 @@ Duration Trunc(Duration d, Duration unit); // // Example: // -// y_absl::Duration d = y_absl::Nanoseconds(123456789); -// y_absl::Duration b = y_absl::Floor(d, y_absl::Microseconds(1)); // 123456us +// y_absl::Duration d = y_absl::Nanoseconds(123456789); +// y_absl::Duration b = y_absl::Floor(d, y_absl::Microseconds(1)); // 123456us Duration Floor(Duration d, Duration unit); // Ceil() @@ -342,8 +342,8 @@ Duration Floor(Duration d, Duration unit); // // Example: // -// y_absl::Duration d = y_absl::Nanoseconds(123456789); -// y_absl::Duration c = y_absl::Ceil(d, y_absl::Microseconds(1)); // 123457us +// y_absl::Duration d = y_absl::Nanoseconds(123456789); +// y_absl::Duration c = y_absl::Ceil(d, y_absl::Microseconds(1)); // 123457us Duration Ceil(Duration d, Duration unit); // InfiniteDuration() @@ -358,8 +358,8 @@ Duration Ceil(Duration d, Duration unit); // // Examples: // -// constexpr y_absl::Duration inf = y_absl::InfiniteDuration(); -// const y_absl::Duration d = ... any finite duration ... +// constexpr y_absl::Duration inf = y_absl::InfiniteDuration(); +// const y_absl::Duration d = ... any finite duration ... // // inf == inf + inf // inf == inf + d @@ -376,7 +376,7 @@ Duration Ceil(Duration d, Duration unit); // // // Division by zero returns infinity, or INT64_MIN/MAX where appropriate. // inf == d / 0 -// INT64_MAX == d / y_absl::ZeroDuration() +// INT64_MAX == d / y_absl::ZeroDuration() // // The examples involving the `/` operator above also apply to `IDivDuration()` // and `FDivDuration()`. @@ -396,13 +396,13 @@ constexpr Duration InfiniteDuration(); // NOTE: no "Days()" factory function exists because "a day" is ambiguous. // Civil days are not always 24 hours long, and a 24-hour duration often does // not correspond with a civil day. If a 24-hour duration is needed, use -// `y_absl::Hours(24)`. If you actually want a civil day, use y_absl::CivilDay +// `y_absl::Hours(24)`. If you actually want a civil day, use y_absl::CivilDay // from civil_time.h. // // Example: // -// y_absl::Duration a = y_absl::Seconds(60); -// y_absl::Duration b = y_absl::Minutes(1); // b == a +// y_absl::Duration a = y_absl::Seconds(60); +// y_absl::Duration b = y_absl::Minutes(1); // b == a template <typename T, time_internal::EnableIfIntegral<T> = 0> constexpr Duration Nanoseconds(T n) { return time_internal::FromInt64(n, std::nano{}); @@ -435,8 +435,8 @@ constexpr Duration Hours(T n) { // // Example: // -// auto a = y_absl::Seconds(1.5); // OK -// auto b = y_absl::Milliseconds(1500); // BETTER +// auto a = y_absl::Seconds(1.5); // OK +// auto b = y_absl::Milliseconds(1500); // BETTER template <typename T, time_internal::EnableIfFloat<T> = 0> Duration Nanoseconds(T n) { return n * Nanoseconds(1); @@ -486,8 +486,8 @@ Duration Hours(T n) { // // Example: // -// y_absl::Duration d = y_absl::Milliseconds(1500); -// int64_t isec = y_absl::ToInt64Seconds(d); // isec == 1 +// y_absl::Duration d = y_absl::Milliseconds(1500); +// int64_t isec = y_absl::ToInt64Seconds(d); // isec == 1 ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Nanoseconds(Duration d); ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Microseconds(Duration d); ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d); @@ -508,8 +508,8 @@ ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d); // // Example: // -// y_absl::Duration d = y_absl::Milliseconds(1500); -// double dsec = y_absl::ToDoubleSeconds(d); // dsec == 1.5 +// y_absl::Duration d = y_absl::Milliseconds(1500); +// double dsec = y_absl::ToDoubleSeconds(d); // dsec == 1.5 ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleNanoseconds(Duration d); ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMicroseconds(Duration d); ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMilliseconds(Duration d); @@ -519,12 +519,12 @@ ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleHours(Duration d); // FromChrono() // -// Converts any of the pre-defined std::chrono durations to an y_absl::Duration. +// Converts any of the pre-defined std::chrono durations to an y_absl::Duration. // // Example: // // std::chrono::milliseconds ms(123); -// y_absl::Duration d = y_absl::FromChrono(ms); +// y_absl::Duration d = y_absl::FromChrono(ms); constexpr Duration FromChrono(const std::chrono::nanoseconds& d); constexpr Duration FromChrono(const std::chrono::microseconds& d); constexpr Duration FromChrono(const std::chrono::milliseconds& d); @@ -539,16 +539,16 @@ constexpr Duration FromChrono(const std::chrono::hours& d); // ToChronoMinutes() // ToChronoHours() // -// Converts an y_absl::Duration to any of the pre-defined std::chrono durations. +// Converts an y_absl::Duration to any of the pre-defined std::chrono durations. // If overflow would occur, the returned value will saturate at the min/max // chrono duration value instead. // // Example: // -// y_absl::Duration d = y_absl::Microseconds(123); -// auto x = y_absl::ToChronoMicroseconds(d); -// auto y = y_absl::ToChronoNanoseconds(d); // x == y -// auto z = y_absl::ToChronoSeconds(y_absl::InfiniteDuration()); +// y_absl::Duration d = y_absl::Microseconds(123); +// auto x = y_absl::ToChronoMicroseconds(d); +// auto y = y_absl::ToChronoNanoseconds(d); // x == y +// auto z = y_absl::ToChronoSeconds(y_absl::InfiniteDuration()); // // z == std::chrono::seconds::max() std::chrono::nanoseconds ToChronoNanoseconds(Duration d); std::chrono::microseconds ToChronoMicroseconds(Duration d); @@ -561,7 +561,7 @@ std::chrono::hours ToChronoHours(Duration d); // // Returns a string representing the duration in the form "72h3m0.5s". // Returns "inf" or "-inf" for +/- `InfiniteDuration()`. -TString FormatDuration(Duration d); +TString FormatDuration(Duration d); // Output stream operator. inline std::ostream& operator<<(std::ostream& os, Duration d) { @@ -582,35 +582,35 @@ bool ParseDuration(y_absl::string_view dur_string, Duration* d); // Parses a command-line flag string representation `text` into a a Duration // value. Duration flags must be specified in a format that is valid input for // `y_absl::ParseDuration()`. -bool AbslParseFlag(y_absl::string_view text, Duration* dst, TString* error); +bool AbslParseFlag(y_absl::string_view text, Duration* dst, TString* error); // AbslUnparseFlag() // // Unparses a Duration value into a command-line string representation using // the format specified by `y_absl::ParseDuration()`. -TString AbslUnparseFlag(Duration d); +TString AbslUnparseFlag(Duration d); ABSL_DEPRECATED("Use AbslParseFlag() instead.") -bool ParseFlag(const TString& text, Duration* dst, TString* error); +bool ParseFlag(const TString& text, Duration* dst, TString* error); ABSL_DEPRECATED("Use AbslUnparseFlag() instead.") -TString UnparseFlag(Duration d); +TString UnparseFlag(Duration d); // Time // -// An `y_absl::Time` represents a specific instant in time. Arithmetic operators +// An `y_absl::Time` represents a specific instant in time. Arithmetic operators // are provided for naturally expressing time calculations. Instances are -// created using `y_absl::Now()` and the `y_absl::From*()` factory functions that +// created using `y_absl::Now()` and the `y_absl::From*()` factory functions that // accept the gamut of other time representations. Formatting and parsing -// functions are provided for conversion to and from strings. `y_absl::Time` +// functions are provided for conversion to and from strings. `y_absl::Time` // should be passed by value rather than const reference. // -// `y_absl::Time` assumes there are 60 seconds in a minute, which means the +// `y_absl::Time` assumes there are 60 seconds in a minute, which means the // underlying time scales must be "smeared" to eliminate leap seconds. // See https://developers.google.com/time/smear. // -// Even though `y_absl::Time` supports a wide range of timestamps, exercise -// caution when using values in the distant past. `y_absl::Time` uses the +// Even though `y_absl::Time` supports a wide range of timestamps, exercise +// caution when using values in the distant past. `y_absl::Time` uses the // Proleptic Gregorian calendar, which extends the Gregorian calendar backward // to dates before its introduction in 1582. // See https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar @@ -623,10 +623,10 @@ TString UnparseFlag(Duration d); // breakdown of future timestamps is subject to the whim of regional // governments. // -// The `y_absl::Time` class represents an instant in time as a count of clock +// The `y_absl::Time` class represents an instant in time as a count of clock // ticks of some granularity (resolution) from some starting point (epoch). // -// `y_absl::Time` uses a resolution that is high enough to avoid loss in +// `y_absl::Time` uses a resolution that is high enough to avoid loss in // precision, and a range that is wide enough to avoid overflow, when // converting between tick counts in most Google time scales (i.e., resolution // of at least one nanosecond, and range +/-100 billion years). Conversions @@ -635,9 +635,9 @@ TString UnparseFlag(Duration d); // // Examples: // -// y_absl::Time t1 = ...; -// y_absl::Time t2 = t1 + y_absl::Minutes(2); -// y_absl::Duration d = t2 - t1; // == y_absl::Minutes(2) +// y_absl::Time t1 = ...; +// y_absl::Time t2 = t1 + y_absl::Minutes(2); +// y_absl::Duration d = t2 - t1; // == y_absl::Minutes(2) // class Time { public: @@ -648,10 +648,10 @@ class Time { // readable by explicitly initializing all instances before use. // // Example: - // y_absl::Time t = y_absl::UnixEpoch(); - // y_absl::Time t = y_absl::Now(); - // y_absl::Time t = y_absl::TimeFromTimeval(tv); - // y_absl::Time t = y_absl::InfinitePast(); + // y_absl::Time t = y_absl::UnixEpoch(); + // y_absl::Time t = y_absl::Now(); + // y_absl::Time t = y_absl::TimeFromTimeval(tv); + // y_absl::Time t = y_absl::InfinitePast(); constexpr Time() = default; // Copyable. @@ -671,12 +671,12 @@ class Time { // Time::Breakdown // // The calendar and wall-clock (aka "civil time") components of an - // `y_absl::Time` in a certain `y_absl::TimeZone`. This struct is not + // `y_absl::Time` in a certain `y_absl::TimeZone`. This struct is not // intended to represent an instant in time. So, rather than passing - // a `Time::Breakdown` to a function, pass an `y_absl::Time` and an - // `y_absl::TimeZone`. + // a `Time::Breakdown` to a function, pass an `y_absl::Time` and an + // `y_absl::TimeZone`. // - // Deprecated. Use `y_absl::TimeZone::CivilInfo`. + // Deprecated. Use `y_absl::TimeZone::CivilInfo`. struct Breakdown { int64_t year; // year (e.g., 2013) @@ -703,7 +703,7 @@ class Time { // // Returns the breakdown of this instant in the given TimeZone. // - // Deprecated. Use `y_absl::TimeZone::At(Time)`. + // Deprecated. Use `y_absl::TimeZone::At(Time)`. Breakdown In(TimeZone tz) const; template <typename H> @@ -740,12 +740,12 @@ inline Duration operator-(Time lhs, Time rhs) { return lhs.rep_ - rhs.rep_; } // UnixEpoch() // -// Returns the `y_absl::Time` representing "1970-01-01 00:00:00.0 +0000". +// Returns the `y_absl::Time` representing "1970-01-01 00:00:00.0 +0000". constexpr Time UnixEpoch() { return Time(); } // UniversalEpoch() // -// Returns the `y_absl::Time` representing "0001-01-01 00:00:00.0 +0000", the +// Returns the `y_absl::Time` representing "0001-01-01 00:00:00.0 +0000", the // epoch of the ICU Universal Time Scale. constexpr Time UniversalEpoch() { // 719162 is the number of days from 0001-01-01 to 1970-01-01, @@ -755,7 +755,7 @@ constexpr Time UniversalEpoch() { // InfiniteFuture() // -// Returns an `y_absl::Time` that is infinitely far in the future. +// Returns an `y_absl::Time` that is infinitely far in the future. constexpr Time InfiniteFuture() { return Time( time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(), ~0U)); @@ -763,7 +763,7 @@ constexpr Time InfiniteFuture() { // InfinitePast() // -// Returns an `y_absl::Time` that is infinitely far in the past. +// Returns an `y_absl::Time` that is infinitely far in the past. constexpr Time InfinitePast() { return Time( time_internal::MakeDuration((std::numeric_limits<int64_t>::min)(), ~0U)); @@ -777,7 +777,7 @@ constexpr Time InfinitePast() { // FromUDate() // FromUniversal() // -// Creates an `y_absl::Time` from a variety of other representations. +// Creates an `y_absl::Time` from a variety of other representations. constexpr Time FromUnixNanos(int64_t ns); constexpr Time FromUnixMicros(int64_t us); constexpr Time FromUnixMillis(int64_t ms); @@ -794,7 +794,7 @@ Time FromUniversal(int64_t universal); // ToUDate() // ToUniversal() // -// Converts an `y_absl::Time` to a variety of other representations. Note that +// Converts an `y_absl::Time` to a variety of other representations. Note that // these operations round down toward negative infinity where necessary to // adjust to the resolution of the result type. Beware of possible time_t // over/underflow in ToTime{T,val,spec}() on 32-bit platforms. @@ -831,25 +831,25 @@ timeval ToTimeval(Time t); // FromChrono() // -// Converts a std::chrono::system_clock::time_point to an y_absl::Time. +// Converts a std::chrono::system_clock::time_point to an y_absl::Time. // // Example: // // auto tp = std::chrono::system_clock::from_time_t(123); -// y_absl::Time t = y_absl::FromChrono(tp); -// // t == y_absl::FromTimeT(123) +// y_absl::Time t = y_absl::FromChrono(tp); +// // t == y_absl::FromTimeT(123) Time FromChrono(const std::chrono::system_clock::time_point& tp); // ToChronoTime() // -// Converts an y_absl::Time to a std::chrono::system_clock::time_point. If +// Converts an y_absl::Time to a std::chrono::system_clock::time_point. If // overflow would occur, the returned value will saturate at the min/max time // point value instead. // // Example: // -// y_absl::Time t = y_absl::FromTimeT(123); -// auto tp = y_absl::ToChronoTime(t); +// y_absl::Time t = y_absl::FromTimeT(123); +// auto tp = y_absl::ToChronoTime(t); // // tp == std::chrono::system_clock::from_time_t(123); std::chrono::system_clock::time_point ToChronoTime(Time); @@ -865,29 +865,29 @@ std::chrono::system_clock::time_point ToChronoTime(Time); // Note: A UTC offset (or 'Z' indicating a zero-offset from UTC) is required. // // Additionally, if you'd like to specify a time as a count of -// seconds/milliseconds/etc from the Unix epoch, use an y_absl::Duration flag -// and add that duration to y_absl::UnixEpoch() to get an y_absl::Time. -bool AbslParseFlag(y_absl::string_view text, Time* t, TString* error); +// seconds/milliseconds/etc from the Unix epoch, use an y_absl::Duration flag +// and add that duration to y_absl::UnixEpoch() to get an y_absl::Time. +bool AbslParseFlag(y_absl::string_view text, Time* t, TString* error); // AbslUnparseFlag() // // Unparses a Time value into a command-line string representation using // the format specified by `y_absl::ParseTime()`. -TString AbslUnparseFlag(Time t); +TString AbslUnparseFlag(Time t); ABSL_DEPRECATED("Use AbslParseFlag() instead.") -bool ParseFlag(const TString& text, Time* t, TString* error); +bool ParseFlag(const TString& text, Time* t, TString* error); ABSL_DEPRECATED("Use AbslUnparseFlag() instead.") -TString UnparseFlag(Time t); +TString UnparseFlag(Time t); // TimeZone // -// The `y_absl::TimeZone` is an opaque, small, value-type class representing a +// The `y_absl::TimeZone` is an opaque, small, value-type class representing a // geo-political region within which particular rules are used for converting -// between absolute and civil times (see https://git.io/v59Ly). `y_absl::TimeZone` +// between absolute and civil times (see https://git.io/v59Ly). `y_absl::TimeZone` // values are named using the TZ identifiers from the IANA Time Zone Database, -// such as "America/Los_Angeles" or "Australia/Sydney". `y_absl::TimeZone` values -// are created from factory functions such as `y_absl::LoadTimeZone()`. Note: +// such as "America/Los_Angeles" or "Australia/Sydney". `y_absl::TimeZone` values +// are created from factory functions such as `y_absl::LoadTimeZone()`. Note: // strings like "PST" and "EDT" are not valid TZ identifiers. Prefer to pass by // value rather than const reference. // @@ -896,11 +896,11 @@ TString UnparseFlag(Time t); // // Examples: // -// y_absl::TimeZone utc = y_absl::UTCTimeZone(); -// y_absl::TimeZone pst = y_absl::FixedTimeZone(-8 * 60 * 60); -// y_absl::TimeZone loc = y_absl::LocalTimeZone(); -// y_absl::TimeZone lax; -// if (!y_absl::LoadTimeZone("America/Los_Angeles", &lax)) { +// y_absl::TimeZone utc = y_absl::UTCTimeZone(); +// y_absl::TimeZone pst = y_absl::FixedTimeZone(-8 * 60 * 60); +// y_absl::TimeZone loc = y_absl::LocalTimeZone(); +// y_absl::TimeZone lax; +// if (!y_absl::LoadTimeZone("America/Los_Angeles", &lax)) { // // handle error case // } // @@ -919,14 +919,14 @@ class TimeZone { explicit operator time_internal::cctz::time_zone() const { return cz_; } - TString name() const { return cz_.name(); } + TString name() const { return cz_.name(); } // TimeZone::CivilInfo // // Information about the civil time corresponding to an absolute time. // This struct is not intended to represent an instant in time. So, rather - // than passing a `TimeZone::CivilInfo` to a function, pass an `y_absl::Time` - // and an `y_absl::TimeZone`. + // than passing a `TimeZone::CivilInfo` to a function, pass an `y_absl::Time` + // and an `y_absl::TimeZone`. struct CivilInfo { CivilSecond cs; Duration subsecond; @@ -943,15 +943,15 @@ class TimeZone { // TimeZone::At(Time) // - // Returns the civil time for this TimeZone at a certain `y_absl::Time`. + // Returns the civil time for this TimeZone at a certain `y_absl::Time`. // If the input time is infinite, the output civil second will be set to // CivilSecond::max() or min(), and the subsecond will be infinite. // // Example: // - // const auto epoch = lax.At(y_absl::UnixEpoch()); + // const auto epoch = lax.At(y_absl::UnixEpoch()); // // epoch.cs == 1969-12-31 16:00:00 - // // epoch.subsecond == y_absl::ZeroDuration() + // // epoch.subsecond == y_absl::ZeroDuration() // // epoch.offset == -28800 // // epoch.is_dst == false // // epoch.abbr == "PST" @@ -969,8 +969,8 @@ class TimeZone { // transition skips or repeats civil times---in the United States, // March 13, 2011 02:15 never occurred, while November 6, 2011 01:15 // occurred twice---so requests for such times are not well-defined. - // To account for these possibilities, `y_absl::TimeZone::TimeInfo` is - // richer than just a single `y_absl::Time`. + // To account for these possibilities, `y_absl::TimeZone::TimeInfo` is + // richer than just a single `y_absl::Time`. struct TimeInfo { enum CivilKind { UNIQUE, // the civil time was singular (pre == trans == post) @@ -984,29 +984,29 @@ class TimeZone { // TimeZone::At(CivilSecond) // - // Returns an `y_absl::TimeInfo` containing the absolute time(s) for this - // TimeZone at an `y_absl::CivilSecond`. When the civil time is skipped or + // Returns an `y_absl::TimeInfo` containing the absolute time(s) for this + // TimeZone at an `y_absl::CivilSecond`. When the civil time is skipped or // repeated, returns times calculated using the pre-transition and post- // transition UTC offsets, plus the transition time itself. // // Examples: // // // A unique civil time - // const auto jan01 = lax.At(y_absl::CivilSecond(2011, 1, 1, 0, 0, 0)); + // const auto jan01 = lax.At(y_absl::CivilSecond(2011, 1, 1, 0, 0, 0)); // // jan01.kind == TimeZone::TimeInfo::UNIQUE // // jan01.pre is 2011-01-01 00:00:00 -0800 // // jan01.trans is 2011-01-01 00:00:00 -0800 // // jan01.post is 2011-01-01 00:00:00 -0800 // // // A Spring DST transition, when there is a gap in civil time - // const auto mar13 = lax.At(y_absl::CivilSecond(2011, 3, 13, 2, 15, 0)); + // const auto mar13 = lax.At(y_absl::CivilSecond(2011, 3, 13, 2, 15, 0)); // // mar13.kind == TimeZone::TimeInfo::SKIPPED // // mar13.pre is 2011-03-13 03:15:00 -0700 // // mar13.trans is 2011-03-13 03:00:00 -0700 // // mar13.post is 2011-03-13 01:15:00 -0800 // // // A Fall DST transition, when civil times are repeated - // const auto nov06 = lax.At(y_absl::CivilSecond(2011, 11, 6, 1, 15, 0)); + // const auto nov06 = lax.At(y_absl::CivilSecond(2011, 11, 6, 1, 15, 0)); // // nov06.kind == TimeZone::TimeInfo::REPEATED // // nov06.pre is 2011-11-06 01:15:00 -0700 // // nov06.trans is 2011-11-06 01:00:00 -0800 @@ -1035,11 +1035,11 @@ class TimeZone { // occur. // // Example: - // y_absl::TimeZone nyc; - // if (!y_absl::LoadTimeZone("America/New_York", &nyc)) { ... } - // const auto now = y_absl::Now(); - // auto t = y_absl::InfinitePast(); - // y_absl::TimeZone::CivilTransition trans; + // y_absl::TimeZone nyc; + // if (!y_absl::LoadTimeZone("America/New_York", &nyc)) { ... } + // const auto now = y_absl::Now(); + // auto t = y_absl::InfinitePast(); + // y_absl::TimeZone::CivilTransition trans; // while (t <= now && nyc.NextTransition(t, &trans)) { // // transition: trans.from -> trans.to // t = nyc.At(trans.to).trans; @@ -1120,9 +1120,9 @@ inline TimeZone LocalTimeZone() { // // Example: // -// y_absl::Time t = ...; -// y_absl::TimeZone tz = ...; -// const auto cd = y_absl::ToCivilDay(t, tz); +// y_absl::Time t = ...; +// y_absl::TimeZone tz = ...; +// const auto cd = y_absl::ToCivilDay(t, tz); inline CivilSecond ToCivilSecond(Time t, TimeZone tz) { return tz.At(t).cs; // already a CivilSecond } @@ -1162,12 +1162,12 @@ inline Time FromCivil(CivilSecond ct, TimeZone tz) { // TimeConversion // -// An `y_absl::TimeConversion` represents the conversion of year, month, day, +// An `y_absl::TimeConversion` represents the conversion of year, month, day, // hour, minute, and second values (i.e., a civil time), in a particular -// `y_absl::TimeZone`, to a time instant (an absolute time), as returned by -// `y_absl::ConvertDateTime()`. Legacy version of `y_absl::TimeZone::TimeInfo`. +// `y_absl::TimeZone`, to a time instant (an absolute time), as returned by +// `y_absl::ConvertDateTime()`. Legacy version of `y_absl::TimeZone::TimeInfo`. // -// Deprecated. Use `y_absl::TimeZone::TimeInfo`. +// Deprecated. Use `y_absl::TimeZone::TimeInfo`. struct TimeConversion { Time pre; // time calculated using the pre-transition offset @@ -1186,7 +1186,7 @@ struct // ConvertDateTime() // -// Legacy version of `y_absl::TimeZone::At(y_absl::CivilSecond)` that takes +// Legacy version of `y_absl::TimeZone::At(y_absl::CivilSecond)` that takes // the civil time as six, separate values (YMDHMS). // // The input month, day, hour, minute, and second values can be outside @@ -1196,31 +1196,31 @@ struct // Example: // // // "October 32" normalizes to "November 1". -// y_absl::TimeConversion tc = -// y_absl::ConvertDateTime(2013, 10, 32, 8, 30, 0, lax); +// y_absl::TimeConversion tc = +// y_absl::ConvertDateTime(2013, 10, 32, 8, 30, 0, lax); // // tc.kind == TimeConversion::UNIQUE && tc.normalized == true -// // y_absl::ToCivilDay(tc.pre, tz).month() == 11 -// // y_absl::ToCivilDay(tc.pre, tz).day() == 1 +// // y_absl::ToCivilDay(tc.pre, tz).month() == 11 +// // y_absl::ToCivilDay(tc.pre, tz).day() == 1 // -// Deprecated. Use `y_absl::TimeZone::At(CivilSecond)`. +// Deprecated. Use `y_absl::TimeZone::At(CivilSecond)`. TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour, int min, int sec, TimeZone tz); // FromDateTime() // -// A convenience wrapper for `y_absl::ConvertDateTime()` that simply returns -// the "pre" `y_absl::Time`. That is, the unique result, or the instant that +// A convenience wrapper for `y_absl::ConvertDateTime()` that simply returns +// the "pre" `y_absl::Time`. That is, the unique result, or the instant that // is correct using the pre-transition offset (as if the transition never // happened). // // Example: // -// y_absl::Time t = y_absl::FromDateTime(2017, 9, 26, 9, 30, 0, lax); +// y_absl::Time t = y_absl::FromDateTime(2017, 9, 26, 9, 30, 0, lax); // // t = 2017-09-26 09:30:00 -0700 // -// Deprecated. Use `y_absl::FromCivil(CivilSecond, TimeZone)`. Note that the +// Deprecated. Use `y_absl::FromCivil(CivilSecond, TimeZone)`. Note that the // behavior of `FromCivil()` differs from `FromDateTime()` for skipped civil -// times. If you care about that see `y_absl::TimeZone::At(y_absl::CivilSecond)`. +// times. If you care about that see `y_absl::TimeZone::At(y_absl::CivilSecond)`. inline Time FromDateTime(int64_t year, int mon, int day, int hour, int min, int sec, TimeZone tz) { return ConvertDateTime(year, mon, day, hour, min, sec, tz).pre; @@ -1229,7 +1229,7 @@ inline Time FromDateTime(int64_t year, int mon, int day, int hour, // FromTM() // // Converts the `tm_year`, `tm_mon`, `tm_mday`, `tm_hour`, `tm_min`, and -// `tm_sec` fields to an `y_absl::Time` using the given time zone. See ctime(3) +// `tm_sec` fields to an `y_absl::Time` using the given time zone. See ctime(3) // for a description of the expected values of the tm fields. If the civil time // is unique (see `y_absl::TimeZone::At(y_absl::CivilSecond)` above), the matching // time instant is returned. Otherwise, the `tm_isdst` field is consulted to @@ -1243,7 +1243,7 @@ Time FromTM(const struct tm& tm, TimeZone tz); // ToTM() // -// Converts the given `y_absl::Time` to a struct tm using the given time zone. +// Converts the given `y_absl::Time` to a struct tm using the given time zone. // See ctime(3) for a description of the values of the tm fields. struct tm ToTM(Time t, TimeZone tz); @@ -1269,7 +1269,7 @@ ABSL_DLL extern const char RFC1123_no_wday[]; // %d %b %E4Y %H:%M:%S %z // FormatTime() // -// Formats the given `y_absl::Time` in the `y_absl::TimeZone` according to the +// Formats the given `y_absl::Time` in the `y_absl::TimeZone` according to the // provided format string. Uses strftime()-like formatting options, with // the following extensions: // @@ -1294,23 +1294,23 @@ ABSL_DLL extern const char RFC1123_no_wday[]; // %d %b %E4Y %H:%M:%S %z // // Example: // -// y_absl::CivilSecond cs(2013, 1, 2, 3, 4, 5); -// y_absl::Time t = y_absl::FromCivil(cs, lax); -// TString f = y_absl::FormatTime("%H:%M:%S", t, lax); // "03:04:05" -// f = y_absl::FormatTime("%H:%M:%E3S", t, lax); // "03:04:05.000" +// y_absl::CivilSecond cs(2013, 1, 2, 3, 4, 5); +// y_absl::Time t = y_absl::FromCivil(cs, lax); +// TString f = y_absl::FormatTime("%H:%M:%S", t, lax); // "03:04:05" +// f = y_absl::FormatTime("%H:%M:%E3S", t, lax); // "03:04:05.000" // -// Note: If the given `y_absl::Time` is `y_absl::InfiniteFuture()`, the returned -// string will be exactly "infinite-future". If the given `y_absl::Time` is -// `y_absl::InfinitePast()`, the returned string will be exactly "infinite-past". -// In both cases the given format string and `y_absl::TimeZone` are ignored. +// Note: If the given `y_absl::Time` is `y_absl::InfiniteFuture()`, the returned +// string will be exactly "infinite-future". If the given `y_absl::Time` is +// `y_absl::InfinitePast()`, the returned string will be exactly "infinite-past". +// In both cases the given format string and `y_absl::TimeZone` are ignored. // TString FormatTime(y_absl::string_view format, Time t, TimeZone tz); // Convenience functions that format the given time using the RFC3339_full // format. The first overload uses the provided TimeZone, while the second // uses LocalTimeZone(). -TString FormatTime(Time t, TimeZone tz); -TString FormatTime(Time t); +TString FormatTime(Time t, TimeZone tz); +TString FormatTime(Time t); // Output stream operator. inline std::ostream& operator<<(std::ostream& os, Time t) { @@ -1320,7 +1320,7 @@ inline std::ostream& operator<<(std::ostream& os, Time t) { // ParseTime() // // Parses an input string according to the provided format string and -// returns the corresponding `y_absl::Time`. Uses strftime()-like formatting +// returns the corresponding `y_absl::Time`. Uses strftime()-like formatting // options, with the same extensions as FormatTime(), but with the // exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f. %Ez // and %E*z also accept the same inputs, which (along with %z) includes @@ -1334,20 +1334,20 @@ inline std::ostream& operator<<(std::ostream& os, Time t) { // // "1970-01-01 00:00:00.0 +0000" // -// For example, parsing a string of "15:45" (%H:%M) will return an y_absl::Time +// For example, parsing a string of "15:45" (%H:%M) will return an y_absl::Time // that represents "1970-01-01 15:45:00.0 +0000". // // Note that since ParseTime() returns time instants, it makes the most sense // to parse fully-specified date/time strings that include a UTC offset (%z, // %Ez, or %E*z). // -// Note also that `y_absl::ParseTime()` only heeds the fields year, month, day, +// Note also that `y_absl::ParseTime()` only heeds the fields year, month, day, // hour, minute, (fractional) second, and UTC offset. Other fields, like // weekday (%a or %A), while parsed for syntactic validity, are ignored // in the conversion. // // Date and time fields that are out-of-range will be treated as errors -// rather than normalizing them like `y_absl::CivilSecond` does. For example, +// rather than normalizing them like `y_absl::CivilSecond` does. For example, // it is an error to parse the date "Oct 32, 2013" because 32 is out of range. // // A leap second of ":60" is normalized to ":00" of the following minute @@ -1362,12 +1362,12 @@ inline std::ostream& operator<<(std::ostream& os, Time t) { // to the "err" out param if it is non-null. // // Note: If the input string is exactly "infinite-future", the returned -// `y_absl::Time` will be `y_absl::InfiniteFuture()` and `true` will be returned. -// If the input string is "infinite-past", the returned `y_absl::Time` will be -// `y_absl::InfinitePast()` and `true` will be returned. +// `y_absl::Time` will be `y_absl::InfiniteFuture()` and `true` will be returned. +// If the input string is "infinite-past", the returned `y_absl::Time` will be +// `y_absl::InfinitePast()` and `true` will be returned. // bool ParseTime(y_absl::string_view format, y_absl::string_view input, Time* time, - TString* err); + TString* err); // Like ParseTime() above, but if the format string does not contain a UTC // offset specification (%z/%Ez/%E*z) then the input is interpreted in the @@ -1377,7 +1377,7 @@ bool ParseTime(y_absl::string_view format, y_absl::string_view input, Time* time // by TimeZone::TimeInfo) is returned. For these reasons we recommend that // all date/time strings include a UTC offset so they're context independent. bool ParseTime(y_absl::string_view format, y_absl::string_view input, TimeZone tz, - Time* time, TString* err); + Time* time, TString* err); // ============================================================================ // Implementation Details Follow @@ -1477,7 +1477,7 @@ constexpr auto IsValidRep64(char) -> bool { return false; } -// Converts a std::chrono::duration to an y_absl::Duration. +// Converts a std::chrono::duration to an y_absl::Duration. template <typename Rep, typename Period> constexpr Duration FromChrono(const std::chrono::duration<Rep, Period>& d) { static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid"); @@ -1510,7 +1510,7 @@ inline int64_t ToInt64(Duration d, std::ratio<3600>) { return ToInt64Hours(d); } -// Converts an y_absl::Duration to a chrono duration of type T. +// Converts an y_absl::Duration to a chrono duration of type T. template <typename T> T ToChronoDuration(Duration d) { using Rep = typename T::rep; @@ -1611,6 +1611,6 @@ constexpr Time FromTimeT(time_t t) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TIME_TIME_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone/ya.make index 363df14f7d..d7e1dc0c26 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone/ya.make @@ -21,7 +21,7 @@ ENDIF() NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src) SRCS( time_zone_fixed.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/time/ya.make index f6d3bd0ced..37cc779265 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/ya.make @@ -15,16 +15,16 @@ LICENSE( LICENSE_TEXTS(.yandex_meta/licenses.list.txt) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity - contrib/restricted/abseil-cpp-tstring/y_absl/numeric - contrib/restricted/abseil-cpp-tstring/y_absl/strings + contrib/restricted/abseil-cpp-tstring/y_absl/base + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/numeric + contrib/restricted/abseil-cpp-tstring/y_absl/strings contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal - contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time - contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone + contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time + contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone ) ADDINCL( diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h index c743f03b4c..f03d940ed9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h @@ -17,33 +17,33 @@ // any.h // ----------------------------------------------------------------------------- // -// This header file define the `y_absl::any` type for holding a type-safe value -// of any type. The 'y_absl::any` type is useful for providing a way to hold +// This header file define the `y_absl::any` type for holding a type-safe value +// of any type. The 'y_absl::any` type is useful for providing a way to hold // something that is, as yet, unspecified. Such unspecified types // traditionally are passed between API boundaries until they are later cast to // their "destination" types. To cast to such a destination type, use -// `y_absl::any_cast()`. Note that when casting an `y_absl::any`, you must cast it +// `y_absl::any_cast()`. Note that when casting an `y_absl::any`, you must cast it // to an explicit type; implicit conversions will throw. // // Example: // -// auto a = y_absl::any(65); -// y_absl::any_cast<int>(a); // 65 -// y_absl::any_cast<char>(a); // throws y_absl::bad_any_cast -// y_absl::any_cast<TString>(a); // throws y_absl::bad_any_cast +// auto a = y_absl::any(65); +// y_absl::any_cast<int>(a); // 65 +// y_absl::any_cast<char>(a); // throws y_absl::bad_any_cast +// y_absl::any_cast<TString>(a); // throws y_absl::bad_any_cast // -// `y_absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction +// `y_absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction // and is designed to be a drop-in replacement for code compliant with C++17. // // Traditionally, the behavior of casting to a temporary unspecified type has // been accomplished with the `void *` paradigm, where the pointer was to some -// other unspecified type. `y_absl::any` provides an "owning" version of `void *` +// other unspecified type. `y_absl::any` provides an "owning" version of `void *` // that avoids issues of pointer management. // -// Note: just as in the case of `void *`, use of `y_absl::any` (and its C++17 +// Note: just as in the case of `void *`, use of `y_absl::any` (and its C++17 // version `std::any`) is a code smell indicating that your API might not be // constructed correctly. We have seen that most uses of `any` are unwarranted, -// and `y_absl::any`, like `std::any`, is difficult to use properly. Before using +// and `y_absl::any`, like `std::any`, is difficult to use properly. Before using // this abstraction, make sure that you should not instead be rewriting your // code to be more specific. // @@ -53,21 +53,21 @@ #ifndef ABSL_TYPES_ANY_H_ #define ABSL_TYPES_ANY_H_ -#include "y_absl/base/config.h" -#include "y_absl/utility/utility.h" +#include "y_absl/base/config.h" +#include "y_absl/utility/utility.h" #ifdef ABSL_USES_STD_ANY #include <any> // IWYU pragma: export -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN using std::any; using std::any_cast; using std::bad_any_cast; using std::make_any; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else // ABSL_USES_STD_ANY @@ -81,9 +81,9 @@ ABSL_NAMESPACE_END #include <utility> #include "y_absl/base/internal/fast_type_id.h" -#include "y_absl/base/macros.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/types/bad_any_cast.h" +#include "y_absl/base/macros.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/types/bad_any_cast.h" // NOTE: This macro is an implementation detail that is undefined at the bottom // of the file. It is not intended for expansion directly from user code. @@ -93,107 +93,107 @@ ABSL_NAMESPACE_END #define ABSL_ANY_DETAIL_HAS_RTTI 1 #endif // !defined(__GNUC__) || defined(__GXX_RTTI) -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN class any; // swap() // -// Swaps two `y_absl::any` values. Equivalent to `x.swap(y) where `x` and `y` are -// `y_absl::any` types. +// Swaps two `y_absl::any` values. Equivalent to `x.swap(y) where `x` and `y` are +// `y_absl::any` types. void swap(any& x, any& y) noexcept; // make_any() // -// Constructs an `y_absl::any` of type `T` with the given arguments. +// Constructs an `y_absl::any` of type `T` with the given arguments. template <typename T, typename... Args> any make_any(Args&&... args); -// Overload of `y_absl::make_any()` for constructing an `y_absl::any` type from an +// Overload of `y_absl::make_any()` for constructing an `y_absl::any` type from an // initializer list. template <typename T, typename U, typename... Args> any make_any(std::initializer_list<U> il, Args&&... args); // any_cast() // -// Statically casts the value of a `const y_absl::any` type to the given type. -// This function will throw `y_absl::bad_any_cast` if the stored value type of the -// `y_absl::any` does not match the cast. +// Statically casts the value of a `const y_absl::any` type to the given type. +// This function will throw `y_absl::bad_any_cast` if the stored value type of the +// `y_absl::any` does not match the cast. // // `any_cast()` can also be used to get a reference to the internal storage iff // a reference type is passed as its `ValueType`: // // Example: // -// y_absl::any my_any = std::vector<int>(); -// y_absl::any_cast<std::vector<int>&>(my_any).push_back(42); +// y_absl::any my_any = std::vector<int>(); +// y_absl::any_cast<std::vector<int>&>(my_any).push_back(42); template <typename ValueType> ValueType any_cast(const any& operand); // Overload of `any_cast()` to statically cast the value of a non-const -// `y_absl::any` type to the given type. This function will throw -// `y_absl::bad_any_cast` if the stored value type of the `y_absl::any` does not +// `y_absl::any` type to the given type. This function will throw +// `y_absl::bad_any_cast` if the stored value type of the `y_absl::any` does not // match the cast. template <typename ValueType> ValueType any_cast(any& operand); // NOLINT(runtime/references) -// Overload of `any_cast()` to statically cast the rvalue of an `y_absl::any` -// type. This function will throw `y_absl::bad_any_cast` if the stored value type -// of the `y_absl::any` does not match the cast. +// Overload of `any_cast()` to statically cast the rvalue of an `y_absl::any` +// type. This function will throw `y_absl::bad_any_cast` if the stored value type +// of the `y_absl::any` does not match the cast. template <typename ValueType> ValueType any_cast(any&& operand); // Overload of `any_cast()` to statically cast the value of a const pointer -// `y_absl::any` type to the given pointer type, or `nullptr` if the stored value -// type of the `y_absl::any` does not match the cast. +// `y_absl::any` type to the given pointer type, or `nullptr` if the stored value +// type of the `y_absl::any` does not match the cast. template <typename ValueType> const ValueType* any_cast(const any* operand) noexcept; // Overload of `any_cast()` to statically cast the value of a pointer -// `y_absl::any` type to the given pointer type, or `nullptr` if the stored value -// type of the `y_absl::any` does not match the cast. +// `y_absl::any` type to the given pointer type, or `nullptr` if the stored value +// type of the `y_absl::any` does not match the cast. template <typename ValueType> ValueType* any_cast(any* operand) noexcept; // ----------------------------------------------------------------------------- -// y_absl::any +// y_absl::any // ----------------------------------------------------------------------------- // -// An `y_absl::any` object provides the facility to either store an instance of a -// type, known as the "contained object", or no value. An `y_absl::any` is used to -// store values of types that are unknown at compile time. The `y_absl::any` +// An `y_absl::any` object provides the facility to either store an instance of a +// type, known as the "contained object", or no value. An `y_absl::any` is used to +// store values of types that are unknown at compile time. The `y_absl::any` // object, when containing a value, must contain a value type; storing a // reference type is neither desired nor supported. // -// An `y_absl::any` can only store a type that is copy-constructible; move-only +// An `y_absl::any` can only store a type that is copy-constructible; move-only // types are not allowed within an `any` object. // // Example: // -// auto a = y_absl::any(65); // Literal, copyable -// auto b = y_absl::any(std::vector<int>()); // Default-initialized, copyable +// auto a = y_absl::any(65); // Literal, copyable +// auto b = y_absl::any(std::vector<int>()); // Default-initialized, copyable // std::unique_ptr<Foo> my_foo; -// auto c = y_absl::any(std::move(my_foo)); // Error, not copy-constructible +// auto c = y_absl::any(std::move(my_foo)); // Error, not copy-constructible // -// Note that `y_absl::any` makes use of decayed types (`y_absl::decay_t` in this +// Note that `y_absl::any` makes use of decayed types (`y_absl::decay_t` in this // context) to remove const-volatile qualifiers (known as "cv qualifiers"), // decay functions to function pointers, etc. We essentially "decay" a given // type into its essential type. // -// `y_absl::any` makes use of decayed types when determining the basic type `T` of +// `y_absl::any` makes use of decayed types when determining the basic type `T` of // the value to store in the any's contained object. In the documentation below, // we explicitly denote this by using the phrase "a decayed type of `T`". // // Example: // // const int a = 4; -// y_absl::any foo(a); // Decay ensures we store an "int", not a "const int&". +// y_absl::any foo(a); // Decay ensures we store an "int", not a "const int&". // // void my_function() {} -// y_absl::any bar(my_function); // Decay ensures we store a function pointer. +// y_absl::any bar(my_function); // Decay ensures we store a function pointer. // -// `y_absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction +// `y_absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction // and is designed to be a drop-in replacement for code compliant with C++17. class any { private: @@ -203,51 +203,51 @@ class any { public: // Constructors - // Constructs an empty `y_absl::any` object (`any::has_value()` will return + // Constructs an empty `y_absl::any` object (`any::has_value()` will return // `false`). constexpr any() noexcept; - // Copy constructs an `y_absl::any` object with a "contained object" of the - // passed type of `other` (or an empty `y_absl::any` if `other.has_value()` is + // Copy constructs an `y_absl::any` object with a "contained object" of the + // passed type of `other` (or an empty `y_absl::any` if `other.has_value()` is // `false`. any(const any& other) : obj_(other.has_value() ? other.obj_->Clone() : std::unique_ptr<ObjInterface>()) {} - // Move constructs an `y_absl::any` object with a "contained object" of the - // passed type of `other` (or an empty `y_absl::any` if `other.has_value()` is + // Move constructs an `y_absl::any` object with a "contained object" of the + // passed type of `other` (or an empty `y_absl::any` if `other.has_value()` is // `false`). any(any&& other) noexcept = default; - // Constructs an `y_absl::any` object with a "contained object" of the decayed + // Constructs an `y_absl::any` object with a "contained object" of the decayed // type of `T`, which is initialized via `std::forward<T>(value)`. // // This constructor will not participate in overload resolution if the // decayed type of `T` is not copy-constructible. template < - typename T, typename VT = y_absl::decay_t<T>, - y_absl::enable_if_t<!y_absl::disjunction< + typename T, typename VT = y_absl::decay_t<T>, + y_absl::enable_if_t<!y_absl::disjunction< std::is_same<any, VT>, IsInPlaceType<VT>, - y_absl::negation<std::is_copy_constructible<VT> > >::value>* = nullptr> + y_absl::negation<std::is_copy_constructible<VT> > >::value>* = nullptr> any(T&& value) : obj_(new Obj<VT>(in_place, std::forward<T>(value))) {} - // Constructs an `y_absl::any` object with a "contained object" of the decayed + // Constructs an `y_absl::any` object with a "contained object" of the decayed // type of `T`, which is initialized via `std::forward<T>(value)`. - template <typename T, typename... Args, typename VT = y_absl::decay_t<T>, - y_absl::enable_if_t<y_absl::conjunction< + template <typename T, typename... Args, typename VT = y_absl::decay_t<T>, + y_absl::enable_if_t<y_absl::conjunction< std::is_copy_constructible<VT>, std::is_constructible<VT, Args...>>::value>* = nullptr> explicit any(in_place_type_t<T> /*tag*/, Args&&... args) : obj_(new Obj<VT>(in_place, std::forward<Args>(args)...)) {} - // Constructs an `y_absl::any` object with a "contained object" of the passed + // Constructs an `y_absl::any` object with a "contained object" of the passed // type `VT` as a decayed type of `T`. `VT` is initialized as if // direct-non-list-initializing an object of type `VT` with the arguments // `initializer_list, std::forward<Args>(args)...`. template < - typename T, typename U, typename... Args, typename VT = y_absl::decay_t<T>, - y_absl::enable_if_t< - y_absl::conjunction<std::is_copy_constructible<VT>, + typename T, typename U, typename... Args, typename VT = y_absl::decay_t<T>, + y_absl::enable_if_t< + y_absl::conjunction<std::is_copy_constructible<VT>, std::is_constructible<VT, std::initializer_list<U>&, Args...>>::value>* = nullptr> explicit any(in_place_type_t<T> /*tag*/, std::initializer_list<U> ilist, @@ -256,24 +256,24 @@ class any { // Assignment operators - // Copy assigns an `y_absl::any` object with a "contained object" of the + // Copy assigns an `y_absl::any` object with a "contained object" of the // passed type. any& operator=(const any& rhs) { any(rhs).swap(*this); return *this; } - // Move assigns an `y_absl::any` object with a "contained object" of the + // Move assigns an `y_absl::any` object with a "contained object" of the // passed type. `rhs` is left in a valid but otherwise unspecified state. any& operator=(any&& rhs) noexcept { any(std::move(rhs)).swap(*this); return *this; } - // Assigns an `y_absl::any` object with a "contained object" of the passed type. - template <typename T, typename VT = y_absl::decay_t<T>, - y_absl::enable_if_t<y_absl::conjunction< - y_absl::negation<std::is_same<VT, any>>, + // Assigns an `y_absl::any` object with a "contained object" of the passed type. + template <typename T, typename VT = y_absl::decay_t<T>, + y_absl::enable_if_t<y_absl::conjunction< + y_absl::negation<std::is_same<VT, any>>, std::is_copy_constructible<VT>>::value>* = nullptr> any& operator=(T&& rhs) { any tmp(in_place_type_t<VT>(), std::forward<T>(rhs)); @@ -285,7 +285,7 @@ class any { // any::emplace() // - // Emplaces a value within an `y_absl::any` object by calling `any::reset()`, + // Emplaces a value within an `y_absl::any` object by calling `any::reset()`, // initializing the contained value as if direct-non-list-initializing an // object of type `VT` with the arguments `std::forward<Args>(args)...`, and // returning a reference to the new contained value. @@ -294,8 +294,8 @@ class any { // `*this` does not contain a value, and any previously contained value has // been destroyed. template < - typename T, typename... Args, typename VT = y_absl::decay_t<T>, - y_absl::enable_if_t<std::is_copy_constructible<VT>::value && + typename T, typename... Args, typename VT = y_absl::decay_t<T>, + y_absl::enable_if_t<std::is_copy_constructible<VT>::value && std::is_constructible<VT, Args...>::value>* = nullptr> VT& emplace(Args&&... args) { reset(); // NOTE: reset() is required here even in the world of exceptions. @@ -305,7 +305,7 @@ class any { return object_ptr->value; } - // Overload of `any::emplace()` to emplace a value within an `y_absl::any` + // Overload of `any::emplace()` to emplace a value within an `y_absl::any` // object by calling `any::reset()`, initializing the contained value as if // direct-non-list-initializing an object of type `VT` with the arguments // `initializer_list, std::forward<Args>(args)...`, and returning a reference @@ -317,8 +317,8 @@ class any { // unless `is_copy_constructible_v<VT>` is `true` and // `is_constructible_v<VT, initializer_list<U>&, Args...>` is `true`. template < - typename T, typename U, typename... Args, typename VT = y_absl::decay_t<T>, - y_absl::enable_if_t<std::is_copy_constructible<VT>::value && + typename T, typename U, typename... Args, typename VT = y_absl::decay_t<T>, + y_absl::enable_if_t<std::is_copy_constructible<VT>::value && std::is_constructible<VT, std::initializer_list<U>&, Args...>::value>* = nullptr> VT& emplace(std::initializer_list<U> ilist, Args&&... args) { @@ -331,13 +331,13 @@ class any { // any::reset() // - // Resets the state of the `y_absl::any` object, destroying the contained object + // Resets the state of the `y_absl::any` object, destroying the contained object // if present. void reset() noexcept { obj_ = nullptr; } // any::swap() // - // Swaps the passed value and the value of this `y_absl::any` object. + // Swaps the passed value and the value of this `y_absl::any` object. void swap(any& other) noexcept { obj_.swap(other.obj_); } // Observers @@ -411,7 +411,7 @@ class any { return obj_ ? obj_->ObjTypeId() : base_internal::FastTypeId<void>(); } - // `y_absl::any` nonmember functions // + // `y_absl::any` nonmember functions // // Description at the declaration site (top of file). template <typename ValueType> @@ -519,7 +519,7 @@ T* any_cast(any* operand) noexcept { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #undef ABSL_ANY_DETAIL_HAS_RTTI diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.cc index c7ca197521..29916186da 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.cc @@ -12,16 +12,16 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/types/bad_any_cast.h" +#include "y_absl/types/bad_any_cast.h" #ifndef ABSL_USES_STD_ANY #include <cstdlib> -#include "y_absl/base/config.h" -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/config.h" +#include "y_absl/base/internal/raw_logging.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN bad_any_cast::~bad_any_cast() = default; @@ -41,6 +41,6 @@ void ThrowBadAnyCast() { } // namespace any_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_USES_STD_ANY diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.h index 4dec75ed95..92c3bfe522 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.h @@ -16,44 +16,44 @@ // bad_any_cast.h // ----------------------------------------------------------------------------- // -// This header file defines the `y_absl::bad_any_cast` type. +// This header file defines the `y_absl::bad_any_cast` type. #ifndef ABSL_TYPES_BAD_ANY_CAST_H_ #define ABSL_TYPES_BAD_ANY_CAST_H_ #include <typeinfo> -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" #ifdef ABSL_USES_STD_ANY #include <any> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN using std::bad_any_cast; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else // ABSL_USES_STD_ANY -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ----------------------------------------------------------------------------- // bad_any_cast // ----------------------------------------------------------------------------- // -// An `y_absl::bad_any_cast` type is an exception type that is thrown when -// failing to successfully cast the return value of an `y_absl::any` object. +// An `y_absl::bad_any_cast` type is an exception type that is thrown when +// failing to successfully cast the return value of an `y_absl::any` object. // // Example: // -// auto a = y_absl::any(65); -// y_absl::any_cast<int>(a); // 65 +// auto a = y_absl::any(65); +// y_absl::any_cast<int>(a); // 65 // try { -// y_absl::any_cast<char>(a); -// } catch(const y_absl::bad_any_cast& e) { +// y_absl::any_cast<char>(a); +// } catch(const y_absl::bad_any_cast& e) { // std::cout << "Bad any cast: " << e.what() << '\n'; // } class bad_any_cast : public std::bad_cast { @@ -68,7 +68,7 @@ namespace any_internal { } // namespace any_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_USES_STD_ANY diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast/ya.make index 5cc89fd70e..a008127937 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast/ya.make @@ -12,8 +12,8 @@ OWNER( LICENSE(Apache-2.0) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity ) ADDINCL( @@ -22,7 +22,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/types) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/types) SRCS( bad_any_cast.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.cc index f8c405fbbb..e583756cd5 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.cc @@ -12,16 +12,16 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/types/bad_optional_access.h" +#include "y_absl/types/bad_optional_access.h" #ifndef ABSL_USES_STD_OPTIONAL #include <cstdlib> -#include "y_absl/base/config.h" -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/config.h" +#include "y_absl/base/internal/raw_logging.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN bad_optional_access::~bad_optional_access() = default; @@ -43,6 +43,6 @@ void throw_bad_optional_access() { } // namespace optional_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_USES_STD_OPTIONAL diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.h index b48a88d1ab..7420ade10f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.h @@ -16,45 +16,45 @@ // bad_optional_access.h // ----------------------------------------------------------------------------- // -// This header file defines the `y_absl::bad_optional_access` type. +// This header file defines the `y_absl::bad_optional_access` type. #ifndef ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_ #define ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_ #include <stdexcept> -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" #ifdef ABSL_USES_STD_OPTIONAL #include <optional> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN using std::bad_optional_access; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else // ABSL_USES_STD_OPTIONAL -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ----------------------------------------------------------------------------- // bad_optional_access // ----------------------------------------------------------------------------- // -// An `y_absl::bad_optional_access` type is an exception type that is thrown when -// attempting to access an `y_absl::optional` object that does not contain a +// An `y_absl::bad_optional_access` type is an exception type that is thrown when +// attempting to access an `y_absl::optional` object that does not contain a // value. // // Example: // -// y_absl::optional<int> o; +// y_absl::optional<int> o; // // try { // int n = o.value(); -// } catch(const y_absl::bad_optional_access& e) { +// } catch(const y_absl::bad_optional_access& e) { // std::cout << "Bad optional access: " << e.what() << '\n'; // } class bad_optional_access : public std::exception { @@ -71,7 +71,7 @@ namespace optional_internal { } // namespace optional_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_USES_STD_OPTIONAL diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access/ya.make index dd4f7fb639..fca9a916ac 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access/ya.make @@ -12,8 +12,8 @@ OWNER( LICENSE(Apache-2.0) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity ) ADDINCL( @@ -22,7 +22,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/types) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/types) SRCS( bad_optional_access.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.cc index db6498b520..77df7736a9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.cc @@ -12,17 +12,17 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "y_absl/types/bad_variant_access.h" +#include "y_absl/types/bad_variant_access.h" #ifndef ABSL_USES_STD_VARIANT #include <cstdlib> #include <stdexcept> -#include "y_absl/base/config.h" -#include "y_absl/base/internal/raw_logging.h" +#include "y_absl/base/config.h" +#include "y_absl/base/internal/raw_logging.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN ////////////////////////// @@ -51,7 +51,7 @@ void Rethrow() { throw; #else ABSL_RAW_LOG(FATAL, - "Internal error in y_absl::variant implementation. Attempted to " + "Internal error in y_absl::variant implementation. Attempted to " "rethrow an exception when building with exceptions disabled."); abort(); // TODO(calabrese) Remove once RAW_LOG FATAL is noreturn. #endif @@ -59,6 +59,6 @@ void Rethrow() { } // namespace variant_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_USES_STD_VARIANT diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.h index a79de8e049..6e41782e78 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.h @@ -16,49 +16,49 @@ // bad_variant_access.h // ----------------------------------------------------------------------------- // -// This header file defines the `y_absl::bad_variant_access` type. +// This header file defines the `y_absl::bad_variant_access` type. #ifndef ABSL_TYPES_BAD_VARIANT_ACCESS_H_ #define ABSL_TYPES_BAD_VARIANT_ACCESS_H_ #include <stdexcept> -#include "y_absl/base/config.h" +#include "y_absl/base/config.h" #ifdef ABSL_USES_STD_VARIANT #include <variant> -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN using std::bad_variant_access; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else // ABSL_USES_STD_VARIANT -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ----------------------------------------------------------------------------- // bad_variant_access // ----------------------------------------------------------------------------- // -// An `y_absl::bad_variant_access` type is an exception type that is thrown in +// An `y_absl::bad_variant_access` type is an exception type that is thrown in // the following cases: // -// * Calling `y_absl::get(y_absl::variant) with an index or type that does not +// * Calling `y_absl::get(y_absl::variant) with an index or type that does not // match the currently selected alternative type -// * Calling `y_absl::visit on an `y_absl::variant` that is in the +// * Calling `y_absl::visit on an `y_absl::variant` that is in the // `variant::valueless_by_exception` state. // // Example: // -// y_absl::variant<int, TString> v; +// y_absl::variant<int, TString> v; // v = 1; // try { -// y_absl::get<TString>(v); -// } catch(const y_absl::bad_variant_access& e) { +// y_absl::get<TString>(v); +// } catch(const y_absl::bad_variant_access& e) { // std::cout << "Bad variant access: " << e.what() << '\n'; // } class bad_variant_access : public std::exception { @@ -75,7 +75,7 @@ namespace variant_internal { } // namespace variant_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_USES_STD_VARIANT diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access/ya.make index f250c0223e..a80f8ed987 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access/ya.make @@ -12,8 +12,8 @@ OWNER( LICENSE(Apache-2.0) PEERDIR( - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity ) ADDINCL( @@ -22,7 +22,7 @@ ADDINCL( NO_COMPILER_WARNINGS() -SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/types) +SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/types) SRCS( bad_variant_access.cc diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h index 3400db2f60..4c8cf2f59f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h @@ -16,12 +16,12 @@ // compare.h // ----------------------------------------------------------------------------- // -// This header file defines the `y_absl::weak_equality`, `y_absl::strong_equality`, -// `y_absl::partial_ordering`, `y_absl::weak_ordering`, and `y_absl::strong_ordering` +// This header file defines the `y_absl::weak_equality`, `y_absl::strong_equality`, +// `y_absl::partial_ordering`, `y_absl::weak_ordering`, and `y_absl::strong_ordering` // types for storing the results of three way comparisons. // // Example: -// y_absl::weak_ordering compare(const TString& a, const TString& b); +// y_absl::weak_ordering compare(const TString& a, const TString& b); // // These are C++11 compatible versions of the C++20 corresponding types // (`std::weak_equality`, etc.) and are designed to be drop-in replacements @@ -35,10 +35,10 @@ #include <cstdlib> #include <type_traits> -#include "y_absl/base/attributes.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/base/attributes.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace compare_internal { @@ -539,15 +539,15 @@ ABSL_COMPARE_INLINE_INIT(strong_ordering, greater, #undef ABSL_COMPARE_INLINE_INIT namespace compare_internal { -// We also provide these comparator adapter functions for internal y_absl use. +// We also provide these comparator adapter functions for internal y_absl use. // Helper functions to do a boolean comparison of two keys given a boolean // or three-way comparator. // SFINAE prevents implicit conversions to bool (such as from int). template <typename Bool, - y_absl::enable_if_t<std::is_same<bool, Bool>::value, int> = 0> + y_absl::enable_if_t<std::is_same<bool, Bool>::value, int> = 0> constexpr bool compare_result_as_less_than(const Bool r) { return r; } -constexpr bool compare_result_as_less_than(const y_absl::weak_ordering r) { +constexpr bool compare_result_as_less_than(const y_absl::weak_ordering r) { return r < 0; } @@ -561,40 +561,40 @@ constexpr bool do_less_than_comparison(const Compare &compare, const K &x, // three-way comparator. // SFINAE prevents implicit conversions to int (such as from bool). template <typename Int, - y_absl::enable_if_t<std::is_same<int, Int>::value, int> = 0> -constexpr y_absl::weak_ordering compare_result_as_ordering(const Int c) { - return c < 0 ? y_absl::weak_ordering::less - : c == 0 ? y_absl::weak_ordering::equivalent - : y_absl::weak_ordering::greater; + y_absl::enable_if_t<std::is_same<int, Int>::value, int> = 0> +constexpr y_absl::weak_ordering compare_result_as_ordering(const Int c) { + return c < 0 ? y_absl::weak_ordering::less + : c == 0 ? y_absl::weak_ordering::equivalent + : y_absl::weak_ordering::greater; } -constexpr y_absl::weak_ordering compare_result_as_ordering( - const y_absl::weak_ordering c) { +constexpr y_absl::weak_ordering compare_result_as_ordering( + const y_absl::weak_ordering c) { return c; } template < typename Compare, typename K, typename LK, - y_absl::enable_if_t<!std::is_same<bool, y_absl::result_of_t<Compare( + y_absl::enable_if_t<!std::is_same<bool, y_absl::result_of_t<Compare( const K &, const LK &)>>::value, int> = 0> -constexpr y_absl::weak_ordering do_three_way_comparison(const Compare &compare, +constexpr y_absl::weak_ordering do_three_way_comparison(const Compare &compare, const K &x, const LK &y) { return compare_result_as_ordering(compare(x, y)); } template < typename Compare, typename K, typename LK, - y_absl::enable_if_t<std::is_same<bool, y_absl::result_of_t<Compare( + y_absl::enable_if_t<std::is_same<bool, y_absl::result_of_t<Compare( const K &, const LK &)>>::value, int> = 0> -constexpr y_absl::weak_ordering do_three_way_comparison(const Compare &compare, +constexpr y_absl::weak_ordering do_three_way_comparison(const Compare &compare, const K &x, const LK &y) { - return compare(x, y) ? y_absl::weak_ordering::less - : compare(y, x) ? y_absl::weak_ordering::greater - : y_absl::weak_ordering::equivalent; + return compare(x, y) ? y_absl::weak_ordering::less + : compare(y, x) ? y_absl::weak_ordering::greater + : y_absl::weak_ordering::equivalent; } } // namespace compare_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TYPES_COMPARE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/optional.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/optional.h index aded6699a1..1004a6a68a 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/optional.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/optional.h @@ -20,10 +20,10 @@ #include <type_traits> #include <utility> -#include "y_absl/base/internal/inline_variable.h" -#include "y_absl/memory/memory.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/utility/utility.h" +#include "y_absl/base/internal/inline_variable.h" +#include "y_absl/memory/memory.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/utility/utility.h" // ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS // @@ -53,7 +53,7 @@ #define ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1 #endif -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // Forward declaration @@ -101,7 +101,7 @@ class optional_data_dtor_base { template <typename... Args> constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args) - : engaged_(true), data_(y_absl::forward<Args>(args)...) {} + : engaged_(true), data_(y_absl::forward<Args>(args)...) {} ~optional_data_dtor_base() { destruct(); } }; @@ -130,7 +130,7 @@ class optional_data_dtor_base<T, true> { template <typename... Args> constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args) - : engaged_(true), data_(y_absl::forward<Args>(args)...) {} + : engaged_(true), data_(y_absl::forward<Args>(args)...) {} }; template <typename T> @@ -144,7 +144,7 @@ class optional_data_base : public optional_data_dtor_base<T> { template <typename... Args> constexpr explicit optional_data_base(in_place_t t, Args&&... args) - : base(t, y_absl::forward<Args>(args)...) {} + : base(t, y_absl::forward<Args>(args)...) {} #endif template <typename... Args> @@ -164,15 +164,15 @@ class optional_data_base : public optional_data_dtor_base<T> { } }; -// TODO(y_absl-team): Add another class using +// TODO(y_absl-team): Add another class using // std::is_trivially_move_constructible trait when available to match // http://cplusplus.github.io/LWG/lwg-defects.html#2900, for types that // have trivial move but nontrivial copy. // Also, we should be checking is_trivially_copyable here, which is not // supported now, so we use is_trivially_* traits instead. template <typename T, - bool unused = y_absl::is_trivially_copy_constructible<T>::value&& - y_absl::is_trivially_copy_assignable<typename std::remove_cv< + bool unused = y_absl::is_trivially_copy_constructible<T>::value&& + y_absl::is_trivially_copy_assignable<typename std::remove_cv< T>::type>::value&& std::is_trivially_destructible<T>::value> class optional_data; @@ -187,7 +187,7 @@ class optional_data<T, true> : public optional_data_base<T> { template <typename... Args> constexpr explicit optional_data(in_place_t t, Args&&... args) - : optional_data_base<T>(t, y_absl::forward<Args>(args)...) {} + : optional_data_base<T>(t, y_absl::forward<Args>(args)...) {} #endif }; @@ -199,7 +199,7 @@ class optional_data<T, false> : public optional_data_base<T> { #else template <typename... Args> constexpr explicit optional_data(in_place_t t, Args&&... args) - : optional_data_base<T>(t, y_absl::forward<Args>(args)...) {} + : optional_data_base<T>(t, y_absl::forward<Args>(args)...) {} #endif optional_data() = default; @@ -211,7 +211,7 @@ class optional_data<T, false> : public optional_data_base<T> { } optional_data(optional_data&& rhs) noexcept( - y_absl::default_allocator_is_nothrow::value || + y_absl::default_allocator_is_nothrow::value || std::is_nothrow_move_constructible<T>::value) : optional_data_base<T>() { if (rhs.engaged_) { @@ -324,9 +324,9 @@ struct ctor_copy_traits { template <typename T> struct assign_copy_traits { static constexpr copy_traits traits = - y_absl::is_copy_assignable<T>::value && std::is_copy_constructible<T>::value + y_absl::is_copy_assignable<T>::value && std::is_copy_constructible<T>::value ? copy_traits::copyable - : y_absl::is_move_assignable<T>::value && + : y_absl::is_move_assignable<T>::value && std::is_move_constructible<T>::value ? copy_traits::movable : copy_traits::non_movable; @@ -359,7 +359,7 @@ struct is_constructible_convertible_assignable_from_optional // for checking whether an expression is convertible to bool. bool convertible_to_bool(bool); -// Base class for std::hash<y_absl::optional<T>>: +// Base class for std::hash<y_absl::optional<T>>: // If std::hash<std::remove_const_t<T>> is enabled, it provides operator() to // compute the hash; Otherwise, it is disabled. // Reference N4659 23.14.15 [unord.hash]. @@ -373,14 +373,14 @@ struct optional_hash_base { }; template <typename T> -struct optional_hash_base<T, decltype(std::hash<y_absl::remove_const_t<T> >()( - std::declval<y_absl::remove_const_t<T> >()))> { - using argument_type = y_absl::optional<T>; +struct optional_hash_base<T, decltype(std::hash<y_absl::remove_const_t<T> >()( + std::declval<y_absl::remove_const_t<T> >()))> { + using argument_type = y_absl::optional<T>; using result_type = size_t; - size_t operator()(const y_absl::optional<T>& opt) const { - y_absl::type_traits_internal::AssertHashEnabled<y_absl::remove_const_t<T>>(); + size_t operator()(const y_absl::optional<T>& opt) const { + y_absl::type_traits_internal::AssertHashEnabled<y_absl::remove_const_t<T>>(); if (opt) { - return std::hash<y_absl::remove_const_t<T> >()(*opt); + return std::hash<y_absl::remove_const_t<T> >()(*opt); } else { return static_cast<size_t>(0x297814aaad196e6dULL); } @@ -389,7 +389,7 @@ struct optional_hash_base<T, decltype(std::hash<y_absl::remove_const_t<T> >()( } // namespace optional_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #undef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/span.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/span.h index 6a519a4577..6b36c3b0d0 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/span.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/span.h @@ -21,11 +21,11 @@ #include <util/generic/string.h> #include <type_traits> -#include "y_absl/algorithm/algorithm.h" -#include "y_absl/base/internal/throw_delegate.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/algorithm/algorithm.h" +#include "y_absl/base/internal/throw_delegate.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace span_internal { @@ -39,8 +39,8 @@ constexpr auto GetDataImpl(C& c, char) noexcept // NOLINT(runtime/references) return c.data(); } -// Before C++17, TString::data returns a const char* in all cases. -inline char* GetDataImpl(TString& s, // NOLINT(runtime/references) +// Before C++17, TString::data returns a const char* in all cases. +inline char* GetDataImpl(TString& s, // NOLINT(runtime/references) int) noexcept { return &s[0]; } @@ -54,7 +54,7 @@ constexpr auto GetData(C& c) noexcept // NOLINT(runtime/references) // Detection idioms for size() and data(). template <typename C> using HasSize = - std::is_integral<y_absl::decay_t<decltype(std::declval<C&>().size())>>; + std::is_integral<y_absl::decay_t<decltype(std::declval<C&>().size())>>; // We want to enable conversion from vector<T*> to Span<const T* const> but // disable conversion from vector<Derived> to Span<Base>. Here we use @@ -64,13 +64,13 @@ using HasSize = // which returns a reference. template <typename T, typename C> using HasData = - std::is_convertible<y_absl::decay_t<decltype(GetData(std::declval<C&>()))>*, + std::is_convertible<y_absl::decay_t<decltype(GetData(std::declval<C&>()))>*, T* const*>; // Extracts value type from a Container template <typename C> struct ElementType { - using type = typename y_absl::remove_reference_t<C>::value_type; + using type = typename y_absl::remove_reference_t<C>::value_type; }; template <typename T, size_t N> @@ -88,7 +88,7 @@ using EnableIfMutable = template <template <typename> class SpanT, typename T> bool EqualImpl(SpanT<T> a, SpanT<T> b) { static_assert(std::is_const<T>::value, ""); - return y_absl::equal(a.begin(), a.end(), b.begin(), b.end()); + return y_absl::equal(a.begin(), a.end(), b.begin(), b.end()); } template <template <typename> class SpanT, typename T> @@ -123,6 +123,6 @@ using EnableIfConvertibleTo = typename std::enable_if<IsConvertible<From, To>::value>::type; } // namespace span_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TYPES_INTERNAL_SPAN_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h index 9707661d94..4495fb4de6 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. // -// Implementation details of y_absl/types/variant.h, pulled into a +// Implementation details of y_absl/types/variant.h, pulled into a // separate file to avoid cluttering the top of the API header with // implementation details. @@ -27,19 +27,19 @@ #include <tuple> #include <type_traits> -#include "y_absl/base/config.h" -#include "y_absl/base/internal/identity.h" -#include "y_absl/base/internal/inline_variable.h" -#include "y_absl/base/internal/invoke.h" -#include "y_absl/base/macros.h" -#include "y_absl/base/optimization.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/types/bad_variant_access.h" -#include "y_absl/utility/utility.h" +#include "y_absl/base/config.h" +#include "y_absl/base/internal/identity.h" +#include "y_absl/base/internal/inline_variable.h" +#include "y_absl/base/internal/invoke.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/optimization.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/types/bad_variant_access.h" +#include "y_absl/utility/utility.h" #if !defined(ABSL_USES_STD_VARIANT) -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN template <class... Types> @@ -136,24 +136,24 @@ struct VariantAccessResultImpl; template <std::size_t I, template <class...> class Variantemplate, class... T> struct VariantAccessResultImpl<I, Variantemplate<T...>&> { - using type = typename y_absl::variant_alternative<I, variant<T...>>::type&; + using type = typename y_absl::variant_alternative<I, variant<T...>>::type&; }; template <std::size_t I, template <class...> class Variantemplate, class... T> struct VariantAccessResultImpl<I, const Variantemplate<T...>&> { using type = - const typename y_absl::variant_alternative<I, variant<T...>>::type&; + const typename y_absl::variant_alternative<I, variant<T...>>::type&; }; template <std::size_t I, template <class...> class Variantemplate, class... T> struct VariantAccessResultImpl<I, Variantemplate<T...>&&> { - using type = typename y_absl::variant_alternative<I, variant<T...>>::type&&; + using type = typename y_absl::variant_alternative<I, variant<T...>>::type&&; }; template <std::size_t I, template <class...> class Variantemplate, class... T> struct VariantAccessResultImpl<I, const Variantemplate<T...>&&> { using type = - const typename y_absl::variant_alternative<I, variant<T...>>::type&&; + const typename y_absl::variant_alternative<I, variant<T...>>::type&&; }; template <std::size_t I, class Variant> @@ -198,7 +198,7 @@ using AlwaysZero = SizeT<0>; template <class Op, class... Vs> struct VisitIndicesResultImpl { - using type = y_absl::result_of_t<Op(AlwaysZero<Vs>...)>; + using type = y_absl::result_of_t<Op(AlwaysZero<Vs>...)>; }; template <class Op, class... Vs> @@ -214,7 +214,7 @@ constexpr ReturnType call_with_indices(FunctionObject&& function) { std::is_same<ReturnType, decltype(std::declval<FunctionObject>()( SizeT<Indices>()...))>::value, "Not all visitation overloads have the same return type."); - return y_absl::forward<FunctionObject>(function)(SizeT<Indices>()...); + return y_absl::forward<FunctionObject>(function)(SizeT<Indices>()...); } template <class ReturnType, class FunctionObject, std::size_t... BoundIndices> @@ -265,7 +265,7 @@ struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<BoundIndices...>> : MakeVisitationMatrixImpl<ReturnType, FunctionObject, index_sequence<TailEndIndices...>, - y_absl::make_index_sequence<HeadEndIndex>, + y_absl::make_index_sequence<HeadEndIndex>, index_sequence<BoundIndices...>> {}; struct UnreachableSwitchCase { @@ -284,7 +284,7 @@ struct UnreachableSwitchCase { assert(false); // NOLINT // Hack to silence potential no return warning -- cause an infinite loop. - return Run(y_absl::forward<Op>(op)); + return Run(y_absl::forward<Op>(op)); #endif // Checks for __builtin_unreachable } }; @@ -326,7 +326,7 @@ using PickCase = typename PickCaseImpl<(I < EndIndex)>::template Apply<Op, I>; template <class ReturnType> [[noreturn]] ReturnType TypedThrowBadVariantAccess() { - y_absl::variant_internal::ThrowBadVariantAccess(); + y_absl::variant_internal::ThrowBadVariantAccess(); } // Given N variant sizes, determine the number of cases there would need to be @@ -357,71 +357,71 @@ struct VisitIndicesSwitch { static VisitIndicesResultT<Op, std::size_t> Run(Op&& op, std::size_t i) { switch (i) { case 0: - return PickCase<Op, 0, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 0, EndIndex>::Run(y_absl::forward<Op>(op)); case 1: - return PickCase<Op, 1, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 1, EndIndex>::Run(y_absl::forward<Op>(op)); case 2: - return PickCase<Op, 2, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 2, EndIndex>::Run(y_absl::forward<Op>(op)); case 3: - return PickCase<Op, 3, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 3, EndIndex>::Run(y_absl::forward<Op>(op)); case 4: - return PickCase<Op, 4, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 4, EndIndex>::Run(y_absl::forward<Op>(op)); case 5: - return PickCase<Op, 5, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 5, EndIndex>::Run(y_absl::forward<Op>(op)); case 6: - return PickCase<Op, 6, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 6, EndIndex>::Run(y_absl::forward<Op>(op)); case 7: - return PickCase<Op, 7, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 7, EndIndex>::Run(y_absl::forward<Op>(op)); case 8: - return PickCase<Op, 8, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 8, EndIndex>::Run(y_absl::forward<Op>(op)); case 9: - return PickCase<Op, 9, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 9, EndIndex>::Run(y_absl::forward<Op>(op)); case 10: - return PickCase<Op, 10, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 10, EndIndex>::Run(y_absl::forward<Op>(op)); case 11: - return PickCase<Op, 11, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 11, EndIndex>::Run(y_absl::forward<Op>(op)); case 12: - return PickCase<Op, 12, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 12, EndIndex>::Run(y_absl::forward<Op>(op)); case 13: - return PickCase<Op, 13, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 13, EndIndex>::Run(y_absl::forward<Op>(op)); case 14: - return PickCase<Op, 14, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 14, EndIndex>::Run(y_absl::forward<Op>(op)); case 15: - return PickCase<Op, 15, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 15, EndIndex>::Run(y_absl::forward<Op>(op)); case 16: - return PickCase<Op, 16, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 16, EndIndex>::Run(y_absl::forward<Op>(op)); case 17: - return PickCase<Op, 17, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 17, EndIndex>::Run(y_absl::forward<Op>(op)); case 18: - return PickCase<Op, 18, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 18, EndIndex>::Run(y_absl::forward<Op>(op)); case 19: - return PickCase<Op, 19, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 19, EndIndex>::Run(y_absl::forward<Op>(op)); case 20: - return PickCase<Op, 20, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 20, EndIndex>::Run(y_absl::forward<Op>(op)); case 21: - return PickCase<Op, 21, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 21, EndIndex>::Run(y_absl::forward<Op>(op)); case 22: - return PickCase<Op, 22, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 22, EndIndex>::Run(y_absl::forward<Op>(op)); case 23: - return PickCase<Op, 23, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 23, EndIndex>::Run(y_absl::forward<Op>(op)); case 24: - return PickCase<Op, 24, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 24, EndIndex>::Run(y_absl::forward<Op>(op)); case 25: - return PickCase<Op, 25, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 25, EndIndex>::Run(y_absl::forward<Op>(op)); case 26: - return PickCase<Op, 26, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 26, EndIndex>::Run(y_absl::forward<Op>(op)); case 27: - return PickCase<Op, 27, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 27, EndIndex>::Run(y_absl::forward<Op>(op)); case 28: - return PickCase<Op, 28, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 28, EndIndex>::Run(y_absl::forward<Op>(op)); case 29: - return PickCase<Op, 29, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 29, EndIndex>::Run(y_absl::forward<Op>(op)); case 30: - return PickCase<Op, 30, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 30, EndIndex>::Run(y_absl::forward<Op>(op)); case 31: - return PickCase<Op, 31, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 31, EndIndex>::Run(y_absl::forward<Op>(op)); case 32: - return PickCase<Op, 32, EndIndex>::Run(y_absl::forward<Op>(op)); + return PickCase<Op, 32, EndIndex>::Run(y_absl::forward<Op>(op)); default: ABSL_ASSERT(i == variant_npos); return y_absl::base_internal::invoke(y_absl::forward<Op>(op), NPos()); @@ -437,7 +437,7 @@ struct VisitIndicesFallback { MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op, index_sequence<(EndIndices + 1)...>, index_sequence<>>::Run(), - (indices + 1)...)(y_absl::forward<Op>(op)); + (indices + 1)...)(y_absl::forward<Op>(op)); } }; @@ -479,7 +479,7 @@ template <class IndexSequence, std::size_t... EndIndices> struct VisitIndicesVariadicImpl; template <std::size_t... N, std::size_t... EndIndices> -struct VisitIndicesVariadicImpl<y_absl::index_sequence<N...>, EndIndices...> { +struct VisitIndicesVariadicImpl<y_absl::index_sequence<N...>, EndIndices...> { // A type that can take an N-ary function object and converts it to a unary // function object that takes a single, flattened index, and "unflattens" it // into its individual dimensions when forwarding to the wrapped object. @@ -489,7 +489,7 @@ struct VisitIndicesVariadicImpl<y_absl::index_sequence<N...>, EndIndices...> { VisitIndicesResultT<Op, decltype(EndIndices)...> operator()( SizeT<I> /*index*/) && { return base_internal::invoke( - y_absl::forward<Op>(op), + y_absl::forward<Op>(op), SizeT<UnflattenIndex<I, N, (EndIndices + 1)...>::value - std::size_t{1}>()...); } @@ -501,7 +501,7 @@ struct VisitIndicesVariadicImpl<y_absl::index_sequence<N...>, EndIndices...> { static VisitIndicesResultT<Op, decltype(EndIndices)...> Run( Op&& op, SizeType... i) { return VisitIndicesSwitch<NumCasesOfSwitch<EndIndices...>::value>::Run( - FlattenedOp<Op>{y_absl::forward<Op>(op)}, + FlattenedOp<Op>{y_absl::forward<Op>(op)}, FlattenIndices<(EndIndices + std::size_t{1})...>::Run( (i + std::size_t{1})...)); } @@ -509,7 +509,7 @@ struct VisitIndicesVariadicImpl<y_absl::index_sequence<N...>, EndIndices...> { template <std::size_t... EndIndices> struct VisitIndicesVariadic - : VisitIndicesVariadicImpl<y_absl::make_index_sequence<sizeof...(EndIndices)>, + : VisitIndicesVariadicImpl<y_absl::make_index_sequence<sizeof...(EndIndices)>, EndIndices...> {}; // This implementation will flatten N-ary visit operations into a single switch @@ -522,14 +522,14 @@ struct VisitIndicesVariadic // size. template <std::size_t... EndIndices> struct VisitIndices - : y_absl::conditional_t<(NumCasesOfSwitch<EndIndices...>::value <= + : y_absl::conditional_t<(NumCasesOfSwitch<EndIndices...>::value <= MaxUnrolledVisitCases), VisitIndicesVariadic<EndIndices...>, VisitIndicesFallback<EndIndices...>> {}; template <std::size_t EndIndex> struct VisitIndices<EndIndex> - : y_absl::conditional_t<(EndIndex <= MaxUnrolledVisitCases), + : y_absl::conditional_t<(EndIndex <= MaxUnrolledVisitCases), VisitIndicesSwitch<EndIndex>, VisitIndicesFallback<EndIndex>> {}; @@ -577,7 +577,7 @@ struct VariantCoreAccess { template <class VariantType> static void Destroy(VariantType& self) { // NOLINT Derived(self).destroy(); - self.index_ = y_absl::variant_npos; + self.index_ = y_absl::variant_npos; } template <class Variant> @@ -587,7 +587,7 @@ struct VariantCoreAccess { template <class Variant> static void InitFrom(Variant& self, Variant&& other) { // NOLINT - VisitIndices<y_absl::variant_size<Variant>::value>::Run( + VisitIndices<y_absl::variant_size<Variant>::value>::Run( InitFromVisitor<Variant, Variant&&>{&self, std::forward<Variant>(other)}, other.index()); @@ -612,7 +612,7 @@ struct VariantCoreAccess { TypedThrowBadVariantAccess<VariantAccessResult<I, Variant>>(); } - return Access<I>(y_absl::forward<Variant>(self)); + return Access<I>(y_absl::forward<Variant>(self)); } // The implementation of the move-assignment operation for a variant. @@ -629,7 +629,7 @@ struct VariantCoreAccess { } } - void operator()(SizeT<y_absl::variant_npos> /*new_i*/) const { + void operator()(SizeT<y_absl::variant_npos> /*new_i*/) const { Destroy(*left); } @@ -650,7 +650,7 @@ struct VariantCoreAccess { template <std::size_t NewIndex> void operator()(SizeT<NewIndex> /*new_i*/) const { using New = - typename y_absl::variant_alternative<NewIndex, DerivedType>::type; + typename y_absl::variant_alternative<NewIndex, DerivedType>::type; if (left->index_ == NewIndex) { Access<NewIndex>(*left) = Access<NewIndex>(*right); @@ -662,7 +662,7 @@ struct VariantCoreAccess { } } - void operator()(SizeT<y_absl::variant_npos> /*new_i*/) const { + void operator()(SizeT<y_absl::variant_npos> /*new_i*/) const { Destroy(*left); } @@ -684,24 +684,24 @@ struct VariantCoreAccess { void operator()(SizeT<NewIndex::value> /*old_i*/ ) const { - Access<NewIndex::value>(*left) = y_absl::forward<QualifiedNew>(other); + Access<NewIndex::value>(*left) = y_absl::forward<QualifiedNew>(other); } template <std::size_t OldIndex> void operator()(SizeT<OldIndex> /*old_i*/ ) const { using New = - typename y_absl::variant_alternative<NewIndex::value, Left>::type; + typename y_absl::variant_alternative<NewIndex::value, Left>::type; if (std::is_nothrow_constructible<New, QualifiedNew>::value || !std::is_nothrow_move_constructible<New>::value) { left->template emplace<NewIndex::value>( - y_absl::forward<QualifiedNew>(other)); + y_absl::forward<QualifiedNew>(other)); } else { // the standard says "equivalent to // operator=(variant(std::forward<T>(t)))", but we use `emplace` here // because the variant's move assignment operator could be deleted. left->template emplace<NewIndex::value>( - New(y_absl::forward<QualifiedNew>(other))); + New(y_absl::forward<QualifiedNew>(other))); } } @@ -712,18 +712,18 @@ struct VariantCoreAccess { template <class Left, class QualifiedNew> static ConversionAssignVisitor<Left, QualifiedNew> MakeConversionAssignVisitor(Left* left, QualifiedNew&& qual) { - return {left, y_absl::forward<QualifiedNew>(qual)}; + return {left, y_absl::forward<QualifiedNew>(qual)}; } // Backend for operations for `emplace()` which destructs `*self` then // construct a new alternative with `Args...`. template <std::size_t NewIndex, class Self, class... Args> - static typename y_absl::variant_alternative<NewIndex, Self>::type& Replace( + static typename y_absl::variant_alternative<NewIndex, Self>::type& Replace( Self* self, Args&&... args) { Destroy(*self); - using New = typename y_absl::variant_alternative<NewIndex, Self>::type; + using New = typename y_absl::variant_alternative<NewIndex, Self>::type; New* const result = ::new (static_cast<void*>(&self->state_)) - New(y_absl::forward<Args>(args)...); + New(y_absl::forward<Args>(args)...); self->index_ = NewIndex; return *result; } @@ -738,7 +738,7 @@ struct VariantCoreAccess { Access<NewIndex>(std::forward<QualifiedRightVariant>(right))); } - void operator()(SizeT<y_absl::variant_npos> /*new_i*/) const { + void operator()(SizeT<y_absl::variant_npos> /*new_i*/) const { // This space intentionally left blank. } LeftVariant* left; @@ -888,13 +888,13 @@ struct IndexOfConstructedType< template <std::size_t... Is> struct ContainsVariantNPos - : y_absl::negation<std::is_same< // NOLINT - y_absl::integer_sequence<bool, 0 <= Is...>, - y_absl::integer_sequence<bool, Is != y_absl::variant_npos...>>> {}; + : y_absl::negation<std::is_same< // NOLINT + y_absl::integer_sequence<bool, 0 <= Is...>, + y_absl::integer_sequence<bool, Is != y_absl::variant_npos...>>> {}; template <class Op, class... QualifiedVariants> using RawVisitResult = - y_absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>; + y_absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>; // NOTE: The spec requires that all return-paths yield the same type and is not // SFINAE-friendly, so we can deduce the return type by examining the first @@ -905,7 +905,7 @@ using RawVisitResult = template <class Op, class... QualifiedVariants> struct VisitResultImpl { using type = - y_absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>; + y_absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>; }; // Done in two steps intentionally so that we don't cause substitution to fail. @@ -919,7 +919,7 @@ struct PerformVisitation { template <std::size_t... Is> constexpr ReturnType operator()(SizeT<Is>... indices) const { return Run(typename ContainsVariantNPos<Is...>::type{}, - y_absl::index_sequence_for<QualifiedVariants...>(), indices...); + y_absl::index_sequence_for<QualifiedVariants...>(), indices...); } template <std::size_t... TupIs, std::size_t... Is> @@ -927,19 +927,19 @@ struct PerformVisitation { index_sequence<TupIs...>, SizeT<Is>...) const { static_assert( std::is_same<ReturnType, - y_absl::result_of_t<Op(VariantAccessResult< + y_absl::result_of_t<Op(VariantAccessResult< Is, QualifiedVariants>...)>>::value, "All visitation overloads must have the same return type."); return y_absl::base_internal::invoke( - y_absl::forward<Op>(op), + y_absl::forward<Op>(op), VariantCoreAccess::Access<Is>( - y_absl::forward<QualifiedVariants>(std::get<TupIs>(variant_tup)))...); + y_absl::forward<QualifiedVariants>(std::get<TupIs>(variant_tup)))...); } template <std::size_t... TupIs, std::size_t... Is> [[noreturn]] ReturnType Run(std::true_type /*has_valueless*/, index_sequence<TupIs...>, SizeT<Is>...) const { - y_absl::variant_internal::ThrowBadVariantAccess(); + y_absl::variant_internal::ThrowBadVariantAccess(); } // TODO(calabrese) Avoid using a tuple, which causes lots of instantiations @@ -981,11 +981,11 @@ union Union<Head, Tail...> { template <class... P> explicit constexpr Union(EmplaceTag<0>, P&&... args) - : head(y_absl::forward<P>(args)...) {} + : head(y_absl::forward<P>(args)...) {} template <std::size_t I, class... P> explicit constexpr Union(EmplaceTag<I>, P&&... args) - : tail(EmplaceTag<I - 1>{}, y_absl::forward<P>(args)...) {} + : tail(EmplaceTag<I - 1>{}, y_absl::forward<P>(args)...) {} Head head; TailUnion tail; @@ -1013,11 +1013,11 @@ union DestructibleUnionImpl<Head, Tail...> { template <class... P> explicit constexpr DestructibleUnionImpl(EmplaceTag<0>, P&&... args) - : head(y_absl::forward<P>(args)...) {} + : head(y_absl::forward<P>(args)...) {} template <std::size_t I, class... P> explicit constexpr DestructibleUnionImpl(EmplaceTag<I>, P&&... args) - : tail(EmplaceTag<I - 1>{}, y_absl::forward<P>(args)...) {} + : tail(EmplaceTag<I - 1>{}, y_absl::forward<P>(args)...) {} ~DestructibleUnionImpl() {} @@ -1030,7 +1030,7 @@ union DestructibleUnionImpl<Head, Tail...> { // this resultant type. template <class... T> using DestructibleUnion = - y_absl::conditional_t<std::is_destructible<Union<T...>>::value, Union<T...>, + y_absl::conditional_t<std::is_destructible<Union<T...>>::value, Union<T...>, DestructibleUnionImpl<T...>>; // Deepest base, containing the actual union and the discriminator @@ -1040,7 +1040,7 @@ class VariantStateBase { using Variant = variant<H, T...>; template <class LazyH = H, - class ConstructibleH = y_absl::enable_if_t< + class ConstructibleH = y_absl::enable_if_t< std::is_default_constructible<LazyH>::value, LazyH>> constexpr VariantStateBase() noexcept( std::is_nothrow_default_constructible<ConstructibleH>::value) @@ -1048,7 +1048,7 @@ class VariantStateBase { template <std::size_t I, class... P> explicit constexpr VariantStateBase(EmplaceTag<I> tag, P&&... args) - : state_(tag, y_absl::forward<P>(args)...), index_(I) {} + : state_(tag, y_absl::forward<P>(args)...), index_(I) {} explicit constexpr VariantStateBase(NoopConstructorTag) : state_(NoopConstructorTag()), index_(variant_npos) {} @@ -1059,7 +1059,7 @@ class VariantStateBase { std::size_t index_; }; -using y_absl::internal::identity; +using y_absl::internal::identity; // OverloadSet::Overload() is a unary function which is overloaded to // take any of the element types of the variant, by reference-to-const. @@ -1106,37 +1106,37 @@ using NotEqualResult = decltype(std::declval<T>() != std::declval<T>()); using type_traits_internal::is_detected_convertible; template <class... T> -using RequireAllHaveEqualT = y_absl::enable_if_t< - y_absl::conjunction<is_detected_convertible<bool, EqualResult, T>...>::value, +using RequireAllHaveEqualT = y_absl::enable_if_t< + y_absl::conjunction<is_detected_convertible<bool, EqualResult, T>...>::value, bool>; template <class... T> using RequireAllHaveNotEqualT = - y_absl::enable_if_t<y_absl::conjunction<is_detected_convertible< + y_absl::enable_if_t<y_absl::conjunction<is_detected_convertible< bool, NotEqualResult, T>...>::value, bool>; template <class... T> using RequireAllHaveLessThanT = - y_absl::enable_if_t<y_absl::conjunction<is_detected_convertible< + y_absl::enable_if_t<y_absl::conjunction<is_detected_convertible< bool, LessThanResult, T>...>::value, bool>; template <class... T> using RequireAllHaveLessThanOrEqualT = - y_absl::enable_if_t<y_absl::conjunction<is_detected_convertible< + y_absl::enable_if_t<y_absl::conjunction<is_detected_convertible< bool, LessThanOrEqualResult, T>...>::value, bool>; template <class... T> using RequireAllHaveGreaterThanOrEqualT = - y_absl::enable_if_t<y_absl::conjunction<is_detected_convertible< + y_absl::enable_if_t<y_absl::conjunction<is_detected_convertible< bool, GreaterThanOrEqualResult, T>...>::value, bool>; template <class... T> using RequireAllHaveGreaterThanT = - y_absl::enable_if_t<y_absl::conjunction<is_detected_convertible< + y_absl::enable_if_t<y_absl::conjunction<is_detected_convertible< bool, GreaterThanResult, T>...>::value, bool>; @@ -1171,7 +1171,7 @@ struct VariantHelper<variant<Ts...>> { template <typename... Us> struct CanConvertFrom<variant<Us...>> - : public y_absl::conjunction<CanAccept<Us>...> {}; + : public y_absl::conjunction<CanAccept<Us>...> {}; }; // A type with nontrivial copy ctor and trivial move ctor. @@ -1220,7 +1220,7 @@ class VariantCopyAssignBaseNontrivial; // Base that is dependent on whether or not the destructor can be trivial. template <class... T> using VariantStateBaseDestructor = - y_absl::conditional_t<std::is_destructible<Union<T...>>::value, + y_absl::conditional_t<std::is_destructible<Union<T...>>::value, VariantStateBase<T...>, VariantStateBaseDestructorNontrivial<T...>>; @@ -1232,44 +1232,44 @@ using VariantStateBaseDestructor = // So we have to use a different approach (i.e. `HasTrivialMoveConstructor`) to // work around the bug. template <class... T> -using VariantMoveBase = y_absl::conditional_t< - y_absl::disjunction< - y_absl::negation<y_absl::conjunction<std::is_move_constructible<T>...>>, - y_absl::conjunction<IsTriviallyMoveConstructible<T>...>>::value, +using VariantMoveBase = y_absl::conditional_t< + y_absl::disjunction< + y_absl::negation<y_absl::conjunction<std::is_move_constructible<T>...>>, + y_absl::conjunction<IsTriviallyMoveConstructible<T>...>>::value, VariantStateBaseDestructor<T...>, VariantMoveBaseNontrivial<T...>>; // Base that is dependent on whether or not the copy-constructor can be trivial. template <class... T> -using VariantCopyBase = y_absl::conditional_t< - y_absl::disjunction< - y_absl::negation<y_absl::conjunction<std::is_copy_constructible<T>...>>, +using VariantCopyBase = y_absl::conditional_t< + y_absl::disjunction< + y_absl::negation<y_absl::conjunction<std::is_copy_constructible<T>...>>, std::is_copy_constructible<Union<T...>>>::value, VariantMoveBase<T...>, VariantCopyBaseNontrivial<T...>>; // Base that is dependent on whether or not the move-assign can be trivial. template <class... T> -using VariantMoveAssignBase = y_absl::conditional_t< - y_absl::disjunction< - y_absl::conjunction<y_absl::is_move_assignable<Union<T...>>, +using VariantMoveAssignBase = y_absl::conditional_t< + y_absl::disjunction< + y_absl::conjunction<y_absl::is_move_assignable<Union<T...>>, std::is_move_constructible<Union<T...>>, std::is_destructible<Union<T...>>>, - y_absl::negation<y_absl::conjunction<std::is_move_constructible<T>..., + y_absl::negation<y_absl::conjunction<std::is_move_constructible<T>..., // Note: We're not qualifying this with - // y_absl:: because it doesn't compile + // y_absl:: because it doesn't compile // under MSVC. is_move_assignable<T>...>>>::value, VariantCopyBase<T...>, VariantMoveAssignBaseNontrivial<T...>>; // Base that is dependent on whether or not the copy-assign can be trivial. template <class... T> -using VariantCopyAssignBase = y_absl::conditional_t< - y_absl::disjunction< - y_absl::conjunction<y_absl::is_copy_assignable<Union<T...>>, +using VariantCopyAssignBase = y_absl::conditional_t< + y_absl::disjunction< + y_absl::conjunction<y_absl::is_copy_assignable<Union<T...>>, std::is_copy_constructible<Union<T...>>, std::is_destructible<Union<T...>>>, - y_absl::negation<y_absl::conjunction<std::is_copy_constructible<T>..., + y_absl::negation<y_absl::conjunction<std::is_copy_constructible<T>..., // Note: We're not qualifying this with - // y_absl:: because it doesn't compile + // y_absl:: because it doesn't compile // under MSVC. is_copy_assignable<T>...>>>::value, VariantMoveAssignBase<T...>, VariantCopyAssignBaseNontrivial<T...>>; @@ -1299,11 +1299,11 @@ class VariantStateBaseDestructorNontrivial : protected VariantStateBase<T...> { template <std::size_t I> void operator()(SizeT<I> i) const { using Alternative = - typename y_absl::variant_alternative<I, variant<T...>>::type; + typename y_absl::variant_alternative<I, variant<T...>>::type; variant_internal::AccessUnion(self->state_, i).~Alternative(); } - void operator()(SizeT<y_absl::variant_npos> /*i*/) const { + void operator()(SizeT<y_absl::variant_npos> /*i*/) const { // This space intentionally left blank } @@ -1331,12 +1331,12 @@ class VariantMoveBaseNontrivial : protected VariantStateBaseDestructor<T...> { template <std::size_t I> void operator()(SizeT<I> i) const { using Alternative = - typename y_absl::variant_alternative<I, variant<T...>>::type; + typename y_absl::variant_alternative<I, variant<T...>>::type; ::new (static_cast<void*>(&self->state_)) Alternative( - variant_internal::AccessUnion(y_absl::move(other->state_), i)); + variant_internal::AccessUnion(y_absl::move(other->state_), i)); } - void operator()(SizeT<y_absl::variant_npos> /*i*/) const {} + void operator()(SizeT<y_absl::variant_npos> /*i*/) const {} VariantMoveBaseNontrivial* self; VariantMoveBaseNontrivial* other; @@ -1344,7 +1344,7 @@ class VariantMoveBaseNontrivial : protected VariantStateBaseDestructor<T...> { VariantMoveBaseNontrivial() = default; VariantMoveBaseNontrivial(VariantMoveBaseNontrivial&& other) noexcept( - y_absl::conjunction<std::is_nothrow_move_constructible<T>...>::value) + y_absl::conjunction<std::is_nothrow_move_constructible<T>...>::value) : Base(NoopConstructorTag()) { VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_); index_ = other.index_; @@ -1376,12 +1376,12 @@ class VariantCopyBaseNontrivial : protected VariantMoveBase<T...> { template <std::size_t I> void operator()(SizeT<I> i) const { using Alternative = - typename y_absl::variant_alternative<I, variant<T...>>::type; + typename y_absl::variant_alternative<I, variant<T...>>::type; ::new (static_cast<void*>(&self->state_)) Alternative(variant_internal::AccessUnion(other->state_, i)); } - void operator()(SizeT<y_absl::variant_npos> /*i*/) const {} + void operator()(SizeT<y_absl::variant_npos> /*i*/) const {} VariantCopyBaseNontrivial* self; const VariantCopyBaseNontrivial* other; @@ -1421,7 +1421,7 @@ class VariantMoveAssignBaseNontrivial : protected VariantCopyBase<T...> { VariantMoveAssignBaseNontrivial& operator=(VariantMoveAssignBaseNontrivial&& other) noexcept( - y_absl::conjunction<std::is_nothrow_move_constructible<T>..., + y_absl::conjunction<std::is_nothrow_move_constructible<T>..., std::is_nothrow_move_assignable<T>...>::value) { VisitIndices<sizeof...(T)>::Run( VariantCoreAccess::MakeMoveAssignVisitor(this, &other), other.index_); @@ -1471,7 +1471,7 @@ struct EqualsOp { const variant<Types...>* v; const variant<Types...>* w; - constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { + constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { return true; } @@ -1486,7 +1486,7 @@ struct NotEqualsOp { const variant<Types...>* v; const variant<Types...>* w; - constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { + constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { return false; } @@ -1501,7 +1501,7 @@ struct LessThanOp { const variant<Types...>* v; const variant<Types...>* w; - constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { + constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { return false; } @@ -1516,7 +1516,7 @@ struct GreaterThanOp { const variant<Types...>* v; const variant<Types...>* w; - constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { + constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { return false; } @@ -1531,7 +1531,7 @@ struct LessThanOrEqualsOp { const variant<Types...>* v; const variant<Types...>* w; - constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { + constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { return true; } @@ -1546,7 +1546,7 @@ struct GreaterThanOrEqualsOp { const variant<Types...>* v; const variant<Types...>* w; - constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { + constexpr bool operator()(SizeT<y_absl::variant_npos> /*v_i*/) const { return true; } @@ -1584,7 +1584,7 @@ struct Swap { VariantCoreAccess::InitFrom(*v, std::move(tmp)); } - void operator()(SizeT<y_absl::variant_npos> /*w_i*/) const { + void operator()(SizeT<y_absl::variant_npos> /*w_i*/) const { if (!v->valueless_by_exception()) { generic_swap(); } @@ -1618,7 +1618,7 @@ struct VariantHashVisitor { template <typename Variant, typename... Ts> struct VariantHashBase<Variant, - y_absl::enable_if_t<y_absl::conjunction< + y_absl::enable_if_t<y_absl::conjunction< type_traits_internal::IsHashable<Ts>...>::value>, Ts...> { using argument_type = Variant; @@ -1640,7 +1640,7 @@ struct VariantHashBase<Variant, } // namespace variant_internal ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // !defined(ABSL_USES_STD_VARIANT) #endif // ABSL_TYPES_variant_internal_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h index 7465de0f86..d4ef0bb57b 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h @@ -16,7 +16,7 @@ // optional.h // ----------------------------------------------------------------------------- // -// This header file defines the `y_absl::optional` type for holding a value which +// This header file defines the `y_absl::optional` type for holding a value which // may or may not be present. This type is useful for providing value semantics // for operations that may either wish to return or hold "something-or-nothing". // @@ -26,23 +26,23 @@ // // parameter and a bool return type: // bool AcquireResource(const Input&, Resource * out); // -// // Providing an y_absl::optional return type provides a cleaner API: -// y_absl::optional<Resource> AcquireResource(const Input&); +// // Providing an y_absl::optional return type provides a cleaner API: +// y_absl::optional<Resource> AcquireResource(const Input&); // -// `y_absl::optional` is a C++11 compatible version of the C++17 `std::optional` +// `y_absl::optional` is a C++11 compatible version of the C++17 `std::optional` // abstraction and is designed to be a drop-in replacement for code compliant // with C++17. #ifndef ABSL_TYPES_OPTIONAL_H_ #define ABSL_TYPES_OPTIONAL_H_ -#include "y_absl/base/config.h" // TODO(calabrese) IWYU removal? -#include "y_absl/utility/utility.h" +#include "y_absl/base/config.h" // TODO(calabrese) IWYU removal? +#include "y_absl/utility/utility.h" #ifdef ABSL_USES_STD_OPTIONAL #include <optional> // IWYU pragma: export -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN using std::bad_optional_access; using std::optional; @@ -50,7 +50,7 @@ using std::make_optional; using std::nullopt_t; using std::nullopt; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else // ABSL_USES_STD_OPTIONAL @@ -60,18 +60,18 @@ ABSL_NAMESPACE_END #include <type_traits> #include <utility> -#include "y_absl/base/attributes.h" -#include "y_absl/base/internal/inline_variable.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/types/bad_optional_access.h" -#include "y_absl/types/internal/optional.h" +#include "y_absl/base/attributes.h" +#include "y_absl/base/internal/inline_variable.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/types/bad_optional_access.h" +#include "y_absl/types/internal/optional.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // nullopt_t // -// Class type for `y_absl::nullopt` used to indicate an `y_absl::optional<T>` type +// Class type for `y_absl::nullopt` used to indicate an `y_absl::optional<T>` type // that does not contain a value. struct nullopt_t { // It must not be default-constructible to avoid ambiguity for opt = {}. @@ -80,16 +80,16 @@ struct nullopt_t { // nullopt // -// A tag constant of type `y_absl::nullopt_t` used to indicate an empty -// `y_absl::optional` in certain functions, such as construction or assignment. +// A tag constant of type `y_absl::nullopt_t` used to indicate an empty +// `y_absl::optional` in certain functions, such as construction or assignment. ABSL_INTERNAL_INLINE_CONSTEXPR(nullopt_t, nullopt, nullopt_t(optional_internal::init_t())); // ----------------------------------------------------------------------------- -// y_absl::optional +// y_absl::optional // ----------------------------------------------------------------------------- // -// A value of type `y_absl::optional<T>` holds either a value of `T` or an +// A value of type `y_absl::optional<T>` holds either a value of `T` or an // "empty" value. When it holds a value of `T`, it stores it as a direct // sub-object, so `sizeof(optional<T>)` is approximately // `sizeof(T) + sizeof(bool)`. @@ -97,13 +97,13 @@ ABSL_INTERNAL_INLINE_CONSTEXPR(nullopt_t, nullopt, // This implementation is based on the specification in the latest draft of the // C++17 `std::optional` specification as of May 2017, section 20.6. // -// Differences between `y_absl::optional<T>` and `std::optional<T>` include: +// Differences between `y_absl::optional<T>` and `std::optional<T>` include: // // * `constexpr` is not used for non-const member functions. // (dependency on some differences between C++11 and C++14.) -// * `y_absl::nullopt` and `y_absl::in_place` are not declared `constexpr`. We +// * `y_absl::nullopt` and `y_absl::in_place` are not declared `constexpr`. We // need the inline variable support in C++17 for external linkage. -// * Throws `y_absl::bad_optional_access` instead of +// * Throws `y_absl::bad_optional_access` instead of // `std::bad_optional_access`. // * `make_optional()` cannot be declared `constexpr` due to the absence of // guaranteed copy elision. @@ -146,11 +146,11 @@ class optional : private optional_internal::optional_data<T>, // (The `in_place_t` is a tag used to indicate that the contained object // should be constructed in-place.) template <typename InPlaceT, typename... Args, - y_absl::enable_if_t<y_absl::conjunction< + y_absl::enable_if_t<y_absl::conjunction< std::is_same<InPlaceT, in_place_t>, std::is_constructible<T, Args&&...> >::value>* = nullptr> constexpr explicit optional(InPlaceT, Args&&... args) - : data_base(in_place_t(), y_absl::forward<Args>(args)...) {} + : data_base(in_place_t(), y_absl::forward<Args>(args)...) {} // Constructs a non-empty `optional` direct-initialized value of type `T` from // the arguments of an initializer_list and `std::forward<Args>(args)...`. @@ -161,43 +161,43 @@ class optional : private optional_internal::optional_data<T>, T, std::initializer_list<U>&, Args&&...>::value>::type> constexpr explicit optional(in_place_t, std::initializer_list<U> il, Args&&... args) - : data_base(in_place_t(), il, y_absl::forward<Args>(args)...) { + : data_base(in_place_t(), il, y_absl::forward<Args>(args)...) { } // Value constructor (implicit) template < typename U = T, typename std::enable_if< - y_absl::conjunction<y_absl::negation<std::is_same< + y_absl::conjunction<y_absl::negation<std::is_same< in_place_t, typename std::decay<U>::type> >, - y_absl::negation<std::is_same< + y_absl::negation<std::is_same< optional<T>, typename std::decay<U>::type> >, std::is_convertible<U&&, T>, std::is_constructible<T, U&&> >::value, bool>::type = false> - constexpr optional(U&& v) : data_base(in_place_t(), y_absl::forward<U>(v)) {} + constexpr optional(U&& v) : data_base(in_place_t(), y_absl::forward<U>(v)) {} // Value constructor (explicit) template < typename U = T, typename std::enable_if< - y_absl::conjunction<y_absl::negation<std::is_same< + y_absl::conjunction<y_absl::negation<std::is_same< in_place_t, typename std::decay<U>::type>>, - y_absl::negation<std::is_same< + y_absl::negation<std::is_same< optional<T>, typename std::decay<U>::type>>, - y_absl::negation<std::is_convertible<U&&, T>>, + y_absl::negation<std::is_convertible<U&&, T>>, std::is_constructible<T, U&&>>::value, bool>::type = false> explicit constexpr optional(U&& v) - : data_base(in_place_t(), y_absl::forward<U>(v)) {} + : data_base(in_place_t(), y_absl::forward<U>(v)) {} // Converting copy constructor (implicit) template <typename U, typename std::enable_if< - y_absl::conjunction< - y_absl::negation<std::is_same<T, U> >, + y_absl::conjunction< + y_absl::negation<std::is_same<T, U> >, std::is_constructible<T, const U&>, - y_absl::negation< + y_absl::negation< optional_internal:: is_constructible_convertible_from_optional<T, U> >, std::is_convertible<const U&, T> >::value, @@ -211,13 +211,13 @@ class optional : private optional_internal::optional_data<T>, // Converting copy constructor (explicit) template <typename U, typename std::enable_if< - y_absl::conjunction< - y_absl::negation<std::is_same<T, U>>, + y_absl::conjunction< + y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, const U&>, - y_absl::negation< + y_absl::negation< optional_internal:: is_constructible_convertible_from_optional<T, U>>, - y_absl::negation<std::is_convertible<const U&, T>>>::value, + y_absl::negation<std::is_convertible<const U&, T>>>::value, bool>::type = false> explicit optional(const optional<U>& rhs) { if (rhs) { @@ -228,10 +228,10 @@ class optional : private optional_internal::optional_data<T>, // Converting move constructor (implicit) template <typename U, typename std::enable_if< - y_absl::conjunction< - y_absl::negation<std::is_same<T, U> >, + y_absl::conjunction< + y_absl::negation<std::is_same<T, U> >, std::is_constructible<T, U&&>, - y_absl::negation< + y_absl::negation< optional_internal:: is_constructible_convertible_from_optional<T, U> >, std::is_convertible<U&&, T> >::value, @@ -246,12 +246,12 @@ class optional : private optional_internal::optional_data<T>, template < typename U, typename std::enable_if< - y_absl::conjunction< - y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, - y_absl::negation< + y_absl::conjunction< + y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, + y_absl::negation< optional_internal::is_constructible_convertible_from_optional< T, U>>, - y_absl::negation<std::is_convertible<U&&, T>>>::value, + y_absl::negation<std::is_convertible<U&&, T>>>::value, bool>::type = false> explicit optional(optional<U>&& rhs) { if (rhs) { @@ -269,7 +269,7 @@ class optional : private optional_internal::optional_data<T>, // Example: // // struct S { int value; }; - // optional<S> opt = y_absl::nullopt; // Could also use opt = { }; + // optional<S> opt = y_absl::nullopt; // Could also use opt = { }; optional& operator=(nullopt_t) noexcept { this->destruct(); return *this; @@ -284,11 +284,11 @@ class optional : private optional_internal::optional_data<T>, // Value assignment operators template < typename U = T, - typename = typename std::enable_if<y_absl::conjunction< - y_absl::negation< + typename = typename std::enable_if<y_absl::conjunction< + y_absl::negation< std::is_same<optional<T>, typename std::decay<U>::type>>, - y_absl::negation< - y_absl::conjunction<std::is_scalar<T>, + y_absl::negation< + y_absl::conjunction<std::is_scalar<T>, std::is_same<T, typename std::decay<U>::type>>>, std::is_constructible<T, U>, std::is_assignable<T&, U>>::value>::type> optional& operator=(U&& v) { @@ -298,10 +298,10 @@ class optional : private optional_internal::optional_data<T>, template < typename U, - typename = typename std::enable_if<y_absl::conjunction< - y_absl::negation<std::is_same<T, U>>, + typename = typename std::enable_if<y_absl::conjunction< + y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, const U&>, std::is_assignable<T&, const U&>, - y_absl::negation< + y_absl::negation< optional_internal:: is_constructible_convertible_assignable_from_optional< T, U>>>::value>::type> @@ -315,10 +315,10 @@ class optional : private optional_internal::optional_data<T>, } template <typename U, - typename = typename std::enable_if<y_absl::conjunction< - y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U>, + typename = typename std::enable_if<y_absl::conjunction< + y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U>, std::is_assignable<T&, U>, - y_absl::negation< + y_absl::negation< optional_internal:: is_constructible_convertible_assignable_from_optional< T, U>>>::value>::type> @@ -335,7 +335,7 @@ class optional : private optional_internal::optional_data<T>, // optional::reset() // - // Destroys the inner `T` value of an `y_absl::optional` if one is present. + // Destroys the inner `T` value of an `y_absl::optional` if one is present. ABSL_ATTRIBUTE_REINITIALIZES void reset() noexcept { this->destruct(); } // optional::emplace() @@ -467,7 +467,7 @@ class optional : private optional_internal::optional_data<T>, // // Returns a reference to an `optional`s underlying value. The constness // and lvalue/rvalue-ness of the `optional` is preserved to the view of - // the `T` sub-object. Throws `y_absl::bad_optional_access` when the `optional` + // the `T` sub-object. Throws `y_absl::bad_optional_access` when the `optional` // is empty. constexpr const T& value() const & { return static_cast<bool>(*this) @@ -486,7 +486,7 @@ class optional : private optional_internal::optional_data<T>, : (optional_internal::throw_bad_optional_access(), reference())); } constexpr const T&& value() const && { // NOLINT(build/c++11) - return y_absl::move( + return y_absl::move( static_cast<bool>(*this) ? reference() : (optional_internal::throw_bad_optional_access(), reference())); @@ -507,7 +507,7 @@ class optional : private optional_internal::optional_data<T>, "optional<T>::value_or: U must be convertible to T"); return static_cast<bool>(*this) ? **this - : static_cast<T>(y_absl::forward<U>(v)); + : static_cast<T>(y_absl::forward<U>(v)); } template <typename U> T value_or(U&& v) && { // NOLINT(build/c++11) @@ -540,7 +540,7 @@ class optional : private optional_internal::optional_data<T>, // swap() // -// Performs a swap between two `y_absl::optional` objects, using standard +// Performs a swap between two `y_absl::optional` objects, using standard // semantics. template <typename T, typename std::enable_if< std::is_move_constructible<T>::value && @@ -553,7 +553,7 @@ void swap(optional<T>& a, optional<T>& b) noexcept(noexcept(a.swap(b))) { // make_optional() // // Creates a non-empty `optional<T>` where the type of `T` is deduced. An -// `y_absl::optional` can also be explicitly instantiated with +// `y_absl::optional` can also be explicitly instantiated with // `make_optional<T>(v)`. // // Note: `make_optional()` constructions may be declared `constexpr` for @@ -563,23 +563,23 @@ void swap(optional<T>& a, optional<T>& b) noexcept(noexcept(a.swap(b))) { // // Example: // -// constexpr y_absl::optional<int> opt = y_absl::make_optional(1); +// constexpr y_absl::optional<int> opt = y_absl::make_optional(1); // static_assert(opt.value() == 1, ""); template <typename T> constexpr optional<typename std::decay<T>::type> make_optional(T&& v) { - return optional<typename std::decay<T>::type>(y_absl::forward<T>(v)); + return optional<typename std::decay<T>::type>(y_absl::forward<T>(v)); } template <typename T, typename... Args> constexpr optional<T> make_optional(Args&&... args) { - return optional<T>(in_place_t(), y_absl::forward<Args>(args)...); + return optional<T>(in_place_t(), y_absl::forward<Args>(args)...); } template <typename T, typename U, typename... Args> constexpr optional<T> make_optional(std::initializer_list<U> il, Args&&... args) { return optional<T>(in_place_t(), il, - y_absl::forward<Args>(args)...); + y_absl::forward<Args>(args)...); } // Relational operators [optional.relops] @@ -758,14 +758,14 @@ constexpr auto operator>=(const U& v, const optional<T>& x) } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl namespace std { -// std::hash specialization for y_absl::optional. +// std::hash specialization for y_absl::optional. template <typename T> -struct hash<y_absl::optional<T> > - : y_absl::optional_internal::optional_hash_base<T> {}; +struct hash<y_absl::optional<T> > + : y_absl::optional_internal::optional_hash_base<T> {}; } // namespace std diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h index ab4a70b266..1490b2f1b2 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h @@ -34,19 +34,19 @@ // differences between `y_absl::Span` and `std::span` are: // * `y_absl::Span` has `operator==` (which is likely a design bug, // per https://abseil.io/blog/20180531-regular-types) -// * `y_absl::Span` has the factory functions `MakeSpan()` and +// * `y_absl::Span` has the factory functions `MakeSpan()` and // `MakeConstSpan()` -// * bounds-checked access to `y_absl::Span` is accomplished with `at()` -// * `y_absl::Span` has compiler-provided move and copy constructors and +// * bounds-checked access to `y_absl::Span` is accomplished with `at()` +// * `y_absl::Span` has compiler-provided move and copy constructors and // assignment. This is due to them being specified as `constexpr`, but that // implies const in C++11. -// * A read-only `y_absl::Span<const T>` can be implicitly constructed from an +// * A read-only `y_absl::Span<const T>` can be implicitly constructed from an // initializer list. -// * `y_absl::Span` has no `bytes()`, `size_bytes()`, `as_bytes()`, or +// * `y_absl::Span` has no `bytes()`, `size_bytes()`, `as_bytes()`, or // `as_mutable_bytes()` methods -// * `y_absl::Span` has no static extent template parameter, nor constructors +// * `y_absl::Span` has no static extent template parameter, nor constructors // which exist only because of the static extent parameter. -// * `y_absl::Span` has an explicit mutable-reference constructor +// * `y_absl::Span` has an explicit mutable-reference constructor // // For more information, see the class comments below. #ifndef ABSL_TYPES_SPAN_H_ @@ -60,14 +60,14 @@ #include <type_traits> #include <utility> -#include "y_absl/base/internal/throw_delegate.h" -#include "y_absl/base/macros.h" -#include "y_absl/base/optimization.h" -#include "y_absl/base/port.h" // TODO(strel): remove this include -#include "y_absl/meta/type_traits.h" -#include "y_absl/types/internal/span.h" +#include "y_absl/base/internal/throw_delegate.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/optimization.h" +#include "y_absl/base/port.h" // TODO(strel): remove this include +#include "y_absl/meta/type_traits.h" +#include "y_absl/types/internal/span.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN //------------------------------------------------------------------------------ @@ -88,12 +88,12 @@ ABSL_NAMESPACE_BEGIN // // Spans may also be constructed from containers holding contiguous sequences. // Such containers must supply `data()` and `size() const` methods (e.g -// `std::vector<T>`, `y_absl::InlinedVector<T, N>`). All implicit conversions to -// `y_absl::Span` from such containers will create spans of type `const T`; +// `std::vector<T>`, `y_absl::InlinedVector<T, N>`). All implicit conversions to +// `y_absl::Span` from such containers will create spans of type `const T`; // spans which can mutate their values (of type `T`) must use explicit // constructors. // -// A `Span<T>` is somewhat analogous to an `y_absl::string_view`, but for an array +// A `Span<T>` is somewhat analogous to an `y_absl::string_view`, but for an array // of elements of type `T`, and unlike an `y_absl::string_view`, a span can hold a // reference to mutable data. A user of `Span` must ensure that the data being // pointed to outlives the `Span` itself. @@ -109,14 +109,14 @@ ABSL_NAMESPACE_BEGIN // // // Construct a Span explicitly from a container: // std::vector<int> v = {1, 2, 3, 4, 5}; -// auto span = y_absl::Span<const int>(v); +// auto span = y_absl::Span<const int>(v); // // // Construct a Span explicitly from a C-style array: // int a[5] = {1, 2, 3, 4, 5}; -// auto span = y_absl::Span<const int>(a); +// auto span = y_absl::Span<const int>(a); // // // Construct a Span implicitly from a container -// void MyRoutine(y_absl::Span<const int> a) { +// void MyRoutine(y_absl::Span<const int> a) { // ... // } // std::vector v = {1,2,3,4,5}; @@ -129,25 +129,25 @@ ABSL_NAMESPACE_BEGIN // (such as resizing) or invalidate iterators into the container. // // One common use for a `Span` is when passing arguments to a routine that can -// accept a variety of array types (e.g. a `std::vector`, `y_absl::InlinedVector`, +// accept a variety of array types (e.g. a `std::vector`, `y_absl::InlinedVector`, // a C-style array, etc.). Instead of creating overloads for each case, you // can simply specify a `Span` as the argument to such a routine. // // Example: // -// void MyRoutine(y_absl::Span<const int> a) { +// void MyRoutine(y_absl::Span<const int> a) { // ... // } // // std::vector v = {1,2,3,4,5}; // MyRoutine(v); // -// y_absl::InlinedVector<int, 4> my_inline_vector; +// y_absl::InlinedVector<int, 4> my_inline_vector; // MyRoutine(my_inline_vector); // // // Explicit constructor from pointer,size // int* my_array = new int[10]; -// MyRoutine(y_absl::Span<const int>(my_array, 10)); +// MyRoutine(y_absl::Span<const int>(my_array, 10)); template <typename T> class Span { private: @@ -170,7 +170,7 @@ class Span { public: using element_type = T; - using value_type = y_absl::remove_cv_t<T>; + using value_type = y_absl::remove_cv_t<T>; using pointer = T*; using const_pointer = const T*; using reference = T&; @@ -210,7 +210,7 @@ class Span { // brace-enclosed initializer list to a function expecting a `Span`. Such // spans constructed from an initializer list must be of type `Span<const T>`. // - // void Process(y_absl::Span<const int> x); + // void Process(y_absl::Span<const int> x); // Process({1, 2, 3}); // // Note that as always the array referenced by the span must outlive the span. @@ -223,7 +223,7 @@ class Span { // // // Assume that this function uses the array directly, not retaining any // // copy of the span or pointer to any of its elements. - // void Process(y_absl::Span<const int> ints); + // void Process(y_absl::Span<const int> ints); // // // Okay: the std::initializer_list<int> will reference a temporary array // // that isn't destroyed until after the call to Process returns. @@ -231,14 +231,14 @@ class Span { // // // Not okay: the storage used by the std::initializer_list<int> is not // // allowed to be referenced after the first line. - // y_absl::Span<const int> ints = { 17, 19 }; + // y_absl::Span<const int> ints = { 17, 19 }; // Process(ints); // // // Not okay for the same reason as above: even when the elements of the // // initializer list expression are not temporaries the underlying array // // is, so the initializer list must still outlive the span. // const int foo = 17; - // y_absl::Span<const int> ints = { foo }; + // y_absl::Span<const int> ints = { foo }; // Process(ints); // template <typename LazyT = T, @@ -391,11 +391,11 @@ class Span { // Examples: // // std::vector<int> vec = {10, 11, 12, 13}; - // y_absl::MakeSpan(vec).subspan(1, 2); // {11, 12} - // y_absl::MakeSpan(vec).subspan(2, 8); // {12, 13} - // y_absl::MakeSpan(vec).subspan(1); // {11, 12, 13} - // y_absl::MakeSpan(vec).subspan(4); // {} - // y_absl::MakeSpan(vec).subspan(5); // throws std::out_of_range + // y_absl::MakeSpan(vec).subspan(1, 2); // {11, 12} + // y_absl::MakeSpan(vec).subspan(2, 8); // {12, 13} + // y_absl::MakeSpan(vec).subspan(1); // {11, 12, 13} + // y_absl::MakeSpan(vec).subspan(4); // {} + // y_absl::MakeSpan(vec).subspan(5); // throws std::out_of_range constexpr Span subspan(size_type pos = 0, size_type len = npos) const { return (pos <= size()) ? Span(data() + pos, span_internal::Min(size() - pos, len)) @@ -410,9 +410,9 @@ class Span { // Examples: // // std::vector<int> vec = {10, 11, 12, 13}; - // y_absl::MakeSpan(vec).first(1); // {10} - // y_absl::MakeSpan(vec).first(3); // {10, 11, 12} - // y_absl::MakeSpan(vec).first(5); // throws std::out_of_range + // y_absl::MakeSpan(vec).first(1); // {10} + // y_absl::MakeSpan(vec).first(3); // {10, 11, 12} + // y_absl::MakeSpan(vec).first(5); // throws std::out_of_range constexpr Span first(size_type len) const { return (len <= size()) ? Span(data(), len) @@ -427,16 +427,16 @@ class Span { // Examples: // // std::vector<int> vec = {10, 11, 12, 13}; - // y_absl::MakeSpan(vec).last(1); // {13} - // y_absl::MakeSpan(vec).last(3); // {11, 12, 13} - // y_absl::MakeSpan(vec).last(5); // throws std::out_of_range + // y_absl::MakeSpan(vec).last(1); // {13} + // y_absl::MakeSpan(vec).last(3); // {11, 12, 13} + // y_absl::MakeSpan(vec).last(5); // throws std::out_of_range constexpr Span last(size_type len) const { return (len <= size()) ? Span(size() - len + data(), len) : (base_internal::ThrowStdOutOfRange("len > size()"), Span()); } - // Support for y_absl::Hash. + // Support for y_absl::Hash. template <typename H> friend H AbslHashValue(H h, Span v) { return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()), @@ -480,13 +480,13 @@ bool operator==(Span<T> a, Span<const T> b) { } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator==(const U& a, Span<T> b) { return span_internal::EqualImpl<Span, const T>(a, b); } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator==(Span<T> a, const U& b) { return span_internal::EqualImpl<Span, const T>(a, b); } @@ -506,13 +506,13 @@ bool operator!=(Span<T> a, Span<const T> b) { } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator!=(const U& a, Span<T> b) { return !(a == b); } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator!=(Span<T> a, const U& b) { return !(a == b); } @@ -532,13 +532,13 @@ bool operator<(Span<T> a, Span<const T> b) { } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator<(const U& a, Span<T> b) { return span_internal::LessThanImpl<Span, const T>(a, b); } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator<(Span<T> a, const U& b) { return span_internal::LessThanImpl<Span, const T>(a, b); } @@ -558,13 +558,13 @@ bool operator>(Span<T> a, Span<const T> b) { } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator>(const U& a, Span<T> b) { return b < a; } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator>(Span<T> a, const U& b) { return b < a; } @@ -584,13 +584,13 @@ bool operator<=(Span<T> a, Span<const T> b) { } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator<=(const U& a, Span<T> b) { return !(b < a); } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator<=(Span<T> a, const U& b) { return !(b < a); } @@ -610,13 +610,13 @@ bool operator>=(Span<T> a, Span<const T> b) { } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator>=(const U& a, Span<T> b) { return !(a < b); } template < typename T, typename U, - typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> + typename = span_internal::EnableIfConvertibleTo<U, y_absl::Span<const T>>> bool operator>=(Span<T> a, const U& b) { return !(a < b); } @@ -636,7 +636,7 @@ bool operator>=(Span<T> a, const U& b) { // // Examples: // -// void MyRoutine(y_absl::Span<MyComplicatedType> a) { +// void MyRoutine(y_absl::Span<MyComplicatedType> a) { // ... // }; // // my_vector is a container of non-const types @@ -647,14 +647,14 @@ bool operator>=(Span<T> a, const U& b) { // MyRoutine(my_vector); // error, type mismatch // // // Explicitly constructing the Span is verbose -// MyRoutine(y_absl::Span<MyComplicatedType>(my_vector)); +// MyRoutine(y_absl::Span<MyComplicatedType>(my_vector)); // -// // Use MakeSpan() to make an y_absl::Span<T> -// MyRoutine(y_absl::MakeSpan(my_vector)); +// // Use MakeSpan() to make an y_absl::Span<T> +// MyRoutine(y_absl::MakeSpan(my_vector)); // // // Construct a span from an array ptr+size -// y_absl::Span<T> my_span() { -// return y_absl::MakeSpan(&array[0], num_elements_); +// y_absl::Span<T> my_span() { +// return y_absl::MakeSpan(&array[0], num_elements_); // } // template <int&... ExplicitArgumentBarrier, typename T> @@ -669,7 +669,7 @@ Span<T> MakeSpan(T* begin, T* end) noexcept { template <int&... ExplicitArgumentBarrier, typename C> constexpr auto MakeSpan(C& c) noexcept // NOLINT(runtime/references) - -> decltype(y_absl::MakeSpan(span_internal::GetData(c), c.size())) { + -> decltype(y_absl::MakeSpan(span_internal::GetData(c), c.size())) { return MakeSpan(span_internal::GetData(c), c.size()); } @@ -685,22 +685,22 @@ constexpr Span<T> MakeSpan(T (&array)[N]) noexcept { // // Examples: // -// void ProcessInts(y_absl::Span<const int> some_ints); +// void ProcessInts(y_absl::Span<const int> some_ints); // // // Call with a pointer and size. // int array[3] = { 0, 0, 0 }; -// ProcessInts(y_absl::MakeConstSpan(&array[0], 3)); +// ProcessInts(y_absl::MakeConstSpan(&array[0], 3)); // // // Call with a [begin, end) pair. -// ProcessInts(y_absl::MakeConstSpan(&array[0], &array[3])); +// ProcessInts(y_absl::MakeConstSpan(&array[0], &array[3])); // // // Call directly with an array. -// ProcessInts(y_absl::MakeConstSpan(array)); +// ProcessInts(y_absl::MakeConstSpan(array)); // // // Call with a contiguous container. // std::vector<int> some_ints = ...; -// ProcessInts(y_absl::MakeConstSpan(some_ints)); -// ProcessInts(y_absl::MakeConstSpan(std::vector<int>{ 0, 0, 0 })); +// ProcessInts(y_absl::MakeConstSpan(some_ints)); +// ProcessInts(y_absl::MakeConstSpan(std::vector<int>{ 0, 0, 0 })); // template <int&... ExplicitArgumentBarrier, typename T> constexpr Span<const T> MakeConstSpan(T* ptr, size_t size) noexcept { @@ -722,5 +722,5 @@ constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept { return Span<const T>(array, N); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TYPES_SPAN_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h index 3eecc7dfd4..b3d7235018 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h @@ -16,40 +16,40 @@ // variant.h // ----------------------------------------------------------------------------- // -// This header file defines an `y_absl::variant` type for holding a type-safe +// This header file defines an `y_absl::variant` type for holding a type-safe // value of some prescribed set of types (noted as alternative types), and // associated functions for managing variants. // -// The `y_absl::variant` type is a form of type-safe union. An `y_absl::variant` +// The `y_absl::variant` type is a form of type-safe union. An `y_absl::variant` // should always hold a value of one of its alternative types (except in the // "valueless by exception state" -- see below). A default-constructed -// `y_absl::variant` will hold the value of its first alternative type, provided +// `y_absl::variant` will hold the value of its first alternative type, provided // it is default-constructible. // -// In exceptional cases due to error, an `y_absl::variant` can hold no +// In exceptional cases due to error, an `y_absl::variant` can hold no // value (known as a "valueless by exception" state), though this is not the // norm. // -// As with `y_absl::optional`, an `y_absl::variant` -- when it holds a value -- +// As with `y_absl::optional`, an `y_absl::variant` -- when it holds a value -- // allocates a value of that type directly within the `variant` itself; it // cannot hold a reference, array, or the type `void`; it can, however, hold a // pointer to externally managed memory. // -// `y_absl::variant` is a C++11 compatible version of the C++17 `std::variant` +// `y_absl::variant` is a C++11 compatible version of the C++17 `std::variant` // abstraction and is designed to be a drop-in replacement for code compliant // with C++17. #ifndef ABSL_TYPES_VARIANT_H_ #define ABSL_TYPES_VARIANT_H_ -#include "y_absl/base/config.h" -#include "y_absl/utility/utility.h" +#include "y_absl/base/config.h" +#include "y_absl/utility/utility.h" #ifdef ABSL_USES_STD_VARIANT #include <variant> // IWYU pragma: export -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN using std::bad_variant_access; using std::get; @@ -64,7 +64,7 @@ using std::variant_size; using std::variant_size_v; using std::visit; ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #else // ABSL_USES_STD_VARIANT @@ -73,49 +73,49 @@ ABSL_NAMESPACE_END #include <type_traits> #include <utility> -#include "y_absl/base/macros.h" -#include "y_absl/base/port.h" -#include "y_absl/meta/type_traits.h" -#include "y_absl/types/internal/variant.h" +#include "y_absl/base/macros.h" +#include "y_absl/base/port.h" +#include "y_absl/meta/type_traits.h" +#include "y_absl/types/internal/variant.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // ----------------------------------------------------------------------------- -// y_absl::variant +// y_absl::variant // ----------------------------------------------------------------------------- // -// An `y_absl::variant` type is a form of type-safe union. An `y_absl::variant` -- +// An `y_absl::variant` type is a form of type-safe union. An `y_absl::variant` -- // except in exceptional cases -- always holds a value of one of its alternative // types. // // Example: // -// // Construct a variant that holds either an integer or a TString and -// // assign it to a TString. -// y_absl::variant<int, TString> v = TString("abc"); +// // Construct a variant that holds either an integer or a TString and +// // assign it to a TString. +// y_absl::variant<int, TString> v = TString("abc"); // // // A default-constructed variant will hold a value-initialized value of // // the first alternative type. -// auto a = y_absl::variant<int, TString>(); // Holds an int of value '0'. +// auto a = y_absl::variant<int, TString>(); // Holds an int of value '0'. // // // variants are assignable. // // // copy assignment -// auto v1 = y_absl::variant<int, TString>("abc"); -// auto v2 = y_absl::variant<int, TString>(10); +// auto v1 = y_absl::variant<int, TString>("abc"); +// auto v2 = y_absl::variant<int, TString>(10); // v2 = v1; // copy assign // // // move assignment -// auto v1 = y_absl::variant<int, TString>("abc"); -// v1 = y_absl::variant<int, TString>(10); +// auto v1 = y_absl::variant<int, TString>("abc"); +// v1 = y_absl::variant<int, TString>(10); // // // assignment through type conversion // a = 128; // variant contains int -// a = "128"; // variant contains TString +// a = "128"; // variant contains TString // -// An `y_absl::variant` holding a value of one of its alternative types `T` holds -// an allocation of `T` directly within the variant itself. An `y_absl::variant` +// An `y_absl::variant` holding a value of one of its alternative types `T` holds +// an allocation of `T` directly within the variant itself. An `y_absl::variant` // is not allowed to allocate additional storage, such as dynamic memory, to // allocate the contained value. The contained value shall be allocated in a // region of the variant storage suitably aligned for all alternative types. @@ -124,8 +124,8 @@ class variant; // swap() // -// Swaps two `y_absl::variant` values. This function is equivalent to `v.swap(w)` -// where `v` and `w` are `y_absl::variant` types. +// Swaps two `y_absl::variant` values. This function is equivalent to `v.swap(w)` +// where `v` and `w` are `y_absl::variant` types. // // Note that this function requires all alternative types to be both swappable // and move-constructible, because any two variants may refer to either the same @@ -134,8 +134,8 @@ class variant; // template < typename... Ts, - y_absl::enable_if_t< - y_absl::conjunction<std::is_move_constructible<Ts>..., + y_absl::enable_if_t< + y_absl::conjunction<std::is_move_constructible<Ts>..., type_traits_internal::IsSwappable<Ts>...>::value, int> = 0> void swap(variant<Ts...>& v, variant<Ts...>& w) noexcept(noexcept(v.swap(w))) { @@ -144,25 +144,25 @@ void swap(variant<Ts...>& v, variant<Ts...>& w) noexcept(noexcept(v.swap(w))) { // variant_size // -// Returns the number of alternative types available for a given `y_absl::variant` +// Returns the number of alternative types available for a given `y_absl::variant` // type as a compile-time constant expression. As this is a class template, it // is not generally useful for accessing the number of alternative types of -// any given `y_absl::variant` instance. +// any given `y_absl::variant` instance. // // Example: // -// auto a = y_absl::variant<int, TString>; +// auto a = y_absl::variant<int, TString>; // constexpr int num_types = -// y_absl::variant_size<y_absl::variant<int, TString>>(); +// y_absl::variant_size<y_absl::variant<int, TString>>(); // // // You can also use the member constant `value`. // constexpr int num_types = -// y_absl::variant_size<y_absl::variant<int, TString>>::value; +// y_absl::variant_size<y_absl::variant<int, TString>>::value; // -// // `y_absl::variant_size` is more valuable for use in generic code: +// // `y_absl::variant_size` is more valuable for use in generic code: // template <typename Variant> // constexpr bool IsVariantMultivalue() { -// return y_absl::variant_size<Variant>() > 1; +// return y_absl::variant_size<Variant>() > 1; // } // // Note that the set of cv-qualified specializations of `variant_size` are @@ -189,20 +189,20 @@ struct variant_size<const volatile T> : variant_size<T>::type {}; // variant_alternative // -// Returns the alternative type for a given `y_absl::variant` at the passed +// Returns the alternative type for a given `y_absl::variant` at the passed // index value as a compile-time constant expression. As this is a class // template resulting in a type, it is not useful for access of the run-time -// value of any given `y_absl::variant` variable. +// value of any given `y_absl::variant` variable. // // Example: // // // The type of the 0th alternative is "int". // using alternative_type_0 -// = y_absl::variant_alternative<0, y_absl::variant<int, TString>>::type; +// = y_absl::variant_alternative<0, y_absl::variant<int, TString>>::type; // // static_assert(std::is_same<alternative_type_0, int>::value, ""); // -// // `y_absl::variant_alternative` is more valuable for use in generic code: +// // `y_absl::variant_alternative` is more valuable for use in generic code: // template <typename Variant> // constexpr bool IsFirstElementTrivial() { // return std::is_trivial_v<variant_alternative<0, Variant>::type>; @@ -244,7 +244,7 @@ struct variant_alternative<I, const volatile T> { // Example: // // using alternative_type_0 -// = y_absl::variant_alternative_t<0, y_absl::variant<int, TString>>; +// = y_absl::variant_alternative_t<0, y_absl::variant<int, TString>>; // static_assert(std::is_same<alternative_type_0, int>::value, ""); template <std::size_t I, class T> using variant_alternative_t = typename variant_alternative<I, T>::type; @@ -256,8 +256,8 @@ using variant_alternative_t = typename variant_alternative<I, T>::type; // // Example: // -// y_absl::variant<int, TString> foo = 42; -// if (y_absl::holds_alternative<int>(foo)) { +// y_absl::variant<int, TString> foo = 42; +// if (y_absl::holds_alternative<int>(foo)) { // std::cout << "The variant holds an integer"; // } template <class T, class... Types> @@ -278,22 +278,22 @@ constexpr bool holds_alternative(const variant<Types...>& v) noexcept { // using a type that is not unique within the variant's set of alternative types // is a compile-time error. If the index of the alternative being specified is // different from the index of the alternative that is currently stored, throws -// `y_absl::bad_variant_access`. +// `y_absl::bad_variant_access`. // // Example: // -// auto a = y_absl::variant<int, TString>; +// auto a = y_absl::variant<int, TString>; // // // Get the value by type (if unique). -// int i = y_absl::get<int>(a); +// int i = y_absl::get<int>(a); // -// auto b = y_absl::variant<int, int>; +// auto b = y_absl::variant<int, int>; // // // Getting the value by a type that is not unique is ill-formed. -// int j = y_absl::get<int>(b); // Compile Error! +// int j = y_absl::get<int>(b); // Compile Error! // // // Getting value by index not ambiguous and allowed. -// int k = y_absl::get<1>(b); +// int k = y_absl::get<1>(b); // Overload for getting a variant's lvalue by type. template <class T, class... Types> @@ -303,11 +303,11 @@ constexpr T& get(variant<Types...>& v) { // NOLINT } // Overload for getting a variant's rvalue by type. -// Note: `y_absl::move()` is required to allow use of constexpr in C++11. +// Note: `y_absl::move()` is required to allow use of constexpr in C++11. template <class T, class... Types> constexpr T&& get(variant<Types...>&& v) { return variant_internal::VariantCoreAccess::CheckedAccess< - variant_internal::IndexOf<T, Types...>::value>(y_absl::move(v)); + variant_internal::IndexOf<T, Types...>::value>(y_absl::move(v)); } // Overload for getting a variant's const lvalue by type. @@ -318,11 +318,11 @@ constexpr const T& get(const variant<Types...>& v) { } // Overload for getting a variant's const rvalue by type. -// Note: `y_absl::move()` is required to allow use of constexpr in C++11. +// Note: `y_absl::move()` is required to allow use of constexpr in C++11. template <class T, class... Types> constexpr const T&& get(const variant<Types...>&& v) { return variant_internal::VariantCoreAccess::CheckedAccess< - variant_internal::IndexOf<T, Types...>::value>(y_absl::move(v)); + variant_internal::IndexOf<T, Types...>::value>(y_absl::move(v)); } // Overload for getting a variant's lvalue by index. @@ -333,11 +333,11 @@ constexpr variant_alternative_t<I, variant<Types...>>& get( } // Overload for getting a variant's rvalue by index. -// Note: `y_absl::move()` is required to allow use of constexpr in C++11. +// Note: `y_absl::move()` is required to allow use of constexpr in C++11. template <std::size_t I, class... Types> constexpr variant_alternative_t<I, variant<Types...>>&& get( variant<Types...>&& v) { - return variant_internal::VariantCoreAccess::CheckedAccess<I>(y_absl::move(v)); + return variant_internal::VariantCoreAccess::CheckedAccess<I>(y_absl::move(v)); } // Overload for getting a variant's const lvalue by index. @@ -348,11 +348,11 @@ constexpr const variant_alternative_t<I, variant<Types...>>& get( } // Overload for getting a variant's const rvalue by index. -// Note: `y_absl::move()` is required to allow use of constexpr in C++11. +// Note: `y_absl::move()` is required to allow use of constexpr in C++11. template <std::size_t I, class... Types> constexpr const variant_alternative_t<I, variant<Types...>>&& get( const variant<Types...>&& v) { - return variant_internal::VariantCoreAccess::CheckedAccess<I>(y_absl::move(v)); + return variant_internal::VariantCoreAccess::CheckedAccess<I>(y_absl::move(v)); } // get_if() @@ -368,7 +368,7 @@ constexpr const variant_alternative_t<I, variant<Types...>>&& get( // Overload for getting a pointer to the value stored in the given variant by // index. template <std::size_t I, class... Types> -constexpr y_absl::add_pointer_t<variant_alternative_t<I, variant<Types...>>> +constexpr y_absl::add_pointer_t<variant_alternative_t<I, variant<Types...>>> get_if(variant<Types...>* v) noexcept { return (v != nullptr && v->index() == I) ? std::addressof( @@ -379,7 +379,7 @@ get_if(variant<Types...>* v) noexcept { // Overload for getting a pointer to the const value stored in the given // variant by index. template <std::size_t I, class... Types> -constexpr y_absl::add_pointer_t<const variant_alternative_t<I, variant<Types...>>> +constexpr y_absl::add_pointer_t<const variant_alternative_t<I, variant<Types...>>> get_if(const variant<Types...>* v) noexcept { return (v != nullptr && v->index() == I) ? std::addressof( @@ -390,21 +390,21 @@ get_if(const variant<Types...>* v) noexcept { // Overload for getting a pointer to the value stored in the given variant by // type. template <class T, class... Types> -constexpr y_absl::add_pointer_t<T> get_if(variant<Types...>* v) noexcept { - return y_absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v); +constexpr y_absl::add_pointer_t<T> get_if(variant<Types...>* v) noexcept { + return y_absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v); } // Overload for getting a pointer to the const value stored in the given variant // by type. template <class T, class... Types> -constexpr y_absl::add_pointer_t<const T> get_if( +constexpr y_absl::add_pointer_t<const T> get_if( const variant<Types...>* v) noexcept { - return y_absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v); + return y_absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v); } // visit() // -// Calls a provided functor on a given set of variants. `y_absl::visit()` is +// Calls a provided functor on a given set of variants. `y_absl::visit()` is // commonly used to conditionally inspect the state of a given variant (or set // of variants). // @@ -421,19 +421,19 @@ constexpr y_absl::add_pointer_t<const T> get_if( // } // }; // -// // Declare our variant, and call `y_absl::visit()` on it. +// // Declare our variant, and call `y_absl::visit()` on it. // // Note that `GetVariant()` returns void in either case. -// y_absl::variant<int, TString> foo = TString("foo"); +// y_absl::variant<int, TString> foo = TString("foo"); // GetVariant visitor; -// y_absl::visit(visitor, foo); // Prints `The variant's value is: foo' +// y_absl::visit(visitor, foo); // Prints `The variant's value is: foo' template <typename Visitor, typename... Variants> variant_internal::VisitResult<Visitor, Variants...> visit(Visitor&& vis, Variants&&... vars) { return variant_internal:: - VisitIndices<variant_size<y_absl::decay_t<Variants> >::value...>::Run( + VisitIndices<variant_size<y_absl::decay_t<Variants> >::value...>::Run( variant_internal::PerformVisitation<Visitor, Variants...>{ - std::forward_as_tuple(y_absl::forward<Variants>(vars)...), - y_absl::forward<Visitor>(vis)}, + std::forward_as_tuple(y_absl::forward<Variants>(vars)...), + y_absl::forward<Visitor>(vis)}, vars.index()...); } @@ -443,7 +443,7 @@ variant_internal::VisitResult<Visitor, Variants...> visit(Visitor&& vis, // which the first variant type is otherwise not default-constructible. struct monostate {}; -// `y_absl::monostate` Relational Operators +// `y_absl::monostate` Relational Operators constexpr bool operator<(monostate, monostate) noexcept { return false; } constexpr bool operator>(monostate, monostate) noexcept { return false; } @@ -454,20 +454,20 @@ constexpr bool operator!=(monostate, monostate) noexcept { return false; } //------------------------------------------------------------------------------ -// `y_absl::variant` Template Definition +// `y_absl::variant` Template Definition //------------------------------------------------------------------------------ template <typename T0, typename... Tn> class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { - static_assert(y_absl::conjunction<std::is_object<T0>, + static_assert(y_absl::conjunction<std::is_object<T0>, std::is_object<Tn>...>::value, "Attempted to instantiate a variant containing a non-object " "type."); - // Intentionally not qualifying `negation` with `y_absl::` to work around a bug + // Intentionally not qualifying `negation` with `y_absl::` to work around a bug // in MSVC 2015 with inline namespace and variadic template. - static_assert(y_absl::conjunction<negation<std::is_array<T0> >, + static_assert(y_absl::conjunction<negation<std::is_array<T0> >, negation<std::is_array<Tn> >...>::value, "Attempted to instantiate a variant containing an array type."); - static_assert(y_absl::conjunction<std::is_nothrow_destructible<T0>, + static_assert(y_absl::conjunction<std::is_nothrow_destructible<T0>, std::is_nothrow_destructible<Tn>...>::value, "Attempted to instantiate a variant containing a non-nothrow " "destructible type."); @@ -499,18 +499,18 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { // // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html // has been voted passed the design phase in the C++ standard meeting in Mar - // 2018. It will be implemented and integrated into `y_absl::variant`. + // 2018. It will be implemented and integrated into `y_absl::variant`. template < class T, std::size_t I = std::enable_if< variant_internal::IsNeitherSelfNorInPlace<variant, - y_absl::decay_t<T>>::value, + y_absl::decay_t<T>>::value, variant_internal::IndexOfConstructedType<variant, T>>::type::value, - class Tj = y_absl::variant_alternative_t<I, variant>, - y_absl::enable_if_t<std::is_constructible<Tj, T>::value>* = + class Tj = y_absl::variant_alternative_t<I, variant>, + y_absl::enable_if_t<std::is_constructible<Tj, T>::value>* = nullptr> constexpr variant(T&& t) noexcept(std::is_nothrow_constructible<Tj, T>::value) - : Base(variant_internal::EmplaceTag<I>(), y_absl::forward<T>(t)) {} + : Base(variant_internal::EmplaceTag<I>(), y_absl::forward<T>(t)) {} // Constructs a variant of an alternative type from the arguments through // direct-initialization. @@ -524,7 +524,7 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { constexpr explicit variant(in_place_type_t<T>, Args&&... args) : Base(variant_internal::EmplaceTag< variant_internal::UnambiguousIndexOf<variant, T>::value>(), - y_absl::forward<Args>(args)...) {} + y_absl::forward<Args>(args)...) {} // Constructs a variant of an alternative type from an initializer list // and other arguments through direct-initialization. @@ -539,7 +539,7 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { Args&&... args) : Base(variant_internal::EmplaceTag< variant_internal::UnambiguousIndexOf<variant, T>::value>(), - il, y_absl::forward<Args>(args)...) {} + il, y_absl::forward<Args>(args)...) {} // Constructs a variant of an alternative type from a provided index, // through value-initialization using the provided forwarded arguments. @@ -548,7 +548,7 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { variant_internal::VariantAlternativeSfinaeT<I, variant>, Args...>::value>::type* = nullptr> constexpr explicit variant(in_place_index_t<I>, Args&&... args) - : Base(variant_internal::EmplaceTag<I>(), y_absl::forward<Args>(args)...) {} + : Base(variant_internal::EmplaceTag<I>(), y_absl::forward<Args>(args)...) {} // Constructs a variant of an alternative type from a provided index, // through value-initialization of an initializer list and the provided @@ -560,12 +560,12 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { constexpr explicit variant(in_place_index_t<I>, std::initializer_list<U> il, Args&&... args) : Base(variant_internal::EmplaceTag<I>(), il, - y_absl::forward<Args>(args)...) {} + y_absl::forward<Args>(args)...) {} // Destructors // Destroys the variant's currently contained value, provided that - // `y_absl::valueless_by_exception()` is false. + // `y_absl::valueless_by_exception()` is false. ~variant() = default; // Assignment Operators @@ -580,13 +580,13 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { // // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html // has been voted passed the design phase in the C++ standard meeting in Mar - // 2018. It will be implemented and integrated into `y_absl::variant`. + // 2018. It will be implemented and integrated into `y_absl::variant`. template < class T, std::size_t I = std::enable_if< - !std::is_same<y_absl::decay_t<T>, variant>::value, + !std::is_same<y_absl::decay_t<T>, variant>::value, variant_internal::IndexOfConstructedType<variant, T>>::type::value, - class Tj = y_absl::variant_alternative_t<I, variant>, + class Tj = y_absl::variant_alternative_t<I, variant>, typename std::enable_if<std::is_assignable<Tj&, T>::value && std::is_constructible<Tj, T>::value>::type* = nullptr> @@ -595,7 +595,7 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { std::is_nothrow_constructible<Tj, T>::value) { variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run( variant_internal::VariantCoreAccess::MakeConversionAssignVisitor( - this, y_absl::forward<T>(t)), + this, y_absl::forward<T>(t)), index()); return *this; @@ -611,19 +611,19 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { // // Example: // - // y_absl::variant<std::vector<int>, int, TString> v; + // y_absl::variant<std::vector<int>, int, TString> v; // v.emplace<int>(99); - // v.emplace<TString>("abc"); + // v.emplace<TString>("abc"); template < class T, class... Args, typename std::enable_if<std::is_constructible< - y_absl::variant_alternative_t< + y_absl::variant_alternative_t< variant_internal::UnambiguousIndexOf<variant, T>::value, variant>, Args...>::value>::type* = nullptr> T& emplace(Args&&... args) { return variant_internal::VariantCoreAccess::Replace< variant_internal::UnambiguousIndexOf<variant, T>::value>( - this, y_absl::forward<Args>(args)...); + this, y_absl::forward<Args>(args)...); } // Constructs a value of the given alternative type T within the variant using @@ -633,18 +633,18 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { // // Example: // - // y_absl::variant<std::vector<int>, int, TString> v; + // y_absl::variant<std::vector<int>, int, TString> v; // v.emplace<std::vector<int>>({0, 1, 2}); template < class T, class U, class... Args, typename std::enable_if<std::is_constructible< - y_absl::variant_alternative_t< + y_absl::variant_alternative_t< variant_internal::UnambiguousIndexOf<variant, T>::value, variant>, std::initializer_list<U>&, Args...>::value>::type* = nullptr> T& emplace(std::initializer_list<U> il, Args&&... args) { return variant_internal::VariantCoreAccess::Replace< variant_internal::UnambiguousIndexOf<variant, T>::value>( - this, il, y_absl::forward<Args>(args)...); + this, il, y_absl::forward<Args>(args)...); } // Destroys the current value of the variant (provided that @@ -653,17 +653,17 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { // // Example: // - // y_absl::variant<std::vector<int>, int, int> v; + // y_absl::variant<std::vector<int>, int, int> v; // v.emplace<1>(99); // v.emplace<2>(98); // v.emplace<int>(99); // Won't compile. 'int' isn't a unique type. template <std::size_t I, class... Args, typename std::enable_if< - std::is_constructible<y_absl::variant_alternative_t<I, variant>, + std::is_constructible<y_absl::variant_alternative_t<I, variant>, Args...>::value>::type* = nullptr> - y_absl::variant_alternative_t<I, variant>& emplace(Args&&... args) { + y_absl::variant_alternative_t<I, variant>& emplace(Args&&... args) { return variant_internal::VariantCoreAccess::Replace<I>( - this, y_absl::forward<Args>(args)...); + this, y_absl::forward<Args>(args)...); } // Destroys the current value of the variant (provided that @@ -672,23 +672,23 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { // // Example: // - // y_absl::variant<std::vector<int>, int, int> v; + // y_absl::variant<std::vector<int>, int, int> v; // v.emplace<0>({0, 1, 2}); template <std::size_t I, class U, class... Args, typename std::enable_if<std::is_constructible< - y_absl::variant_alternative_t<I, variant>, + y_absl::variant_alternative_t<I, variant>, std::initializer_list<U>&, Args...>::value>::type* = nullptr> - y_absl::variant_alternative_t<I, variant>& emplace(std::initializer_list<U> il, + y_absl::variant_alternative_t<I, variant>& emplace(std::initializer_list<U> il, Args&&... args) { return variant_internal::VariantCoreAccess::Replace<I>( - this, il, y_absl::forward<Args>(args)...); + this, il, y_absl::forward<Args>(args)...); } // variant::valueless_by_exception() // // Returns false if and only if the variant currently holds a valid value. constexpr bool valueless_by_exception() const noexcept { - return this->index_ == y_absl::variant_npos; + return this->index_ == y_absl::variant_npos; } // variant::index() @@ -702,7 +702,7 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> { // Swaps the values of two variant objects. // void swap(variant& rhs) noexcept( - y_absl::conjunction< + y_absl::conjunction< std::is_nothrow_move_constructible<T0>, std::is_nothrow_move_constructible<Tn>..., type_traits_internal::IsNothrowSwappable<T0>, @@ -804,26 +804,26 @@ operator>=(const variant<Types...>& a, const variant<Types...>& b) { } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl namespace std { // hash() template <> // NOLINT -struct hash<y_absl::monostate> { - std::size_t operator()(y_absl::monostate) const { return 0; } +struct hash<y_absl::monostate> { + std::size_t operator()(y_absl::monostate) const { return 0; } }; template <class... T> // NOLINT -struct hash<y_absl::variant<T...>> - : y_absl::variant_internal::VariantHashBase<y_absl::variant<T...>, void, - y_absl::remove_const_t<T>...> {}; +struct hash<y_absl::variant<T...>> + : y_absl::variant_internal::VariantHashBase<y_absl::variant<T...>, void, + y_absl::remove_const_t<T>...> {}; } // namespace std #endif // ABSL_USES_STD_VARIANT -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN namespace variant_internal { @@ -841,26 +841,26 @@ struct ConversionVisitor { // ConvertVariantTo() // -// Helper functions to convert an `y_absl::variant` to a variant of another set of +// Helper functions to convert an `y_absl::variant` to a variant of another set of // types, provided that the alternative type of the new variant type can be // converted from any type in the source variant. // // Example: // -// y_absl::variant<name1, name2, float> InternalReq(const Req&); +// y_absl::variant<name1, name2, float> InternalReq(const Req&); // // // name1 and name2 are convertible to name -// y_absl::variant<name, float> ExternalReq(const Req& req) { -// return y_absl::ConvertVariantTo<y_absl::variant<name, float>>( +// y_absl::variant<name, float> ExternalReq(const Req& req) { +// return y_absl::ConvertVariantTo<y_absl::variant<name, float>>( // InternalReq(req)); // } template <typename To, typename Variant> To ConvertVariantTo(Variant&& variant) { - return y_absl::visit(variant_internal::ConversionVisitor<To>{}, + return y_absl::visit(variant_internal::ConversionVisitor<To>{}, std::forward<Variant>(variant)); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_TYPES_VARIANT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h b/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h index 842f5e7f22..c2e4d91d43 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h @@ -45,12 +45,12 @@ #include <tuple> #include <utility> -#include "y_absl/base/config.h" -#include "y_absl/base/internal/inline_variable.h" -#include "y_absl/base/internal/invoke.h" -#include "y_absl/meta/type_traits.h" +#include "y_absl/base/config.h" +#include "y_absl/base/internal/inline_variable.h" +#include "y_absl/base/internal/invoke.h" +#include "y_absl/meta/type_traits.h" -namespace y_absl { +namespace y_absl { ABSL_NAMESPACE_BEGIN // integer_sequence @@ -58,7 +58,7 @@ ABSL_NAMESPACE_BEGIN // Class template representing a compile-time integer sequence. An instantiation // of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its // type through its template arguments (which is a common need when -// working with C++11 variadic templates). `y_absl::integer_sequence` is designed +// working with C++11 variadic templates). `y_absl::integer_sequence` is designed // to be a drop-in replacement for C++14's `std::integer_sequence`. // // Example: @@ -81,7 +81,7 @@ struct integer_sequence { // index_sequence // // A helper template for an `integer_sequence` of `size_t`, -// `y_absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `y_absl::index_sequence` is designed to be a drop-in replacement for C++14's // `std::index_sequence`. template <size_t... Ints> using index_sequence = integer_sequence<size_t, Ints...>; @@ -169,7 +169,7 @@ using std::in_place; // in_place_t // // Tag type used to specify in-place construction, such as with -// `y_absl::optional`, designed to be a drop-in replacement for C++17's +// `y_absl::optional`, designed to be a drop-in replacement for C++17's // `std::in_place_t`. struct in_place_t {}; @@ -185,7 +185,7 @@ using std::in_place_type_t; // in_place_type_t // // Tag type used for in-place construction when the type to construct needs to -// be specified, such as with `y_absl::any`, designed to be a drop-in replacement +// be specified, such as with `y_absl::any`, designed to be a drop-in replacement // for C++17's `std::in_place_type_t`. template <typename T> using in_place_type_t = void (*)(utility_internal::InPlaceTypeTag<T>); @@ -202,7 +202,7 @@ using std::in_place_index_t; // in_place_index_t // // Tag type used for in-place construction when the type to construct needs to -// be specified, such as with `y_absl::any`, designed to be a drop-in replacement +// be specified, such as with `y_absl::any`, designed to be a drop-in replacement // for C++17's `std::in_place_index_t`. template <size_t I> using in_place_index_t = void (*)(utility_internal::InPlaceIndexTag<I>); @@ -218,8 +218,8 @@ void in_place_index(utility_internal::InPlaceIndexTag<I>) {} // A constexpr version of `std::move()`, designed to be a drop-in replacement // for C++14's `std::move()`. template <typename T> -constexpr y_absl::remove_reference_t<T>&& move(T&& t) noexcept { - return static_cast<y_absl::remove_reference_t<T>&&>(t); +constexpr y_absl::remove_reference_t<T>&& move(T&& t) noexcept { + return static_cast<y_absl::remove_reference_t<T>&&>(t); } // forward() @@ -228,7 +228,7 @@ constexpr y_absl::remove_reference_t<T>&& move(T&& t) noexcept { // for C++14's `std::forward()`. template <typename T> constexpr T&& forward( - y_absl::remove_reference_t<T>& t) noexcept { // NOLINT(runtime/references) + y_absl::remove_reference_t<T>& t) noexcept { // NOLINT(runtime/references) return static_cast<T&&>(t); } @@ -237,11 +237,11 @@ namespace utility_internal { template <typename Functor, typename Tuple, std::size_t... Indexes> auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>) -> decltype(y_absl::base_internal::invoke( - y_absl::forward<Functor>(functor), - std::get<Indexes>(y_absl::forward<Tuple>(t))...)) { + y_absl::forward<Functor>(functor), + std::get<Indexes>(y_absl::forward<Tuple>(t))...)) { return y_absl::base_internal::invoke( - y_absl::forward<Functor>(functor), - std::get<Indexes>(y_absl::forward<Tuple>(t))...); + y_absl::forward<Functor>(functor), + std::get<Indexes>(y_absl::forward<Tuple>(t))...); } } // namespace utility_internal @@ -252,7 +252,7 @@ auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>) // Each element of the tuple corresponds to an argument of the call (in order). // Both the Callable argument and the tuple argument are perfect-forwarded. // For member-function Callables, the first tuple element acts as the `this` -// pointer. `y_absl::apply` is designed to be a drop-in replacement for C++17's +// pointer. `y_absl::apply` is designed to be a drop-in replacement for C++17's // `std::apply`. Unlike C++17's `std::apply`, this is not currently `constexpr`. // // Example: @@ -261,65 +261,65 @@ auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>) // public: // void Bar(int); // }; -// void user_function1(int, TString); +// void user_function1(int, TString); // void user_function2(std::unique_ptr<Foo>); // auto user_lambda = [](int, int) {}; // // int main() // { -// std::tuple<int, TString> tuple1(42, "bar"); -// // Invokes the first user function on int, TString. -// y_absl::apply(&user_function1, tuple1); +// std::tuple<int, TString> tuple1(42, "bar"); +// // Invokes the first user function on int, TString. +// y_absl::apply(&user_function1, tuple1); // -// std::tuple<std::unique_ptr<Foo>> tuple2(y_absl::make_unique<Foo>()); +// std::tuple<std::unique_ptr<Foo>> tuple2(y_absl::make_unique<Foo>()); // // Invokes the user function that takes ownership of the unique // // pointer. -// y_absl::apply(&user_function2, std::move(tuple2)); +// y_absl::apply(&user_function2, std::move(tuple2)); // -// auto foo = y_absl::make_unique<Foo>(); +// auto foo = y_absl::make_unique<Foo>(); // std::tuple<Foo*, int> tuple3(foo.get(), 42); // // Invokes the method Bar on foo with one argument, 42. -// y_absl::apply(&Foo::Bar, tuple3); +// y_absl::apply(&Foo::Bar, tuple3); // // std::tuple<int, int> tuple4(8, 9); // // Invokes a lambda. -// y_absl::apply(user_lambda, tuple4); +// y_absl::apply(user_lambda, tuple4); // } template <typename Functor, typename Tuple> auto apply(Functor&& functor, Tuple&& t) -> decltype(utility_internal::apply_helper( - y_absl::forward<Functor>(functor), y_absl::forward<Tuple>(t), - y_absl::make_index_sequence<std::tuple_size< + y_absl::forward<Functor>(functor), y_absl::forward<Tuple>(t), + y_absl::make_index_sequence<std::tuple_size< typename std::remove_reference<Tuple>::type>::value>{})) { return utility_internal::apply_helper( - y_absl::forward<Functor>(functor), y_absl::forward<Tuple>(t), - y_absl::make_index_sequence<std::tuple_size< + y_absl::forward<Functor>(functor), y_absl::forward<Tuple>(t), + y_absl::make_index_sequence<std::tuple_size< typename std::remove_reference<Tuple>::type>::value>{}); } // exchange // // Replaces the value of `obj` with `new_value` and returns the old value of -// `obj`. `y_absl::exchange` is designed to be a drop-in replacement for C++14's +// `obj`. `y_absl::exchange` is designed to be a drop-in replacement for C++14's // `std::exchange`. // // Example: // // Foo& operator=(Foo&& other) { -// ptr1_ = y_absl::exchange(other.ptr1_, nullptr); -// int1_ = y_absl::exchange(other.int1_, -1); +// ptr1_ = y_absl::exchange(other.ptr1_, nullptr); +// int1_ = y_absl::exchange(other.int1_, -1); // return *this; // } template <typename T, typename U = T> T exchange(T& obj, U&& new_value) { - T old_value = y_absl::move(obj); - obj = y_absl::forward<U>(new_value); + T old_value = y_absl::move(obj); + obj = y_absl::forward<U>(new_value); return old_value; } namespace utility_internal { template <typename T, typename Tuple, size_t... I> -T make_from_tuple_impl(Tuple&& tup, y_absl::index_sequence<I...>) { +T make_from_tuple_impl(Tuple&& tup, y_absl::index_sequence<I...>) { return T(std::get<I>(std::forward<Tuple>(tup))...); } } // namespace utility_internal @@ -333,18 +333,18 @@ T make_from_tuple_impl(Tuple&& tup, y_absl::index_sequence<I...>) { // Example: // // std::tuple<const char*, size_t> args("hello world", 5); -// auto s = y_absl::make_from_tuple<TString>(args); +// auto s = y_absl::make_from_tuple<TString>(args); // assert(s == "hello"); // template <typename T, typename Tuple> constexpr T make_from_tuple(Tuple&& tup) { return utility_internal::make_from_tuple_impl<T>( std::forward<Tuple>(tup), - y_absl::make_index_sequence< - std::tuple_size<y_absl::decay_t<Tuple>>::value>{}); + y_absl::make_index_sequence< + std::tuple_size<y_absl::decay_t<Tuple>>::value>{}); } ABSL_NAMESPACE_END -} // namespace y_absl +} // namespace y_absl #endif // ABSL_UTILITY_UTILITY_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/ya.make b/contrib/restricted/abseil-cpp-tstring/ya.make index 8a9d782dc9..67363a6930 100644 --- a/contrib/restricted/abseil-cpp-tstring/ya.make +++ b/contrib/restricted/abseil-cpp-tstring/ya.make @@ -15,60 +15,60 @@ LICENSE_TEXTS(.yandex_meta/licenses.list.txt) PEERDIR( contrib/restricted/abseil-cpp-tstring/y_absl/algorithm - contrib/restricted/abseil-cpp-tstring/y_absl/base - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait + contrib/restricted/abseil-cpp-tstring/y_absl/base + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror - contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate - contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity - contrib/restricted/abseil-cpp-tstring/y_absl/city + contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate + contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity + contrib/restricted/abseil-cpp-tstring/y_absl/city contrib/restricted/abseil-cpp-tstring/y_absl/container - contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/absl_hashtablez_sampler - contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set - contrib/restricted/abseil-cpp-tstring/y_absl/debugging - contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler - contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal - contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check - contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check_disable - contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace - contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize - contrib/restricted/abseil-cpp-tstring/y_absl/demangle - contrib/restricted/abseil-cpp-tstring/y_absl/flags + contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/absl_hashtablez_sampler + contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set + contrib/restricted/abseil-cpp-tstring/y_absl/debugging + contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler + contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal + contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check + contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check_disable + contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace + contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize + contrib/restricted/abseil-cpp-tstring/y_absl/demangle + contrib/restricted/abseil-cpp-tstring/y_absl/flags contrib/restricted/abseil-cpp-tstring/y_absl/flags/commandlineflag contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/commandlineflag - contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag + contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/flag contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/private_handle_accessor - contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/program_name - contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/usage - contrib/restricted/abseil-cpp-tstring/y_absl/flags/marshalling - contrib/restricted/abseil-cpp-tstring/y_absl/flags/parse + contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/program_name + contrib/restricted/abseil-cpp-tstring/y_absl/flags/internal/usage + contrib/restricted/abseil-cpp-tstring/y_absl/flags/marshalling + contrib/restricted/abseil-cpp-tstring/y_absl/flags/parse contrib/restricted/abseil-cpp-tstring/y_absl/flags/reflection - contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage - contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage_config + contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage + contrib/restricted/abseil-cpp-tstring/y_absl/flags/usage_config contrib/restricted/abseil-cpp-tstring/y_absl/functional - contrib/restricted/abseil-cpp-tstring/y_absl/hash + contrib/restricted/abseil-cpp-tstring/y_absl/hash contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal contrib/restricted/abseil-cpp-tstring/y_absl/memory contrib/restricted/abseil-cpp-tstring/y_absl/meta - contrib/restricted/abseil-cpp-tstring/y_absl/numeric + contrib/restricted/abseil-cpp-tstring/y_absl/numeric contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler - contrib/restricted/abseil-cpp-tstring/y_absl/random/absl_random_distributions - contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/absl_random_internal_distribution_test_util - contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/pool_urbg - contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/randen - contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/randen_detect - contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/randen_hwaes + contrib/restricted/abseil-cpp-tstring/y_absl/random/absl_random_distributions + contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/absl_random_internal_distribution_test_util + contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/pool_urbg + contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/randen + contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/randen_detect + contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/randen_hwaes contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/randen_round_keys - contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/randen_slow - contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/seed_material - contrib/restricted/abseil-cpp-tstring/y_absl/random/seed_gen_exception - contrib/restricted/abseil-cpp-tstring/y_absl/random/seed_sequences + contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/randen_slow + contrib/restricted/abseil-cpp-tstring/y_absl/random/internal/seed_material + contrib/restricted/abseil-cpp-tstring/y_absl/random/seed_gen_exception + contrib/restricted/abseil-cpp-tstring/y_absl/random/seed_sequences contrib/restricted/abseil-cpp-tstring/y_absl/status contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor - contrib/restricted/abseil-cpp-tstring/y_absl/strings + contrib/restricted/abseil-cpp-tstring/y_absl/strings contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_cord_internal contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal @@ -76,16 +76,16 @@ PEERDIR( contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_sample_token - contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format - contrib/restricted/abseil-cpp-tstring/y_absl/synchronization - contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal - contrib/restricted/abseil-cpp-tstring/y_absl/time - contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time - contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone + contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format + contrib/restricted/abseil-cpp-tstring/y_absl/synchronization + contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal + contrib/restricted/abseil-cpp-tstring/y_absl/time + contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time + contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone contrib/restricted/abseil-cpp-tstring/y_absl/types - contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast - contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access - contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access + contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast + contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access + contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access contrib/restricted/abseil-cpp-tstring/y_absl/types/internal contrib/restricted/abseil-cpp-tstring/y_absl/utility ) @@ -96,60 +96,60 @@ END() RECURSE( y_absl/algorithm - y_absl/base - y_absl/base/internal/low_level_alloc - y_absl/base/internal/raw_logging - y_absl/base/internal/scoped_set_env - y_absl/base/internal/spinlock_wait + y_absl/base + y_absl/base/internal/low_level_alloc + y_absl/base/internal/raw_logging + y_absl/base/internal/scoped_set_env + y_absl/base/internal/spinlock_wait y_absl/base/internal/strerror - y_absl/base/internal/throw_delegate - y_absl/base/log_severity - y_absl/city + y_absl/base/internal/throw_delegate + y_absl/base/log_severity + y_absl/city y_absl/container - y_absl/container/internal/absl_hashtablez_sampler - y_absl/container/internal/raw_hash_set - y_absl/debugging - y_absl/debugging/failure_signal_handler - y_absl/debugging/internal - y_absl/debugging/leak_check - y_absl/debugging/leak_check_disable - y_absl/debugging/stacktrace - y_absl/debugging/symbolize - y_absl/demangle - y_absl/flags + y_absl/container/internal/absl_hashtablez_sampler + y_absl/container/internal/raw_hash_set + y_absl/debugging + y_absl/debugging/failure_signal_handler + y_absl/debugging/internal + y_absl/debugging/leak_check + y_absl/debugging/leak_check_disable + y_absl/debugging/stacktrace + y_absl/debugging/symbolize + y_absl/demangle + y_absl/flags y_absl/flags/commandlineflag y_absl/flags/internal/commandlineflag - y_absl/flags/internal/flag + y_absl/flags/internal/flag y_absl/flags/internal/private_handle_accessor - y_absl/flags/internal/program_name - y_absl/flags/internal/usage - y_absl/flags/marshalling - y_absl/flags/parse + y_absl/flags/internal/program_name + y_absl/flags/internal/usage + y_absl/flags/marshalling + y_absl/flags/parse y_absl/flags/reflection - y_absl/flags/usage - y_absl/flags/usage_config + y_absl/flags/usage + y_absl/flags/usage_config y_absl/functional - y_absl/hash + y_absl/hash y_absl/hash/internal y_absl/memory y_absl/meta - y_absl/numeric + y_absl/numeric y_absl/profiling/internal/exponential_biased y_absl/profiling/internal/periodic_sampler - y_absl/random/absl_random_distributions - y_absl/random/internal/absl_random_internal_distribution_test_util - y_absl/random/internal/pool_urbg - y_absl/random/internal/randen - y_absl/random/internal/randen_detect - y_absl/random/internal/randen_hwaes + y_absl/random/absl_random_distributions + y_absl/random/internal/absl_random_internal_distribution_test_util + y_absl/random/internal/pool_urbg + y_absl/random/internal/randen + y_absl/random/internal/randen_detect + y_absl/random/internal/randen_hwaes y_absl/random/internal/randen_round_keys - y_absl/random/internal/randen_slow - y_absl/random/internal/seed_material - y_absl/random/seed_gen_exception - y_absl/random/seed_sequences + y_absl/random/internal/randen_slow + y_absl/random/internal/seed_material + y_absl/random/seed_gen_exception + y_absl/random/seed_sequences y_absl/status y_absl/status/statusor - y_absl/strings + y_absl/strings y_absl/strings/cord y_absl/strings/internal/absl_cord_internal y_absl/strings/internal/absl_strings_internal @@ -157,16 +157,16 @@ RECURSE( y_absl/strings/internal/cordz_handle y_absl/strings/internal/cordz_info y_absl/strings/internal/cordz_sample_token - y_absl/strings/internal/str_format - y_absl/synchronization - y_absl/synchronization/internal - y_absl/time - y_absl/time/civil_time - y_absl/time/time_zone + y_absl/strings/internal/str_format + y_absl/synchronization + y_absl/synchronization/internal + y_absl/time + y_absl/time/civil_time + y_absl/time/time_zone y_absl/types - y_absl/types/bad_any_cast - y_absl/types/bad_optional_access - y_absl/types/bad_variant_access + y_absl/types/bad_any_cast + y_absl/types/bad_optional_access + y_absl/types/bad_variant_access y_absl/types/internal y_absl/utility ) |