Restoring authorship annotation for Dmitry Potapov <potapov.d@gmail.com>. Commit 2 of 2.

9 files changed, 86 insertions, 86 deletions

diff --git a/util/generic/cast.h b/util/generic/cast.h
index 0d680f90bd..0d4a41f385 100644
--- a/util/generic/cast.h
+++ b/util/generic/cast.h
@@ -1,14 +1,14 @@
 #pragma once
 
 #include "typetraits.h"
-#include "yexception.h" 
+#include "yexception.h"
 
 #include <util/system/compat.h>
 #include <util/system/type_name.h>
 #include <util/system/unaligned_mem.h>
 #include <util/system/yassert.h>
 
-#include <cstdlib> 
+#include <cstdlib>
 
 template <class T, class F>
 static inline T VerifyDynamicCast(F f) {
@@ -87,7 +87,7 @@ constexpr bool IsNegative(const TType value) noexcept {
     return TInteger<std::is_unsigned<TType>::value>::IsNegative(value);
 }
 
-namespace NPrivate { 
+namespace NPrivate {
     template <class T>
     using TUnderlyingTypeOrSelf = typename std::conditional<
         std::is_enum<T>::value,
@@ -96,21 +96,21 @@ namespace NPrivate {
         >::type::type;           // Left ::type is for std::conditional, right ::type is for underlying_type/enable_if
 
     template <class TSmall, class TLarge>
-    struct TSafelyConvertible { 
+    struct TSafelyConvertible {
         using TSmallInt = TUnderlyingTypeOrSelf<TSmall>;
         using TLargeInt = TUnderlyingTypeOrSelf<TLarge>;
 
         static constexpr bool Result = std::is_integral<TSmallInt>::value && std::is_integral<TLargeInt>::value &&
                                        ((std::is_signed<TSmallInt>::value == std::is_signed<TLargeInt>::value && sizeof(TSmallInt) >= sizeof(TLargeInt)) ||
                                         (std::is_signed<TSmallInt>::value && sizeof(TSmallInt) > sizeof(TLargeInt)));
-    }; 
-} 
- 
+    };
+}
+
 template <class TSmallInt, class TLargeInt>
 constexpr std::enable_if_t<::NPrivate::TSafelyConvertible<TSmallInt, TLargeInt>::Result, TSmallInt> SafeIntegerCast(TLargeInt largeInt) noexcept {
     return static_cast<TSmallInt>(largeInt);
-} 
- 
+}
+
 template <class TSmall, class TLarge>
 inline std::enable_if_t<!::NPrivate::TSafelyConvertible<TSmall, TLarge>::Result, TSmall> SafeIntegerCast(TLarge largeInt) {
     using TSmallInt = ::NPrivate::TUnderlyingTypeOrSelf<TSmall>;
@@ -127,7 +127,7 @@ inline std::enable_if_t<!::NPrivate::TSafelyConvertible<TSmall, TLarge>::Result,
     TSmallInt smallInt = TSmallInt(largeInt);
 
     if (std::is_signed<TSmallInt>::value && std::is_unsigned<TLargeInt>::value) {
-        if (IsNegative(smallInt)) { 
+        if (IsNegative(smallInt)) {
             ythrow TBadCastException() << "Conversion '" << TypeName<TLarge>() << '{' << TLargeInt(largeInt) << "}' to '"
                                        << TypeName<TSmallInt>()
                                        << "', positive value converted to negative";
@@ -141,15 +141,15 @@ inline std::enable_if_t<!::NPrivate::TSafelyConvertible<TSmall, TLarge>::Result,
 
     return static_cast<TSmall>(smallInt);
 }
- 
-template <class TSmallInt, class TLargeInt> 
+
+template <class TSmallInt, class TLargeInt>
 inline TSmallInt IntegerCast(TLargeInt largeInt) noexcept {
-    try { 
-        return SafeIntegerCast<TSmallInt>(largeInt); 
-    } catch (const yexception& exc) { 
+    try {
+        return SafeIntegerCast<TSmallInt>(largeInt);
+    } catch (const yexception& exc) {
         Y_FAIL("IntegerCast: %s", exc.what());
-    } 
-} 
+    }
+}
 
 /* Convert given enum value to its underlying type. This is just a shortcut for
  * `static_cast<std::underlying_type_t<EEnum>>(enum_)`.
diff --git a/util/generic/string.h b/util/generic/string.h
index 61a4bd55ef..8cd8aa6917 100644
--- a/util/generic/string.h
+++ b/util/generic/string.h
@@ -864,7 +864,7 @@ public:
      */
 
     friend TBasicString operator+(TBasicString&& s1, const TBasicString& s2) Y_WARN_UNUSED_RESULT {
-        s1 += s2; 
+        s1 += s2;
         return std::move(s1);
     }
 
@@ -880,17 +880,17 @@ public:
             return std::move(s2);
         }
 #endif
-        s1 += s2; 
+        s1 += s2;
         return std::move(s1);
     }
 
     friend TBasicString operator+(TBasicString&& s1, const TBasicStringBuf<TCharType, TTraits> s2) Y_WARN_UNUSED_RESULT {
-        s1 += s2; 
+        s1 += s2;
         return std::move(s1);
     }
 
     friend TBasicString operator+(TBasicString&& s1, const TCharType* s2) Y_WARN_UNUSED_RESULT {
-        s1 += s2; 
+        s1 += s2;
         return std::move(s1);
     }
 
diff --git a/util/generic/typelist.h b/util/generic/typelist.h
index 7f2a316748..5ce26ab97c 100644
--- a/util/generic/typelist.h
+++ b/util/generic/typelist.h
@@ -80,7 +80,7 @@ namespace NTL {
         using TSignedInts = typename TConcat<TTypeList<T>, TS>::type;
         using TUnsignedInts = TU;
     };
- 
+
     template <class T, class TS, class TU>
     struct TTypeSelectorBase<false, T, TS, TU> {
         using TSignedInts = TS;
diff --git a/util/generic/yexception.h b/util/generic/yexception.h
index 51f7bde050..b0c604e8c4 100644
--- a/util/generic/yexception.h
+++ b/util/generic/yexception.h
@@ -129,8 +129,8 @@ class TFileError: public TIoSystemError {
  * TBadArgumentException.
  */
 struct TBadArgumentException: public virtual yexception {
-}; 
- 
+};
+
 /**
  * TBadCastException should be thrown to indicate the failure of some type casting procedure
  * (e.g. reading an integer parameter from string).
diff --git a/util/generic/ylimits.h b/util/generic/ylimits.h
index 599effa481..fe42b4dfc0 100644
--- a/util/generic/ylimits.h
+++ b/util/generic/ylimits.h
@@ -15,30 +15,30 @@ template <class T>
 static constexpr T Min() noexcept {
     return std::numeric_limits<T>::min();
 }
- 
-namespace NPrivate { 
-    struct TMax { 
-        template <class T> 
+
+namespace NPrivate {
+    struct TMax {
+        template <class T>
         constexpr operator T() const {
-            return Max<T>(); 
-        } 
-    }; 
- 
-    struct TMin { 
-        template <class T> 
+            return Max<T>();
+        }
+    };
+
+    struct TMin {
+        template <class T>
         constexpr operator T() const {
-            return Min<T>(); 
-        } 
-    }; 
-} 
- 
+            return Min<T>();
+        }
+    };
+}
+
 static constexpr ::NPrivate::TMax Max() noexcept {
     return {};
-} 
- 
+}
+
 static constexpr ::NPrivate::TMin Min() noexcept {
     return {};
-} 
+}
 
 namespace NPrivate {
     template <unsigned long long N>
diff --git a/util/generic/ylimits_ut.cpp b/util/generic/ylimits_ut.cpp
index 3a0a70adc9..f1b3c6858c 100644
--- a/util/generic/ylimits_ut.cpp
+++ b/util/generic/ylimits_ut.cpp
@@ -1,4 +1,4 @@
-#include "cast.h" 
+#include "cast.h"
 #include "ylimits.h"
 
 #include <library/cpp/testing/unittest/registar.h>
@@ -42,11 +42,11 @@ static inline bool TestIntegralLimits(const T&, bool unknownSign = true, bool is
     CHECK_COND((unknownSign && ((lim::is_signed && (lim::min() != 0)) || (!lim::is_signed && (lim::min() == 0)))) ||
                (!unknownSign && ((lim::is_signed && isSigned) || (!lim::is_signed && !isSigned))));
 
-    T min = Min(); 
-    UNIT_ASSERT_EQUAL(lim::min(), min); 
-    T max = Max(); 
-    UNIT_ASSERT_EQUAL(lim::max(), max); 
- 
+    T min = Min();
+    UNIT_ASSERT_EQUAL(lim::min(), min);
+    T max = Max();
+    UNIT_ASSERT_EQUAL(lim::max(), max);
+
     if (unknownSign) {
         CHECK_COND(ValidSignInfo(lim::is_signed, T()));
     }
diff --git a/util/memory/blob.cpp b/util/memory/blob.cpp
index 879522ed47..91da5cadca 100644
--- a/util/memory/blob.cpp
+++ b/util/memory/blob.cpp
@@ -363,7 +363,7 @@ static inline TBlob ConstructFromBuffer(TBuffer& in) {
 
 template <class TCounter>
 static inline TBlob ConstructFromStream(IInputStream& in) {
-    TBuffer buf; 
+    TBuffer buf;
 
     {
         TBufferOutput out(buf);
@@ -375,11 +375,11 @@ static inline TBlob ConstructFromStream(IInputStream& in) {
 }
 
 TBlob TBlob::FromStreamSingleThreaded(IInputStream& in) {
-    return ConstructFromStream<TSimpleCounter>(in); 
+    return ConstructFromStream<TSimpleCounter>(in);
 }
 
 TBlob TBlob::FromStream(IInputStream& in) {
-    return ConstructFromStream<TAtomicCounter>(in); 
+    return ConstructFromStream<TAtomicCounter>(in);
 }
 
 TBlob TBlob::FromBufferSingleThreaded(TBuffer& in) {
diff --git a/util/string/cast.h b/util/string/cast.h
index f1e2f06abb..90e925c194 100644
--- a/util/string/cast.h
+++ b/util/string/cast.h
@@ -180,41 +180,41 @@ inline T FromString(const TUtf16String& s) {
     return ::FromString<T, wchar16>(s.data(), s.size());
 }
 
-namespace NPrivate { 
-    template <typename TChar> 
-    class TFromString { 
-        const TChar* const Data; 
-        const size_t Len; 
- 
-    public: 
-        inline TFromString(const TChar* data, size_t len) 
-            : Data(data) 
-            , Len(len) 
-        { 
-        } 
- 
-        template <typename T> 
-        inline operator T() const { 
-            return FromString<T, TChar>(Data, Len); 
-        } 
-    }; 
-} 
- 
-template <typename TChar> 
-inline ::NPrivate::TFromString<TChar> FromString(const TChar* data, size_t len) { 
-    return ::NPrivate::TFromString<TChar>(data, len); 
-} 
- 
-template <typename TChar> 
-inline ::NPrivate::TFromString<TChar> FromString(const TChar* data) { 
+namespace NPrivate {
+    template <typename TChar>
+    class TFromString {
+        const TChar* const Data;
+        const size_t Len;
+
+    public:
+        inline TFromString(const TChar* data, size_t len)
+            : Data(data)
+            , Len(len)
+        {
+        }
+
+        template <typename T>
+        inline operator T() const {
+            return FromString<T, TChar>(Data, Len);
+        }
+    };
+}
+
+template <typename TChar>
+inline ::NPrivate::TFromString<TChar> FromString(const TChar* data, size_t len) {
+    return ::NPrivate::TFromString<TChar>(data, len);
+}
+
+template <typename TChar>
+inline ::NPrivate::TFromString<TChar> FromString(const TChar* data) {
     return ::NPrivate::TFromString<TChar>(data, std::char_traits<TChar>::length(data));
-} 
- 
-template <typename T> 
-inline ::NPrivate::TFromString<typename T::TChar> FromString(const T& s) { 
+}
+
+template <typename T>
+inline ::NPrivate::TFromString<typename T::TChar> FromString(const T& s) {
     return ::NPrivate::TFromString<typename T::TChar>(s.data(), s.size());
-} 
- 
+}
+
 // Conversion exception free versions
 template <typename T, typename TChar>
 bool TryFromStringImpl(const TChar* data, size_t len, T& result);
diff --git a/util/string/cast_ut.cpp b/util/string/cast_ut.cpp
index 949f09486b..033450c38c 100644
--- a/util/string/cast_ut.cpp
+++ b/util/string/cast_ut.cpp
@@ -4,7 +4,7 @@
 
 #include <util/charset/wide.h>
 #include <util/system/defaults.h>
- 
+
 #include <limits>
 
 // positive test (return true or no exception)
@@ -319,7 +319,7 @@ Y_UNIT_TEST_SUITE(TCastTest) {
     Y_UNIT_TEST(TestLiteral) {
         UNIT_ASSERT_VALUES_EQUAL(ToString("abc"), TString("abc"));
     }
- 
+
     Y_UNIT_TEST(TestFromStringStringBuf) {
         TString a = "xyz";
         TStringBuf b = FromString<TStringBuf>(a);