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

1 files changed, 117 insertions, 117 deletions

diff --git a/library/cpp/threading/queue/tune.h b/library/cpp/threading/queue/tune.h
index 50fc3dc17cd..43ad5efe3ef 100644
--- a/library/cpp/threading/queue/tune.h
+++ b/library/cpp/threading/queue/tune.h
@@ -1,101 +1,101 @@
-#pragma once
-
-/*
-  Motivation: consider you have a template class with many parameters
-  with default associations
-
-  template <typename A = TDefA,
-            typename B = TDefB,
-            typename C = TDefC,
-            typename D = TDefD>
-  class TExample {
-  };
-
-  consider you would like to provide easy to use interface to tune all
-  these parameters in position independed manner,
-  In that case TTune would be helpful for you.
-
-  How to use:
-  First step: declare a struct with all default associations
-
-  struct TDefaultTune {
-      using TStructA = TDefA;
-      using TStructB = TDefB;
-      using TStructC = TDefC;
-      using TStructD = TDefD;
-  };
-
-  Second step: declare helper names visible to a user
-
-  DeclareTuneTypeParam(TTuneParamA, TStructA);
-  DeclareTuneTypeParam(TTuneParamB, TStructB);
-  DeclareTuneTypeParam(TTuneParamC, TStructC);
-  DeclareTuneTypeParam(TTuneParamD, TStructD);
-
-  Third step: declare TExample this way:
-
-  template <typename...TParams>
-  class TExample {
-      using TMyParams = TTune<TDefaultTune, TParams...>;
-
-      using TActualA = TMyParams::TStructA;
-      using TActualB = TMyParams::TStructB;
-      ...
-  };
-
-  TTune<TDefaultTune, TParams...> is a struct with the default parameteres
-  taken from TDefaultTune and overridden from "TParams...".
-
-  for example:  "TTune<TDefaultTune, TTuneParamC<TUserClass>>"
-  will be virtually the same as:
-
-  struct TTunedClass {
-      using TStructA = TDefA;
-      using TStructB = TDefB;
-      using TStructC = TUserClass;
-      using TStructD = TDefD;
-  };
-
-  From now on you can tune your TExample in the following manner:
-
-  using TCustomClass =
-      TExample <TTuneParamA<TUserStruct1>, TTuneParamD<TUserStruct2>>;
-
-  You can also tweak constant expressions in your TDefaultTune.
-  Consider you have:
-
-  struct TDefaultTune {
-      static constexpr ui32 MySize = 42;
-  };
-
-  declare an interface to modify the parameter this way:
-
-  DeclareTuneValueParam(TStructSize, ui32, MySize);
-
-  and tweak your class:
-
-  using TTwiceBigger = TExample<TStructSize<84>>;
-
- */
-
-#define DeclareTuneTypeParam(TParamName, InternalName) \
-    template <typename TNewType>                       \
-    struct TParamName {                                \
-        template <typename TBase>                      \
-        struct TApply: public TBase {                  \
-            using InternalName = TNewType;             \
-        };                                             \
-    }
-
-#define DeclareTuneValueParam(TParamName, TValueType, InternalName) \
-    template <TValueType NewValue>                                  \
-    struct TParamName {                                             \
-        template <typename TBase>                                   \
-        struct TApply: public TBase {                               \
-            static constexpr TValueType InternalName = NewValue;    \
-        };                                                          \
-    }
-
+#pragma once 
+ 
+/* 
+  Motivation: consider you have a template class with many parameters 
+  with default associations 
+ 
+  template <typename A = TDefA, 
+            typename B = TDefB, 
+            typename C = TDefC, 
+            typename D = TDefD> 
+  class TExample { 
+  }; 
+ 
+  consider you would like to provide easy to use interface to tune all 
+  these parameters in position independed manner, 
+  In that case TTune would be helpful for you. 
+ 
+  How to use: 
+  First step: declare a struct with all default associations 
+ 
+  struct TDefaultTune { 
+      using TStructA = TDefA; 
+      using TStructB = TDefB; 
+      using TStructC = TDefC; 
+      using TStructD = TDefD; 
+  }; 
+ 
+  Second step: declare helper names visible to a user 
+ 
+  DeclareTuneTypeParam(TTuneParamA, TStructA); 
+  DeclareTuneTypeParam(TTuneParamB, TStructB); 
+  DeclareTuneTypeParam(TTuneParamC, TStructC); 
+  DeclareTuneTypeParam(TTuneParamD, TStructD); 
+ 
+  Third step: declare TExample this way: 
+ 
+  template <typename...TParams> 
+  class TExample { 
+      using TMyParams = TTune<TDefaultTune, TParams...>; 
+ 
+      using TActualA = TMyParams::TStructA; 
+      using TActualB = TMyParams::TStructB; 
+      ... 
+  }; 
+ 
+  TTune<TDefaultTune, TParams...> is a struct with the default parameteres 
+  taken from TDefaultTune and overridden from "TParams...". 
+ 
+  for example:  "TTune<TDefaultTune, TTuneParamC<TUserClass>>" 
+  will be virtually the same as: 
+ 
+  struct TTunedClass { 
+      using TStructA = TDefA; 
+      using TStructB = TDefB; 
+      using TStructC = TUserClass; 
+      using TStructD = TDefD; 
+  }; 
+ 
+  From now on you can tune your TExample in the following manner: 
+ 
+  using TCustomClass = 
+      TExample <TTuneParamA<TUserStruct1>, TTuneParamD<TUserStruct2>>; 
+ 
+  You can also tweak constant expressions in your TDefaultTune. 
+  Consider you have: 
+ 
+  struct TDefaultTune { 
+      static constexpr ui32 MySize = 42; 
+  }; 
+ 
+  declare an interface to modify the parameter this way: 
+ 
+  DeclareTuneValueParam(TStructSize, ui32, MySize); 
+ 
+  and tweak your class: 
+ 
+  using TTwiceBigger = TExample<TStructSize<84>>; 
+ 
+ */ 
+ 
+#define DeclareTuneTypeParam(TParamName, InternalName) \ 
+    template <typename TNewType>                       \ 
+    struct TParamName {                                \ 
+        template <typename TBase>                      \ 
+        struct TApply: public TBase {                  \ 
+            using InternalName = TNewType;             \ 
+        };                                             \ 
+    } 
+ 
+#define DeclareTuneValueParam(TParamName, TValueType, InternalName) \ 
+    template <TValueType NewValue>                                  \ 
+    struct TParamName {                                             \ 
+        template <typename TBase>                                   \ 
+        struct TApply: public TBase {                               \ 
+            static constexpr TValueType InternalName = NewValue;    \ 
+        };                                                          \ 
+    } 
+ 
 #define DeclareTuneContainer(TParamName, InternalName)              \
     template <template <typename, typename...> class TNewContainer> \
     struct TParamName {                                             \
@@ -104,22 +104,22 @@
             template <typename TElem, typename... TRest>            \
             using InternalName = TNewContainer<TElem, TRest...>;    \
         };                                                          \
-    }
-
-namespace NTunePrivate {
-    template <typename TBase, typename... TParams>
-    struct TFold;
-
-    template <typename TBase>
-    struct TFold<TBase>: public TBase {
-    };
-
-    template <typename TBase, typename TFirstArg, typename... TRest>
-    struct TFold<TBase, TFirstArg, TRest...>
-       : public TFold<typename TFirstArg::template TApply<TBase>, TRest...> {
-    };
-}
-
-template <typename TDefault, typename... TParams>
-struct TTune: public NTunePrivate::TFold<TDefault, TParams...> {
-};
+    } 
+ 
+namespace NTunePrivate { 
+    template <typename TBase, typename... TParams> 
+    struct TFold; 
+ 
+    template <typename TBase> 
+    struct TFold<TBase>: public TBase { 
+    }; 
+ 
+    template <typename TBase, typename TFirstArg, typename... TRest> 
+    struct TFold<TBase, TFirstArg, TRest...> 
+       : public TFold<typename TFirstArg::template TApply<TBase>, TRest...> { 
+    }; 
+} 
+ 
+template <typename TDefault, typename... TParams> 
+struct TTune: public NTunePrivate::TFold<TDefault, TParams...> { 
+};