use if statement instead of switch (changes of adding new time specifications outside of standard are probably unlikely anyhow)

pattern_time -> pattern_time_type
ptime variable name -> pattern_time variable name
make sure four spaces used, not tabs

include/spdlog/async_logger.h

@@ -71,7 +71,7 @@ public:
 protected:
     void _sink_it(details::log_msg& msg) override;
     void _set_formatter(spdlog::formatter_ptr msg_formatter) override;
-    void _set_pattern(const std::string& pattern, pattern_time ptime) override;
+    void _set_pattern(const std::string& pattern, pattern_time_type pattern_time) override;
 
 private:
     std::unique_ptr<details::async_log_helper> _async_log_helper;

include/spdlog/common.h

@@ -110,10 +110,10 @@ enum class async_overflow_policy
 // Pattern time - specific time getting to use for pattern_formatter.
 // local time by default
 //
-enum class pattern_time
+enum class pattern_time_type
 {
-	local, // use variant of time similar to std::localtime for std::tm
+    local, // use variant of time similar to std::localtime for std::tm
-	utc // use variant of time similar to std::gmtime for std::tm
+    utc // use variant of time similar to std::gmtime for std::tm
 };
 
 //

include/spdlog/details/async_logger_impl.h

@@ -76,9 +76,9 @@ inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_forma
     _async_log_helper->set_formatter(_formatter);
 }
 
-inline void spdlog::async_logger::_set_pattern(const std::string& pattern, pattern_time ptime)
+inline void spdlog::async_logger::_set_pattern(const std::string& pattern, pattern_time_type pattern_time)
 {
-    _formatter = std::make_shared<pattern_formatter>(pattern, ptime);
+    _formatter = std::make_shared<pattern_formatter>(pattern, pattern_time);
     _async_log_helper->set_formatter(_formatter);
 }
 

include/spdlog/details/logger_impl.h

@@ -53,9 +53,9 @@ inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter)
     _set_formatter(msg_formatter);
 }
 
-inline void spdlog::logger::set_pattern(const std::string& pattern, pattern_time ptime)
+inline void spdlog::logger::set_pattern(const std::string& pattern, pattern_time_type pattern_time)
 {
-    _set_pattern(pattern, ptime);
+    _set_pattern(pattern, pattern_time);
 }
 
 
@@ -316,9 +316,9 @@ inline void spdlog::logger::_sink_it(details::log_msg& msg)
         flush();
 }
 
-inline void spdlog::logger::_set_pattern(const std::string& pattern, pattern_time ptime)
+inline void spdlog::logger::_set_pattern(const std::string& pattern, pattern_time_type pattern_time)
 {
-    _formatter = std::make_shared<pattern_formatter>(pattern, ptime);
+    _formatter = std::make_shared<pattern_formatter>(pattern, pattern_time);
 }
 inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
 {

include/spdlog/details/pattern_formatter_impl.h

@@ -311,15 +311,7 @@ class R_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
-		msg.formatted << (tm_time.tm_year + 1900);
+        pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, ':');
-		msg.formatted << '-';
-		msg.formatted << tm_time.tm_mon;
-		msg.formatted << '-';
-		msg.formatted << tm_time.tm_mday;
-	
-		msg.formatted << ' ';
-		
-		pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, ':');
     }
 };
 
@@ -502,13 +494,13 @@ class full_formatter SPDLOG_FINAL:public flag_formatter
 ///////////////////////////////////////////////////////////////////////////////
 // pattern_formatter inline impl
 ///////////////////////////////////////////////////////////////////////////////
-inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern, pattern_time ptime)
+inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern, pattern_time_type pattern_time)
-: _time(ptime)
+: _pattern_time(pattern_time)
 {
-    compile_pattern(pattern, _time);
+    compile_pattern(pattern);
 }
 
-inline void spdlog::pattern_formatter::compile_pattern(const std::string& pattern, pattern_time ptime)
+inline void spdlog::pattern_formatter::compile_pattern(const std::string& pattern)
 {
     auto end = pattern.end();
     std::unique_ptr<details::aggregate_formatter> user_chars;
@@ -673,26 +665,18 @@ inline void spdlog::pattern_formatter::handle_flag(char flag)
     }
 }
 
+inline std::tm spdlog::pattern_formatter::get_time(details::log_msg& msg) {
+    if (_pattern_time == pattern_time_type::local)
+        return details::os::localtime(log_clock::to_time_t(msg.time));
+    else
+        return details::os::gmtime(log_clock::to_time_t(msg.time));
+}
 
 inline void spdlog::pattern_formatter::format(details::log_msg& msg)
 {
 
 #ifndef SPDLOG_NO_DATETIME
-	auto tm_time = [this, &msg]()
+    auto tm_time = get_time(msg);
-	{
-		switch (_time)
-		{
-		// it is always faster to put the most-common/default case first
-		case (pattern_time::local):
-			return details::os::localtime(log_clock::to_time_t(msg.time));
-
-		case (pattern_time::utc):
-			return details::os::gmtime(log_clock::to_time_t(msg.time));
-		
-		default:
-			return details::os::localtime(log_clock::to_time_t(msg.time));
-		}
-	}();
 #else
     std::tm tm_time;
 #endif

include/spdlog/formatter.h

@@ -29,16 +29,17 @@ class pattern_formatter SPDLOG_FINAL : public formatter
 {
 
 public:
-    explicit pattern_formatter(const std::string& pattern, pattern_time ptime = pattern_time::local);
+    explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local);
     pattern_formatter(const pattern_formatter&) = delete;
     pattern_formatter& operator=(const pattern_formatter&) = delete;
     void format(details::log_msg& msg) override;
 private:
     const std::string _pattern;
-	const pattern_time _time;
+    const pattern_time_type _pattern_time;
     std::vector<std::unique_ptr<details::flag_formatter>> _formatters;
+    std::tm get_time(details::log_msg& msg);
     void handle_flag(char flag);
-    void compile_pattern(const std::string& pattern, pattern_time ptime);
+    void compile_pattern(const std::string& pattern);
 };
 }
 

include/spdlog/logger.h

@@ -66,7 +66,7 @@ public:
     void set_level(level::level_enum);
     level::level_enum level() const;
     const std::string& name() const;
-    void set_pattern(const std::string&, pattern_time = pattern_time::local);
+    void set_pattern(const std::string&, pattern_time_type = pattern_time_type::local);
     void set_formatter(formatter_ptr);
 
     // automatically call flush() if message level >= log_level
@@ -82,7 +82,7 @@ public:
 
 protected:
     virtual void _sink_it(details::log_msg&);
-    virtual void _set_pattern(const std::string&, pattern_time);
+    virtual void _set_pattern(const std::string&, pattern_time_type);
     virtual void _set_formatter(formatter_ptr);
 
     // default error handler: print the error to stderr with the max rate of 1 message/minute