refactor: avoid unnecessary new and raw pointer

Author: ShrBox

src/legacy/api/BlockEntityAPI.cpp

@@ -71,7 +71,7 @@ Local<Value> BlockEntityClass::getType() {
 
 Local<Value> BlockEntityClass::getNbt(const Arguments&) {
     try {
-        CompoundTag* tag = new CompoundTag();
+        auto tag = std::make_unique<CompoundTag>();
         blockEntity->save(*tag, *SaveContextFactory::createCloneSaveContext());
         return NbtCompoundClass::pack(std::move(tag)); // Not sure is that will get right value
     }

src/legacy/legacyapi/db/Row.cpp

@@ -72,10 +72,10 @@ size_t RowHeader::operator[](const std::string& name) {
 std::string& RowHeader::operator[](size_t index) { return at(index); }
 
 Row::Row(const std::shared_ptr<RowHeader>& header) : header(header) {}
-Row::Row(const RowHeader& header) : header(new RowHeader(header)) {}
+Row::Row(const RowHeader& header) : header(std::make_shared<RowHeader>(header)) {}
 Row::Row(const std::initializer_list<Any>& list, const RowHeader& header)
 : std::vector<Any>(list),
-  header(new RowHeader(header)) {
+  header(std::make_shared<RowHeader>(header)) {
     if (!header.empty() && list.size() != header.size()) {
         throw std::invalid_argument("Row::Row: The row and the header mismatch");
     }
@@ -89,20 +89,20 @@ Row::Row(const std::initializer_list<Any>& list, const std::shared_ptr<RowHeader
 }
 Row::Row(std::vector<Any>&& list, const RowHeader& header)
 : std::vector<Any>(std::move(list)),
-  header(new RowHeader(header)) {
+  header(std::make_shared<RowHeader>(header)) {
     if (size() != header.size()) {
         list = std::move(*this); // Restore
         throw std::invalid_argument("Row::Row: The row and the header mismatch");
     }
 }
 Row::Row(const std::vector<Any>& list, const RowHeader& header)
 : std::vector<Any>(list),
-  header(new RowHeader(header)) {
+  header(std::make_shared<RowHeader>(header)) {
     if (list.size() != header.size()) {
         throw std::invalid_argument("Row::Row: The row and the header mismatch");
     }
 }
-Row::Row(const std::initializer_list<std::pair<std::string, Any>>& list) : header(new RowHeader()) {
+Row::Row(const std::initializer_list<std::pair<std::string, Any>>& list) : header(std::make_shared<RowHeader>()) {
     for (auto& pair : list) {
         header->add(pair.first);
         this->push_back(pair.second);

src/legacy/legacyapi/db/RowSet.cpp

@@ -12,7 +12,7 @@ RowSet::RowSet(const std::shared_ptr<RowHeader>& header) : std::vector<Row>(), h
     }
 }
 
-RowSet::RowSet(const RowHeader& header) : std::vector<Row>(), header(new RowHeader(header)) {}
+RowSet::RowSet(const RowHeader& header) : std::vector<Row>(), header(std::make_shared<RowHeader>(header)) {}
 RowSet::RowSet(RowSet&& set) noexcept : std::vector<Row>(std::move(set)), header(set.header) {}
 RowSet::RowSet(const RowSet& set) : std::vector<Row>(set), header(set.header) {}
 RowSet& RowSet::operator=(RowSet&& set) noexcept {

src/legacy/legacyapi/db/Session.cpp

@@ -104,18 +104,18 @@ SharedPointer<Session> Session::create(DBType type, const std::string& path) {
 }
 
 SharedPointer<Session> Session::_Create(DBType type, const ConnParams& params) {
-    Session* session = nullptr;
+    std::shared_ptr<Session> session = nullptr;
     switch (type) {
     case DBType::SQLite:
-        session = params.empty() ? new SQLiteSession() : new SQLiteSession(params);
+        session = params.empty() ? std::make_shared<SQLiteSession>() : std::make_shared<SQLiteSession>(params);
         break;
     case DBType::MySQL:
 #ifdef LSE_BACKEND_NODEJS
         lse::LegacyScriptEngine::getInstance().getSelf().getLogger().error(
             "Session::_Create: MySQL is disabled in NodeJS backend because its OpenSSL has conflicts with libnode"
         );
 #else
-        session = params.empty() ? new MySQLSession() : new MySQLSession(params);
+        session = params.empty() ? std::make_shared<MySQLSession>() : std::make_shared<MySQLSession>(params);
 #endif
         break;
     default:

src/legacy/legacyapi/db/impl/sqlite/Stmt.cpp

@@ -35,7 +35,7 @@ int SQLiteStmt::getNextParamIndex() {
 }
 
 void SQLiteStmt::fetchResultHeader() {
-    if (!resultHeader) resultHeader.reset(new RowHeader);
+    if (!resultHeader) resultHeader = std::make_shared<RowHeader>();
     int colCnt = sqlite3_column_count(stmt);
     for (int i = 0; i < colCnt; i++) {
         auto     name = sqlite3_column_name(stmt, i);
@@ -328,7 +328,7 @@ SQLiteStmt::create(const std::weak_ptr<Session>& session, const std::string& sql
     if (res != SQLITE_OK) {
         throw std::runtime_error("SQLiteStmt::create: " + s->getLastError());
     }
-    auto result    = new SQLiteStmt(stmt, session, autoExecute);
+    auto result    = std::make_shared<SQLiteStmt>(stmt, session, autoExecute);
     result->parent = session;
     result->setDebugOutput(raw->debugOutput);
     if (raw->debugOutput)

src/legacy/legacyapi/db/impl/sqlite/Stmt.h

@@ -20,11 +20,11 @@ class SQLiteStmt : public Stmt {
     bool                       executed         = false;
     std::vector<int>           boundIndexes;
 
-    SQLiteStmt(sqlite3_stmt* stmt, const std::weak_ptr<Session> parent, bool autoExecute);
     int  getNextParamIndex();
     void fetchResultHeader();
 
 public:
+    SQLiteStmt(sqlite3_stmt* stmt, const std::weak_ptr<Session> parent, bool autoExecute);
     ~SQLiteStmt();
     Stmt& bind(const Any& value, int index);
     Stmt& bind(const Any& value, const std::string& name);