Issue #73 - Replace TAutoPtr to std::unique_ptr

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 = {});

src/library/dbg_output/dumpers.h

@@ -6,6 +6,7 @@
 
 #include <list>
 #include <map>
+#include <memory>
 #include <set>
 #include <span>
 #include <string>
@@ -15,10 +16,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(")");
     }
 };
 

src/library/getopt/small/last_getopt_opt.h

@@ -12,6 +12,7 @@
 #include <utility>
 #include <algorithm>
 #include <functional>
+#include <memory>
 
 namespace NLastGetopt {
     enum EHasArg {
@@ -607,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

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 {

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() {

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);

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();
 }

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";
     }
 

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);

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));
             }

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 {

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;