Issue #73 - Replace TAutoPtr to std::unique_ptr (#259)

stanislav-shchetinin · stanislav-shchetinin · commit a39e6f84b092 · 2024-07-16T09:57:10.000+03:00
diff --git a/include/ydb-cpp-sdk/util/thread/pool.h b/include/ydb-cpp-sdk/util/thread/pool.h
@@ -8,6 +8,7 @@
 #include <ydb-cpp-sdk/util/generic/noncopyable.h>
 
 #include <string>
+#include <memory>
 
 class TDuration;
 
@@ -386,4 +387,4 @@ inline void Delete(THolder<IThreadPool> q) {
  * Creates and starts TThreadPool if threadsCount > 1, or TFakeThreadPool otherwise
  * You could specify blocking and catching modes for TThreadPool only
  */
-THolder<IThreadPool> CreateThreadPool(size_t threadCount, size_t queueSizeLimit = 0, const IThreadPool::TParams& params = {});
+std::unique_ptr<IThreadPool> CreateThreadPool(size_t threadCount, size_t queueSizeLimit = 0, const IThreadPool::TParams& params = {});
diff --git a/src/library/dbg_output/dumpers.h b/src/library/dbg_output/dumpers.h
@@ -6,6 +6,7 @@
 
 #include <list>
 #include <map>
+#include <memory>
 #include <set>
 #include <span>
 #include <string>
@@ -17,10 +18,10 @@
 
 //smart pointers
 template <class T, class D>
-struct TDumper<TAutoPtr<T, D>> {
+struct TDumper<std::unique_ptr<T, D>> {
     template <class S>
-    static inline void Dump(S& s, const TAutoPtr<T, D>& v) {
-        s << DumpRaw("TAutoPtr(") << v.Get() << DumpRaw(")");
+    static inline void Dump(S& s, const std::unique_ptr<T, D>& v) {
+        s << DumpRaw("std::unique_ptr(") << v.get() << DumpRaw(")");
     }
 };
 
diff --git a/src/library/getopt/small/last_getopt_opt.h b/src/library/getopt/small/last_getopt_opt.h
@@ -608,13 +608,13 @@ namespace NLastGetopt {
             return Handler1(f);
         }
 
-        TOpt& Handler(TAutoPtr<IOptHandler> handler) {
-            return HandlerImpl(handler.Release());
+        TOpt& Handler(std::unique_ptr<IOptHandler>&& handler) {
+            return HandlerImpl(handler.release());
         }
 
         template <typename T> // T extends IOptHandler
-        TOpt& Handler(TAutoPtr<T> handler) {
-            return HandlerImpl(handler.Release());
+        TOpt& Handler(std::unique_ptr<T>&& handler) {
+            return HandlerImpl(handler.release());
         }
 
         // Stores FromString<T>(arg) in *target
diff --git a/src/library/http/server/http.cpp b/src/library/http/server/http.cpp
@@ -19,6 +19,7 @@
 
 #include <cerrno>
 #include <cstring>
+#include <memory>
 #include <mutex>
 
 using namespace NAddr;
@@ -169,10 +170,10 @@ class THttpServer::TImpl {
         const THttpServerOptions& Options;
     };
 
-    TAutoPtr<TClientRequest> CreateRequest(TAutoPtr<TClientConnection> c) {
-        THolder<TClientRequest> obj(Cb_->CreateClient());
+    std::unique_ptr<TClientRequest> CreateRequest(std::unique_ptr<TClientConnection>&& c) {
+        std::unique_ptr<TClientRequest> obj(Cb_->CreateClient());
 
-        obj->Conn_.Reset(c.Release());
+        obj->Conn_.Reset(c.release());
 
         return obj;
     }
@@ -287,9 +288,9 @@ class THttpServer::TImpl {
         // ignore result
     }
 
-    void AddRequest(TAutoPtr<TClientRequest> req, bool fail) {
+    void AddRequest(std::unique_ptr<TClientRequest>&& req, bool fail) {
         struct TFailRequest: public THttpClientRequestEx {
-            inline TFailRequest(TAutoPtr<TClientRequest> parent) {
+            inline TFailRequest(std::unique_ptr<TClientRequest>&& parent) {
                 Conn_.Reset(parent->Conn_.Release());
                 HttpConn_.Reset(parent->HttpConn_.Release());
             }
@@ -304,13 +305,13 @@ class THttpServer::TImpl {
             }
         };
 
-        if (!fail && Requests->Add(req.Get())) {
-            Y_UNUSED(req.Release());
+        if (!fail && Requests->Add(req.get())) {
+            Y_UNUSED(req.release());
         } else {
-            req = new TFailRequest(req);
+            req = std::make_unique<TFailRequest>(std::move(req));
 
-            if (FailRequests->Add(req.Get())) {
-                Y_UNUSED(req.Release());
+            if (FailRequests->Add(req.get())) {
+                Y_UNUSED(req.release());
             } else {
                 Cb_->OnFailRequest(-1);
             }
@@ -620,7 +621,7 @@ void TClientConnection::ScheduleDelete() {
 }
 
 void TClientConnection::OnPollEvent(TInstant now) {
-    THolder<TClientConnection> this_(this);
+    std::unique_ptr<TClientConnection> this_(this);
     Activate(now);
 
     {
@@ -637,10 +638,10 @@ void TClientConnection::OnPollEvent(TInstant now) {
         }
     }
 
-    THolder<TClientRequest> obj(HttpServ_->CreateRequest(this_));
+    std::unique_ptr<TClientRequest> obj = HttpServ_->CreateRequest(std::move(this_));
     AcceptMoment = now;
 
-    HttpServ_->AddRequest(obj, Reject_);
+    HttpServ_->AddRequest(std::move(obj), Reject_);
 }
 
 void TClientConnection::Activate(TInstant now) noexcept {
diff --git a/src/library/openssl/init/init.cpp b/src/library/openssl/init/init.cpp
@@ -18,6 +18,7 @@
 #include <openssl/conf.h>
 #include <openssl/crypto.h>
 #include <mutex>
+#include <memory>
 #include <vector>
 
 namespace {
@@ -27,7 +28,7 @@ namespace {
                 : Mutexes(CRYPTO_num_locks())
             {
                 for (auto& mpref : Mutexes) {
-                    mpref.Reset(new std::mutex());
+                    mpref = std::make_unique<std::mutex>();
                 }
             }
 
@@ -41,7 +42,7 @@ namespace {
                 }
             }
 
-            std::vector<TAutoPtr<std::mutex>> Mutexes;
+            std::vector<std::unique_ptr<std::mutex>> Mutexes;
         };
 
         inline TInitSsl() {
diff --git a/src/library/streams/lz/lz.h b/src/library/streams/lz/lz.h
@@ -10,6 +10,8 @@
 #include <src/library/streams/lz/lz4/lz4.h>
 #include <src/library/streams/lz/snappy/snappy.h>
 
+#include <memory>
+
 /**
  * @file
  *
@@ -159,10 +161,10 @@ class TLzqDecompress: public IInputStream {
  * @param input                         Stream to decompress.
  * @return                              Decompressing proxy input stream.
  */
-TAutoPtr<IInputStream> OpenLzDecompressor(IInputStream* input);
-TAutoPtr<IInputStream> TryOpenLzDecompressor(IInputStream* input);
-TAutoPtr<IInputStream> TryOpenLzDecompressor(const std::string_view& signature, IInputStream* input);
+std::unique_ptr<IInputStream> OpenLzDecompressor(IInputStream* input);
+std::unique_ptr<IInputStream> TryOpenLzDecompressor(IInputStream* input);
+std::unique_ptr<IInputStream> TryOpenLzDecompressor(const std::string_view& signature, IInputStream* input);
 
-TAutoPtr<IInputStream> OpenOwnedLzDecompressor(TAutoPtr<IInputStream> input);
-TAutoPtr<IInputStream> TryOpenOwnedLzDecompressor(TAutoPtr<IInputStream> input);
-TAutoPtr<IInputStream> TryOpenOwnedLzDecompressor(const std::string_view& signature, TAutoPtr<IInputStream> input);
+std::unique_ptr<IInputStream> OpenOwnedLzDecompressor(std::unique_ptr<IInputStream>&& input);
+std::unique_ptr<IInputStream> TryOpenOwnedLzDecompressor(std::unique_ptr<IInputStream>&& input);
+std::unique_ptr<IInputStream> TryOpenOwnedLzDecompressor(const std::string_view& signature, std::unique_ptr<IInputStream>&& input);
diff --git a/src/library/testing/unittest/gtest.cpp b/src/library/testing/unittest/gtest.cpp
@@ -3,6 +3,8 @@
 
 #include <ydb-cpp-sdk/util/system/type_name.h>
 
+#include <memory>
+
 using namespace NUnitTest;
 using namespace NUnitTest::NPrivate;
 
@@ -53,13 +55,13 @@ namespace {
 }
 
 IGTestFactory* NUnitTest::NPrivate::ByName(const char* name) {
-    static std::map<std::string_view, TAutoPtr<TGTestFactory>> tests;
+    static std::map<std::string_view, std::unique_ptr<TGTestFactory>> tests;
 
     auto& ret = tests[name];
 
     if (!ret) {
-        ret = new TGTestFactory(name);
+        ret = std::make_unique<TGTestFactory>(name);
     }
 
-    return ret.Get();
+    return ret.get();
 }
diff --git a/src/library/testing/unittest/utmain.cpp b/src/library/testing/unittest/utmain.cpp
@@ -129,11 +129,11 @@ class TTraceWriterProcessor: public ITestSuiteProcessor {
     inline TTraceWriterProcessor(const char* traceFilePath, EOpenMode mode)
         : PrevTime(TInstant::Now())
     {
-        TraceFile = new TUnbufferedFileOutput(TFile(traceFilePath, mode | WrOnly | Seq));
+        TraceFile = std::make_unique<TUnbufferedFileOutput>(TFile(traceFilePath, mode | WrOnly | Seq));
     }
 
 private:
-    TAutoPtr<TUnbufferedFileOutput> TraceFile;
+    std::unique_ptr<TUnbufferedFileOutput> TraceFile;
     std::string TraceFilePath;
     TInstant PrevTime;
     std::vector<std::string> ErrorMessages;
@@ -148,7 +148,7 @@ class TTraceWriterProcessor: public ITestSuiteProcessor {
 
         json.EndObject();
 
-        json.FlushTo(TraceFile.Get());
+        json.FlushTo(TraceFile.get());
         *TraceFile << "\n";
     }
 
diff --git a/src/library/threading/chunk_queue/queue.h b/src/library/threading/chunk_queue/queue.h
@@ -13,6 +13,7 @@
 #include <ydb-cpp-sdk/util/system/yassert.h>
 
 #include <mutex>
+#include <memory>
 #include <type_traits>
 #include <utility>
 
@@ -522,21 +523,21 @@ namespace NThreading {
         TImpl Impl;
 
     public:
-        using TItem = TAutoPtr<T>;
+        using TItem = std::unique_ptr<T>;
 
         ~TAutoQueueBase() {
-            TAutoPtr<T> value;
+            std::unique_ptr<T> value;
             while (Dequeue(value)) {
                 // do nothing
             }
         }
 
-        void Enqueue(TAutoPtr<T> value) {
+        void Enqueue(std::unique_ptr<T>&& value) {
             Impl.Enqueue(value.Get());
             Y_UNUSED(value.Release());
         }
 
-        bool Dequeue(TAutoPtr<T>& value) {
+        bool Dequeue(std::unique_ptr<T>&& value) {
             T* ptr = nullptr;
             if (Impl.Dequeue(ptr)) {
                 value.Reset(ptr);
diff --git a/src/library/threading/equeue/equeue_ut.cpp b/src/library/threading/equeue/equeue_ut.cpp
@@ -6,6 +6,7 @@
 #include <ydb-cpp-sdk/util/system/event.h>
 #include <ydb-cpp-sdk/util/datetime/base.h>
 
+#include <memory>
 
 Y_UNIT_TEST_SUITE(TElasticQueueTest) {
     const size_t MaxQueueSize = 20;
@@ -139,7 +140,7 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
         {
             typename TEnv<T>::TQueueSetup setup;
 
-            std::vector< TAutoPtr<IThreadFactory::IThread> > senders;
+            std::vector< std::unique_ptr<IThreadFactory::IThread> > senders;
             for (size_t i = 0; i < ThreadCount; ++i) {
                 senders.push_back(::SystemThreadFactory()->Run(&sender));
             }
diff --git a/src/library/threading/poor_man_openmp/thread_helper.h b/src/library/threading/poor_man_openmp/thread_helper.h
@@ -18,7 +18,7 @@ class TMtpQueueHelper {
         SetThreadCount(NSystemInfo::CachedNumberOfCpus());
     }
     IThreadPool* Get() {
-        return q.Get();
+        return q.get();
     }
     size_t GetThreadCount() {
         return ThreadCount;
@@ -32,7 +32,7 @@ class TMtpQueueHelper {
 
 private:
     size_t ThreadCount;
-    TAutoPtr<IThreadPool> q;
+    std::unique_ptr<IThreadPool> q;
 };
 
 namespace NYmp {
diff --git a/src/util/thread/pool.cpp b/src/util/thread/pool.cpp
@@ -767,12 +767,12 @@ IThread* IThreadPool::DoCreate() {
     return new TPoolThread(this);
 }
 
-THolder<IThreadPool> CreateThreadPool(size_t threadsCount, size_t queueSizeLimit, const TThreadPoolParams& params) {
-    THolder<IThreadPool> queue;
+std::unique_ptr<IThreadPool> CreateThreadPool(size_t threadsCount, size_t queueSizeLimit, const TThreadPoolParams& params) {
+    std::unique_ptr<IThreadPool> queue;
     if (threadsCount > 1) {
-        queue.Reset(new TThreadPool(params));
+        queue = std::make_unique<TThreadPool>(params);
     } else {
-        queue.Reset(new TFakeThreadPool());
+        queue = std::make_unique<TFakeThreadPool>();
     }
     queue->Start(threadsCount, queueSizeLimit);
     return queue;

Original file line number	Diff line number	Diff line change
`@@ -608,13 +608,13 @@ namespace NLastGetopt {`
`608`	`608`	`return Handler1(f);`
`609`	`609`	`}`
`610`	`610`
`611`		`- TOpt& Handler(TAutoPtr<IOptHandler> handler) {`
`612`		`- return HandlerImpl(handler.Release());`
	`611`	`+ TOpt& Handler(std::unique_ptr<IOptHandler>&& handler) {`
	`612`	`+ return HandlerImpl(handler.release());`
`613`	`613`	`}`
`614`	`614`
`615`	`615`	`template <typename T> // T extends IOptHandler`
`616`		`- TOpt& Handler(TAutoPtr<T> handler) {`
`617`		`- return HandlerImpl(handler.Release());`
	`616`	`+ TOpt& Handler(std::unique_ptr<T>&& handler) {`
	`617`	`+ return HandlerImpl(handler.release());`
`618`	`618`	`}`
`619`	`619`
`620`	`620`	`// Stores FromString<T>(arg) in *target`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@`
`18`	`18`	`#include <openssl/conf.h>`
`19`	`19`	`#include <openssl/crypto.h>`
`20`	`20`	`#include <mutex>`
	`21`	`+#include <memory>`
`21`	`22`	`#include <vector>`
`22`	`23`
`23`	`24`	`namespace {`
`@@ -27,7 +28,7 @@ namespace {`
`27`	`28`	`: Mutexes(CRYPTO_num_locks())`
`28`	`29`	`{`
`29`	`30`	`for (auto& mpref : Mutexes) {`
`30`		`- mpref.Reset(new std::mutex());`
	`31`	`+ mpref = std::make_unique<std::mutex>();`
`31`	`32`	`}`
`32`	`33`	`}`
`33`	`34`
`@@ -41,7 +42,7 @@ namespace {`
`41`	`42`	`}`
`42`	`43`	`}`
`43`	`44`
`44`		`- std::vector<TAutoPtr<std::mutex>> Mutexes;`
	`45`	`+ std::vector<std::unique_ptr<std::mutex>> Mutexes;`
`45`	`46`	`};`
`46`	`47`
`47`	`48`	`inline TInitSsl() {`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,8 @@`
`3`	`3`
`4`	`4`	`#include <ydb-cpp-sdk/util/system/type_name.h>`
`5`	`5`
	`6`	`+#include <memory>`
	`7`	`+`
`6`	`8`	`using namespace NUnitTest;`
`7`	`9`	`using namespace NUnitTest::NPrivate;`
`8`	`10`
`@@ -53,13 +55,13 @@ namespace {`
`53`	`55`	`}`
`54`	`56`
`55`	`57`	`IGTestFactory* NUnitTest::NPrivate::ByName(const char* name) {`
`56`		`- static std::map<std::string_view, TAutoPtr<TGTestFactory>> tests;`
	`58`	`+ static std::map<std::string_view, std::unique_ptr<TGTestFactory>> tests;`
`57`	`59`
`58`	`60`	`auto& ret = tests[name];`
`59`	`61`
`60`	`62`	`if (!ret) {`
`61`		`- ret = new TGTestFactory(name);`
	`63`	`+ ret = std::make_unique<TGTestFactory>(name);`
`62`	`64`	`}`
`63`	`65`
`64`		`- return ret.Get();`
	`66`	`+ return ret.get();`
`65`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -129,11 +129,11 @@ class TTraceWriterProcessor: public ITestSuiteProcessor {`
`129`	`129`	`inline TTraceWriterProcessor(const char* traceFilePath, EOpenMode mode)`
`130`	`130`	`: PrevTime(TInstant::Now())`
`131`	`131`	`{`
`132`		`- TraceFile = new TUnbufferedFileOutput(TFile(traceFilePath, mode \| WrOnly \| Seq));`
	`132`	`+ TraceFile = std::make_unique<TUnbufferedFileOutput>(TFile(traceFilePath, mode \| WrOnly \| Seq));`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`private:`
`136`		`- TAutoPtr<TUnbufferedFileOutput> TraceFile;`
	`136`	`+ std::unique_ptr<TUnbufferedFileOutput> TraceFile;`
`137`	`137`	`std::string TraceFilePath;`
`138`	`138`	`TInstant PrevTime;`
`139`	`139`	`std::vector<std::string> ErrorMessages;`
`@@ -148,7 +148,7 @@ class TTraceWriterProcessor: public ITestSuiteProcessor {`
`148`	`148`
`149`	`149`	`json.EndObject();`
`150`	`150`
`151`		`- json.FlushTo(TraceFile.Get());`
	`151`	`+ json.FlushTo(TraceFile.get());`
`152`	`152`	`*TraceFile << "\n";`
`153`	`153`	`}`
`154`	`154`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`	`#include <ydb-cpp-sdk/util/system/event.h>`
`7`	`7`	`#include <ydb-cpp-sdk/util/datetime/base.h>`
`8`	`8`
	`9`	`+#include <memory>`
`9`	`10`
`10`	`11`	`Y_UNIT_TEST_SUITE(TElasticQueueTest) {`
`11`	`12`	`const size_t MaxQueueSize = 20;`
`@@ -139,7 +140,7 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {`
`139`	`140`	`{`
`140`	`141`	`typename TEnv<T>::TQueueSetup setup;`
`141`	`142`
`142`		`- std::vector< TAutoPtr<IThreadFactory::IThread> > senders;`
	`143`	`+ std::vector< std::unique_ptr<IThreadFactory::IThread> > senders;`
`143`	`144`	`for (size_t i = 0; i < ThreadCount; ++i) {`
`144`	`145`	`senders.push_back(::SystemThreadFactory()->Run(&sender));`
`145`	`146`	`}`