Restoring authorship annotation for <thegeorg@yandex-team.ru>. Commit 1 of 2.

1 files changed, 89 insertions, 89 deletions

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 fcbe43accd..32cbbbb27a 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
@@ -21,7 +21,7 @@
 
 #include <algorithm>
 #include <array>
-#include <bitset>
+#include <bitset> 
 #include <cmath>
 #include <cstring>
 #include <deque>
@@ -43,8 +43,8 @@
 #include "y_absl/base/internal/unaligned_access.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/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"
@@ -380,7 +380,7 @@ template <typename H, typename... Ts>
 // This SFINAE gets MSVC confused under some conditions. Let's just disable it
 // for now.
 H
-#else   // _MSC_VER
+#else   // _MSC_VER 
 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) {
@@ -490,9 +490,9 @@ typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
 
 // AbslHashValue for hashing std::vector
 //
-// Do not use this for vector<bool> on platforms that have a working
-// implementation of std::hash. It does not have a .data(), and a fallback for
-// std::hash<> is most likely faster.
+// Do not use this for vector<bool> on platforms that have a working 
+// implementation of std::hash. It does not have a .data(), and a fallback for 
+// std::hash<> is most likely faster. 
 template <typename H, typename T, typename Allocator>
 typename std::enable_if<is_hashable<T>::value && !std::is_same<T, bool>::value,
                         H>::type
@@ -502,27 +502,27 @@ AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
                     vector.size());
 }
 
-#if defined(ABSL_IS_BIG_ENDIAN) && \
-    (defined(__GLIBCXX__) || defined(__GLIBCPP__))
-// AbslHashValue for hashing std::vector<bool>
-//
-// std::hash in libstdc++ does not work correctly with vector<bool> on Big
-// Endian platforms therefore we need to implement a custom AbslHashValue for
-// it. More details on the bug:
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value && std::is_same<T, bool>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
-  typename H::AbslInternalPiecewiseCombiner combiner;
-  for (const auto& i : vector) {
-    unsigned char c = static_cast<unsigned char>(i);
-    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
-  }
-  return H::combine(combiner.finalize(std::move(hash_state)), vector.size());
-}
-#endif
-
+#if defined(ABSL_IS_BIG_ENDIAN) && \ 
+    (defined(__GLIBCXX__) || defined(__GLIBCPP__)) 
+// AbslHashValue for hashing std::vector<bool> 
+// 
+// std::hash in libstdc++ does not work correctly with vector<bool> on Big 
+// Endian platforms therefore we need to implement a custom AbslHashValue for 
+// it. More details on the bug: 
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531 
+template <typename H, typename T, typename Allocator> 
+typename std::enable_if<is_hashable<T>::value && std::is_same<T, bool>::value, 
+                        H>::type 
+AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) { 
+  typename H::AbslInternalPiecewiseCombiner combiner; 
+  for (const auto& i : vector) { 
+    unsigned char c = static_cast<unsigned char>(i); 
+    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c)); 
+  } 
+  return H::combine(combiner.finalize(std::move(hash_state)), vector.size()); 
+} 
+#endif 
+ 
 // -----------------------------------------------------------------------------
 // AbslHashValue for Ordered Associative Containers
 // -----------------------------------------------------------------------------
@@ -615,29 +615,29 @@ AbslHashValue(H hash_state, const y_absl::variant<T...>& v) {
 // AbslHashValue for Other Types
 // -----------------------------------------------------------------------------
 
-// AbslHashValue for hashing std::bitset is not defined on Little Endian
-// platforms, for the same reason as for vector<bool> (see std::vector above):
-// It does not expose the raw bytes, and a fallback to std::hash<> is most
-// likely faster.
-
-#if defined(ABSL_IS_BIG_ENDIAN) && \
-    (defined(__GLIBCXX__) || defined(__GLIBCPP__))
-// AbslHashValue for hashing std::bitset
-//
-// std::hash in libstdc++ does not work correctly with std::bitset on Big Endian
-// platforms therefore we need to implement a custom AbslHashValue for it. More
-// details on the bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531
-template <typename H, size_t N>
-H AbslHashValue(H hash_state, const std::bitset<N>& set) {
-  typename H::AbslInternalPiecewiseCombiner combiner;
-  for (int i = 0; i < N; i++) {
-    unsigned char c = static_cast<unsigned char>(set[i]);
-    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
-  }
-  return H::combine(combiner.finalize(std::move(hash_state)), N);
-}
-#endif
-
+// AbslHashValue for hashing std::bitset is not defined on Little Endian 
+// platforms, for the same reason as for vector<bool> (see std::vector above): 
+// It does not expose the raw bytes, and a fallback to std::hash<> is most 
+// likely faster. 
+
+#if defined(ABSL_IS_BIG_ENDIAN) && \ 
+    (defined(__GLIBCXX__) || defined(__GLIBCPP__)) 
+// AbslHashValue for hashing std::bitset 
+// 
+// std::hash in libstdc++ does not work correctly with std::bitset on Big Endian 
+// platforms therefore we need to implement a custom AbslHashValue for it. More 
+// details on the bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531 
+template <typename H, size_t N> 
+H AbslHashValue(H hash_state, const std::bitset<N>& set) { 
+  typename H::AbslInternalPiecewiseCombiner combiner; 
+  for (int i = 0; i < N; i++) { 
+    unsigned char c = static_cast<unsigned char>(set[i]); 
+    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c)); 
+  } 
+  return H::combine(combiner.finalize(std::move(hash_state)), N); 
+} 
+#endif 
+ 
 // -----------------------------------------------------------------------------
 
 // hash_range_or_bytes()
@@ -756,8 +756,8 @@ template <typename T>
 struct is_hashable
     : std::integral_constant<bool, HashSelect::template Apply<T>::value> {};
 
-// MixingHashState
-class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
+// MixingHashState 
+class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> { 
   // 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
@@ -776,23 +776,23 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
 
  public:
   // Move only
-  MixingHashState(MixingHashState&&) = default;
-  MixingHashState& operator=(MixingHashState&&) = default;
+  MixingHashState(MixingHashState&&) = default; 
+  MixingHashState& operator=(MixingHashState&&) = default; 
 
-  // MixingHashState::combine_contiguous()
+  // MixingHashState::combine_contiguous() 
   //
   // Fundamental base case for hash recursion: mixes the given range of bytes
   // into the hash state.
-  static MixingHashState combine_contiguous(MixingHashState hash_state,
-                                            const unsigned char* first,
-                                            size_t size) {
-    return MixingHashState(
+  static MixingHashState combine_contiguous(MixingHashState hash_state, 
+                                            const unsigned char* first, 
+                                            size_t size) { 
+    return MixingHashState( 
         CombineContiguousImpl(hash_state.state_, first, size,
                               std::integral_constant<int, sizeof(size_t)>{}));
   }
-  using MixingHashState::HashStateBase::combine_contiguous;
+  using MixingHashState::HashStateBase::combine_contiguous; 
 
-  // MixingHashState::hash()
+  // MixingHashState::hash() 
   //
   // For performance reasons in non-opt mode, we specialize this for
   // integral types.
@@ -804,24 +804,24 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
     return static_cast<size_t>(Mix(Seed(), static_cast<uint64_t>(value)));
   }
 
-  // Overload of MixingHashState::hash()
+  // Overload of MixingHashState::hash() 
   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_);
+    return static_cast<size_t>(combine(MixingHashState{}, value).state_); 
   }
 
  private:
   // Invoked only once for a given argument; that plus the fact that this is
   // move-only ensures that there is only one non-moved-from object.
-  MixingHashState() : state_(Seed()) {}
+  MixingHashState() : state_(Seed()) {} 
 
   // Workaround for MSVC bug.
   // We make the type copyable to fix the calling convention, even though we
   // never actually copy it. Keep it private to not affect the public API of the
   // type.
-  MixingHashState(const MixingHashState&) = default;
+  MixingHashState(const MixingHashState&) = default; 
 
-  explicit MixingHashState(uint64_t state) : state_(state) {}
+  explicit MixingHashState(uint64_t state) : state_(state) {} 
 
   // Implementation of the base case for combine_contiguous where we actually
   // mix the bytes into the state.
@@ -898,15 +898,15 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   }
 
   ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
-#if defined(__aarch64__)
-    // On AArch64, calculating a 128-bit product is inefficient, because it
-    // requires a sequence of two instructions to calculate the upper and lower
-    // halves of the result.
-    using MultType = uint64_t;
-#else
+#if defined(__aarch64__) 
+    // On AArch64, calculating a 128-bit product is inefficient, because it 
+    // requires a sequence of two instructions to calculate the upper and lower 
+    // halves of the result. 
+    using MultType = uint64_t; 
+#else 
     using MultType =
         y_absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
-#endif
+#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
     // to assume that the high word is non-zero and needs to perform 2
@@ -916,16 +916,16 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
     return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
   }
 
-  // An extern to avoid bloat on a direct call to LowLevelHash() with fixed
-  // values for both the seed and salt parameters.
-  static uint64_t LowLevelHashImpl(const unsigned char* data, size_t len);
+  // An extern to avoid bloat on a direct call to LowLevelHash() with fixed 
+  // values for both the seed and salt parameters. 
+  static uint64_t LowLevelHashImpl(const unsigned char* data, size_t len); 
 
   ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Hash64(const unsigned char* data,
                                                       size_t len) {
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-    return LowLevelHashImpl(data, len);
+    return LowLevelHashImpl(data, len); 
 #else
-    return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
+    return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len); 
 #endif
   }
 
@@ -960,8 +960,8 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   uint64_t state_;
 };
 
-// MixingHashState::CombineContiguousImpl()
-inline uint64_t MixingHashState::CombineContiguousImpl(
+// MixingHashState::CombineContiguousImpl() 
+inline uint64_t MixingHashState::CombineContiguousImpl( 
     uint64_t state, const unsigned char* first, size_t len,
     std::integral_constant<int, 4> /* sizeof_size_t */) {
   // For large values we use CityHash, for small ones we just use a
@@ -971,7 +971,7 @@ inline uint64_t MixingHashState::CombineContiguousImpl(
     if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
       return CombineLargeContiguousImpl32(state, first, len);
     }
-    v = hash_internal::CityHash32(reinterpret_cast<const char*>(first), len);
+    v = hash_internal::CityHash32(reinterpret_cast<const char*>(first), len); 
   } else if (len >= 4) {
     v = Read4To8(first, len);
   } else if (len > 0) {
@@ -983,12 +983,12 @@ inline uint64_t MixingHashState::CombineContiguousImpl(
   return Mix(state, v);
 }
 
-// Overload of MixingHashState::CombineContiguousImpl()
-inline uint64_t MixingHashState::CombineContiguousImpl(
+// Overload of MixingHashState::CombineContiguousImpl() 
+inline uint64_t MixingHashState::CombineContiguousImpl( 
     uint64_t state, const unsigned char* first, size_t len,
     std::integral_constant<int, 8> /* sizeof_size_t */) {
-  // For large values we use LowLevelHash or CityHash depending on the platform,
-  // for small ones we just use a multiplicative hash.
+  // For large values we use LowLevelHash or CityHash depending on the platform, 
+  // for small ones we just use a multiplicative hash. 
   uint64_t v;
   if (len > 16) {
     if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
@@ -1025,9 +1025,9 @@ struct PoisonedHash : private AggregateBarrier {
 
 template <typename T>
 struct HashImpl {
-  size_t operator()(const T& value) const {
-    return MixingHashState::hash(value);
-  }
+  size_t operator()(const T& value) const { 
+    return MixingHashState::hash(value); 
+  } 
 };
 
 template <typename T>