logger_output.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//
//
 
 
#if !defined(KRATOS_LOGGER_OUTPUT_H_INCLUDED )
#define  KRATOS_LOGGER_OUTPUT_H_INCLUDED
 
 
 
// System includes
#include <string>
#include <iostream>
#include <map>
 
 
// External includes
 
 
// Project includes
#include "includes/define.h"
#include "input_output/logger_message.h"
#include "containers/flags.h"
 
namespace Kratos
{
 
 
 
class KRATOS_API(KRATOS_CORE) LoggerOutput
{
public:
 
  KRATOS_DEFINE_LOCAL_FLAG(WARNING_PREFIX);
  KRATOS_DEFINE_LOCAL_FLAG(INFO_PREFIX);
  KRATOS_DEFINE_LOCAL_FLAG(DETAIL_PREFIX);
  KRATOS_DEFINE_LOCAL_FLAG(DEBUG_PREFIX);
  KRATOS_DEFINE_LOCAL_FLAG(TRACE_PREFIX);
 
  KRATOS_CLASS_POINTER_DEFINITION(LoggerOutput);
 
 
 
  explicit LoggerOutput(std::ostream& rOutputStream)
    : mpStream(&rOutputStream),
      mMaxLevel(1),
      mSeverity(LoggerMessage::Severity::INFO),
      mCategory(LoggerMessage::Category::STATUS)
  {
    mOptions.Set(WARNING_PREFIX, true);
    mOptions.Set(INFO_PREFIX, false);
    mOptions.Set(DETAIL_PREFIX, false);
    mOptions.Set(DEBUG_PREFIX, false);
    mOptions.Set(TRACE_PREFIX, false);
  }
 
  LoggerOutput(LoggerOutput const& Other)
    : mpStream(Other.mpStream), mMaxLevel(Other.mMaxLevel), mSeverity(Other.mSeverity), mCategory(Other.mCategory) {}
 
  virtual ~LoggerOutput() {}
 
 
 
  LoggerOutput& operator=(LoggerOutput const& Other) = delete;
 
 
 
 
  virtual void WriteHeader();
 
  virtual void WriteMessage(LoggerMessage const& TheMessage);
 
  virtual void Flush();
 
  void SetMaxLevel(std::size_t TheLevel) {
    mMaxLevel = TheLevel;
  }
 
  std::size_t GetMaxLevel() const {
    return mMaxLevel;
  }
 
  void SetSeverity(LoggerMessage::Severity const& TheSeverity) {
    mSeverity = TheSeverity;
  }
 
  LoggerMessage::Severity GetSeverity() const {
    return mSeverity;
  }
 
  void SetCategory(LoggerMessage::Category const& TheCategory) {
    mCategory = TheCategory;
  }
 
  LoggerMessage::Category GetCategory() const {
    return mCategory;
  }
 
  void SetOption(const Kratos::Flags ThisFlag, bool Value) {
    mOptions.Set(ThisFlag, Value);
  }
 
  bool GetOption(const Kratos::Flags ThisFlag) {
    return mOptions.Is(ThisFlag);
  }
 
 
 
  virtual std::string Info() const;
 
  virtual void PrintInfo(std::ostream& rOStream) const;
 
  virtual void PrintData(std::ostream& rOStream) const;
 
 
  template<class StreamValueType>
  LoggerOutput& operator << (StreamValueType const& rValue)
  {
    std::stringstream buffer;
    buffer << rValue;
 
    GetStream() << buffer.str();
 
    return *this;
  }
 
  LoggerOutput& operator << (std::ostream& (*pf)(std::ostream&));
 
  LoggerOutput& operator << (const char * rString);
 
 
 
protected:
 
  LoggerOutput()
    : mpStream(nullptr),
      mMaxLevel(1),
      mSeverity(LoggerMessage::Severity::INFO),
      mCategory(LoggerMessage::Category::STATUS)
  {
    mOptions.Set(WARNING_PREFIX, true);
    mOptions.Set(INFO_PREFIX, false);
    mOptions.Set(DETAIL_PREFIX, false);
    mOptions.Set(DEBUG_PREFIX, false);
    mOptions.Set(TRACE_PREFIX, false);
  }
 
  std::ostream& GetStream() {return *mpStream;}
  std::ostream* pGetStream() {return mpStream;}
  void SetStream(std::ostream* pStream) {mpStream = pStream;}
 
  virtual void SetMessageColor(LoggerMessage::Severity MessageSeverity);
  virtual void ResetMessageColor(LoggerMessage::Severity MessageSeverity);
 
private:
 
 
  std::ostream* mpStream;
  std::size_t mMaxLevel;
  LoggerMessage::Severity mSeverity;
  LoggerMessage::Category mCategory;
  Kratos::Flags mOptions;
 
}; // Class LoggerOutput
 
 
 
std::ostream& operator << (std::ostream& rOStream,
  const LoggerOutput& rThis);
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_LOGGER_OUTPUT_H_INCLUDED  defined