logger.h

/*
Copyright (c) 2017-2020,
Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Sustainable
Energy, LLC.  See the top-level NOTICE for additional details. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
*/
/*
 * LLNS Copyright Start
 * Copyright (c) 2014-2018, Lawrence Livermore National Security
 * This work was performed under the auspices of the U.S. Department
 * of Energy by Lawrence Livermore National Laboratory in part under
 * Contract W-7405-Eng-48 and in part under Contract DE-AC52-07NA27344.
 * Produced at the Lawrence Livermore National Laboratory.
 * All rights reserved.
 * For details, see the LICENSE file.
 * LLNS Copyright End
 */
 
#pragma once
 
#include <atomic>
#include <fstream>
#include <memory>
#include <mutex>
#include <string>
#include <utility>
 
namespace helics {
class LoggingCore;
 
constexpr int always_log = -100000;  
constexpr int log_everything = 100;  
 
class Logger {
  private:
    std::atomic<bool> halted{true};  
    std::mutex fileLock;  
    std::atomic<bool> hasFile{false};  
    std::ofstream outFile;  
    std::shared_ptr<LoggingCore> logCore;  
    int coreIndex = -1;  
    std::atomic<int> consoleLevel{
        log_everything};  
    std::atomic<int> fileLevel{log_everything};  
  public:
    Logger();
    explicit Logger(std::shared_ptr<LoggingCore> core);
    ~Logger();
    void openFile(const std::string& file);
    void closeFile();
    void startLogging(int cLevel, int fLevel);
    void startLogging() { startLogging(consoleLevel, fileLevel); }
    void haltLogging();
    void log(int level, std::string logMessage);
    void log(std::string logMessage) { log(always_log, std::move(logMessage)); }
    void flush();
    bool isRunning() const;
    void changeLevels(int cLevel, int fLevel);
 
  private:
    void logFunction(std::string&& message);
};
 
class LoggerNoThread {
  private:
    std::ofstream outFile;  
  public:
    int consoleLevel = log_everything;  
    int fileLevel = log_everything;  
  public:
    LoggerNoThread();
    explicit LoggerNoThread(const std::shared_ptr<LoggingCore>& core);
    void openFile(const std::string& file);
    void closeFile();
    void startLogging(int cLevel, int fLevel);
    void startLogging() { startLogging(consoleLevel, fileLevel); }
    // NOTE:: the interface for log in the noThreadLogging is slightly different
    // due to the threaded Logger making use of move semantics which isn't that useful in the
    // noThreadLogger
    void log(int level, const std::string& logMessage);
    void log(const std::string& logMessage) { log(always_log, logMessage); }
    bool isRunning() const;
    void flush();
    void changeLevels(int cLevel, int fLevel);
};
}  // namespace helics