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

contrib/tools/protoc/plugins/cpp_styleguide/cpp_styleguide.cpp

@@ -715,20 +715,20 @@ namespace NPlugins {
                 }
             }
 
-            void GenerateDeclarations() { 
-                GenerateFieldAccessorDeclarations(); 
- 
+            void GenerateDeclarations() {
+                GenerateFieldAccessorDeclarations();
+
                 for (auto& nestedGenerator: NestedGenerators_) {
                     nestedGenerator.GenerateDeclarations();
-                } 
-            } 
- 
-            void GenerateDefinitions() { 
-                GenerateClassExtension(); 
-                GenerateDebugOutputExtension(); 
-                GenerateClassDefinitionExtension(); 
-            } 
- 
+                }
+            }
+
+            void GenerateDefinitions() {
+                GenerateClassExtension();
+                GenerateDebugOutputExtension();
+                GenerateClassDefinitionExtension();
+            }
+
         private:
             void GenerateFieldAccessorDeclarations() {
                 TProtoStringType fileName = HeaderFileName(Descriptor_->file());
@@ -835,7 +835,7 @@ namespace NPlugins {
                     return;
                 }
 
-                TProtoStringType fileName = SourceFileName(Descriptor_->file()); 
+                TProtoStringType fileName = SourceFileName(Descriptor_->file());
                 TProtoStringType scope = "namespace_scope";
                 std::unique_ptr<io::ZeroCopyOutputStream> output(
                     OutputDirectory_->OpenForInsert(fileName, scope));

library/cpp/bit_io/bitinout_ut.cpp

@@ -51,7 +51,7 @@ class TBitIOTest: public TTestBase {
     UNIT_TEST_SUITE_END();
 
 private:
-    using TBi = NBitIO::TBitInput; 
+    using TBi = NBitIO::TBitInput;
     using TVec = TVector<char>;
 
     void static CheckBits(const TVec& v, const TString& ref, const TString& rem) {

library/cpp/charset/recyr_int.hh

@@ -178,19 +178,19 @@ namespace NCodepagePrivate {
 
     template <class TCharType>
     struct TCharTypeSwitch<TCharType, 2> {
-        using TRealCharType = wchar16; 
+        using TRealCharType = wchar16;
     };
 
     template <class TCharType>
     struct TCharTypeSwitch<TCharType, 4> {
-        using TRealCharType = wchar32; 
+        using TRealCharType = wchar32;
     };
 
     template <class TCharType>
     inline RECODE_RESULT _recodeUnicodeToUTF8(const TCharType* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
         static_assert(sizeof(TCharType) > 1, "expect some wide type");
 
-        using TRealCharType = typename TCharTypeSwitch<TCharType>::TRealCharType; 
+        using TRealCharType = typename TCharTypeSwitch<TCharType>::TRealCharType;
 
         return _recodeUnicodeToUTF8Impl(reinterpret_cast<const TRealCharType*>(in), out, in_size, out_size, in_readed, out_writed);
     }

library/cpp/charset/wide.h

@@ -121,8 +121,8 @@ namespace NDetail {
 
     template <>
     struct TRecodeTraits<char> {
-        using TCharTo = wchar16; 
-        using TStringBufTo = TWtringBuf; 
+        using TCharTo = wchar16;
+        using TStringBufTo = TWtringBuf;
         using TStringTo = TUtf16String;
         enum { ReserveSize = 4 }; // How many TCharFrom characters we should reserve for one TCharTo character in worst case
                                   // Here an unicode character can be converted up to 4 bytes of UTF8
@@ -130,8 +130,8 @@ namespace NDetail {
 
     template <>
     struct TRecodeTraits<wchar16> {
-        using TCharTo = char; 
-        using TStringBufTo = TStringBuf; 
+        using TCharTo = char;
+        using TStringBufTo = TStringBuf;
         using TStringTo = TString;
         enum { ReserveSize = 2 }; // possible surrogate pairs ?
     };
@@ -140,7 +140,7 @@ namespace NDetail {
     template <typename TResult>
     struct TRecodeResultOps {
         // default implementation will work with TString and TUtf16String - 99% of usage
-        using TResultChar = typename TResult::char_type; 
+        using TResultChar = typename TResult::char_type;
 
         static inline size_t Size(const TResult& dst) {
             return dst.size();
@@ -160,7 +160,7 @@ namespace NDetail {
 
     template <typename TCharFrom, typename TResult>
     typename TRecodeTraits<TCharFrom>::TStringBufTo Recode(const TBasicStringBuf<TCharFrom> src, TResult& dst, ECharset encoding) {
-        using TCharTo = typename TRecodeTraits<TCharFrom>::TCharTo; 
+        using TCharTo = typename TRecodeTraits<TCharFrom>::TCharTo;
         // make enough room for re-coded string
         TCharTo* dstbuf = TRecodeResultOps<TResult>::Reserve(dst, src.size() * TRecodeTraits<TCharTo>::ReserveSize);
         // do re-coding
@@ -173,7 +173,7 @@ namespace NDetail {
     // appending version of Recode()
     template <typename TCharFrom, typename TResult>
     typename TRecodeTraits<TCharFrom>::TStringBufTo RecodeAppend(const TBasicStringBuf<TCharFrom> src, TResult& dst, ECharset encoding) {
-        using TCharTo = typename TRecodeTraits<TCharFrom>::TCharTo; 
+        using TCharTo = typename TRecodeTraits<TCharFrom>::TCharTo;
         size_t dstOrigSize = TRecodeResultOps<TResult>::Size(dst);
         TCharTo* dstbuf = TRecodeResultOps<TResult>::Reserve(dst, dstOrigSize + src.size() * TRecodeTraits<TCharTo>::ReserveSize);
         TBasicStringBuf<TCharTo> appended = NBaseOps::Recode(src, dstbuf + dstOrigSize, encoding);

library/cpp/containers/atomizer/atomizer.h

@@ -20,11 +20,11 @@ private:
     TVector<const char*> order;
 
 public:
-    using iterator = typename string_hash<ui32, HashFcn, EqualTo>::iterator; 
-    using const_iterator = typename string_hash<ui32, HashFcn, EqualTo>::const_iterator; 
-    using value_type = typename string_hash<ui32, HashFcn, EqualTo>::value_type; 
-    using size_type = typename string_hash<ui32, HashFcn, EqualTo>::size_type; 
-    using pool_size_type = typename string_hash<ui32, HashFcn, EqualTo>::pool_size_type; 
+    using iterator = typename string_hash<ui32, HashFcn, EqualTo>::iterator;
+    using const_iterator = typename string_hash<ui32, HashFcn, EqualTo>::const_iterator;
+    using value_type = typename string_hash<ui32, HashFcn, EqualTo>::value_type;
+    using size_type = typename string_hash<ui32, HashFcn, EqualTo>::size_type;
+    using pool_size_type = typename string_hash<ui32, HashFcn, EqualTo>::pool_size_type;
 
     using string_hash<ui32, HashFcn, EqualTo>::pool;
     using string_hash<ui32, HashFcn, EqualTo>::size;
@@ -112,15 +112,15 @@ private:
     TOrder order;
 
 public:
-    using iterator = typename string_hash<ui32, HashFcn, EqualTo>::iterator; 
-    using const_iterator = typename string_hash<ui32, HashFcn, EqualTo>::const_iterator; 
-    using value_type = typename string_hash<ui32, HashFcn, EqualTo>::value_type; 
-    using size_type = typename string_hash<ui32, HashFcn, EqualTo>::size_type; 
-    using pool_size_type = typename string_hash<ui32, HashFcn, EqualTo>::pool_size_type; 
-
-    using o_iterator = typename TOrder::iterator; 
-    using o_const_iterator = typename TOrder::const_iterator; 
-    using o_value_type = typename TOrder::value_type; 
+    using iterator = typename string_hash<ui32, HashFcn, EqualTo>::iterator;
+    using const_iterator = typename string_hash<ui32, HashFcn, EqualTo>::const_iterator;
+    using value_type = typename string_hash<ui32, HashFcn, EqualTo>::value_type;
+    using size_type = typename string_hash<ui32, HashFcn, EqualTo>::size_type;
+    using pool_size_type = typename string_hash<ui32, HashFcn, EqualTo>::pool_size_type;
+
+    using o_iterator = typename TOrder::iterator;
+    using o_const_iterator = typename TOrder::const_iterator;
+    using o_value_type = typename TOrder::value_type;
 
     using string_hash<ui32, HashFcn, EqualTo>::pool;
     using string_hash<ui32, HashFcn, EqualTo>::size;

library/cpp/containers/intrusive_avl_tree/avltree.h

@@ -7,7 +7,7 @@ struct TAvlTreeItem;
 
 template <class T, class C>
 class TAvlTree: public TNonCopyable {
-    using TTreeItem = TAvlTreeItem<T, C>; 
+    using TTreeItem = TAvlTreeItem<T, C>;
     friend struct TAvlTreeItem<T, C>;
 
     static inline const T* AsT(const TTreeItem* item) noexcept {
@@ -178,7 +178,7 @@ class TAvlTree: public TNonCopyable {
 
 public:
     using const_iterator = TConstIterator;
-    using iterator = TIterator; 
+    using iterator = TIterator;
 
     inline TAvlTree() noexcept
         : Root_(nullptr)
@@ -721,7 +721,7 @@ private:
 template <class T, class C>
 struct TAvlTreeItem: public TNonCopyable {
 public:
-    using TTree = TAvlTree<T, C>; 
+    using TTree = TAvlTree<T, C>;
     friend class TAvlTree<T, C>;
     friend typename TAvlTree<T, C>::TConstIterator;
     friend typename TAvlTree<T, C>::TIterator;

library/cpp/containers/intrusive_avl_tree/ut/avltree_ut.cpp

@@ -27,7 +27,7 @@ private:
         int Val;
     };
 
-    using TIts = TAvlTree<TIt, TItCompare>; 
+    using TIts = TAvlTree<TIt, TItCompare>;
 };
 
 inline bool TAvlTreeTest::TItCompare::Compare(const TIt& l, const TIt& r) noexcept {

library/cpp/containers/intrusive_rb_tree/rb_tree.h

@@ -3,14 +3,14 @@
 #include <util/generic/utility.h>
 #include <util/generic/yexception.h>
 
-using TRbTreeColorType = bool; 
+using TRbTreeColorType = bool;
 
 #define RBTreeRed false
 #define RBTreeBlack true
 
 struct TRbTreeNodeBase {
-    using TColorType = TRbTreeColorType; 
-    using TBasePtr = TRbTreeNodeBase*; 
+    using TColorType = TRbTreeColorType;
+    using TBasePtr = TRbTreeNodeBase*;
 
     TColorType Color_;
     TBasePtr Parent_;
@@ -63,7 +63,7 @@ struct TRbTreeBaseIterator;
 template <class TDummy>
 class TRbGlobal {
 public:
-    using TBasePtr = TRbTreeNodeBase*; 
+    using TBasePtr = TRbTreeNodeBase*;
 
     static void Rebalance(TBasePtr x, TBasePtr& root);
     static TBasePtr RebalanceForErase(TBasePtr z, TBasePtr& root, TBasePtr& leftmost, TBasePtr& rightmost);
@@ -76,10 +76,10 @@ public:
     static void RotateRight(TBasePtr x, TBasePtr& root);
 };
 
-using TRbGlobalInst = TRbGlobal<bool>; 
+using TRbGlobalInst = TRbGlobal<bool>;
 
 struct TRbTreeBaseIterator {
-    using TBasePtr = TRbTreeNodeBase*; 
+    using TBasePtr = TRbTreeNodeBase*;
     TBasePtr Node_;
 
     inline TRbTreeBaseIterator(TBasePtr x = nullptr) noexcept
@@ -90,10 +90,10 @@ struct TRbTreeBaseIterator {
 
 template <class TValue, class TTraits>
 struct TRbTreeIterator: public TRbTreeBaseIterator {
-    using TReference = typename TTraits::TReference; 
-    using TPointer = typename TTraits::TPointer; 
-    using TSelf = TRbTreeIterator<TValue, TTraits>; 
-    using TBasePtr = TRbTreeNodeBase*; 
+    using TReference = typename TTraits::TReference;
+    using TPointer = typename TTraits::TPointer;
+    using TSelf = TRbTreeIterator<TValue, TTraits>;
+    using TBasePtr = TRbTreeNodeBase*;
 
     inline TRbTreeIterator() noexcept = default;
 
@@ -161,18 +161,18 @@ class TRbTree {
     };
 
     struct TNonConstTraits {
-        using TReference = TValue&; 
-        using TPointer = TValue*; 
+        using TReference = TValue&;
+        using TPointer = TValue*;
     };
 
     struct TConstTraits {
-        using TReference = const TValue&; 
-        using TPointer = const TValue*; 
+        using TReference = const TValue&;
+        using TPointer = const TValue*;
     };
 
-    using TNodeBase = TRbTreeNodeBase; 
-    using TBasePtr = TRbTreeNodeBase*; 
-    using TColorType = TRbTreeColorType; 
+    using TNodeBase = TRbTreeNodeBase;
+    using TBasePtr = TRbTreeNodeBase*;
+    using TColorType = TRbTreeColorType;
 
 public:
     class TRealNode: public TNodeBase {
@@ -206,8 +206,8 @@ public:
         TRbTree* Tree_;
     };
 
-    using TIterator = TRbTreeIterator<TValue, TNonConstTraits>; 
-    using TConstIterator = TRbTreeIterator<TValue, TConstTraits>; 
+    using TIterator = TRbTreeIterator<TValue, TNonConstTraits>;
+    using TConstIterator = TRbTreeIterator<TValue, TConstTraits>;
 
     inline TRbTree() noexcept {
         Init();

library/cpp/containers/intrusive_rb_tree/rb_tree_ut.cpp

@@ -34,7 +34,7 @@ class TRedBlackTreeTest: public TTestBase {
         int N;
     };
 
-    using TTree = TRbTree<TNode, TCmp>; 
+    using TTree = TRbTree<TNode, TCmp>;
 
     UNIT_TEST_SUITE(TRedBlackTreeTest);
     UNIT_TEST(TestEmpty)

library/cpp/containers/str_map/str_map.h

@@ -41,11 +41,11 @@ protected:
 
 public:
     using yh = THashMap<const char*, T, HashFcn, EqualTo, Alloc>;
-    using iterator = typename yh::iterator; 
-    using const_iterator = typename yh::const_iterator; 
-    using mapped_type = typename yh::mapped_type; 
-    using size_type = typename yh::size_type; 
-    using pool_size_type = typename yh::size_type; 
+    using iterator = typename yh::iterator;
+    using const_iterator = typename yh::const_iterator;
+    using mapped_type = typename yh::mapped_type;
+    using size_type = typename yh::size_type;
+    using pool_size_type = typename yh::size_type;
     string_hash() {
         pool.Reserve(HASH_SIZE_DEFAULT * AVERAGEWORD_BUF); // reserve here
     }
@@ -107,12 +107,12 @@ protected:
 
 public:
     using yh = THashMap<const C*, T, HashFcn, EqualTo>;
-    using iterator = typename yh::iterator; 
-    using const_iterator = typename yh::const_iterator; 
-    using mapped_type = typename yh::mapped_type; 
-    using size_type = typename yh::size_type; 
-    using key_type = typename yh::key_type; 
-    using value_type = typename yh::value_type; 
+    using iterator = typename yh::iterator;
+    using const_iterator = typename yh::const_iterator;
+    using mapped_type = typename yh::mapped_type;
+    using size_type = typename yh::size_type;
+    using key_type = typename yh::key_type;
+    using value_type = typename yh::value_type;
 
     THashWithSegmentedPoolForKeys(size_type hash_size = HASH_SIZE_DEFAULT, size_t segsize = HASH_SIZE_DEFAULT * AVERAGEWORD_BUF, bool afs = false)
         : yh(hash_size)
@@ -178,13 +178,13 @@ public:
 template <class T, class HashFcn, class EqualTo>
 class segmented_string_hash: public THashWithSegmentedPoolForKeys<char, T, HashFcn, EqualTo> {
 public:
-    using Base = THashWithSegmentedPoolForKeys<char, T, HashFcn, EqualTo>; 
-    using iterator = typename Base::iterator; 
-    using const_iterator = typename Base::const_iterator; 
-    using mapped_type = typename Base::mapped_type; 
-    using size_type = typename Base::size_type; 
-    using key_type = typename Base::key_type; 
-    using value_type = typename Base::value_type; 
+    using Base = THashWithSegmentedPoolForKeys<char, T, HashFcn, EqualTo>;
+    using iterator = typename Base::iterator;
+    using const_iterator = typename Base::const_iterator;
+    using mapped_type = typename Base::mapped_type;
+    using size_type = typename Base::size_type;
+    using key_type = typename Base::key_type;
+    using value_type = typename Base::value_type;
 
 public:
     segmented_string_hash(size_type hash_size = HASH_SIZE_DEFAULT, size_t segsize = HASH_SIZE_DEFAULT * AVERAGEWORD_BUF, bool afs = false)