Rename Provenance to LogProvenance

app/celer-g4/LocalLogger.cc

@@ -20,7 +20,7 @@ namespace app
 /*!
  * Write a log message.
  */
-void LocalLogger::operator()(Provenance prov, LogLevel lev, std::string msg)
+void LocalLogger::operator()(LogProvenance prov, LogLevel lev, std::string msg)
 {
     // Write preamble to a buffer first
     std::ostringstream os;

app/celer-g4/LocalLogger.hh

@@ -30,7 +30,7 @@ class LocalLogger
     }
 
     // Write a log message
-    void operator()(Provenance prov, LogLevel lev, std::string msg);
+    void operator()(LogProvenance prov, LogLevel lev, std::string msg);
 
   private:
     int num_threads_;

src/accel/Logger.cc

@@ -35,7 +35,7 @@ class MtLogger
 {
   public:
     explicit MtLogger(int num_threads);
-    void operator()(Provenance prov, LogLevel lev, std::string msg);
+    void operator()(LogProvenance prov, LogLevel lev, std::string msg);
 
   private:
     int num_threads_;
@@ -48,7 +48,7 @@ MtLogger::MtLogger(int num_threads) : num_threads_(num_threads)
 }
 
 //---------------------------------------------------------------------------//
-void MtLogger::operator()(Provenance prov, LogLevel lev, std::string msg)
+void MtLogger::operator()(LogProvenance prov, LogLevel lev, std::string msg)
 {
     auto& cerr = G4cerr;
 

src/corecel/io/Logger.cc

@@ -31,7 +31,7 @@ namespace
 // HELPER CLASSES
 //---------------------------------------------------------------------------//
 //! Default global logger prints the error message with basic colors
-void default_global_handler(Provenance prov, LogLevel lev, std::string msg)
+void default_global_handler(LogProvenance prov, LogLevel lev, std::string msg)
 {
     static std::mutex log_mutex;
     std::lock_guard<std::mutex> scoped_lock{log_mutex};
@@ -57,7 +57,7 @@ class LocalHandler
   public:
     explicit LocalHandler(MpiCommunicator const& comm) : rank_(comm.rank()) {}
 
-    void operator()(Provenance prov, LogLevel lev, std::string msg)
+    void operator()(LogProvenance prov, LogLevel lev, std::string msg)
     {
         // Use buffered 'clog'
         std::clog << color_code('x') << prov.file << ':' << prov.line

src/corecel/io/Logger.hh

@@ -17,10 +17,10 @@
 // MACROS
 //---------------------------------------------------------------------------//
 //! Inject the source code provenance (current file and line)
-#define CELER_CODE_PROVENANCE \
-    ::celeritas::Provenance   \
-    {                         \
-        __FILE__, __LINE__    \
+#define CELER_CODE_PROVENANCE  \
+    ::celeritas::LogProvenance \
+    {                          \
+        __FILE__, __LINE__     \
     }
 
 /*!
@@ -90,7 +90,7 @@ class Logger
     Logger(MpiCommunicator const& comm, LogHandler handle);
 
     // Create a logger that flushes its contents when it destructs
-    inline Message operator()(Provenance&& prov, LogLevel lev);
+    inline Message operator()(LogProvenance&& prov, LogLevel lev);
 
     //! Set the minimum logging verbosity
     void level(LogLevel lev) { min_level_ = lev; }
@@ -113,7 +113,7 @@ class Logger
  * anyway), so we mark as \c CELER_UNLIKELY to optimize for the no-logging
  * case.
  */
-auto Logger::operator()(Provenance&& prov, LogLevel lev) -> Message
+auto Logger::operator()(LogProvenance&& prov, LogLevel lev) -> Message
 {
     LogHandler* handle = nullptr;
     if (CELER_UNLIKELY(handle_ && lev >= min_level_))

src/corecel/io/LoggerTypes.hh

@@ -40,14 +40,17 @@ char const* to_color_code(LogLevel);
 
 //---------------------------------------------------------------------------//
 //! Stand-in for a more complex class for the "provenance" of data
-struct Provenance
+struct LogProvenance
 {
     std::string_view file;  //!< Originating file
     int line{0};  //!< Line number
 };
 
 //! Type for handling a log message
-using LogHandler = std::function<void(Provenance, LogLevel, std::string)>;
+using LogHandler = std::function<void(LogProvenance, LogLevel, std::string)>;
+
+// DEPRECATED: remove in v0.6
+using Provenance [[deprecated]] = LogProvenance;
 
 //---------------------------------------------------------------------------//
 }  // namespace celeritas

src/corecel/io/detail/LoggerMessage.cc

@@ -26,7 +26,7 @@ namespace detail
  *
  * This saves the provided data and allocates a stream for output.
  */
-void LoggerMessage::construct_impl(Provenance&& prov, LogLevel lev)
+void LoggerMessage::construct_impl(LogProvenance&& prov, LogLevel lev)
 {
     CELER_EXPECT(handle_ && *handle_);
 

src/corecel/io/detail/LoggerMessage.hh

@@ -36,7 +36,7 @@ class LoggerMessage
 
   public:
     // Construct with reference to function object, etc.
-    inline LoggerMessage(LogHandler* handle, Provenance&& prov, LogLevel lev);
+    inline LoggerMessage(LogHandler* handle, LogProvenance&& prov, LogLevel lev);
 
     // Flush message on destruction
     inline ~LoggerMessage();
@@ -61,12 +61,12 @@ class LoggerMessage
 
   private:
     LogHandler* handle_;
-    Provenance prov_;
+    LogProvenance prov_;
     LogLevel lev_;
     std::unique_ptr<std::ostringstream> os_;
 
     // Create the message when handle is non-null
-    void construct_impl(Provenance&& prov, LogLevel lev);
+    void construct_impl(LogProvenance&& prov, LogLevel lev);
 
     // Flush the message during destruction
     void destroy_impl() noexcept;
@@ -80,7 +80,7 @@ class LoggerMessage
  * not be displayed.
  */
 CELER_FORCEINLINE LoggerMessage::LoggerMessage(LogHandler* handle,
-                                               Provenance&& prov,
+                                               LogProvenance&& prov,
                                                LogLevel lev)
     : handle_(handle)
 {

test/corecel/ScopedLogStorer.cc

@@ -56,7 +56,7 @@ ScopedLogStorer::~ScopedLogStorer()
 
 //---------------------------------------------------------------------------//
 //! Save a log message
-void ScopedLogStorer::operator()(Provenance, LogLevel lev, std::string msg)
+void ScopedLogStorer::operator()(LogProvenance, LogLevel lev, std::string msg)
 {
     static std::regex const delete_ansi("\033\\[[0-9;]*m");
     static std::regex const subs_ptr("0x[0-9a-f]+");

test/corecel/ScopedLogStorer.hh

@@ -60,7 +60,7 @@ class ScopedLogStorer
     ~ScopedLogStorer();
 
     // Save a log message
-    void operator()(Provenance, LogLevel lev, std::string msg);
+    void operator()(LogProvenance, LogLevel lev, std::string msg);
 
     //! Whether no messages were stored
     bool empty() const { return messages_.empty(); }

test/corecel/io/Logger.test.cc

@@ -88,15 +88,16 @@ TEST_F(LoggerTest, null)
 
 TEST_F(LoggerTest, custom_log)
 {
-    Provenance last_prov;
+    LogProvenance last_prov;
     LogLevel last_lev = LogLevel::debug;
     std::string last_msg;
 
-    Logger log(comm_self, [&](Provenance prov, LogLevel lev, std::string msg) {
-        last_prov = prov;
-        last_lev = lev;
-        last_msg = std::move(msg);
-    });
+    Logger log(comm_self,
+               [&](LogProvenance prov, LogLevel lev, std::string msg) {
+                   last_prov = prov;
+                   last_lev = lev;
+                   last_msg = std::move(msg);
+               });
 
     // Update level
     EXPECT_EQ(LogLevel::status, log.level());
@@ -131,9 +132,11 @@ TEST_F(LoggerTest, DISABLED_performance)
 {
     // Construct a logger with an expensive output routine that will never be
     // called
-    Logger log(comm_self, [&](Provenance prov, LogLevel lev, std::string msg) {
-        cout << prov.file << prov.line << static_cast<int>(lev) << msg << endl;
-    });
+    Logger log(comm_self,
+               [&](LogProvenance prov, LogLevel lev, std::string msg) {
+                   cout << prov.file << prov.line << static_cast<int>(lev)
+                        << msg << endl;
+               });
     log.level(LogLevel::critical);
 
     // Even in debug this takes only 26ms