loggerCore.hpp

/*
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 "gmlc/concurrency/TripWire.hpp"
#include "gmlc/containers/BlockingQueue.hpp"
 
#include <atomic>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <thread>
#include <utility>
#include <vector>
 
namespace helics {
class LoggingCore {
  private:
    static std::atomic<bool> fastShutdown;  // set to true to enable a fast shutdown
    std::thread
        loggingThread;  
    std::vector<std::function<void(std::string&& message)>>
        functions;  
    std::mutex functionLock;  
    gmlc::containers::BlockingQueue<std::pair<int32_t, std::string>>
        loggingQueue;  
    gmlc::concurrency::TripWireDetector tripDetector;
 
  public:
    LoggingCore();
    ~LoggingCore();
    void addMessage(const std::string& message);
    void addMessage(std::string&& message);
    void addMessage(int index, const std::string& message);
    void addMessage(int index, std::string&& message);
    int addFileProcessor(std::function<void(std::string&& message)> newFunction);
    void haltOperations(int loggerIndex);
    void updateProcessingFunction(int index,
                                  std::function<void(std::string&& message)> newFunction);
    static void setFastShutdown();
 
  private: 
    void processingLoop();
};
 
class LoggerManager {
  private:
    static std::map<std::string, std::shared_ptr<LoggerManager>>
        loggers;  
    std::string name;  
    std::shared_ptr<LoggingCore> loggingControl;  
    explicit LoggerManager(const std::string& loggerName);
 
  public:
    static std::shared_ptr<LoggerManager> getLoggerManager(const std::string& loggerName = "");
    static std::shared_ptr<LoggingCore> getLoggerCore(const std::string& loggerName = "");
    static void closeLogger(const std::string& loggerName = "");
    static void logMessage(std::string message);
 
    /*destructor*/
    virtual ~LoggerManager();
    const std::string& getName() const { return name; }
};
}  // namespace helics