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

build/ymake.core.conf

@@ -1878,18 +1878,18 @@ module UNITTEST_WITH_CUSTOM_ENTRY_POINT: _BASE_UNITTEST {
 
 # tag:cpp-specific tag:test
 ### @usage: GTEST([name])
-### 
-### Unit test module based on library/cpp/testing/gtest. 
-### It is recommended not to specify the name. 
-### 
-### Documentation: https://docs.yandex-team.ru/arcadia-cpp/cpp_test 
+###
+### Unit test module based on library/cpp/testing/gtest.
+### It is recommended not to specify the name.
+###
+### Documentation: https://docs.yandex-team.ru/arcadia-cpp/cpp_test
 module GTEST: _BASE_UNITTEST {
     .SEM=UNITTEST_SEM
-    PEERDIR(library/cpp/testing/gtest library/cpp/testing/gtest_main) 
+    PEERDIR(library/cpp/testing/gtest library/cpp/testing/gtest_main)
     ADD_YTEST($MODULE_PREFIX$REALPRJNAME gunittest)
     SET(MODULE_LANG CPP)
-} 
- 
+}
+
 USE_AFL=no
 
 # tag:fuzzing
@@ -2246,8 +2246,8 @@ macro STYLE(Globs...) {
 # tag:cpp-specific tag:deprecated tag:test
 ### @usage: GTEST_UGLY([name])
 ###
-### Deprecated, do not use in new projects. Use GTEST instead. 
-### 
+### Deprecated, do not use in new projects. Use GTEST instead.
+###
 ### The test module based on gtest (contrib/libs/gtest contrib/libs/gmock).
 ### Use public documentation on gtest for details.
 ###
@@ -6092,49 +6092,49 @@ macro _SRC("po", SRC, SRCFLAGS...) {
 }
 
 # tag:ydl-specific
-YDL_FLAGS= --force-color -I ${ARCADIA_ROOT} 
-YDL_DESC_FLAGS= 
- 
+YDL_FLAGS= --force-color -I ${ARCADIA_ROOT}
+YDL_DESC_FLAGS=
+
 # tag:src-processing tag:ydl-specific
 macro _SRC("ydl", SRC, SRCFLAGS...) {
-    .CMD=${tool:"statbox/ydl/compiler/tooling/ydl/bin"} c $YDL_FLAGS --cpp-output-header ${output;suf=.h:SRC} --cpp-output-source ${output;suf=.cpp:SRC} ${input:SRC} ${output_include;hide:"statbox/ydl/runtime/cpp/gen_support/standard_includes.h"} ${kv;hide:"p YDL"} ${kv;hide:"pc yellow"} 
+    .CMD=${tool:"statbox/ydl/compiler/tooling/ydl/bin"} c $YDL_FLAGS --cpp-output-header ${output;suf=.h:SRC} --cpp-output-source ${output;suf=.cpp:SRC} ${input:SRC} ${output_include;hide:"statbox/ydl/runtime/cpp/gen_support/standard_includes.h"} ${kv;hide:"p YDL"} ${kv;hide:"pc yellow"}
     .PEERDIR+=statbox/ydl/runtime/cpp
 }
 
 # tag:ydl-specific
-### @usage BUILD_YDL_DESC(Input Symbol Output) 
-### 
-### Generate a descriptor for a Symbol located in a ydl module Input, and put it to the file Output. 
-### 
-### @example: 
-### 
-###     PACKAGE() 
-###         BUILD_YDL_DESC(../types.ydl Event Event.ydld) 
-###     END() 
-### 
-### This will parse file ../types.ydl, generate a descriptor for a symbol Event defined in the said file, and put the descriptor to the Event.ydld. 
-macro BUILD_YDL_DESC(Input, Symbol, Output) { 
-    .CMD=${tool:"statbox/ydl/compiler/tooling/ydl/bin"} ti $YDL_FLAGS $YDL_DESC_FLAGS -o ${output;noauto:Output} ${input:Input} ${Symbol} ${kv;hide:"p YDL"} ${kv;hide:"pc yellow"} 
-} 
- 
+### @usage BUILD_YDL_DESC(Input Symbol Output)
+###
+### Generate a descriptor for a Symbol located in a ydl module Input, and put it to the file Output.
+###
+### @example:
+###
+###     PACKAGE()
+###         BUILD_YDL_DESC(../types.ydl Event Event.ydld)
+###     END()
+###
+### This will parse file ../types.ydl, generate a descriptor for a symbol Event defined in the said file, and put the descriptor to the Event.ydld.
+macro BUILD_YDL_DESC(Input, Symbol, Output) {
+    .CMD=${tool:"statbox/ydl/compiler/tooling/ydl/bin"} ti $YDL_FLAGS $YDL_DESC_FLAGS -o ${output;noauto:Output} ${input:Input} ${Symbol} ${kv;hide:"p YDL"} ${kv;hide:"pc yellow"}
+}
+
 # tag:ydl-specific
-### @usage: YDL_DESC_USE_BINARY() 
-### 
-### Used in conjunction with BUILD_YDL_DESC. When enabled, all generated descriptors are binary. 
-### 
-### @example: 
-### 
-###     PACKAGE() 
-###         YDL_DESC_USE_BINARY() 
-###         BUILD_YDL_DESC(../types.ydl Event Event.ydld) 
-###     END() 
-### 
-### This will generate descriptor Event.ydld in a binary format. 
-macro YDL_DESC_USE_BINARY() { 
-    YDL_DESC_FLAGS_BINARY= --binary 
-    SET_APPEND(YDL_DESC_FLAGS $YDL_DESC_FLAGS_BINARY) 
-} 
- 
+### @usage: YDL_DESC_USE_BINARY()
+###
+### Used in conjunction with BUILD_YDL_DESC. When enabled, all generated descriptors are binary.
+###
+### @example:
+###
+###     PACKAGE()
+###         YDL_DESC_USE_BINARY()
+###         BUILD_YDL_DESC(../types.ydl Event Event.ydld)
+###     END()
+###
+### This will generate descriptor Event.ydld in a binary format.
+macro YDL_DESC_USE_BINARY() {
+    YDL_DESC_FLAGS_BINARY= --binary
+    SET_APPEND(YDL_DESC_FLAGS $YDL_DESC_FLAGS_BINARY)
+}
+
 ### @usage SRC(File Flags...)
 ###
 ### Compile single file with extra Flags.

library/cpp/actors/core/actorsystem.cpp

@@ -10,7 +10,7 @@
 #include "scheduler_actor.h"
 #include "log.h"
 #include "probes.h"
-#include "ask.h" 
+#include "ask.h"
 #include <library/cpp/actors/util/affinity.h>
 #include <library/cpp/actors/util/datetime.h>
 #include <util/generic/hash.h>
@@ -145,14 +145,14 @@ namespace NActors {
         return CpuManager->GetExecutorPool(executorPool)->Register(actor, mailboxType, revolvingCounter, parentId);
     }
 
-    NThreading::TFuture<THolder<IEventBase>> TActorSystem::AskGeneric(TMaybe<ui32> expectedEventType, 
+    NThreading::TFuture<THolder<IEventBase>> TActorSystem::AskGeneric(TMaybe<ui32> expectedEventType,
                                                                       TActorId recipient, THolder<IEventBase> event,
-                                                                      TDuration timeout) { 
-        auto promise = NThreading::NewPromise<THolder<IEventBase>>(); 
-        Register(MakeAskActor(expectedEventType, recipient, std::move(event), timeout, promise).Release()); 
-        return promise.GetFuture(); 
-    } 
- 
+                                                                      TDuration timeout) {
+        auto promise = NThreading::NewPromise<THolder<IEventBase>>();
+        Register(MakeAskActor(expectedEventType, recipient, std::move(event), timeout, promise).Release());
+        return promise.GetFuture();
+    }
+
     ui64 TActorSystem::AllocateIDSpace(ui64 count) {
         Y_VERIFY_DEBUG(count < Max<ui32>() / 65536);
 

library/cpp/actors/core/actorsystem.h

@@ -261,7 +261,7 @@ namespace NActors {
         bool Send(TAutoPtr<IEventHandle> ev) const;
         bool Send(const TActorId& recipient, IEventBase* ev, ui32 flags = 0) const;
 
-        /** 
+        /**
          * Schedule one-shot event that will be send at given time point in the future.
          *
          * @param deadline   the wallclock time point in future when event must be send
@@ -289,38 +289,38 @@ namespace NActors {
         void Schedule(TDuration delta, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie = nullptr) const;
 
         /**
-         * A way to interact with actors from non-actor context. 
-         * 
-         * This method will send the `event` to the `recipient` and then will wait for a response. When response arrives, 
-         * it will be passed to the future. If response is not of type `T`, the future will resolve into an exception. 
-         * 
-         * @tparam T            expected response type. Must be derived from `TEventBase`, 
-         *                      or use `IEventBase` to catch any response. 
-         * @param actorSystem   actor system that will be used to register an actor that'll wait for response. 
-         * @param recipient     who will get a request. 
-         * @param event         a request message. 
-         * @return              future that will be resolved when a message from `recipient` arrives. 
-         */ 
-        template <typename T> 
-        [[nodiscard]] 
+         * A way to interact with actors from non-actor context.
+         *
+         * This method will send the `event` to the `recipient` and then will wait for a response. When response arrives,
+         * it will be passed to the future. If response is not of type `T`, the future will resolve into an exception.
+         *
+         * @tparam T            expected response type. Must be derived from `TEventBase`,
+         *                      or use `IEventBase` to catch any response.
+         * @param actorSystem   actor system that will be used to register an actor that'll wait for response.
+         * @param recipient     who will get a request.
+         * @param event         a request message.
+         * @return              future that will be resolved when a message from `recipient` arrives.
+         */
+        template <typename T>
+        [[nodiscard]]
         NThreading::TFuture<THolder<T>> Ask(TActorId recipient, THolder<IEventBase> event, TDuration timeout = TDuration::Max()) {
-            if constexpr (std::is_same_v<T, IEventBase>) { 
-                return AskGeneric(Nothing(), recipient, std::move(event), timeout); 
-            } else { 
-                return AskGeneric(T::EventType, recipient, std::move(event), timeout) 
-                    .Apply([](const NThreading::TFuture<THolder<IEventBase>>& ev) { 
-                        return THolder<T>(static_cast<T*>(const_cast<THolder<IEventBase>&>(ev.GetValueSync()).Release()));  // =( 
-                    }); 
-            } 
-        } 
- 
-        [[nodiscard]] 
-        NThreading::TFuture<THolder<IEventBase>> AskGeneric( 
-            TMaybe<ui32> expectedEventType, 
+            if constexpr (std::is_same_v<T, IEventBase>) {
+                return AskGeneric(Nothing(), recipient, std::move(event), timeout);
+            } else {
+                return AskGeneric(T::EventType, recipient, std::move(event), timeout)
+                    .Apply([](const NThreading::TFuture<THolder<IEventBase>>& ev) {
+                        return THolder<T>(static_cast<T*>(const_cast<THolder<IEventBase>&>(ev.GetValueSync()).Release()));  // =(
+                    });
+            }
+        }
+
+        [[nodiscard]]
+        NThreading::TFuture<THolder<IEventBase>> AskGeneric(
+            TMaybe<ui32> expectedEventType,
             TActorId recipient,
-            THolder<IEventBase> event, 
-            TDuration timeout); 
- 
+            THolder<IEventBase> event,
+            TDuration timeout);
+
         ui64 AllocateIDSpace(ui64 count);
 
         TActorId InterconnectProxy(ui32 destinationNode) const;

library/cpp/actors/core/ask.cpp

@@ -1,74 +1,74 @@
-#include "ask.h" 
- 
-#include "actor_bootstrapped.h" 
-#include "actorid.h" 
-#include "event.h" 
-#include "hfunc.h" 
- 
-namespace NActors { 
-    namespace { 
-        class TAskActor: public TActorBootstrapped<TAskActor> { 
-            enum { 
-                Timeout = EventSpaceBegin(TEvents::ES_PRIVATE), 
-            }; 
- 
-            // We can't use the standard timeout event because recipient may send us one. 
-            struct TTimeout: public TEventLocal<TTimeout, Timeout> { 
-            }; 
- 
-        public: 
-            TAskActor( 
-                    TMaybe<ui32> expectedEventType, 
+#include "ask.h"
+
+#include "actor_bootstrapped.h"
+#include "actorid.h"
+#include "event.h"
+#include "hfunc.h"
+
+namespace NActors {
+    namespace {
+        class TAskActor: public TActorBootstrapped<TAskActor> {
+            enum {
+                Timeout = EventSpaceBegin(TEvents::ES_PRIVATE),
+            };
+
+            // We can't use the standard timeout event because recipient may send us one.
+            struct TTimeout: public TEventLocal<TTimeout, Timeout> {
+            };
+
+        public:
+            TAskActor(
+                    TMaybe<ui32> expectedEventType,
                     TActorId recipient,
-                    THolder<IEventBase> event, 
-                    TDuration timeout, 
-                    const NThreading::TPromise<THolder<IEventBase>>& promise) 
-                : ExpectedEventType_(expectedEventType) 
-                , Recipient_(recipient) 
-                , Event_(std::move(event)) 
-                , Timeout_(timeout) 
-                , Promise_(promise) 
-            { 
-            } 
- 
-        public: 
-            void Bootstrap() { 
-                Send(Recipient_, std::move(Event_)); 
-                Become(&TAskActor::Waiting); 
- 
-                if (Timeout_ != TDuration::Max()) { 
-                    Schedule(Timeout_, new TTimeout); 
-                } 
-            } 
- 
-            STATEFN(Waiting) { 
-                if (ev->GetTypeRewrite() == TTimeout::EventType) { 
-                    Promise_.SetException(std::make_exception_ptr(yexception() << "ask timeout")); 
-                } else if (!ExpectedEventType_ || ev->GetTypeRewrite() == ExpectedEventType_) { 
-                    Promise_.SetValue(ev->ReleaseBase()); 
-                } else { 
-                    Promise_.SetException(std::make_exception_ptr(yexception() << "received unexpected response " << ev->GetBase()->ToString())); 
-                } 
- 
-                PassAway(); 
-            } 
- 
-        public: 
-            TMaybe<ui32> ExpectedEventType_; 
+                    THolder<IEventBase> event,
+                    TDuration timeout,
+                    const NThreading::TPromise<THolder<IEventBase>>& promise)
+                : ExpectedEventType_(expectedEventType)
+                , Recipient_(recipient)
+                , Event_(std::move(event))
+                , Timeout_(timeout)
+                , Promise_(promise)
+            {
+            }
+
+        public:
+            void Bootstrap() {
+                Send(Recipient_, std::move(Event_));
+                Become(&TAskActor::Waiting);
+
+                if (Timeout_ != TDuration::Max()) {
+                    Schedule(Timeout_, new TTimeout);
+                }
+            }
+
+            STATEFN(Waiting) {
+                if (ev->GetTypeRewrite() == TTimeout::EventType) {
+                    Promise_.SetException(std::make_exception_ptr(yexception() << "ask timeout"));
+                } else if (!ExpectedEventType_ || ev->GetTypeRewrite() == ExpectedEventType_) {
+                    Promise_.SetValue(ev->ReleaseBase());
+                } else {
+                    Promise_.SetException(std::make_exception_ptr(yexception() << "received unexpected response " << ev->GetBase()->ToString()));
+                }
+
+                PassAway();
+            }
+
+        public:
+            TMaybe<ui32> ExpectedEventType_;
             TActorId Recipient_;
-            THolder<IEventBase> Event_; 
-            TDuration Timeout_; 
-            NThreading::TPromise<THolder<IEventBase>> Promise_; 
-        }; 
-    } 
- 
-    THolder<IActor> MakeAskActor( 
-            TMaybe<ui32> expectedEventType, 
+            THolder<IEventBase> Event_;
+            TDuration Timeout_;
+            NThreading::TPromise<THolder<IEventBase>> Promise_;
+        };
+    }
+
+    THolder<IActor> MakeAskActor(
+            TMaybe<ui32> expectedEventType,
             TActorId recipient,
-            THolder<IEventBase> event, 
-            TDuration timeout, 
-            const NThreading::TPromise<THolder<IEventBase>>& promise) 
-    { 
+            THolder<IEventBase> event,
+            TDuration timeout,
+            const NThreading::TPromise<THolder<IEventBase>>& promise)
+    {
         return MakeHolder<TAskActor>(expectedEventType, std::move(recipient), std::move(event), timeout, promise);
-    } 
-} 
+    }
+}

library/cpp/actors/core/ask.h

@@ -1,18 +1,18 @@
-#pragma once 
- 
-#include "actor.h" 
-#include "event.h" 
- 
+#pragma once
+
+#include "actor.h"
+#include "event.h"
+
 #include <library/cpp/threading/future/future.h>
- 
-namespace NActors { 
-    /** 
-     * See `TActorSystem::Ask`. 
-     */ 
-    THolder<IActor> MakeAskActor( 
-        TMaybe<ui32> expectedEventType, 
+
+namespace NActors {
+    /**
+     * See `TActorSystem::Ask`.
+     */
+    THolder<IActor> MakeAskActor(
+        TMaybe<ui32> expectedEventType,
         TActorId recipient,
-        THolder<IEventBase> event, 
-        TDuration timeout, 
-        const NThreading::TPromise<THolder<IEventBase>>& promise); 
-} 
+        THolder<IEventBase> event,
+        TDuration timeout,
+        const NThreading::TPromise<THolder<IEventBase>>& promise);
+}

library/cpp/actors/core/ask_ut.cpp

@@ -1,131 +1,131 @@
 #include <library/cpp/testing/unittest/registar.h>
- 
-#include "actorsystem.h" 
- 
-#include <library/cpp/actors/testlib/test_runtime.h> 
- 
-using namespace NActors; 
- 
-class TPingPong: public TActor<TPingPong> { 
-public: 
-    TPingPong() 
-        : TActor(&TPingPong::Main) 
-    { 
-    } 
- 
-    STATEFN(Main) { 
-        switch (ev->GetTypeRewrite()) { 
-            hFunc(TEvents::TEvPing, OnPing); 
-            hFunc(TEvents::TEvBlob, OnBlob); 
-        } 
-    } 
- 
-    void OnPing(const TEvents::TEvPing::TPtr& ev) { 
-        Send(ev->Sender, new TEvents::TEvPong); 
-    } 
- 
-    void OnBlob(const TEvents::TEvBlob::TPtr& ev) { 
-        Send(ev->Sender, ev->Release().Release()); 
-    } 
-}; 
- 
-class TPing: public TActor<TPing> { 
-public: 
-    TPing() 
-        : TActor(&TPing::Main) 
-    { 
-    } 
- 
-    STATEFN(Main) { 
-        Y_UNUSED(ev); 
-    } 
-}; 
- 
-THolder<TTestActorRuntimeBase> CreateRuntime() { 
-    auto runtime = MakeHolder<TTestActorRuntimeBase>(); 
-    runtime->SetScheduledEventFilter([](auto&&, auto&&, auto&&, auto&&) { return false; }); 
-    runtime->Initialize(); 
-    return runtime; 
-} 
- 
-Y_UNIT_TEST_SUITE(AskActor) { 
-    Y_UNIT_TEST(Ok) { 
-        auto runtime = CreateRuntime(); 
-        auto pingpong = runtime->Register(new TPingPong); 
- 
-        { 
-            auto fut = runtime->GetAnyNodeActorSystem()->Ask<TEvents::TEvPong>( 
-                pingpong, 
+
+#include "actorsystem.h"
+
+#include <library/cpp/actors/testlib/test_runtime.h>
+
+using namespace NActors;
+
+class TPingPong: public TActor<TPingPong> {
+public:
+    TPingPong()
+        : TActor(&TPingPong::Main)
+    {
+    }
+
+    STATEFN(Main) {
+        switch (ev->GetTypeRewrite()) {
+            hFunc(TEvents::TEvPing, OnPing);
+            hFunc(TEvents::TEvBlob, OnBlob);
+        }
+    }
+
+    void OnPing(const TEvents::TEvPing::TPtr& ev) {
+        Send(ev->Sender, new TEvents::TEvPong);
+    }
+
+    void OnBlob(const TEvents::TEvBlob::TPtr& ev) {
+        Send(ev->Sender, ev->Release().Release());
+    }
+};
+
+class TPing: public TActor<TPing> {
+public:
+    TPing()
+        : TActor(&TPing::Main)
+    {
+    }
+
+    STATEFN(Main) {
+        Y_UNUSED(ev);
+    }
+};
+
+THolder<TTestActorRuntimeBase> CreateRuntime() {
+    auto runtime = MakeHolder<TTestActorRuntimeBase>();
+    runtime->SetScheduledEventFilter([](auto&&, auto&&, auto&&, auto&&) { return false; });
+    runtime->Initialize();
+    return runtime;
+}
+
+Y_UNIT_TEST_SUITE(AskActor) {
+    Y_UNIT_TEST(Ok) {
+        auto runtime = CreateRuntime();
+        auto pingpong = runtime->Register(new TPingPong);
+
+        {
+            auto fut = runtime->GetAnyNodeActorSystem()->Ask<TEvents::TEvPong>(
+                pingpong,
                 THolder(new TEvents::TEvPing));
-            runtime->DispatchEvents(); 
-            fut.ExtractValueSync(); 
-        } 
- 
-        { 
-            auto fut = runtime->GetAnyNodeActorSystem()->Ask<TEvents::TEvBlob>( 
-                pingpong, 
+            runtime->DispatchEvents();
+            fut.ExtractValueSync();
+        }
+
+        {
+            auto fut = runtime->GetAnyNodeActorSystem()->Ask<TEvents::TEvBlob>(
+                pingpong,
                 THolder(new TEvents::TEvBlob("hello!")));
-            runtime->DispatchEvents(); 
-            auto ev = fut.ExtractValueSync(); 
-            UNIT_ASSERT_VALUES_EQUAL(ev->Blob, "hello!"); 
-        } 
- 
-        { 
-            auto fut = runtime->GetAnyNodeActorSystem()->Ask<IEventBase>( 
-                pingpong, 
+            runtime->DispatchEvents();
+            auto ev = fut.ExtractValueSync();
+            UNIT_ASSERT_VALUES_EQUAL(ev->Blob, "hello!");
+        }
+
+        {
+            auto fut = runtime->GetAnyNodeActorSystem()->Ask<IEventBase>(
+                pingpong,
                 THolder(new TEvents::TEvPing));
-            runtime->DispatchEvents(); 
-            auto ev = fut.ExtractValueSync(); 
-            UNIT_ASSERT_VALUES_EQUAL(ev->Type(), TEvents::TEvPong::EventType); 
-        } 
-    } 
- 
-    Y_UNIT_TEST(Err) { 
-        auto runtime = CreateRuntime(); 
-        auto pingpong = runtime->Register(new TPingPong); 
- 
-        { 
-            auto fut = runtime->GetAnyNodeActorSystem()->Ask<TEvents::TEvBlob>( 
-                pingpong, 
+            runtime->DispatchEvents();
+            auto ev = fut.ExtractValueSync();
+            UNIT_ASSERT_VALUES_EQUAL(ev->Type(), TEvents::TEvPong::EventType);
+        }
+    }
+
+    Y_UNIT_TEST(Err) {
+        auto runtime = CreateRuntime();
+        auto pingpong = runtime->Register(new TPingPong);
+
+        {
+            auto fut = runtime->GetAnyNodeActorSystem()->Ask<TEvents::TEvBlob>(
+                pingpong,
                 THolder(new TEvents::TEvPing));
-            runtime->DispatchEvents(); 
-            UNIT_ASSERT_EXCEPTION_CONTAINS( 
-                fut.ExtractValueSync(), 
-                yexception, 
-                "received unexpected response HelloWorld: Pong"); 
-        } 
-    } 
- 
-    Y_UNIT_TEST(Timeout) { 
-        auto runtime = CreateRuntime(); 
-        auto ping = runtime->Register(new TPing); 
- 
-        { 
-            auto fut = runtime->GetAnyNodeActorSystem()->Ask<TEvents::TEvPong>( 
-                ping, 
+            runtime->DispatchEvents();
+            UNIT_ASSERT_EXCEPTION_CONTAINS(
+                fut.ExtractValueSync(),
+                yexception,
+                "received unexpected response HelloWorld: Pong");
+        }
+    }
+
+    Y_UNIT_TEST(Timeout) {
+        auto runtime = CreateRuntime();
+        auto ping = runtime->Register(new TPing);
+
+        {
+            auto fut = runtime->GetAnyNodeActorSystem()->Ask<TEvents::TEvPong>(
+                ping,
                 THolder(new TEvents::TEvPing),
-                TDuration::Seconds(1)); 
-            auto start = runtime->GetCurrentTime(); 
-            runtime->DispatchEvents({}, TDuration::Seconds(5)); 
-            UNIT_ASSERT_EXCEPTION_CONTAINS( 
-                fut.ExtractValueSync(), 
-                yexception, 
-                "ask timeout"); 
-            UNIT_ASSERT_VALUES_EQUAL(runtime->GetCurrentTime() - start, TDuration::Seconds(1)); 
-        } 
- 
-        { 
-            auto fut = runtime->GetAnyNodeActorSystem()->Ask<IEventBase>( 
-                ping, 
+                TDuration::Seconds(1));
+            auto start = runtime->GetCurrentTime();
+            runtime->DispatchEvents({}, TDuration::Seconds(5));
+            UNIT_ASSERT_EXCEPTION_CONTAINS(
+                fut.ExtractValueSync(),
+                yexception,
+                "ask timeout");
+            UNIT_ASSERT_VALUES_EQUAL(runtime->GetCurrentTime() - start, TDuration::Seconds(1));
+        }
+
+        {
+            auto fut = runtime->GetAnyNodeActorSystem()->Ask<IEventBase>(
+                ping,
                 THolder(new TEvents::TEvPing),
-                TDuration::Seconds(1)); 
-            auto start = runtime->GetCurrentTime(); 
-            runtime->DispatchEvents({}, TDuration::Seconds(5)); 
-            UNIT_ASSERT_EXCEPTION_CONTAINS( 
-                fut.ExtractValueSync(), 
-                yexception, 
-                "ask timeout"); 
-            UNIT_ASSERT_VALUES_EQUAL(runtime->GetCurrentTime() - start, TDuration::Seconds(1)); 
-        } 
-    } 
-} 
+                TDuration::Seconds(1));
+            auto start = runtime->GetCurrentTime();
+            runtime->DispatchEvents({}, TDuration::Seconds(5));
+            UNIT_ASSERT_EXCEPTION_CONTAINS(
+                fut.ExtractValueSync(),
+                yexception,
+                "ask timeout");
+            UNIT_ASSERT_VALUES_EQUAL(runtime->GetCurrentTime() - start, TDuration::Seconds(1));
+        }
+    }
+}

library/cpp/actors/core/hfunc.h

@@ -42,23 +42,23 @@
         break;                                                                      \
     }
 
-#define hTemplFunc(TEvType, HandleFunc)                                             \ 
-    case TEvType::EventType: {                                                      \ 
-        typename TEvType::TPtr* x = reinterpret_cast<typename TEvType::TPtr*>(&ev); \ 
-        HandleFunc(*x);                                                             \ 
-        break;                                                                      \ 
-    } 
- 
-#define SFunc(TEvType, HandleFunc) \ 
-    case TEvType::EventType:       \ 
-        HandleFunc(ctx);           \ 
-        break; 
- 
-#define sFunc(TEvType, HandleFunc) \ 
-    case TEvType::EventType:       \ 
-        HandleFunc();              \ 
-        break; 
- 
+#define hTemplFunc(TEvType, HandleFunc)                                             \
+    case TEvType::EventType: {                                                      \
+        typename TEvType::TPtr* x = reinterpret_cast<typename TEvType::TPtr*>(&ev); \
+        HandleFunc(*x);                                                             \
+        break;                                                                      \
+    }
+
+#define SFunc(TEvType, HandleFunc) \
+    case TEvType::EventType:       \
+        HandleFunc(ctx);           \
+        break;
+
+#define sFunc(TEvType, HandleFunc) \
+    case TEvType::EventType:       \
+        HandleFunc();              \
+        break;
+
 #define CFunc(TEventType, HandleFunc) \
     case TEventType:                  \
         HandleFunc(ctx);              \

library/cpp/actors/core/ut/ya.make

@@ -32,7 +32,7 @@ SRCS(
     actor_coroutine_ut.cpp
     actor_ut.cpp
     actorsystem_ut.cpp
-    ask_ut.cpp 
+    ask_ut.cpp
     balancer_ut.cpp
     event_pb_payload_ut.cpp
     event_pb_ut.cpp

library/cpp/actors/core/ya.make

@@ -28,8 +28,8 @@ SRCS(
     actorid.h
     actorsystem.cpp
     actorsystem.h
-    ask.cpp 
-    ask.h 
+    ask.cpp
+    ask.h
     balancer.h
     balancer.cpp
     buffer.cpp

library/cpp/colorizer/colors.cpp

@@ -12,160 +12,160 @@
 
 using namespace NColorizer;
 
-namespace { 
-    constexpr TStringBuf ToStringBufC(NColorizer::EAnsiCode x) { 
-        switch(x) { 
-            case RESET: 
+namespace {
+    constexpr TStringBuf ToStringBufC(NColorizer::EAnsiCode x) {
+        switch(x) {
+            case RESET:
                 return "\033[0m";
- 
-            case ST_LIGHT: 
+
+            case ST_LIGHT:
                 return "\033[1m";
-            case ST_DARK: 
+            case ST_DARK:
                 return "\033[2m";
-            case ST_NORMAL: 
+            case ST_NORMAL:
                 return "\033[22m";
- 
-            case ITALIC_ON: 
+
+            case ITALIC_ON:
                 return "\033[3m";
-            case ITALIC_OFF: 
+            case ITALIC_OFF:
                 return "\033[23m";
-            case UNDERLINE_ON: 
+            case UNDERLINE_ON:
                 return "\033[4m";
-            case UNDERLINE_OFF: 
+            case UNDERLINE_OFF:
                 return "\033[24m";
- 
-            case FG_DEFAULT: 
+
+            case FG_DEFAULT:
                 return "\033[39m";
-            case FG_BLACK: 
+            case FG_BLACK:
                 return "\033[30m";
-            case FG_RED: 
+            case FG_RED:
                 return "\033[31m";
-            case FG_GREEN: 
+            case FG_GREEN:
                 return "\033[32m";
-            case FG_YELLOW: 
+            case FG_YELLOW:
                 return "\033[33m";
-            case FG_BLUE: 
+            case FG_BLUE:
                 return "\033[34m";
-            case FG_MAGENTA: 
+            case FG_MAGENTA:
                 return "\033[35m";
-            case FG_CYAN: 
+            case FG_CYAN:
                 return "\033[36m";
-            case FG_WHITE: 
+            case FG_WHITE:
                 return "\033[37m";
- 
-            case BG_DEFAULT: 
+
+            case BG_DEFAULT:
                 return "\033[49m";
-            case BG_BLACK: 
+            case BG_BLACK:
                 return "\033[40m";
-            case BG_RED: 
+            case BG_RED:
                 return "\033[41m";
-            case BG_GREEN: 
+            case BG_GREEN:
                 return "\033[42m";
-            case BG_YELLOW: 
+            case BG_YELLOW:
                 return "\033[43m";
-            case BG_BLUE: 
+            case BG_BLUE:
                 return "\033[44m";
-            case BG_MAGENTA: 
+            case BG_MAGENTA:
                 return "\033[45m";
-            case BG_CYAN: 
+            case BG_CYAN:
                 return "\033[46m";
-            case BG_WHITE: 
+            case BG_WHITE:
                 return "\033[47m";
- 
-            // Note: the following codes are split into two escabe sequences because of how ya.make handles them. 
- 
-            case DEFAULT: 
+
+            // Note: the following codes are split into two escabe sequences because of how ya.make handles them.
+
+            case DEFAULT:
                 return "\033[0m\033[0;39m";
-            case BLACK: 
+            case BLACK:
                 return "\033[0m\033[0;30m";
-            case RED: 
+            case RED:
                 return "\033[0m\033[0;31m";
-            case GREEN: 
+            case GREEN:
                 return "\033[0m\033[0;32m";
-            case YELLOW: 
+            case YELLOW:
                 return "\033[0m\033[0;33m";
-            case BLUE: 
+            case BLUE:
                 return "\033[0m\033[0;34m";
-            case MAGENTA: 
+            case MAGENTA:
                 return "\033[0m\033[0;35m";
-            case CYAN: 
+            case CYAN:
                 return "\033[0m\033[0;36m";
-            case WHITE: 
+            case WHITE:
                 return "\033[0m\033[0;37m";
- 
-            case LIGHT_DEFAULT: 
+
+            case LIGHT_DEFAULT:
                 return "\033[0m\033[1;39m";
-            case LIGHT_BLACK: 
+            case LIGHT_BLACK:
                 return "\033[0m\033[1;30m";
-            case LIGHT_RED: 
+            case LIGHT_RED:
                 return "\033[0m\033[1;31m";
-            case LIGHT_GREEN: 
+            case LIGHT_GREEN:
                 return "\033[0m\033[1;32m";
-            case LIGHT_YELLOW: 
+            case LIGHT_YELLOW:
                 return "\033[0m\033[1;33m";
-            case LIGHT_BLUE: 
+            case LIGHT_BLUE:
                 return "\033[0m\033[1;34m";
-            case LIGHT_MAGENTA: 
+            case LIGHT_MAGENTA:
                 return "\033[0m\033[1;35m";
-            case LIGHT_CYAN: 
+            case LIGHT_CYAN:
                 return "\033[0m\033[1;36m";
-            case LIGHT_WHITE: 
+            case LIGHT_WHITE:
                 return "\033[0m\033[1;37m";
- 
-            case DARK_DEFAULT: 
+
+            case DARK_DEFAULT:
                 return "\033[0m\033[2;39m";
-            case DARK_BLACK: 
+            case DARK_BLACK:
                 return "\033[0m\033[2;30m";
-            case DARK_RED: 
+            case DARK_RED:
                 return "\033[0m\033[2;31m";
-            case DARK_GREEN: 
+            case DARK_GREEN:
                 return "\033[0m\033[2;32m";
-            case DARK_YELLOW: 
+            case DARK_YELLOW:
                 return "\033[0m\033[2;33m";
-            case DARK_BLUE: 
+            case DARK_BLUE:
                 return "\033[0m\033[2;34m";
-            case DARK_MAGENTA: 
+            case DARK_MAGENTA:
                 return "\033[0m\033[2;35m";
-            case DARK_CYAN: 
+            case DARK_CYAN:
                 return "\033[0m\033[2;36m";
-            case DARK_WHITE: 
+            case DARK_WHITE:
                 return "\033[0m\033[2;37m";
 
             case INVALID:
             default:
                 return "";
-        } 
-    } 
-} 
- 
-TStringBuf ToStringBuf(NColorizer::EAnsiCode x) { 
-    return ToStringBufC(x); 
-} 
- 
-TString ToString(NColorizer::EAnsiCode x) { 
-    return TString(ToStringBufC(x)); 
-} 
- 
-template<> 
-void Out<NColorizer::EAnsiCode>(IOutputStream& os, TTypeTraits<NColorizer::EAnsiCode>::TFuncParam x) { 
-    if (AutoColors(os).IsTTY()) { 
-        os << ToStringBufC(x); 
-    } 
-} 
- 
-bool TColors::CalcIsTTY(FILE* file) { 
-    if (GetEnv("ENFORCE_TTY")) { 
-        return true; 
-    } 
- 
-#if defined(_unix_) 
-    return isatty(fileno(file)); 
-#else 
-    Y_UNUSED(file); 
-    return false; 
-#endif 
-} 
- 
+        }
+    }
+}
+
+TStringBuf ToStringBuf(NColorizer::EAnsiCode x) {
+    return ToStringBufC(x);
+}
+
+TString ToString(NColorizer::EAnsiCode x) {
+    return TString(ToStringBufC(x));
+}
+
+template<>
+void Out<NColorizer::EAnsiCode>(IOutputStream& os, TTypeTraits<NColorizer::EAnsiCode>::TFuncParam x) {
+    if (AutoColors(os).IsTTY()) {
+        os << ToStringBufC(x);
+    }
+}
+
+bool TColors::CalcIsTTY(FILE* file) {
+    if (GetEnv("ENFORCE_TTY")) {
+        return true;
+    }
+
+#if defined(_unix_)
+    return isatty(fileno(file));
+#else
+    Y_UNUSED(file);
+    return false;
+#endif
+}
+
 TColors::TColors(FILE* f)
     : IsTTY_(true)
 {
@@ -178,254 +178,254 @@ TColors::TColors(bool ontty)
     SetIsTTY(ontty);
 }
 
-TStringBuf TColors::Reset() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::RESET) : ToStringBufC(EAnsiCode::INVALID); 
-}
-
-TStringBuf TColors::StyleLight() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::ST_LIGHT) : ToStringBufC(EAnsiCode::INVALID); 
-}
-TStringBuf TColors::StyleDark() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::ST_DARK) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::StyleNormal() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::ST_NORMAL) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-
-TStringBuf TColors::ItalicOn() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::ITALIC_ON) : ToStringBufC(EAnsiCode::INVALID); 
-}
-TStringBuf TColors::ItalicOff() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::ITALIC_OFF) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::UnderlineOn() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::UNDERLINE_ON) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::UnderlineOff() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::UNDERLINE_OFF) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-
-TStringBuf TColors::ForeDefault() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::FG_DEFAULT) : ToStringBufC(EAnsiCode::INVALID); 
-}
-TStringBuf TColors::ForeBlack() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::FG_BLACK) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::ForeRed() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::FG_RED) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::ForeGreen() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::FG_GREEN) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::ForeYellow() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::FG_YELLOW) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::ForeBlue() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::FG_BLUE) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::ForeMagenta() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::FG_MAGENTA) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::ForeCyan() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::FG_CYAN) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::ForeWhite() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::FG_WHITE) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-
-TStringBuf TColors::BackDefault() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BG_DEFAULT) : ToStringBufC(EAnsiCode::INVALID); 
-}
-TStringBuf TColors::BackBlack() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BG_BLACK) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::BackRed() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BG_RED) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::BackGreen() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BG_GREEN) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::BackYellow() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BG_YELLOW) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::BackBlue() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BG_BLUE) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::BackMagenta() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BG_MAGENTA) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::BackCyan() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BG_CYAN) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::BackWhite() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BG_WHITE) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-
-TStringBuf TColors::Default() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::DEFAULT) : ToStringBufC(EAnsiCode::INVALID); 
-}
-TStringBuf TColors::Black() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BLACK) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::Red() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::RED) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::Green() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::GREEN) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::Yellow() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::YELLOW) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::Blue() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::BLUE) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::Magenta() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::MAGENTA) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::Cyan() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::CYAN) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::White() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::WHITE) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-
-TStringBuf TColors::LightDefault() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_DEFAULT) : ToStringBufC(EAnsiCode::INVALID); 
-}
-TStringBuf TColors::LightBlack() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_BLACK) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::LightRed() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_RED) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::LightGreen() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_GREEN) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::LightYellow() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_YELLOW) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::LightBlue() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_BLUE) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::LightMagenta() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_MAGENTA) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::LightCyan() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_CYAN) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::LightWhite() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_WHITE) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-
-TStringBuf TColors::DarkDefault() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_DEFAULT) : ToStringBufC(EAnsiCode::INVALID); 
-}
-TStringBuf TColors::DarkBlack() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_BLACK) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::DarkRed() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_RED) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::DarkGreen() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_GREEN) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::DarkYellow() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_YELLOW) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::DarkBlue() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_BLUE) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::DarkMagenta() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_MAGENTA) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::DarkCyan() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_CYAN) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-TStringBuf TColors::DarkWhite() const noexcept { 
-    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_WHITE) : ToStringBufC(EAnsiCode::INVALID); 
-} 
-
-TStringBuf TColors::OldColor() const noexcept { 
+TStringBuf TColors::Reset() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::RESET) : ToStringBufC(EAnsiCode::INVALID);
+}
+
+TStringBuf TColors::StyleLight() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::ST_LIGHT) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::StyleDark() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::ST_DARK) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::StyleNormal() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::ST_NORMAL) : ToStringBufC(EAnsiCode::INVALID);
+}
+
+TStringBuf TColors::ItalicOn() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::ITALIC_ON) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::ItalicOff() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::ITALIC_OFF) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::UnderlineOn() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::UNDERLINE_ON) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::UnderlineOff() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::UNDERLINE_OFF) : ToStringBufC(EAnsiCode::INVALID);
+}
+
+TStringBuf TColors::ForeDefault() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::FG_DEFAULT) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::ForeBlack() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::FG_BLACK) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::ForeRed() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::FG_RED) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::ForeGreen() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::FG_GREEN) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::ForeYellow() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::FG_YELLOW) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::ForeBlue() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::FG_BLUE) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::ForeMagenta() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::FG_MAGENTA) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::ForeCyan() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::FG_CYAN) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::ForeWhite() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::FG_WHITE) : ToStringBufC(EAnsiCode::INVALID);
+}
+
+TStringBuf TColors::BackDefault() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BG_DEFAULT) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::BackBlack() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BG_BLACK) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::BackRed() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BG_RED) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::BackGreen() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BG_GREEN) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::BackYellow() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BG_YELLOW) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::BackBlue() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BG_BLUE) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::BackMagenta() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BG_MAGENTA) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::BackCyan() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BG_CYAN) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::BackWhite() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BG_WHITE) : ToStringBufC(EAnsiCode::INVALID);
+}
+
+TStringBuf TColors::Default() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::DEFAULT) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::Black() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BLACK) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::Red() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::RED) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::Green() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::GREEN) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::Yellow() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::YELLOW) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::Blue() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::BLUE) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::Magenta() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::MAGENTA) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::Cyan() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::CYAN) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::White() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::WHITE) : ToStringBufC(EAnsiCode::INVALID);
+}
+
+TStringBuf TColors::LightDefault() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_DEFAULT) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::LightBlack() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_BLACK) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::LightRed() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_RED) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::LightGreen() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_GREEN) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::LightYellow() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_YELLOW) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::LightBlue() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_BLUE) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::LightMagenta() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_MAGENTA) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::LightCyan() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_CYAN) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::LightWhite() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::LIGHT_WHITE) : ToStringBufC(EAnsiCode::INVALID);
+}
+
+TStringBuf TColors::DarkDefault() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_DEFAULT) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::DarkBlack() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_BLACK) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::DarkRed() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_RED) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::DarkGreen() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_GREEN) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::DarkYellow() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_YELLOW) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::DarkBlue() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_BLUE) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::DarkMagenta() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_MAGENTA) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::DarkCyan() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_CYAN) : ToStringBufC(EAnsiCode::INVALID);
+}
+TStringBuf TColors::DarkWhite() const noexcept {
+    return IsTTY() ? ToStringBufC(EAnsiCode::DARK_WHITE) : ToStringBufC(EAnsiCode::INVALID);
+}
+
+TStringBuf TColors::OldColor() const noexcept {
     return IsTTY() ? "\033[22;39m" : "";
 }
 
-TStringBuf TColors::BoldColor() const noexcept { 
+TStringBuf TColors::BoldColor() const noexcept {
     return IsTTY() ? "\033[1m" : "";
 }
 
-TStringBuf TColors::BlackColor() const noexcept { 
+TStringBuf TColors::BlackColor() const noexcept {
     return IsTTY() ? "\033[22;30m" : "";
 }
 
-TStringBuf TColors::BlueColor() const noexcept { 
+TStringBuf TColors::BlueColor() const noexcept {
     return IsTTY() ? "\033[22;34m" : "";
 }
 
-TStringBuf TColors::GreenColor() const noexcept { 
+TStringBuf TColors::GreenColor() const noexcept {
     return IsTTY() ? "\033[22;32m" : "";
 }
 
-TStringBuf TColors::CyanColor() const noexcept { 
+TStringBuf TColors::CyanColor() const noexcept {
     return IsTTY() ? "\033[22;36m" : "";
 }
 
-TStringBuf TColors::RedColor() const noexcept { 
+TStringBuf TColors::RedColor() const noexcept {
     return IsTTY() ? "\033[22;31m" : "";
 }
 
-TStringBuf TColors::PurpleColor() const noexcept { 
+TStringBuf TColors::PurpleColor() const noexcept {
     return IsTTY() ? "\033[22;35m" : "";
 }
 
-TStringBuf TColors::BrownColor() const noexcept { 
+TStringBuf TColors::BrownColor() const noexcept {
     return IsTTY() ? "\033[22;33m" : "";
 }
 
-TStringBuf TColors::LightGrayColor() const noexcept { 
+TStringBuf TColors::LightGrayColor() const noexcept {
     return IsTTY() ? "\033[22;37m" : "";
 }
 
-TStringBuf TColors::DarkGrayColor() const noexcept { 
+TStringBuf TColors::DarkGrayColor() const noexcept {
     return IsTTY() ? "\033[1;30m" : "";
-} 
+}
 
-TStringBuf TColors::LightBlueColor() const noexcept { 
+TStringBuf TColors::LightBlueColor() const noexcept {
     return IsTTY() ? "\033[1;34m" : "";
-} 
+}
 
-TStringBuf TColors::LightGreenColor() const noexcept { 
+TStringBuf TColors::LightGreenColor() const noexcept {
     return IsTTY() ? "\033[1;32m" : "";
-} 
+}
 
-TStringBuf TColors::LightCyanColor() const noexcept { 
+TStringBuf TColors::LightCyanColor() const noexcept {
     return IsTTY() ? "\033[1;36m" : "";
 }
 
-TStringBuf TColors::LightRedColor() const noexcept { 
+TStringBuf TColors::LightRedColor() const noexcept {
     return IsTTY() ? "\033[1;31m" : "";
-} 
+}
 
-TStringBuf TColors::LightPurpleColor() const noexcept { 
+TStringBuf TColors::LightPurpleColor() const noexcept {
     return IsTTY() ? "\033[1;35m" : "";
 }
 
-TStringBuf TColors::YellowColor() const noexcept { 
+TStringBuf TColors::YellowColor() const noexcept {
     return IsTTY() ? "\033[1;33m" : "";
 }
 
-TStringBuf TColors::WhiteColor() const noexcept { 
+TStringBuf TColors::WhiteColor() const noexcept {
     return IsTTY() ? "\033[1;37m" : "";
 }
 
- 
+
 namespace {
-    class TStdErrColors: public TColors { 
-    public: 
-        TStdErrColors() 
-            : TColors(stderr) 
-        { 
-        } 
-    }; 
+    class TStdErrColors: public TColors {
+    public:
+        TStdErrColors()
+            : TColors(stderr)
+        {
+        }
+    };
 
     class TStdOutColors: public TColors {
     public:
@@ -444,14 +444,14 @@ namespace {
     };
 } // anonymous namespace
 
-TColors& NColorizer::StdErr() { 
-    return *Singleton<TStdErrColors>(); 
-} 
- 
-TColors& NColorizer::StdOut() { 
-    return *Singleton<TStdOutColors>(); 
-} 
- 
+TColors& NColorizer::StdErr() {
+    return *Singleton<TStdErrColors>();
+}
+
+TColors& NColorizer::StdOut() {
+    return *Singleton<TStdOutColors>();
+}
+
 TColors& NColorizer::AutoColors(IOutputStream& os) {
     if (&os == &Cerr) {
         return StdErr();
@@ -461,45 +461,45 @@ TColors& NColorizer::AutoColors(IOutputStream& os) {
     }
     return *Singleton<TDisabledColors>();
 }
- 
-size_t NColorizer::TotalAnsiEscapeCodeLen(TStringBuf text) { 
-    enum { 
-        TEXT, 
-        BEFORE_CODE, 
-        IN_CODE, 
-    } state = TEXT; 
- 
-    size_t totalLen = 0; 
-    size_t curLen = 0; 
- 
-    for (auto it = text.begin(); it < text.end(); ++it) { 
-        switch (state) { 
-            case TEXT: 
-                if (*it == '\033') { 
-                    state = BEFORE_CODE; 
-                    curLen = 1; 
-                } 
-                break; 
-            case BEFORE_CODE: 
-                if (*it == '[') { 
-                    state = IN_CODE; 
-                    curLen++; 
-                } else { 
-                    state = TEXT; 
-                } 
-                break; 
-            case IN_CODE: 
-                if (*it == ';' || isdigit(*it)) { 
-                    curLen++; 
-                } else { 
-                    if (*it == 'm') { 
-                        totalLen += curLen + 1; 
-                    } 
-                    state = TEXT; 
-                } 
-                break; 
-        } 
-    } 
- 
-    return totalLen; 
-} 
+
+size_t NColorizer::TotalAnsiEscapeCodeLen(TStringBuf text) {
+    enum {
+        TEXT,
+        BEFORE_CODE,
+        IN_CODE,
+    } state = TEXT;
+
+    size_t totalLen = 0;
+    size_t curLen = 0;
+
+    for (auto it = text.begin(); it < text.end(); ++it) {
+        switch (state) {
+            case TEXT:
+                if (*it == '\033') {
+                    state = BEFORE_CODE;
+                    curLen = 1;
+                }
+                break;
+            case BEFORE_CODE:
+                if (*it == '[') {
+                    state = IN_CODE;
+                    curLen++;
+                } else {
+                    state = TEXT;
+                }
+                break;
+            case IN_CODE:
+                if (*it == ';' || isdigit(*it)) {
+                    curLen++;
+                } else {
+                    if (*it == 'm') {
+                        totalLen += curLen + 1;
+                    }
+                    state = TEXT;
+                }
+                break;
+        }
+    }
+
+    return totalLen;
+}