Modify some code styles (#59)

an-tao · web-flow · commit ac76712f2afe · 2019-11-20T23:36:34.000+08:00
diff --git a/trantor/net/inner/NormalResolver.cc b/trantor/net/inner/NormalResolver.cc
@@ -66,11 +66,11 @@ void NormalResolver::resolve(const std::string &hostname,
             if (ret == 0 && he != NULL)
 #else
             /// Multi-threads safety
-            static std::mutex _mutex;
+            static std::mutex mutex_;
             struct hostent *he = NULL;
             struct hostent hent;
             {
-                std::lock_guard<std::mutex> guard(_mutex);
+                std::lock_guard<std::mutex> guard(mutex_);
                 auto result = gethostbyname(hostname.c_str());
                 if (result != NULL)
                 {
diff --git a/trantor/net/inner/NormalResolver.h b/trantor/net/inner/NormalResolver.h
@@ -14,7 +14,7 @@
 
 namespace trantor
 {
-constexpr size_t kResolveBufferLength {16 * 1024};
+constexpr size_t kResolveBufferLength{16 * 1024};
 class NormalResolver : public Resolver,
                        public NonCopyable,
                        public std::enable_shared_from_this<NormalResolver>
diff --git a/trantor/net/inner/TimerQueue.cc b/trantor/net/inner/TimerQueue.cc
@@ -77,13 +77,13 @@ void readTimerfd(int timerfd, const Date &now)
 
 void TimerQueue::handleRead()
 {
-    _loop->assertInLoopThread();
+    loop_->assertInLoopThread();
     const Date now = Date::date();
-    readTimerfd(_timerfd, now);
+    readTimerfd(timerfd_, now);
 
     std::vector<TimerPtr> expired = getExpired(now);
 
-    _callingExpiredTimers = true;
+    callingExpiredTimers_ = true;
     // cancelingTimers_.clear();
     // safe to callback outside critical section
     for (auto const &timerPtr : expired)
@@ -93,7 +93,7 @@ void TimerQueue::handleRead()
             timerPtr->run();
         }
     }
-    _callingExpiredTimers = false;
+    callingExpiredTimers_ = false;
 
     reset(expired, now);
 }
@@ -110,12 +110,12 @@ int howMuchTimeFromNow(const Date &when)
 }
 void TimerQueue::processTimers()
 {
-    _loop->assertInLoopThread();
+    loop_->assertInLoopThread();
     const Date now = Date::date();
 
     std::vector<TimerPtr> expired = getExpired(now);
 
-    _callingExpiredTimers = true;
+    callingExpiredTimers_ = true;
     // cancelingTimers_.clear();
     // safe to callback outside critical section
     for (auto const &timerPtr : expired)
@@ -125,55 +125,55 @@ void TimerQueue::processTimers()
             timerPtr->run();
         }
     }
-    _callingExpiredTimers = false;
+    callingExpiredTimers_ = false;
 
     reset(expired, now);
 }
 #endif
 ///////////////////////////////////////
 TimerQueue::TimerQueue(EventLoop *loop)
-    : _loop(loop),
+    : loop_(loop),
 #ifdef __linux__
-      _timerfd(createTimerfd()),
-      _timerfdChannelPtr(new Channel(loop, _timerfd)),
+      timerfd_(createTimerfd()),
+      timerfdChannelPtr_(new Channel(loop, timerfd_)),
 #endif
-      _timers(),
-      _callingExpiredTimers(false)
+      timers_(),
+      callingExpiredTimers_(false)
 {
 #ifdef __linux__
-    _timerfdChannelPtr->setReadCallback(
+    timerfdChannelPtr_->setReadCallback(
         std::bind(&TimerQueue::handleRead, this));
     // we are always reading the timerfd, we disarm it with timerfd_settime.
-    _timerfdChannelPtr->enableReading();
+    timerfdChannelPtr_->enableReading();
 #endif
 }
 #ifdef __linux__
 void TimerQueue::reset()
 {
-    _loop->runInLoop([this]() {
-        _timerfdChannelPtr->disableAll();
-        _timerfdChannelPtr->remove();
-        close(_timerfd);
-        _timerfd = createTimerfd();
-        _timerfdChannelPtr = std::make_shared<Channel>(_loop, _timerfd);
-        _timerfdChannelPtr->setReadCallback(
+    loop_->runInLoop([this]() {
+        timerfdChannelPtr_->disableAll();
+        timerfdChannelPtr_->remove();
+        close(timerfd_);
+        timerfd_ = createTimerfd();
+        timerfdChannelPtr_ = std::make_shared<Channel>(loop_, timerfd_);
+        timerfdChannelPtr_->setReadCallback(
             std::bind(&TimerQueue::handleRead, this));
         // we are always reading the timerfd, we disarm it with timerfd_settime.
-        _timerfdChannelPtr->enableReading();
-        if (!_timers.empty())
+        timerfdChannelPtr_->enableReading();
+        if (!timers_.empty())
         {
-            const Date nextExpire = _timers.top()->when();
-            resetTimerfd(_timerfd, nextExpire);
+            const Date nextExpire = timers_.top()->when();
+            resetTimerfd(timerfd_, nextExpire);
         }
     });
 }
 #endif
 TimerQueue::~TimerQueue()
 {
 #ifdef __linux__
-    auto chlPtr = _timerfdChannelPtr;
-    auto fd = _timerfd;
-    _loop->runInLoop([chlPtr, fd]() {
+    auto chlPtr = timerfdChannelPtr_;
+    auto fd = timerfd_;
+    loop_->runInLoop([chlPtr, fd]() {
         chlPtr->disableAll();
         chlPtr->remove();
         ::close(fd);
@@ -188,7 +188,7 @@ TimerId TimerQueue::addTimer(const TimerCallback &cb,
     std::shared_ptr<Timer> timerPtr =
         std::make_shared<Timer>(cb, when, interval);
 
-    _loop->runInLoop([=]() { addTimerInLoop(timerPtr); });
+    loop_->runInLoop([=]() { addTimerInLoop(timerPtr); });
     return timerPtr->id();
 }
 TimerId TimerQueue::addTimer(TimerCallback &&cb,
@@ -198,64 +198,64 @@ TimerId TimerQueue::addTimer(TimerCallback &&cb,
     std::shared_ptr<Timer> timerPtr =
         std::make_shared<Timer>(std::move(cb), when, interval);
 
-    _loop->runInLoop([=]() { addTimerInLoop(timerPtr); });
+    loop_->runInLoop([=]() { addTimerInLoop(timerPtr); });
     return timerPtr->id();
 }
 void TimerQueue::addTimerInLoop(const TimerPtr &timer)
 {
-    _loop->assertInLoopThread();
+    loop_->assertInLoopThread();
     timerIdSet_.insert(timer->id());
     if (insert(timer))
     {
 // the earliest timer changed
 #ifdef __linux__
-        resetTimerfd(_timerfd, timer->when());
+        resetTimerfd(timerfd_, timer->when());
 #endif
     }
 }
 
 void TimerQueue::invalidateTimer(TimerId id)
 {
-    _loop->runInLoop([=]() { timerIdSet_.erase(id); });
+    loop_->runInLoop([=]() { timerIdSet_.erase(id); });
 }
 
 bool TimerQueue::insert(const TimerPtr &timerPtr)
 {
-    _loop->assertInLoopThread();
+    loop_->assertInLoopThread();
     bool earliestChanged = false;
-    if (_timers.size() == 0 || *timerPtr < *_timers.top())
+    if (timers_.size() == 0 || *timerPtr < *timers_.top())
     {
         earliestChanged = true;
     }
-    _timers.push(timerPtr);
+    timers_.push(timerPtr);
     // std::cout<<"after push new
     // timer:"<<timerPtr->when().microSecondsSinceEpoch()/1000000<<std::endl;
     return earliestChanged;
 }
 #ifndef __linux__
 int TimerQueue::getTimeout() const
 {
-    _loop->assertInLoopThread();
-    if (_timers.empty())
+    loop_->assertInLoopThread();
+    if (timers_.empty())
     {
         return 10000;
     }
     else
     {
-        return howMuchTimeFromNow(_timers.top()->when());
+        return howMuchTimeFromNow(timers_.top()->when());
     }
 }
 #endif
 
 std::vector<TimerPtr> TimerQueue::getExpired(const Date &now)
 {
     std::vector<TimerPtr> expired;
-    while (!_timers.empty())
+    while (!timers_.empty())
     {
-        if (_timers.top()->when() < now)
+        if (timers_.top()->when() < now)
         {
-            expired.push_back(_timers.top());
-            _timers.pop();
+            expired.push_back(timers_.top());
+            timers_.pop();
         }
         else
             break;
@@ -264,7 +264,7 @@ std::vector<TimerPtr> TimerQueue::getExpired(const Date &now)
 }
 void TimerQueue::reset(const std::vector<TimerPtr> &expired, const Date &now)
 {
-    _loop->assertInLoopThread();
+    loop_->assertInLoopThread();
     for (auto const &timerPtr : expired)
     {
         if (timerPtr->isRepeat() &&
@@ -275,10 +275,10 @@ void TimerQueue::reset(const std::vector<TimerPtr> &expired, const Date &now)
         }
     }
 #ifdef __linux__
-    if (!_timers.empty())
+    if (!timers_.empty())
     {
-        const Date nextExpire = _timers.top()->when();
-        resetTimerfd(_timerfd, nextExpire);
+        const Date nextExpire = timers_.top()->when();
+        resetTimerfd(timerfd_, nextExpire);
     }
 #endif
 }
diff --git a/trantor/net/inner/TimerQueue.h b/trantor/net/inner/TimerQueue.h
@@ -54,15 +54,15 @@ class TimerQueue : NonCopyable
     void processTimers();
 #endif
   protected:
-    EventLoop *_loop;
+    EventLoop *loop_;
 #ifdef __linux__
-    int _timerfd;
-    std::shared_ptr<Channel> _timerfdChannelPtr;
+    int timerfd_;
+    std::shared_ptr<Channel> timerfdChannelPtr_;
     void handleRead();
 #endif
-    std::priority_queue<TimerPtr, std::vector<TimerPtr>, comp> _timers;
+    std::priority_queue<TimerPtr, std::vector<TimerPtr>, comp> timers_;
 
-    bool _callingExpiredTimers;
+    bool callingExpiredTimers_;
     bool insert(const TimerPtr &timePtr);
     std::vector<TimerPtr> getExpired();
     void reset(const std::vector<TimerPtr> &expired, const Date &now);
diff --git a/trantor/net/ssl/SSLConnection.cc b/trantor/net/ssl/SSLConnection.cc
@@ -44,46 +44,46 @@ class SSLContext
   public:
     SSLContext()
     {
-        _ctxPtr = SSL_CTX_new(SSLv23_method());
-        // SSL_CTX_set_mode(_ctxPtr, SSL_MODE_ENABLE_PARTIAL_WRITE);
+        ctxPtr_ = SSL_CTX_new(SSLv23_method());
+        // SSL_CTX_set_mode(ctxPtr_, SSL_MODE_ENABLE_PARTIAL_WRITE);
     }
     ~SSLContext()
     {
-        if (_ctxPtr)
+        if (ctxPtr_)
         {
-            SSL_CTX_free(_ctxPtr);
+            SSL_CTX_free(ctxPtr_);
         }
     }
 
     SSL_CTX *get()
     {
-        return _ctxPtr;
+        return ctxPtr_;
     }
 
   private:
-    SSL_CTX *_ctxPtr;
+    SSL_CTX *ctxPtr_;
 };
 class SSLConn
 {
   public:
     explicit SSLConn(SSL_CTX *ctx)
     {
-        _SSL = SSL_new(ctx);
+        SSL_ = SSL_new(ctx);
     }
     ~SSLConn()
     {
-        if (_SSL)
+        if (SSL_)
         {
-            SSL_free(_SSL);
+            SSL_free(SSL_);
         }
     }
     SSL *get()
     {
-        return _SSL;
+        return SSL_;
     }
 
   private:
-    SSL *_SSL;
+    SSL *SSL_;
 };
 
 std::shared_ptr<SSLContext> newSSLContext()
diff --git a/trantor/utils/MsgBuffer.cc b/trantor/utils/MsgBuffer.cc
@@ -23,7 +23,7 @@
 using namespace trantor;
 namespace trantor
 {
-static constexpr size_t kBufferOffset {8};
+static constexpr size_t kBufferOffset{8};
 }
 
 MsgBuffer::MsgBuffer(size_t len)

Original file line number	Diff line number	Diff line change
`@@ -66,11 +66,11 @@ void NormalResolver::resolve(const std::string &hostname,`
`66`	`66`	`if (ret == 0 && he != NULL)`
`67`	`67`	`#else`
`68`	`68`	`/// Multi-threads safety`
`69`		`- static std::mutex _mutex;`
	`69`	`+ static std::mutex mutex_;`
`70`	`70`	`struct hostent *he = NULL;`
`71`	`71`	`struct hostent hent;`
`72`	`72`	`{`
`73`		`- std::lock_guard<std::mutex> guard(_mutex);`
	`73`	`+ std::lock_guard<std::mutex> guard(mutex_);`
`74`	`74`	`auto result = gethostbyname(hostname.c_str());`
`75`	`75`	`if (result != NULL)`
`76`	`76`	`{`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@`
`14`	`14`
`15`	`15`	`namespace trantor`
`16`	`16`	`{`
`17`		`-constexpr size_t kResolveBufferLength {16 * 1024};`
	`17`	`+constexpr size_t kResolveBufferLength{16 * 1024};`
`18`	`18`	`class NormalResolver : public Resolver,`
`19`	`19`	`public NonCopyable,`
`20`	`20`	`public std::enable_shared_from_this<NormalResolver>`
Original file line number	Diff line number	Diff line change
`@@ -77,13 +77,13 @@ void readTimerfd(int timerfd, const Date &now)`
`77`	`77`
`78`	`78`	`void TimerQueue::handleRead()`
`79`	`79`	`{`
`80`		`- _loop->assertInLoopThread();`
	`80`	`+ loop_->assertInLoopThread();`
`81`	`81`	`const Date now = Date::date();`
`82`		`- readTimerfd(_timerfd, now);`
	`82`	`+ readTimerfd(timerfd_, now);`
`83`	`83`
`84`	`84`	`std::vector<TimerPtr> expired = getExpired(now);`
`85`	`85`
`86`		`- _callingExpiredTimers = true;`
	`86`	`+ callingExpiredTimers_ = true;`
`87`	`87`	`// cancelingTimers_.clear();`
`88`	`88`	`// safe to callback outside critical section`
`89`	`89`	`for (auto const &timerPtr : expired)`
`@@ -93,7 +93,7 @@ void TimerQueue::handleRead()`
`93`	`93`	`timerPtr->run();`
`94`	`94`	`}`
`95`	`95`	`}`
`96`		`- _callingExpiredTimers = false;`
	`96`	`+ callingExpiredTimers_ = false;`
`97`	`97`
`98`	`98`	`reset(expired, now);`
`99`	`99`	`}`
`@@ -110,12 +110,12 @@ int howMuchTimeFromNow(const Date &when)`
`110`	`110`	`}`
`111`	`111`	`void TimerQueue::processTimers()`
`112`	`112`	`{`
`113`		`- _loop->assertInLoopThread();`
	`113`	`+ loop_->assertInLoopThread();`
`114`	`114`	`const Date now = Date::date();`
`115`	`115`
`116`	`116`	`std::vector<TimerPtr> expired = getExpired(now);`
`117`	`117`
`118`		`- _callingExpiredTimers = true;`
	`118`	`+ callingExpiredTimers_ = true;`
`119`	`119`	`// cancelingTimers_.clear();`
`120`	`120`	`// safe to callback outside critical section`
`121`	`121`	`for (auto const &timerPtr : expired)`
`@@ -125,55 +125,55 @@ void TimerQueue::processTimers()`
`125`	`125`	`timerPtr->run();`
`126`	`126`	`}`
`127`	`127`	`}`
`128`		`- _callingExpiredTimers = false;`
	`128`	`+ callingExpiredTimers_ = false;`
`129`	`129`
`130`	`130`	`reset(expired, now);`
`131`	`131`	`}`
`132`	`132`	`#endif`
`133`	`133`	`///////////////////////////////////////`
`134`	`134`	`TimerQueue::TimerQueue(EventLoop *loop)`
`135`		`- : _loop(loop),`
	`135`	`+ : loop_(loop),`
`136`	`136`	`#ifdef __linux__`
`137`		`- _timerfd(createTimerfd()),`
`138`		`- _timerfdChannelPtr(new Channel(loop, _timerfd)),`
	`137`	`+ timerfd_(createTimerfd()),`
	`138`	`+ timerfdChannelPtr_(new Channel(loop, timerfd_)),`
`139`	`139`	`#endif`
`140`		`- _timers(),`
`141`		`- _callingExpiredTimers(false)`
	`140`	`+ timers_(),`
	`141`	`+ callingExpiredTimers_(false)`
`142`	`142`	`{`
`143`	`143`	`#ifdef __linux__`
`144`		`- _timerfdChannelPtr->setReadCallback(`
	`144`	`+ timerfdChannelPtr_->setReadCallback(`
`145`	`145`	`std::bind(&TimerQueue::handleRead, this));`
`146`	`146`	`// we are always reading the timerfd, we disarm it with timerfd_settime.`
`147`		`- _timerfdChannelPtr->enableReading();`
	`147`	`+ timerfdChannelPtr_->enableReading();`
`148`	`148`	`#endif`
`149`	`149`	`}`
`150`	`150`	`#ifdef __linux__`
`151`	`151`	`void TimerQueue::reset()`
`152`	`152`	`{`
`153`		`- _loop->runInLoop([this]() {`
`154`		`- _timerfdChannelPtr->disableAll();`
`155`		`- _timerfdChannelPtr->remove();`
`156`		`- close(_timerfd);`
`157`		`- _timerfd = createTimerfd();`
`158`		`- _timerfdChannelPtr = std::make_shared<Channel>(_loop, _timerfd);`
`159`		`- _timerfdChannelPtr->setReadCallback(`
	`153`	`+ loop_->runInLoop([this]() {`
	`154`	`+ timerfdChannelPtr_->disableAll();`
	`155`	`+ timerfdChannelPtr_->remove();`
	`156`	`+ close(timerfd_);`
	`157`	`+ timerfd_ = createTimerfd();`
	`158`	`+ timerfdChannelPtr_ = std::make_shared<Channel>(loop_, timerfd_);`
	`159`	`+ timerfdChannelPtr_->setReadCallback(`
`160`	`160`	`std::bind(&TimerQueue::handleRead, this));`
`161`	`161`	`// we are always reading the timerfd, we disarm it with timerfd_settime.`
`162`		`- _timerfdChannelPtr->enableReading();`
`163`		`- if (!_timers.empty())`
	`162`	`+ timerfdChannelPtr_->enableReading();`
	`163`	`+ if (!timers_.empty())`
`164`	`164`	`{`
`165`		`- const Date nextExpire = _timers.top()->when();`
`166`		`- resetTimerfd(_timerfd, nextExpire);`
	`165`	`+ const Date nextExpire = timers_.top()->when();`
	`166`	`+ resetTimerfd(timerfd_, nextExpire);`
`167`	`167`	`}`
`168`	`168`	`});`
`169`	`169`	`}`
`170`	`170`	`#endif`
`171`	`171`	`TimerQueue::~TimerQueue()`
`172`	`172`	`{`
`173`	`173`	`#ifdef __linux__`
`174`		`- auto chlPtr = _timerfdChannelPtr;`
`175`		`- auto fd = _timerfd;`
`176`		`- _loop->runInLoop([chlPtr, fd]() {`
	`174`	`+ auto chlPtr = timerfdChannelPtr_;`
	`175`	`+ auto fd = timerfd_;`
	`176`	`+ loop_->runInLoop([chlPtr, fd]() {`
`177`	`177`	`chlPtr->disableAll();`
`178`	`178`	`chlPtr->remove();`
`179`	`179`	`::close(fd);`
`@@ -188,7 +188,7 @@ TimerId TimerQueue::addTimer(const TimerCallback &cb,`
`188`	`188`	`std::shared_ptr<Timer> timerPtr =`
`189`	`189`	`std::make_shared<Timer>(cb, when, interval);`
`190`	`190`
`191`		`- _loop->runInLoop([=]() { addTimerInLoop(timerPtr); });`
	`191`	`+ loop_->runInLoop([=]() { addTimerInLoop(timerPtr); });`
`192`	`192`	`return timerPtr->id();`
`193`	`193`	`}`
`194`	`194`	`TimerId TimerQueue::addTimer(TimerCallback &&cb,`
`@@ -198,64 +198,64 @@ TimerId TimerQueue::addTimer(TimerCallback &&cb,`
`198`	`198`	`std::shared_ptr<Timer> timerPtr =`
`199`	`199`	`std::make_shared<Timer>(std::move(cb), when, interval);`
`200`	`200`
`201`		`- _loop->runInLoop([=]() { addTimerInLoop(timerPtr); });`
	`201`	`+ loop_->runInLoop([=]() { addTimerInLoop(timerPtr); });`
`202`	`202`	`return timerPtr->id();`
`203`	`203`	`}`
`204`	`204`	`void TimerQueue::addTimerInLoop(const TimerPtr &timer)`
`205`	`205`	`{`
`206`		`- _loop->assertInLoopThread();`
	`206`	`+ loop_->assertInLoopThread();`
`207`	`207`	`timerIdSet_.insert(timer->id());`
`208`	`208`	`if (insert(timer))`
`209`	`209`	`{`
`210`	`210`	`// the earliest timer changed`
`211`	`211`	`#ifdef __linux__`
`212`		`- resetTimerfd(_timerfd, timer->when());`
	`212`	`+ resetTimerfd(timerfd_, timer->when());`
`213`	`213`	`#endif`
`214`	`214`	`}`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`void TimerQueue::invalidateTimer(TimerId id)`
`218`	`218`	`{`
`219`		`- _loop->runInLoop([=]() { timerIdSet_.erase(id); });`
	`219`	`+ loop_->runInLoop([=]() { timerIdSet_.erase(id); });`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`bool TimerQueue::insert(const TimerPtr &timerPtr)`
`223`	`223`	`{`
`224`		`- _loop->assertInLoopThread();`
	`224`	`+ loop_->assertInLoopThread();`
`225`	`225`	`bool earliestChanged = false;`
`226`		`- if (_timers.size() == 0 \|\| timerPtr < _timers.top())`
	`226`	`+ if (timers_.size() == 0 \|\| timerPtr < timers_.top())`
`227`	`227`	`{`
`228`	`228`	`earliestChanged = true;`
`229`	`229`	`}`
`230`		`- _timers.push(timerPtr);`
	`230`	`+ timers_.push(timerPtr);`
`231`	`231`	`// std::cout<<"after push new`
`232`	`232`	`// timer:"<<timerPtr->when().microSecondsSinceEpoch()/1000000<<std::endl;`
`233`	`233`	`return earliestChanged;`
`234`	`234`	`}`
`235`	`235`	`#ifndef __linux__`
`236`	`236`	`int TimerQueue::getTimeout() const`
`237`	`237`	`{`
`238`		`- _loop->assertInLoopThread();`
`239`		`- if (_timers.empty())`
	`238`	`+ loop_->assertInLoopThread();`
	`239`	`+ if (timers_.empty())`
`240`	`240`	`{`
`241`	`241`	`return 10000;`
`242`	`242`	`}`
`243`	`243`	`else`
`244`	`244`	`{`
`245`		`- return howMuchTimeFromNow(_timers.top()->when());`
	`245`	`+ return howMuchTimeFromNow(timers_.top()->when());`
`246`	`246`	`}`
`247`	`247`	`}`
`248`	`248`	`#endif`
`249`	`249`
`250`	`250`	`std::vector<TimerPtr> TimerQueue::getExpired(const Date &now)`
`251`	`251`	`{`
`252`	`252`	`std::vector<TimerPtr> expired;`
`253`		`- while (!_timers.empty())`
	`253`	`+ while (!timers_.empty())`
`254`	`254`	`{`
`255`		`- if (_timers.top()->when() < now)`
	`255`	`+ if (timers_.top()->when() < now)`
`256`	`256`	`{`
`257`		`- expired.push_back(_timers.top());`
`258`		`- _timers.pop();`
	`257`	`+ expired.push_back(timers_.top());`
	`258`	`+ timers_.pop();`
`259`	`259`	`}`
`260`	`260`	`else`
`261`	`261`	`break;`
`@@ -264,7 +264,7 @@ std::vector<TimerPtr> TimerQueue::getExpired(const Date &now)`
`264`	`264`	`}`
`265`	`265`	`void TimerQueue::reset(const std::vector<TimerPtr> &expired, const Date &now)`
`266`	`266`	`{`
`267`		`- _loop->assertInLoopThread();`
	`267`	`+ loop_->assertInLoopThread();`
`268`	`268`	`for (auto const &timerPtr : expired)`
`269`	`269`	`{`
`270`	`270`	`if (timerPtr->isRepeat() &&`
`@@ -275,10 +275,10 @@ void TimerQueue::reset(const std::vector<TimerPtr> &expired, const Date &now)`
`275`	`275`	`}`
`276`	`276`	`}`
`277`	`277`	`#ifdef __linux__`
`278`		`- if (!_timers.empty())`
	`278`	`+ if (!timers_.empty())`
`279`	`279`	`{`
`280`		`- const Date nextExpire = _timers.top()->when();`
`281`		`- resetTimerfd(_timerfd, nextExpire);`
	`280`	`+ const Date nextExpire = timers_.top()->when();`
	`281`	`+ resetTimerfd(timerfd_, nextExpire);`
`282`	`282`	`}`
`283`	`283`	`#endif`
`284`	`284`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,46 +44,46 @@ class SSLContext`
`44`	`44`	`public:`
`45`	`45`	`SSLContext()`
`46`	`46`	`{`
`47`		`- _ctxPtr = SSL_CTX_new(SSLv23_method());`
`48`		`- // SSL_CTX_set_mode(_ctxPtr, SSL_MODE_ENABLE_PARTIAL_WRITE);`
	`47`	`+ ctxPtr_ = SSL_CTX_new(SSLv23_method());`
	`48`	`+ // SSL_CTX_set_mode(ctxPtr_, SSL_MODE_ENABLE_PARTIAL_WRITE);`
`49`	`49`	`}`
`50`	`50`	`~SSLContext()`
`51`	`51`	`{`
`52`		`- if (_ctxPtr)`
	`52`	`+ if (ctxPtr_)`
`53`	`53`	`{`
`54`		`- SSL_CTX_free(_ctxPtr);`
	`54`	`+ SSL_CTX_free(ctxPtr_);`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`SSL_CTX *get()`
`59`	`59`	`{`
`60`		`- return _ctxPtr;`
	`60`	`+ return ctxPtr_;`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`private:`
`64`		`- SSL_CTX *_ctxPtr;`
	`64`	`+ SSL_CTX *ctxPtr_;`
`65`	`65`	`};`
`66`	`66`	`class SSLConn`
`67`	`67`	`{`
`68`	`68`	`public:`
`69`	`69`	`explicit SSLConn(SSL_CTX *ctx)`
`70`	`70`	`{`
`71`		`- _SSL = SSL_new(ctx);`
	`71`	`+ SSL_ = SSL_new(ctx);`
`72`	`72`	`}`
`73`	`73`	`~SSLConn()`
`74`	`74`	`{`
`75`		`- if (_SSL)`
	`75`	`+ if (SSL_)`
`76`	`76`	`{`
`77`		`- SSL_free(_SSL);`
	`77`	`+ SSL_free(SSL_);`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`	`SSL *get()`
`81`	`81`	`{`
`82`		`- return _SSL;`
	`82`	`+ return SSL_;`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`private:`
`86`		`- SSL *_SSL;`
	`86`	`+ SSL *SSL_;`
`87`	`87`	`};`
`88`	`88`
`89`	`89`	`std::shared_ptr<SSLContext> newSSLContext()`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@`
`23`	`23`	`using namespace trantor;`
`24`	`24`	`namespace trantor`
`25`	`25`	`{`
`26`		`-static constexpr size_t kBufferOffset {8};`
	`26`	`+static constexpr size_t kBufferOffset{8};`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`MsgBuffer::MsgBuffer(size_t len)`