Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

3 files changed, 60 insertions, 60 deletions

diff --git a/util/generic/string.h b/util/generic/string.h
index 8cd8aa6917f..6ad1e5b78f5 100644
--- a/util/generic/string.h
+++ b/util/generic/string.h
@@ -530,7 +530,7 @@ public:
         return TBasicString(TUninitialized(n));
     }
 
-private:
+private: 
     template <typename... R>
     static size_t SumLength(const TBasicStringBuf<TCharType, TTraits> s1, const R&... r) noexcept {
         return s1.size() + SumLength(r...);
@@ -542,15 +542,15 @@ private:
     }
 
     static constexpr size_t SumLength() noexcept {
-        return 0;
+        return 0; 
     }
 
     template <typename... R>
     static void CopyAll(TCharType* p, const TBasicStringBuf<TCharType, TTraits> s, const R&... r) {
         TTraits::copy(p, s.data(), s.size());
         CopyAll(p + s.size(), r...);
-    }
-
+    } 
+ 
     template <typename... R, class TNextCharType, typename = std::enable_if_t<std::is_same<TCharType, TNextCharType>::value>>
     static void CopyAll(TCharType* p, const TNextCharType s, const R&... r) {
         p[0] = s;
@@ -558,9 +558,9 @@ private:
     }
 
     static void CopyAll(TCharType*) noexcept {
-    }
-
-public:
+    } 
+ 
+public: 
     inline void clear() noexcept {
 #ifdef TSTRING_IS_STD_STRING
         Storage_.clear();
@@ -575,13 +575,13 @@ public:
 #endif
     }
 
-    template <typename... R>
+    template <typename... R> 
     static inline TBasicString Join(const R&... r) {
         TBasicString s{TUninitialized{SumLength(r...)}};
 
         TBasicString::CopyAll((TCharType*)s.data(), r...);
 
-        return s;
+        return s; 
     }
 
     // ~~~ Assignment ~~~ : FAMILY0(TBasicString&, assign);
diff --git a/util/generic/typelist.h b/util/generic/typelist.h
index 5ce26ab97c7..a2ecaa5bcac 100644
--- a/util/generic/typelist.h
+++ b/util/generic/typelist.h
@@ -7,8 +7,8 @@
 #include <type_traits>
 
 template <class... R>
-struct TTypeList;
-
+struct TTypeList; 
+ 
 namespace NTL {
     template <unsigned N, typename TL>
     struct TGetImpl {
@@ -22,7 +22,7 @@ namespace NTL {
 }
 
 template <>
-struct TTypeList<> {
+struct TTypeList<> { 
     static constexpr size_t Length = 0;
 
     template <class>
@@ -34,13 +34,13 @@ struct TTypeList<> {
     };
 };
 
-using TNone = TTypeList<>;
+using TNone = TTypeList<>; 
 
 template <class H, class... R>
-struct TTypeList<H, R...> {
-    using THead = H;
-    using TTail = TTypeList<R...>;
-
+struct TTypeList<H, R...> { 
+    using THead = H; 
+    using TTail = TTypeList<R...>; 
+ 
     static constexpr size_t Length = 1 + sizeof...(R);
 
     template <class V>
@@ -55,26 +55,26 @@ struct TTypeList<H, R...> {
     };
 };
 
-//FIXME: temporary to check overall build
+//FIXME: temporary to check overall build 
 template <class T>
 struct TTypeList<T, TNone>: public TTypeList<T> {
-};
-
+}; 
+ 
 using TCommonSignedInts = TTypeList<signed char, signed short, signed int, signed long, signed long long>;
 using TCommonUnsignedInts = TTypeList<unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long, bool>;
 using TFixedWidthSignedInts = TTypeList<i8, i16, i32, i64>;
 using TFixedWidthUnsignedInts = TTypeList<ui8, ui16, ui32, ui64>;
 using TFloats = TTypeList<float, double, long double>;
-
+ 
 namespace NTL {
     template <class T1, class T2>
-    struct TConcat;
-
+    struct TConcat; 
+ 
     template <class... R1, class... R2>
-    struct TConcat<TTypeList<R1...>, TTypeList<R2...>> {
+    struct TConcat<TTypeList<R1...>, TTypeList<R2...>> { 
         using type = TTypeList<R1..., R2...>;
-    };
-
+    }; 
+ 
     template <bool isSigned, class T, class TS, class TU>
     struct TTypeSelectorBase {
         using TSignedInts = typename TConcat<TTypeList<T>, TS>::type;
diff --git a/util/generic/typelist_ut.cpp b/util/generic/typelist_ut.cpp
index eeabfa97b17..6846391c383 100644
--- a/util/generic/typelist_ut.cpp
+++ b/util/generic/typelist_ut.cpp
@@ -1,20 +1,20 @@
 #include <library/cpp/testing/unittest/registar.h>
 #include <util/system/type_name.h>
-
+ 
 #include "typelist.h"
 #include "vector.h"
 #include "map.h"
-
-class TTypeListTest: public TTestBase {
-    UNIT_TEST_SUITE(TTypeListTest);
-    UNIT_TEST(TestSimple);
-    UNIT_TEST(TestHave);
+ 
+class TTypeListTest: public TTestBase { 
+    UNIT_TEST_SUITE(TTypeListTest); 
+    UNIT_TEST(TestSimple); 
+    UNIT_TEST(TestHave); 
     UNIT_TEST(TestGet);
     UNIT_TEST(TestFloatList);
-    UNIT_TEST(TestSelectBy);
-    UNIT_TEST_SUITE_END();
-
-public:
+    UNIT_TEST(TestSelectBy); 
+    UNIT_TEST_SUITE_END(); 
+ 
+public: 
     void TestGet() {
         using TListType = TTypeList<int, char, float>;
 
@@ -23,56 +23,56 @@ public:
         UNIT_ASSERT_TYPES_EQUAL(TListType::TGet<2>, float);
     }
 
-    void TestSimple() {
+    void TestSimple() { 
         using TListType = TTypeList<int, char, float>;
         UNIT_ASSERT_EQUAL(TListType::Length, 3);
         UNIT_ASSERT_TYPES_EQUAL(TListType::THead, int);
-    }
-
-    struct TA {};
-    struct TB {};
-    struct TC {};
-    void TestHave() {
+    } 
+ 
+    struct TA {}; 
+    struct TB {}; 
+    struct TC {}; 
+    void TestHave() { 
         using TListType = TTypeList<TA, TB*, const TC&>;
         UNIT_ASSERT(TListType::THave<TA>::value);
         UNIT_ASSERT(TListType::THave<TB*>::value);
         UNIT_ASSERT(!TListType::THave<TB>::value);
         UNIT_ASSERT(TListType::THave<const TC&>::value);
         UNIT_ASSERT(!TListType::THave<TC&>::value);
-    }
-
+    } 
+ 
     template <class T>
     class TT {};
-
+ 
     template <class T>
     struct TIs1ArgTemplate: std::false_type {};
-
+ 
     template <class T, template <class> class TT>
     struct TIs1ArgTemplate<TT<T>>: std::true_type {};
-
+ 
     template <class T>
     struct TIsNArgTemplate: std::false_type {};
-
+ 
     template <template <class...> class TT, class... R>
     struct TIsNArgTemplate<TT<R...>>: std::true_type {};
 
     template <class>
     struct TAnyType: std::true_type {};
-
+ 
     template <class T>
-    struct TMyVector {};
-
+    struct TMyVector {}; 
+ 
     template <class T1, class T2>
-    struct TMyMap {};
-
-    void TestSelectBy() {
+    struct TMyMap {}; 
+ 
+    void TestSelectBy() { 
         using TListType = TTypeList<TA, TB, TMyMap<TA*, TB>, TMyVector<TA>, TC>;
-
+ 
         UNIT_ASSERT_TYPES_EQUAL(TListType::TSelectBy<TAnyType>::type, TA);
         UNIT_ASSERT_TYPES_EQUAL(TListType::TSelectBy<TIs1ArgTemplate>::type, TMyVector<TA>);
         using TMyMapPTATB = TMyMap<TA*, TB>;
         UNIT_ASSERT_TYPES_EQUAL(TListType::TSelectBy<TIsNArgTemplate>::type, TMyMapPTATB);
-    }
+    } 
 
     void TestFloatList() {
         UNIT_ASSERT_TYPES_EQUAL(TFixedWidthFloat<ui32>, float);
@@ -80,6 +80,6 @@ public:
         UNIT_ASSERT_TYPES_EQUAL(TFixedWidthFloat<ui64>, double);
         UNIT_ASSERT_TYPES_EQUAL(TFixedWidthFloat<i64>, double);
     }
-};
-
-UNIT_TEST_SUITE_REGISTRATION(TTypeListTest);
+}; 
+ 
+UNIT_TEST_SUITE_REGISTRATION(TTypeListTest);