use raw pointer

Author: zhanglei1949

include/neug/main/neug_db.h

@@ -237,9 +237,7 @@ class NeugDB {
    *
    * @return true if a NeugDBService is associated with this database.
    */
-  inline bool HasActiveService() const {
-    return active_service_.load() != nullptr;
-  }
+  bool HasActiveService() const;
 
   /**
    * @brief Create a new connection to the database for query execution.
@@ -422,11 +420,11 @@ class NeugDB {
   // Serializes the check-and-set sections of Close() and RegisterService()
   // so that closing the database and registering a service can never
   // interleave.
-  std::mutex service_mutex_;
+  mutable std::mutex service_mutex_;
 
   // The NeugDBService currently associated with this database, nullptr if
-  // none. At most one service can be associated at any given time.
-  std::atomic<NeugDBService*> active_service_{nullptr};
+  // none. All access is protected by service_mutex_.
+  NeugDBService* active_service_{nullptr};
 };
 
 }  // namespace neug

src/main/neug_db.cc

@@ -183,7 +183,7 @@ void NeugDB::Close() {
     // closed flag update are atomic with respect to service registration,
     // so no rollback or re-check is needed and Close() stays idempotent.
     std::lock_guard<std::mutex> lock(service_mutex_);
-    if (HasActiveService()) {
+    if (active_service_ != nullptr) {
       THROW_RUNTIME_ERROR(
           "Cannot close NeugDB while a NeugDBService is still associated "
           "with it. Stop and destroy the service first.");
@@ -227,14 +227,24 @@ void NeugDB::Close() {
 }
 
 std::shared_ptr<Connection> NeugDB::Connect() {
-  if (HasActiveService()) {
+  std::lock_guard<std::mutex> lock(service_mutex_);
+  if (IsClosed()) {
+    THROW_RUNTIME_ERROR(
+        "Cannot create connection on a closed NeugDB instance.");
+  }
+  if (active_service_ != nullptr) {
     THROW_RUNTIME_ERROR(
         "Cannot create connection while the database is being served by a "
         "NeugDBService.");
   }
   return connection_manager_->CreateConnection();
 }
 
+bool NeugDB::HasActiveService() const {
+  std::lock_guard<std::mutex> lock(service_mutex_);
+  return active_service_ != nullptr;
+}
+
 void NeugDB::RegisterService(NeugDBService* svc) {
   // Serialized with Close(): either the database is closed first (and this
   // registration is rejected), or the service registers first (and Close()
@@ -245,20 +255,22 @@ void NeugDB::RegisterService(NeugDBService* svc) {
     THROW_RUNTIME_ERROR(
         "Cannot register a NeugDBService on a closed NeugDB instance.");
   }
-  NeugDBService* expected = nullptr;
-  if (!active_service_.compare_exchange_strong(expected, svc)) {
+  if (active_service_ != nullptr) {
     THROW_RUNTIME_ERROR(
         "NeugDB instance is already associated with a NeugDBService. Only "
         "one service instance is allowed per database.");
   }
+  active_service_ = svc;
 }
 
 void NeugDB::UnregisterService(NeugDBService* svc) {
-  NeugDBService* expected = svc;
-  if (!active_service_.compare_exchange_strong(expected, nullptr)) {
+  std::lock_guard<std::mutex> lock(service_mutex_);
+  if (active_service_ != svc) {
     LOG(WARNING) << "UnregisterService: the given service is not the active "
                     "service of this database.";
+    return;
   }
+  active_service_ = nullptr;
 }
 
 void NeugDB::RemoveConnection(std::shared_ptr<Connection> conn) {