FMT_NOEXCEPT -> noexcept; upgrade fmtlib to 9.1.0

fmtlog-inl.h

@@ -494,7 +494,7 @@ fmtlogDetailT<> fmtlogDetailWrapper<_>::impl;
 
 template<int _>
 void fmtlogT<_>::registerLogInfo(uint32_t& logId, FormatToFn fn, const char* location,
-                                 LogLevel level, fmt::string_view fmtString) FMT_NOEXCEPT {
+                                 LogLevel level, fmt::string_view fmtString) noexcept {
   auto& d = fmtlogDetailWrapper<>::impl;
   std::lock_guard<std::mutex> lock(d.logInfoMutex);
   if (logId) return;
@@ -522,7 +522,7 @@ void fmtlogT<_>::vformat_to(char* out, fmt::string_view fmt, fmt::format_args ar
 
 template<int _>
 typename fmtlogT<_>::SPSCVarQueueOPT::MsgHeader* fmtlogT<_>::allocMsg(uint32_t size,
-                                                                      bool q_full_cb) FMT_NOEXCEPT {
+                                                                      bool q_full_cb) noexcept {
   auto& d = fmtlogDetailWrapper<>::impl;
   if (threadBuffer == nullptr) preallocate();
   auto ret = threadBuffer->varq.alloc(size);
@@ -532,12 +532,12 @@ typename fmtlogT<_>::SPSCVarQueueOPT::MsgHeader* fmtlogT<_>::allocMsg(uint32_t s
 
 template<int _>
 typename fmtlogT<_>::SPSCVarQueueOPT::MsgHeader*
-fmtlogT<_>::SPSCVarQueueOPT::allocMsg(uint32_t size) FMT_NOEXCEPT {
+fmtlogT<_>::SPSCVarQueueOPT::allocMsg(uint32_t size) noexcept {
   return alloc(size);
 }
 
 template<int _>
-void fmtlogT<_>::preallocate() FMT_NOEXCEPT {
+void fmtlogT<_>::preallocate() noexcept {
   fmtlogDetailWrapper<>::impl.preallocate();
 }
 
@@ -572,22 +572,22 @@ void fmtlogT<_>::setLogFile(FILE* fp, bool manageFp) {
 }
 
 template<int _>
-void fmtlogT<_>::setFlushDelay(int64_t ns) FMT_NOEXCEPT {
+void fmtlogT<_>::setFlushDelay(int64_t ns) noexcept {
   fmtlogDetailWrapper<>::impl.flushDelay = ns;
 }
 
 template<int _>
-void fmtlogT<_>::flushOn(LogLevel flushLogLevel) FMT_NOEXCEPT {
+void fmtlogT<_>::flushOn(LogLevel flushLogLevel) noexcept {
   fmtlogDetailWrapper<>::impl.flushLogLevel = flushLogLevel;
 }
 
 template<int _>
-void fmtlogT<_>::setFlushBufSize(uint32_t bytes) FMT_NOEXCEPT {
+void fmtlogT<_>::setFlushBufSize(uint32_t bytes) noexcept {
   fmtlogDetailWrapper<>::impl.flushBufSize = bytes;
 }
 
 template<int _>
-void fmtlogT<_>::closeLogFile() FMT_NOEXCEPT {
+void fmtlogT<_>::closeLogFile() noexcept {
   fmtlogDetailWrapper<>::impl.closeLogFile();
 }
 
@@ -597,20 +597,20 @@ void fmtlogT<_>::poll(bool forceFlush) {
 }
 
 template<int _>
-void fmtlogT<_>::setThreadName(const char* name) FMT_NOEXCEPT {
+void fmtlogT<_>::setThreadName(const char* name) noexcept {
   preallocate();
   threadBuffer->nameSize = fmt::format_to_n(threadBuffer->name, sizeof(fmtlog::threadBuffer->name), "{}", name).size;
 }
 
 template<int _>
-void fmtlogT<_>::setLogCB(LogCBFn cb, LogLevel minCBLogLevel_) FMT_NOEXCEPT {
+void fmtlogT<_>::setLogCB(LogCBFn cb, LogLevel minCBLogLevel_) noexcept {
   auto& d = fmtlogDetailWrapper<>::impl;
   d.logCB = cb;
   d.minCBLogLevel = minCBLogLevel_;
 }
 
 template<int _>
-void fmtlogT<_>::setLogQFullCB(LogQFullCBFn cb, void* userData) FMT_NOEXCEPT {
+void fmtlogT<_>::setLogQFullCB(LogQFullCBFn cb, void* userData) noexcept {
   auto& d = fmtlogDetailWrapper<>::impl;
   d.logQFullCB = cb;
   d.logQFullCBArg = userData;
@@ -622,12 +622,12 @@ void fmtlogT<_>::setHeaderPattern(const char* pattern) {
 }
 
 template<int _>
-void fmtlogT<_>::startPollingThread(int64_t pollInterval) FMT_NOEXCEPT {
+void fmtlogT<_>::startPollingThread(int64_t pollInterval) noexcept {
   fmtlogDetailWrapper<>::impl.startPollingThread(pollInterval);
 }
 
 template<int _>
-void fmtlogT<_>::stopPollingThread() FMT_NOEXCEPT {
+void fmtlogT<_>::stopPollingThread() noexcept {
   fmtlogDetailWrapper<>::impl.stopPollingThread();
 }
 

fmtlog.h

@@ -98,7 +98,7 @@ class fmtlogT
   };
 
   // Preallocate thread queue for current thread
-  static void preallocate() FMT_NOEXCEPT;
+  static void preallocate() noexcept;
 
   // Set the file for logging
   static void setLogFile(const char* filename, bool truncate = false);
@@ -114,13 +114,13 @@ class fmtlogT
 
   // Set flush delay in nanosecond
   // If there's msg older than ns in the buffer, flush will be triggered
-  static void setFlushDelay(int64_t ns) FMT_NOEXCEPT;
+  static void setFlushDelay(int64_t ns) noexcept;
 
   // If current msg has level >= flushLogLevel, flush will be triggered
-  static void flushOn(LogLevel flushLogLevel) FMT_NOEXCEPT;
+  static void flushOn(LogLevel flushLogLevel) noexcept;
 
   // If file buffer has more than specified bytes, flush will be triggered
-  static void setFlushBufSize(uint32_t bytes) FMT_NOEXCEPT;
+  static void setFlushBufSize(uint32_t bytes) noexcept;
 
   // callback signature user can register
   // ns: nanosecond timestamp
@@ -136,36 +136,36 @@ class fmtlogT
                           size_t logFilePos);
 
   // Set a callback function for all log msgs with a mininum log level
-  static void setLogCB(LogCBFn cb, LogLevel minCBLogLevel) FMT_NOEXCEPT;
+  static void setLogCB(LogCBFn cb, LogLevel minCBLogLevel) noexcept;
 
   typedef void (*LogQFullCBFn)(void* userData);
-  static void setLogQFullCB(LogQFullCBFn cb, void* userData) FMT_NOEXCEPT;
+  static void setLogQFullCB(LogQFullCBFn cb, void* userData) noexcept;
 
   // Close the log file and subsequent msgs will not be written into the file,
   // but callback function can still be used
-  static void closeLogFile() FMT_NOEXCEPT;
+  static void closeLogFile() noexcept;
 
   // Set log header pattern with fmt named arguments
   static void setHeaderPattern(const char* pattern);
 
   // Set a name for current thread, it'll be shown in {t} part in header pattern
-  static void setThreadName(const char* name) FMT_NOEXCEPT;
+  static void setThreadName(const char* name) noexcept;
 
   // Set current log level, lower level log msgs will be discarded
-  static inline void setLogLevel(LogLevel logLevel) FMT_NOEXCEPT;
+  static inline void setLogLevel(LogLevel logLevel) noexcept;
 
   // Get current log level
-  static inline LogLevel getLogLevel() FMT_NOEXCEPT;
+  static inline LogLevel getLogLevel() noexcept;
 
   // return true if passed log level is not lower than current log level
-  static inline bool checkLogLevel(LogLevel logLevel) FMT_NOEXCEPT;
+  static inline bool checkLogLevel(LogLevel logLevel) noexcept;
 
   // Run a polling thread in the background with a polling interval
   // Note that user must not call poll() himself when the thread is running
-  static void startPollingThread(int64_t pollInterval = 1000000) FMT_NOEXCEPT;
+  static void startPollingThread(int64_t pollInterval = 1000000) noexcept;
 
   // Stop the polling thread
-  static void stopPollingThread() FMT_NOEXCEPT;
+  static void stopPollingThread() noexcept;
 
   // https://github.com/MengRao/SPSC_Queue
   class SPSCVarQueueOPT
@@ -180,7 +180,7 @@ class fmtlogT
     };
     static constexpr uint32_t BLK_CNT = (1 << 20) / sizeof(MsgHeader);
 
-    MsgHeader* allocMsg(uint32_t size) FMT_NOEXCEPT;
+    MsgHeader* allocMsg(uint32_t size) noexcept;
 
     MsgHeader* alloc(uint32_t size) {
       size += sizeof(MsgHeader);
@@ -374,15 +374,15 @@ class fmtlogT
                                     int& argIdx, std::vector<fmt::basic_format_arg<Context>>& args);
 
   static void registerLogInfo(uint32_t& logId, FormatToFn fn, const char* location, LogLevel level,
-                              fmt::string_view fmtString) FMT_NOEXCEPT;
+                              fmt::string_view fmtString) noexcept;
 
   static void vformat_to(MemoryBuffer& out, fmt::string_view fmt, fmt::format_args args);
 
   static size_t formatted_size(fmt::string_view fmt, fmt::format_args args);
 
   static void vformat_to(char* out, fmt::string_view fmt, fmt::format_args args);
 
-  static typename SPSCVarQueueOPT::MsgHeader* allocMsg(uint32_t size, bool logQFullCB) FMT_NOEXCEPT;
+  static typename SPSCVarQueueOPT::MsgHeader* allocMsg(uint32_t size, bool logQFullCB) noexcept;
 
   TSCNS tscns;
 
@@ -668,7 +668,7 @@ class fmtlogT
   inline void log(
     uint32_t& logId, int64_t tsc, const char* location, LogLevel level,
     fmt::format_string<typename fmtlogdetail::UnrefPtr<fmt::remove_cvref_t<Args>>::type...> format,
-    Args&&... args) FMT_NOEXCEPT {
+    Args&&... args) noexcept {
     if (!logId) {
       auto unnamed_format = unNameFormat<false>(fmt::string_view(format), nullptr, args...);
       registerLogInfo(logId, formatTo<Args...>, location, level, unnamed_format);
@@ -729,17 +729,17 @@ template<int _>
 fmtlog fmtlogWrapper<_>::impl;
 
 template<int _>
-inline void fmtlogT<_>::setLogLevel(LogLevel logLevel) FMT_NOEXCEPT {
+inline void fmtlogT<_>::setLogLevel(LogLevel logLevel) noexcept {
   fmtlogWrapper<>::impl.currentLogLevel = logLevel;
 }
 
 template<int _>
-inline typename fmtlogT<_>::LogLevel fmtlogT<_>::getLogLevel() FMT_NOEXCEPT {
+inline typename fmtlogT<_>::LogLevel fmtlogT<_>::getLogLevel() noexcept {
   return fmtlogWrapper<>::impl.currentLogLevel;
 }
 
 template<int _>
-inline bool fmtlogT<_>::checkLogLevel(LogLevel logLevel) FMT_NOEXCEPT {
+inline bool fmtlogT<_>::checkLogLevel(LogLevel logLevel) noexcept {
 #ifdef FMTLOG_NO_CHECK_LEVEL
   return true;
 #else

test/enc_dec_test.cc

@@ -24,7 +24,7 @@ struct fmt::formatter<MyType> : formatter<int>
 {
   // parse is inherited from formatter<string_view>.
   template<typename FormatContext>
-  auto format(const MyType& val, FormatContext& ctx) {
+  auto format(const MyType& val, FormatContext& ctx) const {
     return formatter<int>::format(val.v, ctx);
   }
 };
@@ -51,7 +51,7 @@ struct fmt::formatter<MovableType> : formatter<int>
 template<typename S, typename... Args>
 void test(const S& format, Args&&... args) {
   fmt::detail::check_format_string<Args...>(format);
-  auto sv = fmt::to_string_view(format);
+  auto sv = fmt::detail::to_string_view(format);
   size_t formatted_size = fmt::formatted_size(fmt::runtime(sv), std::forward<Args>(args)...);
   string ans = fmt::format(fmt::runtime(sv), std::forward<Args>(args)...);
   assert(ans.size() == formatted_size);