Muduolearn

.clang-format

@@ -0,0 +1,137 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveMacros: false
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: MultiLine
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+    SortPriority:    0
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+    SortPriority:    0
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentCaseLabels: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+Standard:        Latest
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        8
+UseCRLF:         false
+UseTab:          Never
+...
+

.gitignore

@@ -1,3 +1,6 @@
 *.swp
 bazel-*
 compile_commands.json
+build
+.vscode
+tmp

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.6)
+cmake_minimum_required(VERSION 3.0)
 
 project(muduo C CXX)
 

muduo/base/AsyncLogging.cc

@@ -11,52 +11,36 @@
 
 using namespace muduo;
 
-AsyncLogging::AsyncLogging(const string& basename,
-                           off_t rollSize,
+AsyncLogging::AsyncLogging(const string &basename, off_t rollSize,
                            int flushInterval)
-  : flushInterval_(flushInterval),
-    running_(false),
-    basename_(basename),
-    rollSize_(rollSize),
-    thread_(std::bind(&AsyncLogging::threadFunc, this), "Logging"),
-    latch_(1),
-    mutex_(),
-    cond_(mutex_),
-    currentBuffer_(new Buffer),
-    nextBuffer_(new Buffer),
-    buffers_()
-{
+    : flushInterval_(flushInterval), running_(false), basename_(basename),
+      rollSize_(rollSize),
+      thread_(std::bind(&AsyncLogging::threadFunc, this), "Logging"), latch_(1),
+      mutex_(), cond_(mutex_), currentBuffer_(new Buffer),
+      nextBuffer_(new Buffer), buffers_() {
   currentBuffer_->bzero();
   nextBuffer_->bzero();
   buffers_.reserve(16);
 }
 
-void AsyncLogging::append(const char* logline, int len)
-{
+void AsyncLogging::append(const char *logline, int len) {
   muduo::MutexLockGuard lock(mutex_);
-  if (currentBuffer_->avail() > len)
-  {
+  if (currentBuffer_->avail() > len) {
     currentBuffer_->append(logline, len);
-  }
-  else
-  {
+  } else {
     buffers_.push_back(std::move(currentBuffer_));
 
-    if (nextBuffer_)
-    {
+    if (nextBuffer_) {
       currentBuffer_ = std::move(nextBuffer_);
-    }
-    else
-    {
+    } else {
       currentBuffer_.reset(new Buffer); // Rarely happens
     }
     currentBuffer_->append(logline, len);
     cond_.notify();
   }
 }
 
-void AsyncLogging::threadFunc()
-{
+void AsyncLogging::threadFunc() {
   assert(running_ == true);
   latch_.countDown();
   LogFile output(basename_, rollSize_, false);
@@ -66,62 +50,56 @@ void AsyncLogging::threadFunc()
   newBuffer2->bzero();
   BufferVector buffersToWrite;
   buffersToWrite.reserve(16);
-  while (running_)
-  {
+  while (running_) {
     assert(newBuffer1 && newBuffer1->length() == 0);
     assert(newBuffer2 && newBuffer2->length() == 0);
     assert(buffersToWrite.empty());
 
     {
       muduo::MutexLockGuard lock(mutex_);
-      if (buffers_.empty())  // unusual usage!
+      if (buffers_.empty()) // unusual usage!
       {
         cond_.waitForSeconds(flushInterval_);
       }
       buffers_.push_back(std::move(currentBuffer_));
       currentBuffer_ = std::move(newBuffer1);
       buffersToWrite.swap(buffers_);
-      if (!nextBuffer_)
-      {
+      if (!nextBuffer_) {
         nextBuffer_ = std::move(newBuffer2);
       }
     }
 
     assert(!buffersToWrite.empty());
 
-    if (buffersToWrite.size() > 25)
-    {
+    if (buffersToWrite.size() > 25) {
       char buf[256];
-      snprintf(buf, sizeof buf, "Dropped log messages at %s, %zd larger buffers\n",
+      snprintf(buf, sizeof buf,
+               "Dropped log messages at %s, %zd larger buffers\n",
                Timestamp::now().toFormattedString().c_str(),
-               buffersToWrite.size()-2);
+               buffersToWrite.size() - 2);
       fputs(buf, stderr);
       output.append(buf, static_cast<int>(strlen(buf)));
-      buffersToWrite.erase(buffersToWrite.begin()+2, buffersToWrite.end());
+      buffersToWrite.erase(buffersToWrite.begin() + 2, buffersToWrite.end());
     }
 
-    for (const auto& buffer : buffersToWrite)
-    {
+    for (const auto &buffer : buffersToWrite) {
       // FIXME: use unbuffered stdio FILE ? or use ::writev ?
       output.append(buffer->data(), buffer->length());
     }
 
-    if (buffersToWrite.size() > 2)
-    {
+    if (buffersToWrite.size() > 2) {
       // drop non-bzero-ed buffers, avoid trashing
       buffersToWrite.resize(2);
     }
 
-    if (!newBuffer1)
-    {
+    if (!newBuffer1) {
       assert(!buffersToWrite.empty());
       newBuffer1 = std::move(buffersToWrite.back());
       buffersToWrite.pop_back();
       newBuffer1->reset();
     }
 
-    if (!newBuffer2)
-    {
+    if (!newBuffer2) {
       assert(!buffersToWrite.empty());
       newBuffer2 = std::move(buffersToWrite.back());
       buffersToWrite.pop_back();
@@ -133,4 +111,3 @@ void AsyncLogging::threadFunc()
   }
   output.flush();
 }
-

muduo/base/AsyncLogging.h

@@ -9,50 +9,40 @@
 #include "muduo/base/BlockingQueue.h"
 #include "muduo/base/BoundedBlockingQueue.h"
 #include "muduo/base/CountDownLatch.h"
+#include "muduo/base/LogStream.h"
 #include "muduo/base/Mutex.h"
 #include "muduo/base/Thread.h"
-#include "muduo/base/LogStream.h"
 
 #include <atomic>
 #include <vector>
 
-namespace muduo
-{
+namespace muduo {
 
-class AsyncLogging : noncopyable
-{
- public:
+class AsyncLogging : noncopyable {
+public:
+  AsyncLogging(const string &basename, off_t rollSize, int flushInterval = 3);
 
-  AsyncLogging(const string& basename,
-               off_t rollSize,
-               int flushInterval = 3);
-
-  ~AsyncLogging()
-  {
-    if (running_)
-    {
+  ~AsyncLogging() {
+    if (running_) {
       stop();
     }
   }
 
-  void append(const char* logline, int len);
+  void append(const char *logline, int len);
 
-  void start()
-  {
+  void start() {
     running_ = true;
     thread_.start();
     latch_.wait();
   }
 
-  void stop() NO_THREAD_SAFETY_ANALYSIS
-  {
+  void stop() NO_THREAD_SAFETY_ANALYSIS {
     running_ = false;
     cond_.notify();
     thread_.join();
   }
 
- private:
-
+private:
   void threadFunc();
 
   typedef muduo::detail::FixedBuffer<muduo::detail::kLargeBuffer> Buffer;
@@ -72,6 +62,6 @@ class AsyncLogging : noncopyable
   BufferVector buffers_ GUARDED_BY(mutex_);
 };
 
-}  // namespace muduo
+} // namespace muduo
 
-#endif  // MUDUO_BASE_ASYNCLOGGING_H
+#endif // MUDUO_BASE_ASYNCLOGGING_H