Update CI nodes

CMakeLists.txt

@@ -54,7 +54,7 @@ add_library(FairLogger
   logger/Logger.cxx
   logger/Logger.h
 )
-target_compile_features(FairLogger PUBLIC cxx_std_17)
+target_compile_features(FairLogger PUBLIC cxx_std_14)
 
 if(USE_BOOST_PRETTY_FUNCTION)
   target_link_libraries(FairLogger PUBLIC Boost::boost)

cmake/FairLoggerLib.cmake

@@ -94,7 +94,7 @@ macro(set_fairlogger_defaults)
   endif()
 
   # Handle C++ standard level
-  set(PROJECT_MIN_CXX_STANDARD 17)
+  set(PROJECT_MIN_CXX_STANDARD 14)
   if(CMAKE_CXX_STANDARD LESS PROJECT_MIN_CXX_STANDARD)
     message(FATAL_ERROR "A minimum CMAKE_CXX_STANDARD of ${PROJECT_MIN_CXX_STANDARD} is required.")
   endif()

logger/Logger.cxx

@@ -6,7 +6,6 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 #include "Logger.h"
-#include <string_view>
 
 #if FMT_VERSION < 60000
 #include <fmt/time.h>
@@ -45,58 +44,58 @@ const string Logger::fProcessName = program_invocation_short_name;
 const string Logger::fProcessName = "?";
 #endif
 
-const unordered_map<string_view, Verbosity> Logger::fVerbosityMap =
+const unordered_map<string, Verbosity> Logger::fVerbosityMap =
 {
-    { {"veryhigh"}, Verbosity::veryhigh },
+    { "veryhigh", Verbosity::veryhigh },
-    { {"high"},     Verbosity::high     },
+    { "high",     Verbosity::high     },
-    { {"medium"},   Verbosity::medium   },
+    { "medium",   Verbosity::medium   },
-    { {"low"},      Verbosity::low      },
+    { "low",      Verbosity::low      },
-    { {"verylow"},  Verbosity::verylow  },
+    { "verylow",  Verbosity::verylow  },
-    { {"VERYHIGH"}, Verbosity::veryhigh },
+    { "VERYHIGH", Verbosity::veryhigh },
-    { {"HIGH"},     Verbosity::high     },
+    { "HIGH",     Verbosity::high     },
-    { {"MEDIUM"},   Verbosity::medium   },
+    { "MEDIUM",   Verbosity::medium   },
-    { {"LOW"},      Verbosity::low      },
+    { "LOW",      Verbosity::low      },
-    { {"VERYLOW"},  Verbosity::verylow  },
+    { "VERYLOW",  Verbosity::verylow  },
-    { {"user1"},    Verbosity::user1    },
+    { "user1",    Verbosity::user1    },
-    { {"user2"},    Verbosity::user2    },
+    { "user2",    Verbosity::user2    },
-    { {"user3"},    Verbosity::user3    },
+    { "user3",    Verbosity::user3    },
-    { {"user4"},    Verbosity::user4    }
+    { "user4",    Verbosity::user4    }
 };
 
-const unordered_map<string_view, Severity> Logger::fSeverityMap =
+const unordered_map<string, Severity> Logger::fSeverityMap =
 {
-    { {"nolog"},     Severity::nolog     },
+    { "nolog",     Severity::nolog     },
-    { {"NOLOG"},     Severity::nolog     },
+    { "NOLOG",     Severity::nolog     },
-    { {"fatal"},     Severity::fatal     },
+    { "fatal",     Severity::fatal     },
-    { {"FATAL"},     Severity::fatal     },
+    { "FATAL",     Severity::fatal     },
-    { {"error"},     Severity::error     },
+    { "error",     Severity::error     },
-    { {"ERROR"},     Severity::error     },
+    { "ERROR",     Severity::error     },
-    { {"alarm"},     Severity::alarm     },
+    { "alarm",     Severity::alarm     },
-    { {"important"}, Severity::important },
+    { "important", Severity::important },
-    { {"warn"},      Severity::warn      },
+    { "warn",      Severity::warn      },
-    { {"WARN"},      Severity::warn      },
+    { "WARN",      Severity::warn      },
-    { {"warning"},   Severity::warn      },
+    { "warning",   Severity::warn      },
-    { {"WARNING"},   Severity::warn      },
+    { "WARNING",   Severity::warn      },
-    { {"state"},     Severity::state     },
+    { "state",     Severity::state     },
-    { {"STATE"},     Severity::state     },
+    { "STATE",     Severity::state     },
-    { {"info"},      Severity::info      },
+    { "info",      Severity::info      },
-    { {"INFO"},      Severity::info      },
+    { "INFO",      Severity::info      },
-    { {"detail"},    Severity::detail    },
+    { "detail",    Severity::detail    },
-    { {"debug"},     Severity::debug     },
+    { "debug",     Severity::debug     },
-    { {"DEBUG"},     Severity::debug     },
+    { "DEBUG",     Severity::debug     },
-    { {"debug1"},    Severity::debug1    },
+    { "debug1",    Severity::debug1    },
-    { {"DEBUG1"},    Severity::debug1    },
+    { "DEBUG1",    Severity::debug1    },
-    { {"debug2"},    Severity::debug2    },
+    { "debug2",    Severity::debug2    },
-    { {"DEBUG2"},    Severity::debug2    },
+    { "DEBUG2",    Severity::debug2    },
-    { {"debug3"},    Severity::debug3    },
+    { "debug3",    Severity::debug3    },
-    { {"DEBUG3"},    Severity::debug3    },
+    { "DEBUG3",    Severity::debug3    },
-    { {"debug4"},    Severity::debug4    },
+    { "debug4",    Severity::debug4    },
-    { {"DEBUG4"},    Severity::debug4    },
+    { "DEBUG4",    Severity::debug4    },
-    { {"trace"},     Severity::trace     },
+    { "trace",     Severity::trace     },
-    { {"TRACE"},     Severity::trace     }
+    { "TRACE",     Severity::trace     }
 };
 
-const array<string_view, 15> Logger::fSeverityNames =
+const array<string, 15> Logger::fSeverityNames =
 {
     {
         "NOLOG",
@@ -117,7 +116,7 @@ const array<string_view, 15> Logger::fSeverityNames =
     }
 };
 
-const array<string_view, 9> Logger::fVerbosityNames =
+const array<string, 9> Logger::fVerbosityNames =
 {
     {
         "verylow",
@@ -145,11 +144,12 @@ map<Verbosity, VSpec> Logger::fVerbosities =
     { Verbosity::user4,    VSpec::Make(VSpec::Info::severity)                                                                                        }
 };
 
-Logger::Logger(Severity severity, Verbosity verbosity, std::string_view file, std::string_view line, std::string_view func)
+Logger::Logger(Severity severity, Verbosity verbosity, const string& file, const string& line, const string& func)
     : fTimeCalculated(false)
 {
     if (!fIsDestructed) {
         size_t pos = file.rfind("/");
+
         // fInfos.timestamp is filled conditionally
         // fInfos.us is filled conditionally
         fInfos.process_name = fProcessName;

logger/Logger.h

@@ -45,7 +45,6 @@
 #include <time.h> // time_t
 #include <type_traits> // is_same
 #include <unordered_map>
-#include <string_view>
 #include <utility> // pair
 
 namespace fair
@@ -176,19 +175,19 @@ struct LogMetaData
 {
     std::time_t timestamp;
     std::chrono::microseconds us;
-    std::string_view process_name;
+    std::string process_name;
-    std::string_view file;
+    std::string file;
-    std::string_view line;
+    std::string line;
-    std::string_view func;
+    std::string func;
-    std::string_view severity_name;
+    std::string severity_name;
     fair::Severity severity;
 };
 
 class Logger
 {
   public:
-    Logger(Severity severity, Verbosity verbosity, std::string_view file, std::string_view line, std::string_view func);
+    Logger(Severity severity, Verbosity verbosity, const std::string& file, const std::string& line, const std::string& func);
-    Logger(Severity severity, std::string_view file, std::string_view line, std::string_view func)
+    Logger(Severity severity, const std::string& file, const std::string& line, const std::string& func)
         : Logger(severity, fVerbosity, file, line, func)
     {}
     virtual ~Logger() noexcept(false);
@@ -245,7 +244,7 @@ class Logger
 
     static std::string startColor(Color color) { return fmt::format("\033[01;{}m", static_cast<int>(color)); }
     static std::string endColor() { return "\033[0m"; }
-    static std::string ColorOut(Color c, std::string_view s) { return fmt::format("\033[01;{}m{}\033[0m", static_cast<int>(c), s); }
+    static std::string ColorOut(Color c, const std::string& s) { return fmt::format("\033[01;{}m{}\033[0m", static_cast<int>(c), s); }
     static std::string GetColoredSeverityString(Severity severity);
 
     static void SetConsoleSeverity(const Severity severity);
@@ -286,8 +285,8 @@ class Logger
 
     static void RemoveFileSink();
 
-    static std::string_view SeverityName(Severity s) { return fSeverityNames.at(static_cast<size_t>(s)); }
+    static std::string SeverityName(Severity s) { return fSeverityNames.at(static_cast<size_t>(s)); }
-    static std::string_view VerbosityName(Verbosity v) { return fVerbosityNames.at(static_cast<size_t>(v)); }
+    static std::string VerbosityName(Verbosity v) { return fVerbosityNames.at(static_cast<size_t>(v)); }
 
     static void OnFatal(std::function<void()> func);
 
@@ -323,10 +322,10 @@ class Logger
     Logger& operator<<(std::ios_base& (*manip) (std::ios_base&));
     Logger& operator<<(std::ostream& (*manip) (std::ostream&));
 
-    static const std::unordered_map<std::string_view, Verbosity> fVerbosityMap;
+    static const std::unordered_map<std::string, Verbosity> fVerbosityMap;
-    static const std::unordered_map<std::string_view, Severity> fSeverityMap;
+    static const std::unordered_map<std::string, Severity> fSeverityMap;
-    static const std::array<std::string_view, 15> fSeverityNames;
+    static const std::array<std::string, 15> fSeverityNames;
-    static const std::array<std::string_view, 9> fVerbosityNames;
+    static const std::array<std::string, 9> fVerbosityNames;
 
     // protection for use after static destruction took place
     static bool fIsDestructed;