refactor(db): Env.cpp Env.h

Former-commit-id: 5d774124457d4136dc8c0e4469ac6950c424de09

cpp/src/db/DBImpl.cpp

@@ -219,7 +219,7 @@ void DBImpl<EngineT>::try_schedule_compaction() {
     if (!_bg_error.ok()) return;
 
     _bg_compaction_scheduled = true;
-    _env->schedule(&DBImpl<EngineT>::BGWork, this);
+    _env->Schedule(&DBImpl<EngineT>::BGWork, this);
 }
 
 template<typename EngineT>

cpp/src/db/Env.cpp

@@ -13,66 +13,66 @@ namespace vecwise {
 namespace engine {
 
 Env::Env()
-    : _bg_work_started(false),
-      _shutting_down(false) {
+    : bg_work_started_(false),
+      shutting_down_(false) {
 }
 
-void Env::schedule(void (*function_)(void* arg_), void* arg_) {
-    std::unique_lock<std::mutex> lock(_bg_work_mutex);
-    if (_shutting_down) return;
+void Env::Schedule(void (*function)(void* arg), void* arg) {
+    std::unique_lock<std::mutex> lock(bg_work_mutex_);
+    if (shutting_down_) return;
 
-    if (!_bg_work_started) {
-        _bg_work_started = true;
+    if (!bg_work_started_) {
+        bg_work_started_ = true;
         std::thread bg_thread(Env::BackgroundThreadEntryPoint, this);
         bg_thread.detach();
     }
 
-    if (_bg_work_queue.empty()) {
-        _bg_work_cv.notify_one();
+    if (bg_work_queue_.empty()) {
+        bg_work_cv_.notify_one();
     }
 
-    _bg_work_queue.emplace(function_, arg_);
+    bg_work_queue_.emplace(function, arg);
 }
 
-void Env::backgroud_thread_main() {
-    while (!_shutting_down) {
-        std::unique_lock<std::mutex> lock(_bg_work_mutex);
-        while (_bg_work_queue.empty() && !_shutting_down) {
-            _bg_work_cv.wait(lock);
+void Env::BackgroundThreadMain() {
+    while (!shutting_down_) {
+        std::unique_lock<std::mutex> lock(bg_work_mutex_);
+        while (bg_work_queue_.empty() && !shutting_down_) {
+            bg_work_cv_.wait(lock);
         }
 
-        if (_shutting_down) break;
+        if (shutting_down_) break;
 
-        assert(!_bg_work_queue.empty());
-        auto bg_function = _bg_work_queue.front()._function;
-        void* bg_arg = _bg_work_queue.front()._arg;
-        _bg_work_queue.pop();
+        assert(!bg_work_queue_.empty());
+        auto bg_function = bg_work_queue_.front().function_;
+        void* bg_arg = bg_work_queue_.front().arg_;
+        bg_work_queue_.pop();
 
         lock.unlock();
         bg_function(bg_arg);
     }
 
-    std::unique_lock<std::mutex> lock(_bg_work_mutex);
-    _bg_work_started = false;
-    _bg_work_cv.notify_all();
+    std::unique_lock<std::mutex> lock(bg_work_mutex_);
+    bg_work_started_ = false;
+    bg_work_cv_.notify_all();
 }
 
 void Env::Stop() {
     {
-        std::unique_lock<std::mutex> lock(_bg_work_mutex);
-        if (_shutting_down || !_bg_work_started) return;
+        std::unique_lock<std::mutex> lock(bg_work_mutex_);
+        if (shutting_down_ || !bg_work_started_) return;
     }
-    _shutting_down = true;
+    shutting_down_ = true;
     {
-        std::unique_lock<std::mutex> lock(_bg_work_mutex);
-        if (_bg_work_queue.empty()) {
-            _bg_work_cv.notify_one();
+        std::unique_lock<std::mutex> lock(bg_work_mutex_);
+        if (bg_work_queue_.empty()) {
+            bg_work_cv_.notify_one();
         }
-        while (_bg_work_started) {
-            _bg_work_cv.wait(lock);
+        while (bg_work_started_) {
+            bg_work_cv_.wait(lock);
         }
     }
-    _shutting_down = false;
+    shutting_down_ = false;
 }
 
 Env::~Env() {}

cpp/src/db/Env.h

@@ -22,7 +22,7 @@ public:
     Env(const Env&) = delete;
     Env& operator=(const Env&) = delete;
 
-    void schedule(void (*function_)(void* arg_), void* arg_);
+    void Schedule(void (*function)(void* arg), void* arg);
 
     virtual void Stop();
 
@@ -31,25 +31,24 @@ public:
     static Env* Default();
 
 protected:
-    void backgroud_thread_main();
+    void BackgroundThreadMain();
     static void BackgroundThreadEntryPoint(Env* env) {
-        env->backgroud_thread_main();
+        env->BackgroundThreadMain();
     }
 
     struct BGWork {
-      explicit BGWork(void (*function_)(void*), void* arg_)
-          : _function(function_), _arg(arg_)  {}
+      explicit BGWork(void (*function)(void*), void* arg)
+          : function_(function), arg_(arg)  {}
 
-      void (* const _function)(void*);
-      void* const _arg;
+      void (* const function_)(void*);
+      void* const arg_;
     };
 
-    std::mutex _bg_work_mutex;
-    std::condition_variable _bg_work_cv;
-    std::queue<BGWork> _bg_work_queue;
-    bool _bg_work_started;
-    std::atomic<bool> _shutting_down;
-
+    std::mutex bg_work_mutex_;
+    std::condition_variable bg_work_cv_;
+    std::queue<BGWork> bg_work_queue_;
+    bool bg_work_started_;
+    std::atomic<bool> shutting_down_;
 }; // Env
 
 } // namespace engine