Flow123d  JS_before_hm-2198-g122e1f2e2
logger.cc
Go to the documentation of this file.
1 /*!
2  *
3  * Copyright (C) 2015 Technical University of Liberec. All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify it under
6  * the terms of the GNU General Public License version 3 as published by the
7  * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12  *
13  *
14  * @file logger.cc
15  * @brief
16  */
17 
18 
19 #include "system/logger.hh"
20 #include "system/logger_options.hh"
21 #include "system/global_defs.h"
22 #include "system/file_path.hh"
23 
24 #include <iomanip>
25 
26 
27 /// Helper function, use for shorten the code point path
28 std::string cmn_prefix( std::string a, std::string b ) {
29  if( a.size() > b.size() ) std::swap(a,b) ;
30  return std::string( a.begin(), std::mismatch( a.begin(), a.end(), b.begin() ).first ) ;
31 }
32 
33 
34 /*******************************************************************
35  * implementation of StreamMask
36  */
37 
38 StreamMask StreamMask::cout = StreamMask(0b00000001);
39 StreamMask StreamMask::cerr = StreamMask(0b00000010);
40 StreamMask StreamMask::log = StreamMask(0b00000100);
41 
42 
43 StreamMask StreamMask::operator &(const StreamMask &other)
44 {
45  return StreamMask(this->mask_ & other.mask_);
46 }
47 
48 StreamMask StreamMask::operator |(const StreamMask &other)
49 {
50  return StreamMask(this->mask_ | other.mask_);
51 }
52 
53 int StreamMask::operator()(void)
54 {
55  return mask_;
56 }
57 
58 
59 /*******************************************************************
60  * implementation of Logger
61  */
62 
63 
64 Logger::Logger(MsgType type)
65 : type_(type), every_process_(false), line_(0)
66 {
67  // set actual time
68  date_time_ = LoggerOptions::format_hh_mm_ss();
69 
70  // set MPI rank
71  mpi_rank_ = LoggerOptions::get_instance().get_mpi_rank();
72 }
73 
74 
75 Logger::~Logger()
76 {
77  // print output to streams
78  print_to_screen(std::cout, cout_stream_, StreamMask::cout);
79  print_to_screen(std::cerr, cerr_stream_, StreamMask::cerr);
80  if (LoggerOptions::get_instance().is_init())
81  print_to_file(LoggerOptions::get_instance().file_stream_, this->file_stream_, StreamMask::log);
82 }
83 
84 
85 const std::string Logger::msg_type_string(MsgType msg_type, bool full_format)
86 {
87  static std::vector<std::string> type_names = {"WARNING.", "MESSAGE.", "LOG.", "DEBUG.", "ERROR.",
88  "Wrn", "Msg", "Log", "Dbg", "Err"};
89  int type_idx = msg_type;
90 
91  if (full_format) {
92  return type_names[type_idx];
93  } else {
94  return type_names[type_idx + 5];
95  }
96 }
97 
98 
99 Logger& Logger::set_context(const char* file_name, const char* function, const int line)
100 {
101  file_name_ = std::string(file_name);
102  function_ = std::string(function);
103  line_ = line;
104  this->set_mask();
105 
106  return *this;
107 }
108 
109 
110 Logger& Logger::every_proc()
111 {
112  every_process_ = true;
113  this->set_mask();
114 
115  return *this;
116 }
117 
118 void Logger::set_mask()
119 {
120  if ( !every_process_ && (mpi_rank_ > 0) ) return;
121 
122  bool no_log = LoggerOptions::get_instance().no_log_;
123  bool log_ready = LoggerOptions::get_instance().is_init();
124 
125  switch (type_) {
126  case MsgType::warning:
127  case MsgType::error:
128  if (no_log)
129  streams_mask_ = StreamMask::cerr;
130  else
131  streams_mask_ = StreamMask::cerr | StreamMask::log;
132  break;
133  case MsgType::message:
134  if (no_log)
135  streams_mask_ = StreamMask::cout;
136  else
137  streams_mask_ = StreamMask::cout | StreamMask::log;
138  break;
139  case MsgType::log:
140  if (no_log)
141  streams_mask_ = StreamMask();
142  else if (log_ready)
143  streams_mask_ = StreamMask::log;
144  else
145  streams_mask_ = StreamMask::cout;
146  break;
147 #ifdef FLOW123D_DEBUG
148  case MsgType::debug: // for debug build
149  if (no_log)
150  streams_mask_ = StreamMask();
151  else if (log_ready)
152  streams_mask_ = StreamMask::log | StreamMask::cout;
153  else
154  streams_mask_ = StreamMask::cout;
155  break;
156 #else
157  case MsgType::debug: // for release build
158  streams_mask_ = StreamMask();
159  break;
160 
161 #endif
162  default:
163  ASSERT(false);
164  }
165 
166  full_streams_mask_ = full_streams_mask_ | streams_mask_;
167 
168 }
169 
170 
171 
172 void Logger::print_to_screen(std::ostream& stream, std::stringstream& scr_stream, StreamMask mask)
173 {
174  if ( full_streams_mask_() & mask() ) {
175  stream << setfill(' ');
176 
177  // print header, if method returns true, message continues on the same line and first line of message
178  // doesn't need indentation in following while cycle
179  std::stringstream message_stream;
180  bool header_line = this->print_screen_header(message_stream);
181 
182  // print message
183  std::string segment;
184  std::istringstream istream(scr_stream.str());
185  while(std::getline(istream, segment)) {
186  if (header_line) {
187  header_line = false;
188  } else {
189  message_stream << std::setw(18) << "";
190  }
191  message_stream << segment << "\n";
192  }
193 
194  stream << message_stream.str();
195  stream << std::flush;
196  }
197 }
198 
199 
200 void Logger::print_to_file(std::ofstream& stream, std::stringstream& file_stream, StreamMask mask)
201 {
202  if ( full_streams_mask_() & mask() ) {
203  stream << setfill(' ');
204 
205  // print header
206  std::stringstream message_stream;
207  this->print_file_header(message_stream);
208 
209  // print message
210  std::string segment;
211  std::vector<std::string> segments;
212  std::istringstream istream(file_stream.str());
213  while(std::getline(istream, segment)) {
214  segments.push_back(segment);
215  }
216  if (segments.size() > 1) {
217  message_stream << " - |" << "\n";
218  for (auto seg : segments)
219  message_stream << std::setw(4) << "" << seg << "\n";
220  } else if (segments.size() == 1) {
221  message_stream << " - " << segments[0] << "\n";
222  }
223 
224  stream << message_stream.str();
225  stream << std::flush;
226  }
227 }
228 
229 
230 std::string Logger::compact_file_name(std::string file_name)
231 {
232  // if constant FLOW123D_SOURCE_DIR is defined, we try to erase it from beginning of each CodePoint's filepath
233  #ifdef FLOW123D_SOURCE_DIR
234  string common_path = cmn_prefix(string(FLOW123D_SOURCE_DIR), file_name);
235  file_name.erase (0, common_path.size());
236  #endif
237  return file_name;
238 }
239 
240 bool Logger::print_screen_header(std::stringstream& stream)
241 {
242  stream << date_time_ << " ";
243  if (every_process_) { // rank
244  stringstream rank;
245  rank << "[" << mpi_rank_ << "]";
246  stream << setiosflags(ios::left) << std::setw(5) << rank.str();
247  } else {
248  stream << std::setw(5) << "";
249  }
250 
251  stream << msg_type_string(type_);
252  if (type_ == MsgType::debug) {
253  stream << "(" << compact_file_name(file_name_) << ":" << line_ << ")";
254  }
255  return true;
256 }
257 
258 
259 void Logger::print_file_header(std::stringstream& stream)
260 {
261  stream << "- -" << std::setw(13) << "" << "[ ";
262  stream << msg_type_string(type_, false);
263  if (every_process_) { // add 'E' (only for every_proc) + print rank
264  stream << "E, ";
265  if (mpi_rank_ >= 0) stream << setiosflags(ios::right) << std::setw(4) << mpi_rank_;
266  else stream << "null";
267  } else {
268  stream << " , null";
269  }
270  stream << ", \"" << date_time_ << "\"";
271  stream << ", \"" << compact_file_name(file_name_) << "\", " << line_ << ", \"" << function_ << "\"";
272  stream << " ]\n";
273 }
274 
275 
276 
277 /**
278  * implementation of operators
279  */
280 
281 Logger &operator<<(Logger & log, StreamMask mask)
282 {
283  // set mask
284  log.streams_mask_ = mask;
285  log.full_streams_mask_ = log.full_streams_mask_ | log.streams_mask_;
286 
287  return log;
288 }
289 
290 
291 Logger &operator<<(Logger & log, std::ostream & (*pf) (std::ostream &) )
292 {
293  if ( (log.streams_mask_ & StreamMask::cout)() ) pf(log.cout_stream_);
294  if ( (log.streams_mask_ & StreamMask::cerr)() ) pf(log.cerr_stream_);
295  if ( (log.streams_mask_ & StreamMask::log)() ) pf(log.file_stream_);
296  return log;
297 }
Logger::streams_mask_
StreamMask streams_mask_
Mask of logger, specifies streams in actual time into which to be written.
Definition: logger.hh:219
StreamMask::cerr
static StreamMask cerr
Predefined mask of std::cerr output.
Definition: logger.hh:55
Logger::msg_type_string
static const std::string msg_type_string(MsgType msg_type, bool full_format=true)
Return string value of given MsgType in full or shorter format (e.g. "WARNING" of "Wrn")
Definition: logger.cc:85
StreamMask::mask_
int mask_
Definition: logger.hh:70
StreamMask
Helper class, store mask specifying streams.
Definition: logger.hh:41
StreamMask::log
static StreamMask log
Predefined mask of log file output.
Definition: logger.hh:58
Logger::every_process_
bool every_process_
Flag marked if log message is printing for all processes or only for zero process.
Definition: logger.hh:213
std::swap
void swap(nlohmann::json &j1, nlohmann::json &j2) noexcept(is_nothrow_move_constructible< nlohmann::json >::value and is_nothrow_move_assignable< nlohmann::json >::value)
exchanges the values of two JSON objects
Definition: json.hpp:8688
Logger::cerr_stream_
std::stringstream cerr_stream_
Store messages printed to cerr output stream.
Definition: logger.hh:209
ASSERT
#define ASSERT(expr)
Allow use shorter versions of macro names if these names is not used with external library.
Definition: asserts.hh:347
Logger::file_stream_
std::stringstream file_stream_
Store messages printed to file.
Definition: logger.hh:210
LoggerOptions::no_log_
bool no_log_
Turn off logger file output.
Definition: logger_options.hh:105
file_path.hh
Logger::print_to_screen
void print_to_screen(std::ostream &stream, std::stringstream &scr_stream, StreamMask mask)
Print formated message to given screen stream if mask corresponds with streams_mask_.
Definition: logger.cc:172
Logger::file_name_
std::string file_name_
Actual file.
Definition: logger.hh:214
Logger::print_screen_header
bool print_screen_header(std::stringstream &scr_stream)
Print header to screen stream, helper method called from print_to_screen.
Definition: logger.cc:240
StreamMask::operator&
StreamMask operator&(const StreamMask &other)
Definition: logger.cc:43
std::vector< std::string >
Logger::every_proc
Logger & every_proc()
Set flag every_process_ to true.
Definition: logger.cc:110
Logger::full_streams_mask_
StreamMask full_streams_mask_
Mask of logger, specifies all streams into which to be written in logger message.
Definition: logger.hh:220
Logger::line_
int line_
Actual line.
Definition: logger.hh:216
Logger::Logger
Logger(MsgType type)
Constructor.
Definition: logger.cc:64
Logger::compact_file_name
std::string compact_file_name(std::string file_name)
Return compact (relative) path to the given source file.
Definition: logger.cc:230
LoggerOptions::get_instance
static LoggerOptions & get_instance()
Getter of singleton instance object.
Definition: logger_options.cc:31
LoggerOptions::get_mpi_rank
int get_mpi_rank()
Returns number of actual process, if MPI is not supported returns -1.
Definition: logger_options.cc:85
Logger::date_time_
std::string date_time_
Actual date and time.
Definition: logger.hh:217
Logger::set_mask
void set_mask()
Set streams_mask_ according to the type of message.
Definition: logger.cc:118
cmn_prefix
std::string cmn_prefix(std::string a, std::string b)
Helper function, use for shorten the code point path.
Definition: logger.cc:28
Logger::type_
MsgType type_
Type of message.
Definition: logger.hh:212
Logger::print_to_file
void print_to_file(std::ofstream &stream, std::stringstream &file_stream, StreamMask mask)
Print formated message to given file stream if mask corresponds with streams_mask_.
Definition: logger.cc:200
Logger::set_context
Logger & set_context(const char *file_name, const char *function, const int line)
Stores values for printing out line number, function, etc.
Definition: logger.cc:99
logger.hh
LoggerOptions::is_init
bool is_init()
Check if singleton instance object is initialize.
Definition: logger_options.hh:79
Logger::MsgType
MsgType
Enum of types of Logger messages.
Definition: logger.hh:150
Logger::~Logger
~Logger()
Destructor.
Definition: logger.cc:75
StreamMask::cout
static StreamMask cout
Predefined mask of std::cout output.
Definition: logger.hh:52
StreamMask::operator()
int operator()(void)
Definition: logger.cc:53
Logger::cout_stream_
std::stringstream cout_stream_
Store messages printed to cout output stream.
Definition: logger.hh:208
operator<<
Logger & operator<<(Logger &log, StreamMask mask)
Definition: logger.cc:281
StreamMask::operator|
StreamMask operator|(const StreamMask &other)
Definition: logger.cc:48
global_defs.h
Global macros to enhance readability and debugging, general constants.
StreamMask::StreamMask
StreamMask()
Empty constructor.
Definition: logger.hh:44
Logger::function_
std::string function_
Actual function.
Definition: logger.hh:215
Logger::mpi_rank_
int mpi_rank_
Actual process (if MPI is supported)
Definition: logger.hh:218
Logger
Class for storing logger messages.
Definition: logger.hh:135
Logger::print_file_header
void print_file_header(std::stringstream &file_stream)
Print header to file stream, helper method called from print_to_file.
Definition: logger.cc:259
LoggerOptions::format_hh_mm_ss
static std::string format_hh_mm_ss()
Definition: logger_options.cc:37
logger_options.hh
Generated by   doxygen 1.8.17