From ad8fc14cf55ab1dcee6b945ca941c42691d7c408 Mon Sep 17 00:00:00 2001 From: nojhan Date: Sun, 1 Nov 2020 19:23:48 +0100 Subject: [PATCH] fix build script to handle documentation correctly - make doc target was disabled by default. - update documentation. --- build_all.sh | 1 + docs/classclutchlog-members.html | 31 ++++---- docs/classclutchlog.html | 11 +-- docs/clutchlog_8h.html | 9 ++- docs/clutchlog_8h_source.html | 67 +++++++++--------- docs/dir_000036_000000.html | 2 +- .../dir_59425e443f801f1f2fd8bbe4959a3ccf.html | 2 +- ...r_59425e443f801f1f2fd8bbe4959a3ccf_dep.map | 2 +- ...r_59425e443f801f1f2fd8bbe4959a3ccf_dep.md5 | 2 +- ...r_59425e443f801f1f2fd8bbe4959a3ccf_dep.png | Bin 2402 -> 2465 bytes docs/globals.html | 9 +++ docs/globals_defs.html | 9 +++ docs/group__DefaultConfigMacros.html | 6 +- docs/group__UseMacros.html | 49 +++++++++++-- docs/index.html | 50 +++++++++---- docs/search/all_1.js | 3 + 16 files changed, 177 insertions(+), 76 deletions(-) diff --git a/build_all.sh b/build_all.sh index 500fcd2..12aa9f1 100755 --- a/build_all.sh +++ b/build_all.sh @@ -25,6 +25,7 @@ done echo "Update documentation" cd Debug_ON +cmake -DBUILD_DOCUMENTATION=ON .. make doc cp -r html/* ../docs/ diff --git a/docs/classclutchlog-members.html b/docs/classclutchlog-members.html index d1efec5..3d671bb 100644 --- a/docs/classclutchlog-members.html +++ b/docs/classclutchlog-members.html @@ -93,24 +93,25 @@ $(function() { level enum nameclutchlog level_of(const std::string name)clutchloginline line(std::string line)clutchloginline - locate(const level &stage, const std::string &file, const std::string &func, const size_t line) constclutchloginlineprotected + locate(const level &stage, const std::string &file, const std::string &func, const size_t line) constclutchloginline location(const std::string &in_file, const std::string &in_function=".*", const std::string &in_line=".*")clutchloginline log(const level &stage, const std::string &what, const std::string &file, const std::string &func, size_t line) constclutchloginline logger()clutchloginlinestatic - note enum value (defined in clutchlog)clutchlog - operator=(clutchlog const &)=delete (defined in clutchlog)clutchlog - out(std::ostream &out)clutchloginline - out()clutchloginline - progress enum value (defined in clutchlog)clutchlog - replace(const std::string &form, const std::string &mark, const std::string &tag) constclutchloginline - replace(const std::string &form, const std::string &mark, const size_t tag) constclutchloginline - style(level stage, FMT... styles)clutchloginline - style(level stage, fmt style)clutchloginline - style(level stage) constclutchloginline - threshold(level l)clutchloginline - threshold() constclutchloginline - warning enum value (defined in clutchlog)clutchlog - xdebug enum value (defined in clutchlog)clutchlog + max_buffer (defined in clutchlog)clutchlogprotectedstatic + note enum value (defined in clutchlog)clutchlog + operator=(clutchlog const &)=delete (defined in clutchlog)clutchlog + out(std::ostream &out)clutchloginline + out()clutchloginline + progress enum value (defined in clutchlog)clutchlog + replace(const std::string &form, const std::string &mark, const std::string &tag) constclutchloginline + replace(const std::string &form, const std::string &mark, const size_t tag) constclutchloginline + style(level stage, FMT... styles)clutchloginline + style(level stage, fmt style)clutchloginline + style(level stage) constclutchloginline + threshold(level l)clutchloginline + threshold() constclutchloginline + warning enum value (defined in clutchlog)clutchlog + xdebug enum value (defined in clutchlog)clutchlog
diff --git a/docs/classclutchlog.html b/docs/classclutchlog.html index 171ae1f..b62fa5c 100644 --- a/docs/classclutchlog.html +++ b/docs/classclutchlog.html @@ -143,6 +143,10 @@ void  Return the log level tag corresponding to the given pre-configured name. More...
 
Low-level API
+ +scope_t locate (const level &stage, const std::string &file, const std::string &func, const size_t line) const + Gather information on the current location of the call.
+  std::string replace (const std::string &form, const std::string &mark, const std::string &tag) const  Replace mark by tag in form. More...
  @@ -219,16 +223,15 @@ std::regex _in_func std::regex _in_line   + +static const size_t max_buffer = 4096 +   clutchlog (clutchlog const &)=delete   void operator= (clutchlog const &)=delete   - -scope_t locate (const level &stage, const std::string &file, const std::string &func, const size_t line) const - Gather information on the current location of the call.
- 

Member Function Documentation

diff --git a/docs/clutchlog_8h.html b/docs/clutchlog_8h.html index c114ced..b520bcd 100644 --- a/docs/clutchlog_8h.html +++ b/docs/clutchlog_8h.html @@ -120,10 +120,12 @@ Macros  Default item separator for dump.
  -#define CLUTCHLOG_DEFAULT_DEPTH_MARK   ">" +#define CLUTCHLOG_DEFAULT_DEPTH_MARK   ">" + Default mark for stack depth.
  -#define CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG   clutchlog::level::progress +#define CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG   clutchlog::level::progress + Default level over which calls to the logger are optimized out when NDEBUG is defined.
  #define CLUTCHLOC   __FILE__, __FUNCTION__, __LINE__ @@ -135,6 +137,9 @@ Macros #define CLUTCHDUMP(LEVEL, CONTAINER, FILENAME)  Dump the given container. More...
  +#define CLUTCHFUNC(LEVEL, FUNC, ...) + Call an assert at the given level. More...
+  diff --git a/docs/clutchlog_8h_source.html b/docs/clutchlog_8h_source.html index 3b8ccbb..5c7384a 100644 --- a/docs/clutchlog_8h_source.html +++ b/docs/clutchlog_8h_source.html @@ -67,42 +67,43 @@ $(function() {
clutchlog.h
-Go to the documentation of this file.
1 #ifndef __CLUTCHLOG_H__
2 #define __CLUTCHLOG_H__
3 #pragma once
4 
7 #include <filesystem>
8 #include <iostream>
9 #include <sstream>
10 #include <fstream>
11 #include <cassert>
12 #include <cstdlib>
13 #include <string>
14 #include <limits>
15 #include <regex>
16 #include <map>
17 
18 #if __has_include(<execinfo.h>) && __has_include(<stdlib.h>) && __has_include(<libgen.h>)
19 #include <execinfo.h> // execinfo
20 #include <stdlib.h> // getenv
21 #include <libgen.h> // basename
22 #define CLUTCHLOG_HAVE_UNIX_SYSINFO 1
23 #else
24 #define CLUTCHLOG_HAVE_UNIX_SYSINFO 0
25 #endif
26 
27 /**********************************************************************
28  * Enable by default in Debug builds.
29  **********************************************************************/
30 #ifndef WITH_CLUTCHLOG
31 #ifndef NDEBUG
32 #define WITH_CLUTCHLOG
33 #endif
34 #endif
35 
36 /**********************************************************************
37  * Macros definitions
38  **********************************************************************/
39 #ifdef WITH_CLUTCHLOG
40 
44 #ifndef CLUTCHLOG_DEFAULT_FORMAT
45 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
47 #define CLUTCHLOG_DEFAULT_FORMAT "[{name}] {level_letter}:{depth_marks} {msg}\t\t\t\t\t{func} @ {file}:{line}\n"
48 #else
49 #define CLUTCHLOG_DEFAULT_FORMAT "{level_letter} {msg}\t\t\t\t\t{func} @ {file}:{line}\n"
50 #endif
51 #endif // CLUTCHLOG_DEFAULT_FORMAT
52 
53 #ifndef CLUTCHDUMP_DEFAULT_FORMAT
54 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
56 #define CLUTCHDUMP_DEFAULT_FORMAT "# [{name}] {level} in {func} (at depth {depth}) @ {file}:{line}"
57 #else
58 #define CLUTCHDUMP_DEFAULT_FORMAT "# {level} in {func} @ {file}:{line}"
59 #endif
60 #endif // CLUTCHDUMP_DEFAULT_FORMAT
61 
62 #ifndef CLUTCHDUMP_DEFAULT_SEP
63 #define CLUTCHDUMP_DEFAULT_SEP "\n"
65 #endif // CLUTCHDUMP_DEFAULT_SEP
66 
67 #ifndef CLUTCHLOG_DEFAULT_DEPTH_MARK
68 #define CLUTCHLOG_DEFAULT_DEPTH_MARK ">"
69 #endif // CLUTCHLOG_DEFAULT_DEPTH_MARK
70 
71 #ifndef CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG
72 #define CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG clutchlog::level::progress
73 #endif // CLUTCHLOG_DEFAULT_DEPTH_BUILT
74 
80 #define CLUTCHLOC __FILE__, __FUNCTION__, __LINE__
82 
84 #ifndef NDEBUG
85 #define CLUTCHLOG( LEVEL, WHAT ) { \
86  auto& logger = clutchlog::logger(); \
87  std::ostringstream msg ; msg << WHAT; \
88  logger.log(clutchlog::level::LEVEL, msg.str(), CLUTCHLOC); \
89 }
90 #else // not Debug build.
91 #define CLUTCHLOG( LEVEL, WHAT ) { \
92  if(clutchlog::level::LEVEL <= CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG) { \
93  auto& logger = clutchlog::logger(); \
94  std::ostringstream msg ; msg << WHAT; \
95  logger.log(clutchlog::level::LEVEL, msg.str(), CLUTCHLOC); \
96  } \
97 }
98 #endif // NDEBUG
99 
101 #ifndef NDEBUG
102 #define CLUTCHDUMP( LEVEL, CONTAINER, FILENAME ) { \
103  auto& logger = clutchlog::logger(); \
104  logger.dump(clutchlog::level::LEVEL, std::begin(CONTAINER), std::end(CONTAINER), \
105  CLUTCHLOC, FILENAME, CLUTCHDUMP_DEFAULT_SEP); \
106 }
107 #else // not Debug build.
108 #define CLUTCHDUMP( LEVEL, CONTAINER, FILENAME ) { \
109  if(clutchlog::level::LEVEL <= CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG) { \
110  auto& logger = clutchlog::logger(); \
111  logger.dump(clutchlog::level::LEVEL, std::begin(CONTAINER), std::end(CONTAINER), \
112  CLUTCHLOC, FILENAME, CLUTCHDUMP_DEFAULT_SEP); \
113  } \
114 }
115 #endif // NDEBUG
116 
119 #else // not WITH_CLUTCHLOG
120 // Disabled macros can still be used in Release builds.
121 #define CLUTCHLOG( LEVEL, WHAT ) { do {/*nothing*/} while(false); }
122 #define CLUTCHDUMP( LEVEL, CONTAINER, FILENAME ) { do {/*nothing*/} while(false); }
123 #endif // WITH_CLUTCHLOG
124 
125 /**********************************************************************
126  * Implementation
127  **********************************************************************/
128 
129 #ifdef WITH_CLUTCHLOG
130 
137 class clutchlog
138 {
139  public:
149  static clutchlog& logger()
150  {
151  static clutchlog instance;
152  return instance;
153  }
154 
156  enum level {critical=0, error=1, warning=2, progress=3, note=4, info=5, debug=6, xdebug=7};
157 
170  class fmt {
171  public:
173  enum class fg {
174  black = 30,
175  red = 31,
176  green = 32,
177  yellow = 33,
178  blue = 34,
179  magenta = 35,
180  cyan = 36,
181  white = 37,
182  none
183  } fore;
184 
186  enum class bg {
187  black = 40,
188  red = 41,
189  green = 42,
190  yellow = 43,
191  blue = 44,
192  magenta = 45,
193  cyan = 46,
194  white = 47,
195  none
196  } back;
197 
199  enum class typo {
200  reset = 0,
201  bold = 1,
202  underline = 4,
203  inverse = 7,
204  none
205  } style;
206 
208  fmt() : fore(fg::none), back(bg::none), style(typo::none) { }
209 
212  fmt( fg f, bg b = bg::none, typo s = typo::none) : fore(f), back(b), style(s) { }
213  fmt( fg f, typo s , bg b = bg::none) : fore(f), back(b), style(s) { }
214  fmt( bg b, fg f = fg::none, typo s = typo::none) : fore(f), back(b), style(s) { }
215  fmt( bg b, typo s , fg f = fg::none) : fore(f), back(b), style(s) { }
216  fmt(typo s, fg f = fg::none, bg b = bg::none) : fore(f), back(b), style(s) { }
217  fmt(typo s, bg b , fg f = fg::none) : fore(f), back(b), style(s) { }
220  protected:
222  std::ostream& print_on( std::ostream& os) const
223  {
224  std::vector<int> codes; codes.reserve(3);
225  if(this->fore != fg::none) { codes.push_back(static_cast<int>(this->fore ));}
226  if(this->back != bg::none) { codes.push_back(static_cast<int>(this->back ));}
227  if(this->style != typo::none) { codes.push_back(static_cast<int>(this->style));}
228  if(codes.size() == 0) {return os;}
229 
230  os << "\033[";
231  assert(codes.size() > 0);
232  os << codes[0];
233  for(size_t i=1; i < codes.size(); ++i) {
234  os << ";" << codes[i];
235  }
236  os << "m";
237  return os;
238  }
239 
240  public:
252  friend std::ostream& operator<<(std::ostream& os, const fmt& fmt)
253  {
254  return fmt.print_on(os);
255  }
256 
267  std::string operator()( const std::string& msg ) const
268  {
269  std::ostringstream os;
270  this->print_on(os);
271  fmt reset(fmt::typo::reset);
272  os << msg;
273  reset.print_on(os);
274  return os.str();
275  }
276  }; // fmt class
277 
284  public:
285  clutchlog(clutchlog const&) = delete;
286  void operator=(clutchlog const&) = delete;
287 
288  private:
289  clutchlog() :
290  // system, main, log
291  _strip_calls(5),
292  _level_word({
293  {level::critical,"Critical"},
294  {level::error ,"Error"},
295  {level::warning ,"Warning"},
296  {level::progress,"Progress"},
297  {level::note ,"Note"},
298  {level::info ,"Info"},
299  {level::debug ,"Debug"},
300  {level::xdebug ,"XDebug"}
301  }),
302  _level_fmt({
303  {level::critical,fmt(fmt::fg::red, fmt::typo::underline)},
304  {level::error ,fmt(fmt::fg::red, fmt::typo::bold)},
305  {level::warning ,fmt(fmt::fg::magenta, fmt::typo::bold)},
306  {level::progress,fmt()},
307  {level::note ,fmt()},
308  {level::info ,fmt()},
309  {level::debug ,fmt()},
310  {level::xdebug ,fmt()}
311  }),
312  _format_log(CLUTCHLOG_DEFAULT_FORMAT),
313  _format_dump(CLUTCHDUMP_DEFAULT_FORMAT),
314  _out(&std::clog),
315 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
316  _depth(std::numeric_limits<size_t>::max() - _strip_calls),
317  _depth_mark(CLUTCHLOG_DEFAULT_DEPTH_MARK),
318 #endif
319  _stage(level::error),
320  _in_file(".*"),
321  _in_func(".*"),
322  _in_line(".*")
323  {
324  // Reverse the level->word map into a word->level map.
325  for(auto& lw : _level_word) {
326  _word_level[lw.second] = lw.first;
327  }
328  }
329 
330  protected:
331  const size_t _strip_calls;
332  const std::map<level,std::string> _level_word;
333  std::map<std::string,level> _word_level;
334  std::map<level,fmt> _level_fmt;
335  std::string _format_log;
336  std::string _format_dump;
337  std::ostream* _out;
338 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
339  size_t _depth;
340  std::string _depth_mark;
341 #endif
342  level _stage;
343  std::regex _in_file;
344  std::regex _in_func;
345  std::regex _in_line;
346 
348  struct scope_t {
349  bool matches; // everything is compatible
350  level stage; // current log level
351 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
352  size_t depth; // current depth
353 #endif
354  bool there; // location is compatible
355  scope_t() :
356  matches(false),
357  stage(level::xdebug),
358 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
359  depth(0),
360 #endif
361  there(false)
362  {}
363  };
364 
366  scope_t locate(
367  const level& stage,
368  const std::string& file,
369  const std::string& func,
370  const size_t line
371  ) const
372  {
373  scope_t scope; // False scope by default.
374 
375  /***** Log level stage *****/
376  // Test stage first, because it's fastest.
377  scope.stage = stage;
378  if(not (scope.stage <= _stage)) {
379  // Bypass useless computations if no match
380  // because of the stage.
381  return scope;
382  }
383 
384 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
385  /***** Stack depth *****/
386  // Backtrace in second, quite fast.
387  const size_t max_buffer = 4096;
388  size_t stack_depth;
389  void *buffer[max_buffer];
390  stack_depth = backtrace(buffer, max_buffer);
391  scope.depth = stack_depth;
392  if(not (scope.depth <= _depth + _strip_calls)) {
393  // Bypass if no match.
394  return scope;
395  }
396 #endif
397 
398  /***** Location *****/
399  // Location last, slowest.
400  std::ostringstream sline; sline << line;
401  scope.there =
402  std::regex_search(file, _in_file)
403  and std::regex_search(func, _in_func)
404  and std::regex_search(sline.str(), _in_line);
405 
406  // No need to retest stage and depth, which are true here.
407  scope.matches = scope.there;
408 
409  return scope;
410  }
411 
414  public:
415 
419  void format(const std::string& format) {_format_log = format;}
422  std::string format() const {return _format_log;}
423 
425  void format_comment(const std::string& format) {_format_dump = format;}
427  std::string format_comment() const {return _format_dump;}
428 
430  void out(std::ostream& out) {_out = &out;}
432  std::ostream& out() {return *_out;}
433 
434 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
435  void depth(size_t d) {_depth = d;}
438  size_t depth() const {return _depth;}
439 
441  void depth_mark(std::string mark) {_depth_mark = mark;}
443  std::string depth_mark() const {return _depth_mark;}
444 #endif
445 
447  void threshold(level l) {_stage = l;}
449  level threshold() const {return _stage;}
450 
452  void file(std::string file) {_in_file = file;}
454  void func(std::string func) {_in_func = func;}
456  void line(std::string line) {_in_line = line;}
457 
459  void location(
460  const std::string& in_file,
461  const std::string& in_function=".*",
462  const std::string& in_line=".*"
463  )
464  {
465  file(in_file);
466  func(in_function);
467  line(in_line);
468  }
469 
474  template<class ... FMT>
475  void style(level stage, FMT... styles) { this->style(stage,fmt(styles...)); }
477  void style(level stage, fmt style) { _level_fmt.at(stage) = style; }
479  fmt style(level stage) const { return _level_fmt.at(stage); }
480 
485  level level_of(const std::string name)
486  {
487  const auto ilevel = _word_level.find(name);
488  if( ilevel != std::end(_word_level)) {
489  return ilevel->second;
490  } else {
491  throw std::out_of_range("'" + name + "' is not a valid log level name");
492  }
493  }
494 
497  public:
498 
509  std::string replace(
510  const std::string& form,
511  const std::string& mark,
512  const std::string& tag
513  ) const
514  {
515  // Useless debug code, unless something fancy would be done with name tags.
516  // std::regex re;
517  // try {
518  // re = std::regex(mark);
519  //
520  // } catch(const std::regex_error& e) {
521  // std::cerr << "ERROR with a regular expression \"" << mark << "\": ";
522  // switch(e.code()) {
523  // case std::regex_constants::error_collate:
524  // std::cerr << "the expression contains an invalid collating element name";
525  // break;
526  // case std::regex_constants::error_ctype:
527  // std::cerr << "the expression contains an invalid character class name";
528  // break;
529  // case std::regex_constants::error_escape:
530  // std::cerr << "the expression contains an invalid escaped character or a trailing escape";
531  // break;
532  // case std::regex_constants::error_backref:
533  // std::cerr << "the expression contains an invalid back reference";
534  // break;
535  // case std::regex_constants::error_brack:
536  // std::cerr << "the expression contains mismatched square brackets ('[' and ']')";
537  // break;
538  // case std::regex_constants::error_paren:
539  // std::cerr << "the expression contains mismatched parentheses ('(' and ')')";
540  // break;
541  // case std::regex_constants::error_brace:
542  // std::cerr << "the expression contains mismatched curly braces ('{' and '}')";
543  // break;
544  // case std::regex_constants::error_badbrace:
545  // std::cerr << "the expression contains an invalid range in a {} expression";
546  // break;
547  // case std::regex_constants::error_range:
548  // std::cerr << "the expression contains an invalid character range (e.g. [b-a])";
549  // break;
550  // case std::regex_constants::error_space:
551  // std::cerr << "there was not enough memory to convert the expression into a finite state machine";
552  // break;
553  // case std::regex_constants::error_badrepeat:
554  // std::cerr << "one of *?+{ was not preceded by a valid regular expression";
555  // break;
556  // case std::regex_constants::error_complexity:
557  // std::cerr << "the complexity of an attempted match exceeded a predefined level";
558  // break;
559  // case std::regex_constants::error_stack:
560  // std::cerr << "there was not enough memory to perform a match";
561  // break;
562  // default:
563  // std::cerr << "unknown error";
564  // }
565  // std::cerr << std::endl;
566  // throw;
567  // } // catch
568 
569  const std::regex re(mark);
570  return std::regex_replace(form, re, tag);
571  }
572 
574  std::string replace(
575  const std::string& form,
576  const std::string& mark,
577  const size_t tag
578  ) const
579  {
580  std::ostringstream stag; stag << tag;
581  return replace(form, mark, stag.str());
582  }
583 
585  std::string format(
586  std::string format,
587  const std::string& what,
588 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
589  const std::string& name,
590 #endif
591  const level& stage,
592  const std::string& file,
593  const std::string& func,
594  const size_t line
595 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
596  ,
597  const size_t depth
598 #endif
599  ) const
600  {
601  format = replace(format, "\\{msg\\}", what);
602  format = replace(format, "\\{file\\}", file);
603  format = replace(format, "\\{func\\}", func);
604  format = replace(format, "\\{line\\}", line);
605 
606  format = replace(format, "\\{level\\}", _level_word.at(stage));
607  std::string letter(1, _level_word.at(stage).at(0)); // char -> string
608  format = replace(format, "\\{level_letter\\}", letter);
609 
610 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
611  format = replace(format, "\\{name\\}", name);
612  format = replace(format, "\\{depth\\}", depth);
613 
614  std::ostringstream chevrons;
615  for(size_t i = _strip_calls; i < depth; ++i) {
616  chevrons << _depth_mark;
617  }
618  format = replace(format, "\\{depth_marks\\}", chevrons.str());
619 #endif
620 
621  return _level_fmt.at(stage)(format);
622  }
623 
625  void log(
626  const level& stage,
627  const std::string& what,
628  const std::string& file, const std::string& func, size_t line
629  ) const
630  {
631  scope_t scope = locate(stage, file, func, line);
632 
633  if(scope.matches) {
634 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
635  *_out << format(_format_log, what, basename(getenv("_")),
636  stage, file, func,
637  line, scope.depth );
638 #else
639  *_out << format(_format_log, what,
640  stage, file, func,
641  line );
642 
643 #endif
644  _out->flush();
645  } // if scopes.matches
646  }
647 
649  template<class In>
650  void dump(
651  const level& stage,
652  const In container_begin, const In container_end,
653  const std::string& file, const std::string& func, size_t line,
654  const std::string& filename_template="dump_{n}.dat",
655  const std::string sep=CLUTCHDUMP_DEFAULT_SEP
656  ) const
657  {
658  scope_t scope = locate(stage, file, func, line);
659 
660  if(scope.matches) {
661  const std::string tag = "\\{n\\}";
662  const std::regex re(tag);
663  std::string outfile = "";
664 
665  // If the file name template has the {n} tag.
666  if(std::regex_search(filename_template, re)) {
667  // Increment n until a free one is found.
668  size_t n = 0;
669  do {
670  outfile = replace(filename_template, tag, n);
671  n++;
672  } while( std::filesystem::exists( outfile ) );
673 
674  } else {
675  // Use the parameter as is.
676  outfile = filename_template;
677  }
678 
679  std::ofstream fd(outfile);
680 
681  if(_format_dump.size() > 0) {
682 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
683  fd << format(_format_dump, "", basename(getenv("_")),
684  stage, file, func,
685  line, scope.depth );
686 #else
687  fd << format(_format_dump, "",
688  stage, file, func,
689  line );
690 #endif
691  fd << sep; // sep after comment line.
692  }
693 
694  std::copy(container_begin, container_end,
695  std::ostream_iterator<typename In::value_type>(fd, sep.c_str()));
696 
697  fd.close();
698  } // if scopes.matches
699  }
700 
702 };
703 
706 #else // not WITH_CLUTCHLOG
707 
708 
709 /**********************************************************************
710  * Fake implementation
711  **********************************************************************/
712 
713 // Equivalent class with empty methods, will be optimized out
714 // while allowing to actually have calls implemented without WITH_CLUTCHLOG guards.
715 #pragma GCC diagnostic push
716 #pragma GCC diagnostic ignored "-Wreturn-type"
717 class clutchlog
718 {
719  public:
720  static clutchlog& logger() { }
721  enum level {critical=0, error=1, warning=2, progress=3, note=4, info=5, debug=6, xdebug=7};
722  class fmt {
723  public:
724  enum class fg { black, red, green, yellow, blue, magenta, cyan, white, none } fore;
725  enum class bg { black, red, green, yellow, blue, magenta, cyan, white, none } back;
726  enum class typo { reset, bold, underline, inverse, none } style;
727  fmt() : fore(fg::none), back(bg::none), style(typo::none) { }
728  fmt( fg f, bg b = bg::none, typo s = typo::none) : fore(f), back(b), style(s) { }
729  fmt( fg f, typo s , bg b = bg::none) : fore(f), back(b), style(s) { }
730  fmt( bg b, fg f = fg::none, typo s = typo::none) : fore(f), back(b), style(s) { }
731  fmt( bg b, typo s , fg f = fg::none) : fore(f), back(b), style(s) { }
732  fmt(typo s, fg f = fg::none, bg b = bg::none) : fore(f), back(b), style(s) { }
733  fmt(typo s, bg b , fg f = fg::none) : fore(f), back(b), style(s) { }
734  protected:
735  std::ostream& print_on(std::ostream&) const { }
736  public:
737  friend std::ostream& operator<<(std::ostream&, const fmt&) { }
738  std::string operator()(const std::string&) const { }
739  };
740  public:
741  clutchlog(clutchlog const&) = delete;
742  void operator=(clutchlog const&) = delete;
743  private:
744  clutchlog() {}
745  protected:
746  struct scope_t {};
747  scope_t locate(
748  const level&,
749  const std::string&,
750  const std::string&,
751  const size_t
752  ) const
753  { }
754  public:
755  void format(const std::string&) {}
756  std::string format() const {}
757 
758  void format_comment(const std::string&) {}
759  std::string format_comment() const {}
760 
761  void out(std::ostream&) {}
762  std::ostream& out() {}
763 
764 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
765  void depth(size_t) {}
766  size_t depth() const {}
767 
768  void depth_mark(std::string) {}
769  std::string depth_mark() const {}
770 #endif
771 
772  void threshold(level) {}
773  level threshold() const {}
774 
775  void file(std::string) {}
776  void func(std::string) {}
777  void line(std::string) {}
778 
779 #pragma GCC diagnostic push
780 #pragma GCC diagnostic ignored "-Wunused-parameter"
781  void location(
782  const std::string&,
783  const std::string& in_function=".*",
784  const std::string& in_line=".*"
785  )
786  { }
787 #pragma GCC diagnostic pop
788  void style(level, fmt) { }
789  fmt style(level) const { }
790  level level_of(const std::string) { }
791  public:
792  std::string replace(
793  const std::string&,
794  const std::string&,
795  const std::string&
796  ) const
797  { }
798 
799  std::string replace(
800  const std::string&,
801  const std::string&,
802  const size_t
803  ) const
804  { }
805 
806  std::string format(
807  std::string,
808  const std::string&,
809 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
810  const std::string&,
811 #endif
812  const level&,
813  const std::string&,
814  const std::string&,
815  const size_t
816 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
817  ,
818  const size_t
819 #endif
820  ) const
821  { }
822 
823  void log(
824  const level&,
825  const std::string&,
826  const std::string&, const std::string&, size_t
827  ) const
828  { }
829 
830  template<class In>
831  void dump(
832  const level&,
833  const In, const In,
834  const std::string&, const std::string&, size_t,
835  const std::string&,
836  const std::string
837  ) const
838  { }
839 };
840 #pragma GCC diagnostic pop
841 #endif // WITH_CLUTCHLOG
842 
843 #endif // __CLUTCHLOG_H__
clutchlog::threshold
void threshold(level l)
Set the log level below which logs are not printed.
Definition: clutchlog.h:447
-
clutchlog::out
void out(std::ostream &out)
Set the output stream on which to print.
Definition: clutchlog.h:430
-
clutchlog
Definition: clutchlog.h:137
-
clutchlog::log
void log(const level &stage, const std::string &what, const std::string &file, const std::string &func, size_t line) const
Print a log message IF the location matches the given one.
Definition: clutchlog.h:625
-
clutchlog::replace
std::string replace(const std::string &form, const std::string &mark, const std::string &tag) const
Replace mark by tag in form.
Definition: clutchlog.h:509
-
clutchlog::func
void func(std::string func)
Set the regular expression filtering the function location.
Definition: clutchlog.h:454
-
clutchlog::format
std::string format() const
Get the template string.
Definition: clutchlog.h:422
-
clutchlog::line
void line(std::string line)
Set the regular expression filtering the line location.
Definition: clutchlog.h:456
-
clutchlog::location
void location(const std::string &in_file, const std::string &in_function=".*", const std::string &in_line=".*")
Set the regular expressions filtering the location.
Definition: clutchlog.h:459
-
clutchlog::format_comment
void format_comment(const std::string &format)
Set the template string for dumps.
Definition: clutchlog.h:425
-
clutchlog::format_comment
std::string format_comment() const
Get the template string for dumps.
Definition: clutchlog.h:427
-
clutchlog::fmt::fmt
fmt()
 Empty constructor, only useful for a no-op formatter.
Definition: clutchlog.h:208
-
clutchlog::format
std::string format(std::string format, const std::string &what, const level &stage, const std::string &file, const std::string &func, const size_t line) const
Substitute all tags in the format string with the corresponding information and apply the style corre...
Definition: clutchlog.h:585
-
clutchlog::scope_t
Structure holding a location matching.
Definition: clutchlog.h:348
-
clutchlog::locate
scope_t locate(const level &stage, const std::string &file, const std::string &func, const size_t line) const
Gather information on the current location of the call.
Definition: clutchlog.h:366
+Go to the documentation of this file.
1 #ifndef __CLUTCHLOG_H__
2 #define __CLUTCHLOG_H__
3 #pragma once
4 
7 #include <filesystem>
8 #include <iostream>
9 #include <sstream>
10 #include <fstream>
11 #include <cassert>
12 #include <cstdlib>
13 #include <string>
14 #include <limits>
15 #include <regex>
16 #include <map>
17 
18 #if __has_include(<execinfo.h>) && __has_include(<stdlib.h>) && __has_include(<libgen.h>)
19 #include <execinfo.h> // execinfo
20 #include <stdlib.h> // getenv
21 #include <libgen.h> // basename
22 #define CLUTCHLOG_HAVE_UNIX_SYSINFO 1
23 #else
24 #define CLUTCHLOG_HAVE_UNIX_SYSINFO 0
25 #endif
26 
27 /**********************************************************************
28  * Enable by default in Debug builds.
29  **********************************************************************/
30 #ifndef WITH_CLUTCHLOG
31 #ifndef NDEBUG
32 #define WITH_CLUTCHLOG
33 #endif
34 #endif
35 
36 /**********************************************************************
37  * Macros definitions
38  **********************************************************************/
39 #ifdef WITH_CLUTCHLOG
40 
44 #ifndef CLUTCHLOG_DEFAULT_FORMAT
45 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
47 #define CLUTCHLOG_DEFAULT_FORMAT "[{name}] {level_letter}:{depth_marks} {msg}\t\t\t\t\t{func} @ {file}:{line}\n"
48 #else
49 #define CLUTCHLOG_DEFAULT_FORMAT "{level_letter} {msg}\t\t\t\t\t{func} @ {file}:{line}\n"
50 #endif
51 #endif // CLUTCHLOG_DEFAULT_FORMAT
52 
53 #ifndef CLUTCHDUMP_DEFAULT_FORMAT
54 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
56 #define CLUTCHDUMP_DEFAULT_FORMAT "# [{name}] {level} in {func} (at depth {depth}) @ {file}:{line}"
57 #else
58 #define CLUTCHDUMP_DEFAULT_FORMAT "# {level} in {func} @ {file}:{line}"
59 #endif
60 #endif // CLUTCHDUMP_DEFAULT_FORMAT
61 
62 #ifndef CLUTCHDUMP_DEFAULT_SEP
63 #define CLUTCHDUMP_DEFAULT_SEP "\n"
65 #endif // CLUTCHDUMP_DEFAULT_SEP
66 
67 #ifndef CLUTCHLOG_DEFAULT_DEPTH_MARK
68 #define CLUTCHLOG_DEFAULT_DEPTH_MARK ">"
70 #endif // CLUTCHLOG_DEFAULT_DEPTH_MARK
71 
72 #ifndef CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG
73 #define CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG clutchlog::level::progress
75 #endif // CLUTCHLOG_DEFAULT_DEPTH_BUILT
76 
82 #define CLUTCHLOC __FILE__, __FUNCTION__, __LINE__
84 
86 #ifndef NDEBUG
87 #define CLUTCHLOG( LEVEL, WHAT ) { \
88  auto& logger = clutchlog::logger(); \
89  std::ostringstream msg ; msg << WHAT; \
90  logger.log(clutchlog::level::LEVEL, msg.str(), CLUTCHLOC); \
91 }
92 #else // not Debug build.
93 #define CLUTCHLOG( LEVEL, WHAT ) { \
94  if(clutchlog::level::LEVEL <= CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG) { \
95  auto& logger = clutchlog::logger(); \
96  std::ostringstream msg ; msg << WHAT; \
97  logger.log(clutchlog::level::LEVEL, msg.str(), CLUTCHLOC); \
98  } \
99 }
100 #endif // NDEBUG
101 
103 #ifndef NDEBUG
104 #define CLUTCHDUMP( LEVEL, CONTAINER, FILENAME ) { \
105  auto& logger = clutchlog::logger(); \
106  logger.dump(clutchlog::level::LEVEL, std::begin(CONTAINER), std::end(CONTAINER), \
107  CLUTCHLOC, FILENAME, CLUTCHDUMP_DEFAULT_SEP); \
108 }
109 #else // not Debug build.
110 #define CLUTCHDUMP( LEVEL, CONTAINER, FILENAME ) { \
111  if(clutchlog::level::LEVEL <= CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG) { \
112  auto& logger = clutchlog::logger(); \
113  logger.dump(clutchlog::level::LEVEL, std::begin(CONTAINER), std::end(CONTAINER), \
114  CLUTCHLOC, FILENAME, CLUTCHDUMP_DEFAULT_SEP); \
115  } \
116 }
117 #endif // NDEBUG
118 
120 #ifndef NDEBUG
121 #define CLUTCHFUNC( LEVEL, FUNC, ... ) { \
122  auto& logger = clutchlog::logger(); \
123  clutchlog::scope_t scope = logger.locate(clutchlog::level::LEVEL, CLUTCHLOC); \
124  if(scope.matches) { \
125  FUNC(__VA_ARGS__); \
126  } \
127 }
128 #else // not Debug build.
129 #define CLUTCHFUNC( LEVEL, FUNC, ... ) { do {/*nothing*/} while(false); }
130 #endif // NDEBUG
131 
134 #else // not WITH_CLUTCHLOG
135 // Disabled macros can still be used in Release builds.
136 #define CLUTCHLOG( LEVEL, WHAT ) { do {/*nothing*/} while(false); }
137 #define CLUTCHDUMP( LEVEL, CONTAINER, FILENAME ) { do {/*nothing*/} while(false); }
138 #define CLUTCHFUNC( LEVEL, FUNC, ... ) { do {/*nothing*/} while(false); }
139 #endif // WITH_CLUTCHLOG
140 
141 /**********************************************************************
142  * Implementation
143  **********************************************************************/
144 
145 #ifdef WITH_CLUTCHLOG
146 
153 class clutchlog
154 {
155  public:
165  static clutchlog& logger()
166  {
167  static clutchlog instance;
168  return instance;
169  }
170 
172  enum level {critical=0, error=1, warning=2, progress=3, note=4, info=5, debug=6, xdebug=7};
173 
186  class fmt {
187  public:
189  enum class fg {
190  black = 30,
191  red = 31,
192  green = 32,
193  yellow = 33,
194  blue = 34,
195  magenta = 35,
196  cyan = 36,
197  white = 37,
198  none
199  } fore;
200 
202  enum class bg {
203  black = 40,
204  red = 41,
205  green = 42,
206  yellow = 43,
207  blue = 44,
208  magenta = 45,
209  cyan = 46,
210  white = 47,
211  none
212  } back;
213 
215  enum class typo {
216  reset = 0,
217  bold = 1,
218  underline = 4,
219  inverse = 7,
220  none
221  } style;
222 
224  fmt() : fore(fg::none), back(bg::none), style(typo::none) { }
225 
228  fmt( fg f, bg b = bg::none, typo s = typo::none) : fore(f), back(b), style(s) { }
229  fmt( fg f, typo s , bg b = bg::none) : fore(f), back(b), style(s) { }
230  fmt( bg b, fg f = fg::none, typo s = typo::none) : fore(f), back(b), style(s) { }
231  fmt( bg b, typo s , fg f = fg::none) : fore(f), back(b), style(s) { }
232  fmt(typo s, fg f = fg::none, bg b = bg::none) : fore(f), back(b), style(s) { }
233  fmt(typo s, bg b , fg f = fg::none) : fore(f), back(b), style(s) { }
236  protected:
238  std::ostream& print_on( std::ostream& os) const
239  {
240  std::vector<int> codes; codes.reserve(3);
241  if(this->fore != fg::none) { codes.push_back(static_cast<int>(this->fore ));}
242  if(this->back != bg::none) { codes.push_back(static_cast<int>(this->back ));}
243  if(this->style != typo::none) { codes.push_back(static_cast<int>(this->style));}
244  if(codes.size() == 0) {return os;}
245 
246  os << "\033[";
247  assert(codes.size() > 0);
248  os << codes[0];
249  for(size_t i=1; i < codes.size(); ++i) {
250  os << ";" << codes[i];
251  }
252  os << "m";
253  return os;
254  }
255 
256  public:
268  friend std::ostream& operator<<(std::ostream& os, const fmt& fmt)
269  {
270  return fmt.print_on(os);
271  }
272 
283  std::string operator()( const std::string& msg ) const
284  {
285  std::ostringstream os;
286  this->print_on(os);
287  fmt reset(fmt::typo::reset);
288  os << msg;
289  reset.print_on(os);
290  return os.str();
291  }
292  }; // fmt class
293 
300  public:
301  clutchlog(clutchlog const&) = delete;
302  void operator=(clutchlog const&) = delete;
303 
304  private:
305  clutchlog() :
306  // system, main, log
307  _strip_calls(5),
308  _level_word({
309  {level::critical,"Critical"},
310  {level::error ,"Error"},
311  {level::warning ,"Warning"},
312  {level::progress,"Progress"},
313  {level::note ,"Note"},
314  {level::info ,"Info"},
315  {level::debug ,"Debug"},
316  {level::xdebug ,"XDebug"}
317  }),
318  _level_fmt({
319  {level::critical,fmt(fmt::fg::red, fmt::typo::underline)},
320  {level::error ,fmt(fmt::fg::red, fmt::typo::bold)},
321  {level::warning ,fmt(fmt::fg::magenta, fmt::typo::bold)},
322  {level::progress,fmt()},
323  {level::note ,fmt()},
324  {level::info ,fmt()},
325  {level::debug ,fmt()},
326  {level::xdebug ,fmt()}
327  }),
328  _format_log(CLUTCHLOG_DEFAULT_FORMAT),
329  _format_dump(CLUTCHDUMP_DEFAULT_FORMAT),
330  _out(&std::clog),
331 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
332  _depth(std::numeric_limits<size_t>::max() - _strip_calls),
333  _depth_mark(CLUTCHLOG_DEFAULT_DEPTH_MARK),
334 #endif
335  _stage(level::error),
336  _in_file(".*"),
337  _in_func(".*"),
338  _in_line(".*")
339  {
340  // Reverse the level->word map into a word->level map.
341  for(auto& lw : _level_word) {
342  _word_level[lw.second] = lw.first;
343  }
344  }
345 
346  protected:
347  const size_t _strip_calls;
348  const std::map<level,std::string> _level_word;
349  std::map<std::string,level> _word_level;
350  std::map<level,fmt> _level_fmt;
351  std::string _format_log;
352  std::string _format_dump;
353  std::ostream* _out;
354 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
355  size_t _depth;
356  std::string _depth_mark;
357 #endif
358  level _stage;
359  std::regex _in_file;
360  std::regex _in_func;
361  std::regex _in_line;
362 
363  static const size_t max_buffer = 4096;
366  public:
367 
371  void format(const std::string& format) {_format_log = format;}
374  std::string format() const {return _format_log;}
375 
377  void format_comment(const std::string& format) {_format_dump = format;}
379  std::string format_comment() const {return _format_dump;}
380 
382  void out(std::ostream& out) {_out = &out;}
384  std::ostream& out() {return *_out;}
385 
386 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
387  void depth(size_t d) {_depth = d;}
390  size_t depth() const {return _depth;}
391 
393  void depth_mark(std::string mark) {_depth_mark = mark;}
395  std::string depth_mark() const {return _depth_mark;}
396 #endif
397 
399  void threshold(level l) {_stage = l;}
401  level threshold() const {return _stage;}
402 
404  void file(std::string file) {_in_file = file;}
406  void func(std::string func) {_in_func = func;}
408  void line(std::string line) {_in_line = line;}
409 
411  void location(
412  const std::string& in_file,
413  const std::string& in_function=".*",
414  const std::string& in_line=".*"
415  )
416  {
417  file(in_file);
418  func(in_function);
419  line(in_line);
420  }
421 
426  template<class ... FMT>
427  void style(level stage, FMT... styles) { this->style(stage,fmt(styles...)); }
429  void style(level stage, fmt style) { _level_fmt.at(stage) = style; }
431  fmt style(level stage) const { return _level_fmt.at(stage); }
432 
437  level level_of(const std::string name)
438  {
439  const auto ilevel = _word_level.find(name);
440  if( ilevel != std::end(_word_level)) {
441  return ilevel->second;
442  } else {
443  throw std::out_of_range("'" + name + "' is not a valid log level name");
444  }
445  }
446 
449  public:
450 
454  struct scope_t {
456  bool matches; // everything is compatible
457  level stage; // current log level
458 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
459  size_t depth; // current depth
460 #endif
461  bool there; // location is compatible
462  scope_t() :
463  matches(false),
464  stage(level::xdebug),
465 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
466  depth(0),
467 #endif
468  there(false)
469  {}
470  }; // scope_t
471 
472 
474  scope_t locate(
475  const level& stage,
476  const std::string& file,
477  const std::string& func,
478  const size_t line
479  ) const
480  {
481  scope_t scope; // False scope by default.
482 
483  /***** Log level stage *****/
484  // Test stage first, because it's fastest.
485  scope.stage = stage;
486  if(not (scope.stage <= _stage)) {
487  // Bypass useless computations if no match
488  // because of the stage.
489  return scope;
490  }
491 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
492  /***** Stack depth *****/
493  // Backtrace in second, quite fast.
494  size_t stack_depth;
495  void *buffer[max_buffer];
496  stack_depth = backtrace(buffer, max_buffer);
497  scope.depth = stack_depth;
498  if(not (scope.depth <= _depth + _strip_calls)) {
499  // Bypass if no match.
500  return scope;
501  }
502 #endif
503 
504  /***** Location *****/
505  // Location last, slowest.
506  std::ostringstream sline; sline << line;
507  scope.there =
508  std::regex_search(file, _in_file)
509  and std::regex_search(func, _in_func)
510  and std::regex_search(sline.str(), _in_line);
511 
512  // No need to retest stage and depth, which are true here.
513  scope.matches = scope.there;
514 
515  return scope;
516  } // locate
517 
525  std::string replace(
526  const std::string& form,
527  const std::string& mark,
528  const std::string& tag
529  ) const
530  {
531  // Useless debug code, unless something fancy would be done with name tags.
532  // std::regex re;
533  // try {
534  // re = std::regex(mark);
535  //
536  // } catch(const std::regex_error& e) {
537  // std::cerr << "ERROR with a regular expression \"" << mark << "\": ";
538  // switch(e.code()) {
539  // case std::regex_constants::error_collate:
540  // std::cerr << "the expression contains an invalid collating element name";
541  // break;
542  // case std::regex_constants::error_ctype:
543  // std::cerr << "the expression contains an invalid character class name";
544  // break;
545  // case std::regex_constants::error_escape:
546  // std::cerr << "the expression contains an invalid escaped character or a trailing escape";
547  // break;
548  // case std::regex_constants::error_backref:
549  // std::cerr << "the expression contains an invalid back reference";
550  // break;
551  // case std::regex_constants::error_brack:
552  // std::cerr << "the expression contains mismatched square brackets ('[' and ']')";
553  // break;
554  // case std::regex_constants::error_paren:
555  // std::cerr << "the expression contains mismatched parentheses ('(' and ')')";
556  // break;
557  // case std::regex_constants::error_brace:
558  // std::cerr << "the expression contains mismatched curly braces ('{' and '}')";
559  // break;
560  // case std::regex_constants::error_badbrace:
561  // std::cerr << "the expression contains an invalid range in a {} expression";
562  // break;
563  // case std::regex_constants::error_range:
564  // std::cerr << "the expression contains an invalid character range (e.g. [b-a])";
565  // break;
566  // case std::regex_constants::error_space:
567  // std::cerr << "there was not enough memory to convert the expression into a finite state machine";
568  // break;
569  // case std::regex_constants::error_badrepeat:
570  // std::cerr << "one of *?+{ was not preceded by a valid regular expression";
571  // break;
572  // case std::regex_constants::error_complexity:
573  // std::cerr << "the complexity of an attempted match exceeded a predefined level";
574  // break;
575  // case std::regex_constants::error_stack:
576  // std::cerr << "there was not enough memory to perform a match";
577  // break;
578  // default:
579  // std::cerr << "unknown error";
580  // }
581  // std::cerr << std::endl;
582  // throw;
583  // } // catch
584 
585  const std::regex re(mark);
586  return std::regex_replace(form, re, tag);
587  }
588 
590  std::string replace(
591  const std::string& form,
592  const std::string& mark,
593  const size_t tag
594  ) const
595  {
596  std::ostringstream stag; stag << tag;
597  return replace(form, mark, stag.str());
598  }
599 
601  std::string format(
602  std::string format,
603  const std::string& what,
604 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
605  const std::string& name,
606 #endif
607  const level& stage,
608  const std::string& file,
609  const std::string& func,
610  const size_t line
611 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
612  ,
613  const size_t depth
614 #endif
615  ) const
616  {
617  format = replace(format, "\\{msg\\}", what);
618  format = replace(format, "\\{file\\}", file);
619  format = replace(format, "\\{func\\}", func);
620  format = replace(format, "\\{line\\}", line);
621 
622  format = replace(format, "\\{level\\}", _level_word.at(stage));
623  std::string letter(1, _level_word.at(stage).at(0)); // char -> string
624  format = replace(format, "\\{level_letter\\}", letter);
625 
626 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
627  format = replace(format, "\\{name\\}", name);
628  format = replace(format, "\\{depth\\}", depth);
629 
630  std::ostringstream chevrons;
631  for(size_t i = _strip_calls; i < depth; ++i) {
632  chevrons << _depth_mark;
633  }
634  format = replace(format, "\\{depth_marks\\}", chevrons.str());
635 #endif
636 
637  return _level_fmt.at(stage)(format);
638  }
639 
641  void log(
642  const level& stage,
643  const std::string& what,
644  const std::string& file, const std::string& func, size_t line
645  ) const
646  {
647  scope_t scope = locate(stage, file, func, line);
648 
649  if(scope.matches) {
650 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
651  *_out << format(_format_log, what, basename(getenv("_")),
652  stage, file, func,
653  line, scope.depth );
654 #else
655  *_out << format(_format_log, what,
656  stage, file, func,
657  line );
658 
659 #endif
660  _out->flush();
661  } // if scopes.matches
662  }
663 
665  template<class In>
666  void dump(
667  const level& stage,
668  const In container_begin, const In container_end,
669  const std::string& file, const std::string& func, size_t line,
670  const std::string& filename_template="dump_{n}.dat",
671  const std::string sep=CLUTCHDUMP_DEFAULT_SEP
672  ) const
673  {
674  scope_t scope = locate(stage, file, func, line);
675 
676  if(scope.matches) {
677  const std::string tag = "\\{n\\}";
678  const std::regex re(tag);
679  std::string outfile = "";
680 
681  // If the file name template has the {n} tag.
682  if(std::regex_search(filename_template, re)) {
683  // Increment n until a free one is found.
684  size_t n = 0;
685  do {
686  outfile = replace(filename_template, tag, n);
687  n++;
688  } while( std::filesystem::exists( outfile ) );
689 
690  } else {
691  // Use the parameter as is.
692  outfile = filename_template;
693  }
694 
695  std::ofstream fd(outfile);
696 
697  if(_format_dump.size() > 0) {
698 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
699  fd << format(_format_dump, "", basename(getenv("_")),
700  stage, file, func,
701  line, scope.depth );
702 #else
703  fd << format(_format_dump, "",
704  stage, file, func,
705  line );
706 #endif
707  fd << sep; // sep after comment line.
708  }
709 
710  std::copy(container_begin, container_end,
711  std::ostream_iterator<typename In::value_type>(fd, sep.c_str()));
712 
713  fd.close();
714  } // if scopes.matches
715  }
716 
718 };
719 
722 #else // not WITH_CLUTCHLOG
723 
724 
725 /**********************************************************************
726  * Fake implementation
727  **********************************************************************/
728 
729 // Equivalent class with empty methods, will be optimized out
730 // while allowing to actually have calls implemented without WITH_CLUTCHLOG guards.
731 #pragma GCC diagnostic push
732 #pragma GCC diagnostic ignored "-Wreturn-type"
733 class clutchlog
734 {
735  public:
736  static clutchlog& logger() { }
737  enum level {critical=0, error=1, warning=2, progress=3, note=4, info=5, debug=6, xdebug=7};
738  class fmt {
739  public:
740  enum class fg { black, red, green, yellow, blue, magenta, cyan, white, none } fore;
741  enum class bg { black, red, green, yellow, blue, magenta, cyan, white, none } back;
742  enum class typo { reset, bold, underline, inverse, none } style;
743  fmt() : fore(fg::none), back(bg::none), style(typo::none) { }
744  fmt( fg f, bg b = bg::none, typo s = typo::none) : fore(f), back(b), style(s) { }
745  fmt( fg f, typo s , bg b = bg::none) : fore(f), back(b), style(s) { }
746  fmt( bg b, fg f = fg::none, typo s = typo::none) : fore(f), back(b), style(s) { }
747  fmt( bg b, typo s , fg f = fg::none) : fore(f), back(b), style(s) { }
748  fmt(typo s, fg f = fg::none, bg b = bg::none) : fore(f), back(b), style(s) { }
749  fmt(typo s, bg b , fg f = fg::none) : fore(f), back(b), style(s) { }
750  protected:
751  std::ostream& print_on(std::ostream&) const { }
752  public:
753  friend std::ostream& operator<<(std::ostream&, const fmt&) { }
754  std::string operator()(const std::string&) const { }
755  };
756  public:
757  clutchlog(clutchlog const&) = delete;
758  void operator=(clutchlog const&) = delete;
759  private:
760  clutchlog() {}
761  protected:
762  struct scope_t {};
763  scope_t locate(
764  const level&,
765  const std::string&,
766  const std::string&,
767  const size_t
768  ) const
769  { }
770  public:
771  void format(const std::string&) {}
772  std::string format() const {}
773 
774  void format_comment(const std::string&) {}
775  std::string format_comment() const {}
776 
777  void out(std::ostream&) {}
778  std::ostream& out() {}
779 
780 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
781  void depth(size_t) {}
782  size_t depth() const {}
783 
784  void depth_mark(std::string) {}
785  std::string depth_mark() const {}
786 #endif
787 
788  void threshold(level) {}
789  level threshold() const {}
790 
791  void file(std::string) {}
792  void func(std::string) {}
793  void line(std::string) {}
794 
795 #pragma GCC diagnostic push
796 #pragma GCC diagnostic ignored "-Wunused-parameter"
797  void location(
798  const std::string&,
799  const std::string& in_function=".*",
800  const std::string& in_line=".*"
801  )
802  { }
803 #pragma GCC diagnostic pop
804  void style(level, fmt) { }
805  fmt style(level) const { }
806  level level_of(const std::string) { }
807  public:
808  std::string replace(
809  const std::string&,
810  const std::string&,
811  const std::string&
812  ) const
813  { }
814 
815  std::string replace(
816  const std::string&,
817  const std::string&,
818  const size_t
819  ) const
820  { }
821 
822  std::string format(
823  std::string,
824  const std::string&,
825 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
826  const std::string&,
827 #endif
828  const level&,
829  const std::string&,
830  const std::string&,
831  const size_t
832 #if CLUTCHLOG_HAVE_UNIX_SYSINFO == 1
833  ,
834  const size_t
835 #endif
836  ) const
837  { }
838 
839  void log(
840  const level&,
841  const std::string&,
842  const std::string&, const std::string&, size_t
843  ) const
844  { }
845 
846  template<class In>
847  void dump(
848  const level&,
849  const In, const In,
850  const std::string&, const std::string&, size_t,
851  const std::string&,
852  const std::string
853  ) const
854  { }
855 };
856 #pragma GCC diagnostic pop
857 #endif // WITH_CLUTCHLOG
858 
859 #endif // __CLUTCHLOG_H__
clutchlog::threshold
void threshold(level l)
Set the log level below which logs are not printed.
Definition: clutchlog.h:399
+
clutchlog::out
void out(std::ostream &out)
Set the output stream on which to print.
Definition: clutchlog.h:382
+
clutchlog
Definition: clutchlog.h:153
+
clutchlog::log
void log(const level &stage, const std::string &what, const std::string &file, const std::string &func, size_t line) const
Print a log message IF the location matches the given one.
Definition: clutchlog.h:641
+
clutchlog::replace
std::string replace(const std::string &form, const std::string &mark, const std::string &tag) const
Replace mark by tag in form.
Definition: clutchlog.h:525
+
clutchlog::func
void func(std::string func)
Set the regular expression filtering the function location.
Definition: clutchlog.h:406
+
clutchlog::format
std::string format() const
Get the template string.
Definition: clutchlog.h:374
+
clutchlog::line
void line(std::string line)
Set the regular expression filtering the line location.
Definition: clutchlog.h:408
+
clutchlog::location
void location(const std::string &in_file, const std::string &in_function=".*", const std::string &in_line=".*")
Set the regular expressions filtering the location.
Definition: clutchlog.h:411
+
clutchlog::format_comment
void format_comment(const std::string &format)
Set the template string for dumps.
Definition: clutchlog.h:377
+
clutchlog::format_comment
std::string format_comment() const
Get the template string for dumps.
Definition: clutchlog.h:379
+
clutchlog::fmt::fmt
fmt()
 Empty constructor, only useful for a no-op formatter.
Definition: clutchlog.h:224
+
clutchlog::format
std::string format(std::string format, const std::string &what, const level &stage, const std::string &file, const std::string &func, const size_t line) const
Substitute all tags in the format string with the corresponding information and apply the style corre...
Definition: clutchlog.h:601
+
clutchlog::scope_t
Structure holding a location matching.
Definition: clutchlog.h:455
+
clutchlog::locate
scope_t locate(const level &stage, const std::string &file, const std::string &func, const size_t line) const
Gather information on the current location of the call.
Definition: clutchlog.h:474
CLUTCHLOG_DEFAULT_FORMAT
#define CLUTCHLOG_DEFAULT_FORMAT
Default format of the messages.
Definition: clutchlog.h:49
-
clutchlog::fmt::fg
fg
Foreground color codes.
Definition: clutchlog.h:173
-
clutchlog::level
level
Available log levels.
Definition: clutchlog.h:156
+
clutchlog::fmt::fg
fg
Foreground color codes.
Definition: clutchlog.h:189
+
clutchlog::level
level
Available log levels.
Definition: clutchlog.h:172
CLUTCHDUMP_DEFAULT_FORMAT
#define CLUTCHDUMP_DEFAULT_FORMAT
Default format of the comment line in file dump.
Definition: clutchlog.h:58
-
clutchlog::out
std::ostream & out()
Get the output stream on which to print.
Definition: clutchlog.h:432
-
clutchlog::fmt::operator<<
friend std::ostream & operator<<(std::ostream &os, const fmt &fmt)
Output stream overload.
Definition: clutchlog.h:252
-
clutchlog::level_of
level level_of(const std::string name)
Return the log level tag corresponding to the given pre-configured name.
Definition: clutchlog.h:485
-
clutchlog::style
void style(level stage, FMT... styles)
Set the style (color and typo) of the given log level.
Definition: clutchlog.h:475
-
clutchlog::fmt::operator()
std::string operator()(const std::string &msg) const
Format the given string with the currently encoded format.
Definition: clutchlog.h:267
-
clutchlog::style
void style(level stage, fmt style)
Set the style (color and typo) of the given log level, passing a fmt instance.
Definition: clutchlog.h:477
-
clutchlog::fmt::print_on
std::ostream & print_on(std::ostream &os) const
Print the currently encoded format escape code on the given output stream.
Definition: clutchlog.h:222
-
clutchlog::logger
static clutchlog & logger()
Get the logger instance.
Definition: clutchlog.h:149
-
clutchlog::fmt::typo
typo
Typographic style codes.
Definition: clutchlog.h:199
-
clutchlog::fmt::bg
bg
Background color codes.
Definition: clutchlog.h:186
-
clutchlog::dump
void dump(const level &stage, const In container_begin, const In container_end, const std::string &file, const std::string &func, size_t line, const std::string &filename_template="dump_{n}.dat", const std::string sep=CLUTCHDUMP_DEFAULT_SEP) const
Dump a serializable container after a comment line with log information.
Definition: clutchlog.h:650
-
clutchlog::file
void file(std::string file)
Set the regular expression filtering the file location.
Definition: clutchlog.h:452
-
clutchlog::replace
std::string replace(const std::string &form, const std::string &mark, const size_t tag) const
Replace mark by tag in form, converting tag to its string representation first.
Definition: clutchlog.h:574
-
clutchlog::style
fmt style(level stage) const
Get the configured fmt instance of the given log level.
Definition: clutchlog.h:479
+
clutchlog::out
std::ostream & out()
Get the output stream on which to print.
Definition: clutchlog.h:384
+
clutchlog::fmt::operator<<
friend std::ostream & operator<<(std::ostream &os, const fmt &fmt)
Output stream overload.
Definition: clutchlog.h:268
+
clutchlog::level_of
level level_of(const std::string name)
Return the log level tag corresponding to the given pre-configured name.
Definition: clutchlog.h:437
+
clutchlog::style
void style(level stage, FMT... styles)
Set the style (color and typo) of the given log level.
Definition: clutchlog.h:427
+
clutchlog::fmt::operator()
std::string operator()(const std::string &msg) const
Format the given string with the currently encoded format.
Definition: clutchlog.h:283
+
clutchlog::style
void style(level stage, fmt style)
Set the style (color and typo) of the given log level, passing a fmt instance.
Definition: clutchlog.h:429
+
clutchlog::fmt::print_on
std::ostream & print_on(std::ostream &os) const
Print the currently encoded format escape code on the given output stream.
Definition: clutchlog.h:238
+
clutchlog::logger
static clutchlog & logger()
Get the logger instance.
Definition: clutchlog.h:165
+
clutchlog::fmt::typo
typo
Typographic style codes.
Definition: clutchlog.h:215
+
clutchlog::fmt::bg
bg
Background color codes.
Definition: clutchlog.h:202
+
clutchlog::dump
void dump(const level &stage, const In container_begin, const In container_end, const std::string &file, const std::string &func, size_t line, const std::string &filename_template="dump_{n}.dat", const std::string sep=CLUTCHDUMP_DEFAULT_SEP) const
Dump a serializable container after a comment line with log information.
Definition: clutchlog.h:666
+
clutchlog::file
void file(std::string file)
Set the regular expression filtering the file location.
Definition: clutchlog.h:404
+
clutchlog::replace
std::string replace(const std::string &form, const std::string &mark, const size_t tag) const
Replace mark by tag in form, converting tag to its string representation first.
Definition: clutchlog.h:590
+
clutchlog::style
fmt style(level stage) const
Get the configured fmt instance of the given log level.
Definition: clutchlog.h:431
CLUTCHDUMP_DEFAULT_SEP
#define CLUTCHDUMP_DEFAULT_SEP
Default item separator for dump.
Definition: clutchlog.h:64
-
clutchlog::threshold
level threshold() const
Get the log level below which logs are not printed.
Definition: clutchlog.h:449
-
clutchlog::fmt
Color and style formatter for ANSI terminal escape sequences.
Definition: clutchlog.h:170
+
clutchlog::threshold
level threshold() const
Get the log level below which logs are not printed.
Definition: clutchlog.h:401
+
CLUTCHLOG_DEFAULT_DEPTH_MARK
#define CLUTCHLOG_DEFAULT_DEPTH_MARK
Default mark for stack depth.
Definition: clutchlog.h:69
+
clutchlog::fmt
Color and style formatter for ANSI terminal escape sequences.
Definition: clutchlog.h:186
diff --git a/docs/dir_000036_000000.html b/docs/dir_000036_000000.html index 403f07e..a9bc736 100644 --- a/docs/dir_000036_000000.html +++ b/docs/dir_000036_000000.html @@ -63,7 +63,7 @@ $(function() {
-

tests → clutchlog Relation

File in testsIncludes file in clutchlog
t-color.cppclutchlog.h
t-demo.cppclutchlog.h
t-dump.cppclutchlog.h
t-log.cppclutchlog.h
+

tests → clutchlog Relation

File in testsIncludes file in clutchlog
t-assert.cppclutchlog.h
t-color.cppclutchlog.h
t-demo.cppclutchlog.h
t-dump.cppclutchlog.h
t-log.cppclutchlog.h
Generated by   diff --git a/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf.html b/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf.html index 516cae8..57f1933 100644 --- a/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf.html +++ b/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf.html @@ -74,7 +74,7 @@ Directory dependency graph for tests: - + diff --git a/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf_dep.map b/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf_dep.map index a098bef..8f4297f 100644 --- a/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf_dep.map +++ b/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf_dep.map @@ -1,5 +1,5 @@ - + diff --git a/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf_dep.md5 b/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf_dep.md5 index 44642fd..b4555bf 100644 --- a/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf_dep.md5 +++ b/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf_dep.md5 @@ -1 +1 @@ -a5f8fa0d7d58d59b863458f8c2f78e64 \ No newline at end of file +1952cc54af7dc9a50e1812305a9c5e50 \ No newline at end of file diff --git a/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf_dep.png b/docs/dir_59425e443f801f1f2fd8bbe4959a3ccf_dep.png index d5026d442938e28e76f703769d45781f02ab6aa0..7496e0ad3c98b7d340ede02c99686cff09e15a77 100644 GIT binary patch literal 2465 zcmb7Gdpy(KAO9jHcO^zeDP%mkM5v6-Tqfi?Yh{$Vjm&MsQlwG|lO7MUT0OiAD|7#ChX?Fo&I}!nh`Xy5qDQWJ$0`2ZLnmSUk z9_3J~4lTW+Z5DP+ElCWGOE3pvhqjuiF4c-D+J+vA$-Z4p$pT$=@tZE)gJG<8jal6p zy^*}gn9do0nVwKsFZpJ&zhdpOWAyAr@$v^Y8vU9#Yuokht|kA4fX}z3z7W`cqb-mS5aZt|bRbrg zsKrG`*+e%eTUuK3SEqM3CD69J-}c z&tZfZwlKFn@`975i#$!N^7DRdtQ>e!`dbG2H-~DCXM}m@6Qsf0GZFfig=^HNq@|A| zrtQ=59k}W)0W~cnH#Zz(`?CvNQ1MWQ9C3tz#d3so9bQ{*cV&P05OX4R0}sk6Sz)Od zN&#mYW8fDS$;qOhMwl0%^nE?5YHH?@59sHwI=w4BjG<(ZA+Oh)a7&{B%GE@3h%j+4 zWOKn3)nd8phO%(4ZtBDKq>1}1>xrLA#sP<+{zH)z`yiR?djBydw{e0GY>;LHRJVxU zlXVAiQdU-0oR{OH zU#I*3^yztpq|alvav8i8+gM(DxfSAktJr;JVd2^L2`bGC@{p1k+{{a4oJ zM;vJb&EXZCYd>cvxZGQFb2zw@6O``v7uJG5-COwQu==Xc)a0a>msh$-ba{-Kq+(}h z$Egb^H#vPLK|OHoZxznr6Q?QW+#=b&H`VC4FEvk^Bm40e5k^jq<-4 zR6aR58N0wS=PVKz#+jOrA3ruL={sa(r1t!2-UB+H&yR?X?quCiVUX5vAE&3!u`-ox zl9wNr6A*`li6BCMsfr*J?i8Vgchpq^78gR__X^iG(qQe!G zIttct{(;v={)#R`1_4vzXVoPJjn$*4s z-cl2(EWU%cw|Abg{GL~C1-;XUBuVRKJK1bKLqnHq71EBiK3A;8vM)xZ_4M?DEs9k& zGz@(FeW$*hF)9T@6w%chLZMJ+sxf99hD841>hF>BB)npu+@ZsV*CV7Pvr)rUYK#i{ zoqE6aI$1az{;c+2Z{_ZA8!n7KncCm)E9L50ZVz+D9qK6E(f;q?03M2IynEui`W7i7 z(=H+n-{N|{jF^;k00O}*ScFMl3PST)5D28o%sw5$_AxXt2xg%2D3okj1r5nT)g2uj zF>y-|?&0w@flP@r=H;oz{>^4P&#aL;J3D#HeAeAzNxiS#Kc1uqf#@I*h(pH4tc?vD zfVaS{>*?u9_o2f*J(cI?=fi6V8>D;Mhq}qS;l;(p3msRtRXu-R5E>fFsI9eNgF=p$ z^xdCdq|)9COa)?$C^#i0B|15|D6l2*mQ=8ej0`5l-C$>LUtefoVBkMH!@_DEZzwY= zD!^q!IPOqo0JpszU=kO#CAWUySPUC<1f+Nu;&Gob`1NaI*mLyw=;GpH)zhcB=Iese zAHATAKv*63#H!66WrM=r(`U|fu4a(`d8<5-H{#!8+SoX)6I6Cqk)^OY*dVTcN#wG`u2~E zY%6yEv{u%;I^9dFvh@lZ^OdY5kw{~seSLj4q_5>~HzW=Zv`=-D!+%ex5H-f~VLj9F zi3CD(_X6?wj-5O2zL&AG!*OwO=C6Bu?@%a;#qODbOd_;qMAQ`V`R61?B1;+2jc?u~(GD|diCugo+|0rvBP&b3$lbsMT`w0_ zr^R3}P|tC@?v<3BW1vKXE2myFg~2U$gw#|@K|ukdvlFhdb08y*?fmtk<%QXRmajz*09uvWmN=9vtw^`fR^tidXq0XM&GZ0}JEfxu* zC6wlD&g=lK7*iA8-`{UyZC!Y}8Yy9uhQzStO#L3YUbiZXgD+1AxyZ87r z{KU)Cuf!NPB?Se?&`^D_u`yz`t&nDKbrvl3F9BJixm^fsRiB-ozly9})Ba{O6k(aK zVHscsQpAMpU)c+Ov~`KTCH5cmNc}V+swL!zrTMmx`MZ3%_L4srfN=7JKZONn{1-iT BjxhiL literal 2402 zcma)8c{J2t8~>7IEg9J&$x=g6lszE^VKA2L%aAnLOZ==;)`rPCAw(v|ShJQiDig*s zKTEVpBm7EanK5H$-f!=D-*fusJ#Xipd!KXedCqh1^L#${^W3{Oa8p4(Nj?Ao1kKHi z5ukMdXCV(axI)Ct^=@57Gf%Ke4$Tb0- ztaCa+8pxZ{dnjr?d}am_W0IYTcglyF4*ae0ZkHp`bLrHszBy#EEyXi_jokLqHEOUe zTgV7qV27N6d+B!~c)f^Rl|~ExC=|x`h;45-_VA;(KR6>&g@DQTBC3T{(NT9w79a5a z?~gW)t-5Y`5%)*!p)>k*M6M_HoK8v{Cvm|2OMry}x?K3xzk~gcZDTi7e7p>UF>(l! zawpY-6-A1qcM|ipM2y|$zEKYYKvZmUeIOFaX`1m4UwV{Z+3|5FlK6UkT??3GT+!8E zFBOuI;EiPO;QUdW8oos~v2s>#%3E8%a0Ao}Z>_Hn4byo_;^TNqVpmPmu~_amyzezfPD~lGCL*xwjDEWzRQPFeKChNt zi3>Z-2unEJC>uFRkIc-^Pb5XJJ*p4pL4_L`q!%#DVFwX17mgUj?IIpmTr#u5J@M&L z6cAv_L7@^CcGs=9w^yWVJc3{9oT)FC$*H~>wH zJKWuLm7O%cBdqFq@9TX1AbFnE85G>vBNNQ#26nbq8sKFrU3O zj{KWjTg&tH?Bw3&L$sJ1!oaWd&z_4-`#xAQ)y02Y9?DIp(+#IB$21XOaT~8_J3X!Y zuv8U0X>k7L^DFDiWbFDZ{(@H*#!X6pTkOT!LrKqA*5w#_SIHAUYS>wghuv*AG%Ck< zIYK*G*t3XA^OxE3^yZS&V75;_27Dmt4rLruv0oAVBiw(ZgTaS(V#HFbiBiVK-uktS z$*B19^IT@xMl^prNjJM+MEuS94=DAU_p29KpT@`2a&twPOeUqcZ#z>*U;p0u=vA-C zNT)@6U;skgci_mI=i&1+aI)#B1?lDw;h@jYZbOd4DaDurCVGq0ffC~423A&rF0QVR z9IO9<_n6vej4~KuPA5fuuUvWkPZ$T_rjoZ*;MjN&^{!;ZAk+Dl5>9D0;Kip;E(ML- z=T)`YrA=Ma^z}fCY_1gYZJhGuzT9EuvQ6e?C5#kNT3VU|FBHk*V1FS+#|3U|Y?xVE za+Q{9w={~D2<75%R@W7qTxvzhWO5kcF#4D^o55f}x88JjBj?}Mn!(}s3}EUPvk*^% zY4`T>izY5iv!c8;3gvQ#2W%eOx42-7bt8_csHpgsBqnkNd~8&><7_2ka%nFbgTa)F zDFdl#X$if)h|zf4db|^{P$RIjGl@T8aV1i(va&KY1oqan0pXx@sIR|2;Xb;#`D|`( zE+un}X;WiAIYvNhS{TH{=neR(BYk|X^r28j`ZxqHk8J7NAImenke93DPlNH5m1Y$+ z6|iABhirL!N5@SZPz+CD&A;!@9~(X4qBQBrIW;|P>+XK4|3<~tJ7v~vc1~X2z7#SC zF#GeTv7zDZ0f{72y4)e4s=As3;7%~48{IxiLkRBQKlQHGHEc#$7z^8Do(*zT^6a^D zy~X!roSmIdsHm(4$E+L{Eu<=L>1_H(NnpFt!Nf8@QoO6H>tt$XfqVO{y@45+2Yd#h zM&yI%5P04{<*ixyDwCP{c_UXII@_mTwN?nlh!bODW6i9s^K`M=7Y`yx9;!uf!slxP z5>5AYw6%Gw$1p#C2AuSGAwD)XX81m}<1bW42g#ev4H&>+-OWB8FXN=S6F8tys8-mF z+0f_Yl$3^Gn*L(~K~7njKRi4~(rLqF&Sy8jB%^yXwO&H=B zisR@Ebc^}J&eGCy{giz_mD)8qc@zmY1Hb1rE-k3OB0_)7^(x2eF1%?*%=p5>g4V5{ zPL$o8oE!k%lOZ#x^v#|X+?%Zc-e7iNfz`rdGLNdOL$tNEXXoY^^R$TxX^k(I`7E>A zni}KS*z=7|O$Q;6ga;2K#RZblagtbWAY^y@FL5laNbfJT(m@J^M;HPjNUKXJ;rJAD zc(>M;dJ5F9PKLFG%nr%sQ~gf5KNk^A+k5TWHK+Dlr$FiPZgHW_ttT-2&gWmV3U8nI z1&pts9|lw;TU%S%T=Y88Y@!gsxxaddRMXW>MU7Ba9#fhGIU9-+ElO6&A-I?bHe(9q!T?{9GN;vVzu2nLgo{D0c~ ze>EAMNh2r)x|4(@q@)tz1b+Vm&@o@NEXA{)rzNo*fwpu3oPWag|9l_Ne6MITaAXJl Z!b(fhrpnNJ1@O}Zn47?j>x{ha{0mzvcK84Q diff --git a/docs/globals.html b/docs/globals.html index 8d40c25..9a6533d 100644 --- a/docs/globals.html +++ b/docs/globals.html @@ -69,12 +69,21 @@ $(function() {
  • CLUTCHDUMP_DEFAULT_SEP : clutchlog.h
    • +
  • CLUTCHFUNC +: clutchlog.h +
  • CLUTCHLOC : clutchlog.h
  • CLUTCHLOG : clutchlog.h
    • +
  • CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG +: clutchlog.h +
    • +
  • CLUTCHLOG_DEFAULT_DEPTH_MARK +: clutchlog.h +
  • CLUTCHLOG_DEFAULT_FORMAT : clutchlog.h
    • diff --git a/docs/globals_defs.html b/docs/globals_defs.html index b605061..01a8845 100644 --- a/docs/globals_defs.html +++ b/docs/globals_defs.html @@ -69,12 +69,21 @@ $(function() {
  • CLUTCHDUMP_DEFAULT_SEP : clutchlog.h
    • +
  • CLUTCHFUNC +: clutchlog.h +
  • CLUTCHLOC : clutchlog.h
  • CLUTCHLOG : clutchlog.h
    • +
  • CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG +: clutchlog.h +
    • +
  • CLUTCHLOG_DEFAULT_DEPTH_MARK +: clutchlog.h +
  • CLUTCHLOG_DEFAULT_FORMAT : clutchlog.h
    • diff --git a/docs/group__DefaultConfigMacros.html b/docs/group__DefaultConfigMacros.html index aa21fd7..a9a5b7c 100644 --- a/docs/group__DefaultConfigMacros.html +++ b/docs/group__DefaultConfigMacros.html @@ -81,10 +81,12 @@ Macros  Default item separator for dump.
      -#define CLUTCHLOG_DEFAULT_DEPTH_MARK   ">" +#define CLUTCHLOG_DEFAULT_DEPTH_MARK   ">" + Default mark for stack depth.
      -#define CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG   clutchlog::level::progress +#define CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG   clutchlog::level::progress + Default level over which calls to the logger are optimized out when NDEBUG is defined.
     

    Detailed Description

    diff --git a/docs/group__UseMacros.html b/docs/group__UseMacros.html index a1f4975..2541920 100644 --- a/docs/group__UseMacros.html +++ b/docs/group__UseMacros.html @@ -78,6 +78,9 @@ Macros #define CLUTCHDUMP(LEVEL, CONTAINER, FILENAME)  Dump the given container. More...
      +#define CLUTCHFUNC(LEVEL, FUNC, ...) + Call an assert at the given level. More...
    + 

    Detailed Description

    Macro Definition Documentation

    @@ -112,12 +115,50 @@ Macros
    -Value:
    { \
    auto& logger = clutchlog::logger(); \
    logger.dump(clutchlog::level::LEVEL, std::begin(CONTAINER), std::end(CONTAINER), \
    CLUTCHLOC, FILENAME, CLUTCHDUMP_DEFAULT_SEP); \
    }
    CLUTCHLOC
    #define CLUTCHLOC
    Handy shortcuts to location.
    Definition: clutchlog.h:81
    -
    clutchlog::logger
    static clutchlog & logger()
    Get the logger instance.
    Definition: clutchlog.h:149
    +Value:
    { \
    auto& logger = clutchlog::logger(); \
    logger.dump(clutchlog::level::LEVEL, std::begin(CONTAINER), std::end(CONTAINER), \
    CLUTCHLOC, FILENAME, CLUTCHDUMP_DEFAULT_SEP); \
    }
    CLUTCHLOC
    #define CLUTCHLOC
    Handy shortcuts to location.
    Definition: clutchlog.h:83
    +
    clutchlog::logger
    static clutchlog & logger()
    Get the logger instance.
    Definition: clutchlog.h:165
    CLUTCHDUMP_DEFAULT_SEP
    #define CLUTCHDUMP_DEFAULT_SEP
    Default item separator for dump.
    Definition: clutchlog.h:64

    Dump the given container.

    +
    +
    + +

    ◆ CLUTCHFUNC

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    #define CLUTCHFUNC( LEVEL,
     FUNC,
     ... 
    )
    +
    +Value:
    { \
    auto& logger = clutchlog::logger(); \
    clutchlog::scope_t scope = logger.locate(clutchlog::level::LEVEL, CLUTCHLOC); \
    if(scope.matches) { \
    FUNC(__VA_ARGS__); \
    } \
    }
    CLUTCHLOC
    #define CLUTCHLOC
    Handy shortcuts to location.
    Definition: clutchlog.h:83
    +
    clutchlog::logger
    static clutchlog & logger()
    Get the logger instance.
    Definition: clutchlog.h:165
    +
    +

    Call an assert at the given level.

    +
    @@ -145,8 +186,8 @@ Macros
    -Value:
    { \
    auto& logger = clutchlog::logger(); \
    std::ostringstream msg ; msg << WHAT; \
    logger.log(clutchlog::level::LEVEL, msg.str(), CLUTCHLOC); \
    }
    CLUTCHLOC
    #define CLUTCHLOC
    Handy shortcuts to location.
    Definition: clutchlog.h:81
    -
    clutchlog::logger
    static clutchlog & logger()
    Get the logger instance.
    Definition: clutchlog.h:149
    +Value:
    { \
    auto& logger = clutchlog::logger(); \
    std::ostringstream msg ; msg << WHAT; \
    logger.log(clutchlog::level::LEVEL, msg.str(), CLUTCHLOC); \
    }
    CLUTCHLOC
    #define CLUTCHLOC
    Handy shortcuts to location.
    Definition: clutchlog.h:83
    +
    clutchlog::logger
    static clutchlog & logger()
    Get the logger instance.
    Definition: clutchlog.h:165

    Log a message at the given level.

    diff --git a/docs/index.html b/docs/index.html index 1d3c436..c699516 100644 --- a/docs/index.html +++ b/docs/index.html @@ -73,23 +73,31 @@ $(function() {
  • Output style
  • Disabled calls
  • Low-level API
    • +
  • (De)clutch any function call
    • -
  • Log level semantics
    • -
  • Limitations
    • -
  • Build and tests
    • +
  • Log level semantics
    • +
  • Limitations
    • +
  • Build and tests
    • -

    Clutchlog is a logging system which targets versatile debugging. It allows to (de)clutch messages for a given: log level, source code location or call stack depth.

    +

    Clutchlog is a logging system which targets versatile debugging. It allows to (de)clutch messages for a given: log level, source code location or call stack depth.

    Features

    Clutchlog allows to select which log messages will be displayed, based on their locations:

      -
    • classical log levels: each message has a given detail level and it is displayed if you ask for a at least the same one.
      • -
    • call stack depth: you can ask to display messages within functions which are called up to a given stack depth.
      • -
    • source code location: you can ask to display messages called from given files, functions and line number, all based on regular expressions.
      • +
    • Classical log levels: each message has a given detail level and it is displayed if you ask for a at least the same one.
      • +
    • Call stack depth: you can ask to display messages within functions which are called up to a given stack depth.
      • +
    • Source code location: you can ask to display messages called from given files, functions and line number, all based on regular expressions.

    Additionally, Clutchlog will do its best to allow the compiler to optimize out calls, for instance debug messages in "Release" builds.

    +

    Additional features:

    +
      +
    • Templated log format, to easily design your own format.
      • +
    • Colored log. By default only important ones are colored (critical and error in red, warning in magenta).
      • +
    • Macro to dump the content of a container in a file with automatic naming (yes, it is useful for fast debugging).
      • +
    • Generic clutching wrapper, to wrap any function call. Useful to (de)clutch asserts for example.
      • +

    Example

    Adding a message is a simple as calling a macro (which is declutched in Debug build type, when NDEBUG is not defined):

    CLUTCHLOG(info, "matrix size: " << m << "x" << n);

    To configure the display, you indicate the three types of locations, for example in your main function:

    auto& log = clutchlog::logger();
    log.depth(2); // Log functions called from "main" but not below.
    log.threshold(clutchlog::level::info); // Log only "info", "warning", "error" or "critical" messages.
    log.file("algebra/.*"); // Will match any file in the "algebra" directory.
    log.func("(mul|add|sub|div)"); // Will match "multiply", for instance.

    For more detailled examples, see the "API documentation" section below and the tests directory.

    @@ -123,7 +131,7 @@ Output Configuration

    The default log format is "[{name}] {level_letter}:{depth_marks} {msg}\t\t\t\t\t{func} @ {file}:{line}\n", it can be overriden at compile time by defining the CLUTCHLOG_DEFAULT_FORMAT macro.

    The default format of the comment added with the dump macro is "# [{name}] {level} in {func} (at depth {depth}) @ {file}:{line}". It can be edited with the format_comment method. If it is set to an empty string, then no comment line is added. The default can be modified at compile time with CLUTCHDUMP_DEFAULT_FORMAT. By default, the separator between items in the container is a new line. To change this behaviour, you can change CLUTCHDUMP_DEFAULT_SEP or call the low-level dump method.

    -

    The mark used with the {depth_marks} tag can be configured with the depth_mark method, and its default with the CLUTCHLOG_DEFAULT_DEPTH_MARK macro:

    log.depth_mark(CLUTCHLOG_DEFAULT_DEPTH_MARK); // Defaults to ">".

    +

    The mark used with the {depth_marks} tag can be configured with the depth_mark method, and its default with the CLUTCHLOG_DEFAULT_DEPTH_MARK macro:

    log.depth_mark(CLUTCHLOG_DEFAULT_DEPTH_MARK); // Defaults to ">".

    Output style

    The output can be colored differently depending on the log level.

    // Print error messages in bold red:
    log.style(clutchlog::level::error, // First, the log level.
    clutchlog::fmt::fg::red, // Then the styles, in any order...
    clutchlog::fmt::typo::bold);

    Or, if you want to declare some semantics beforehand:

    // Print warning messages in bold magenta:
    using fmt = clutchlog::fmt;
    fmt warn(fmt::fg::magenta, fmt::typo::bold);
    log.style(clutchlog::level::warning, warn);

    Using the clutchlog::fmt class, you can style:

      @@ -162,7 +170,11 @@ Disabled calls

      This behavior intend to remove as many conditional statements as possible when not debugging, without having to use preprocessor guards around calls to clutchlog, thus saving run time at no readability cost.

      Low-level API

      -

      All configuration setters have a getters counterpart, with the same name but taking no parameter, for example:

      std::string mark = log.depth_mark();

      To control more precisely the logging, one can use the low-level log method:

      log.log(clutchlog::level::xdebug, "hello world", "main.cpp", "main", 122);

      A helper macro can helps to fill in the location with the actual one, as seen by the compiler:

      log.log(clutchlog::level::xdebug, "hello world", CLUTCHLOC);

      A similar dump method exists:

      log.dump(clutchlog::level::xdebug, cont.begin(), cont.end(), CLUTCHLOC, "dumped_{n}.dat", "\n");
      log.dump(clutchlog::level::xdebug, cont.begin(), cont.end(), "main.cpp", "main", 122, "dumped.dat", "\n\n");

      +

      All configuration setters have a getters counterpart, with the same name but taking no parameter, for example:

      std::string mark = log.depth_mark();

      To control more precisely the logging, one can use the low-level log method:

      log.log(clutchlog::level::xdebug, "hello world", "main.cpp", "main", 122);

      A helper macro can helps to fill in the location with the actual one, as seen by the compiler:

      log.log(clutchlog::level::xdebug, "hello world", CLUTCHLOC);

      A similar dump method exists:

      log.dump(clutchlog::level::xdebug, cont.begin(), cont.end(), CLUTCHLOC, "dumped_{n}.dat", "\n");
      log.dump(clutchlog::level::xdebug, cont.begin(), cont.end(), "main.cpp", "main", 122, "dumped.dat", "\n\n");

      +(De)clutch any function call

      +

      The CLUTHFUNC macro allows to wrap any function within the current logger.

      +

      For instance, this can be useful if you want to (de)clutch calls to asserts. To do that, just declare your own macro:

      #define ASSERT(LEVEL, ...) { CLUTCHFUNC(LEVEL, assert, __VA_ARGS__) }

      Thus, any call like ASSERT(error, x > 3); will be declutchable with the same configuration than a call to CLUTCHLOG.

      +

      Log level semantics

      Log levels use a classical semantics for a human skilled in the art, in decreasing order of importance:

        @@ -176,12 +188,26 @@ Log level semantics
      • XDebug: debugging information which would be heavy to read.

      Note: the log levels constants are lower case (for example: clutchlog::level::xdebug), but their string representation is not (e.g. "XDebug", this should be taken into account when using level_of).

      -

      +

      Limitations

      Because the call stack depth and program name access are system-dependent, the features relying on the depth of the call stack and the display of the program name are only available for operating systems having the following headers: execinfo.h, stdlib.h and libgen.h (so far, tested with Linux).

      Some colors/styles may not be supported by some exotic terminal emulators.

      -

      Clutchlog needs C++-17 with the filesystem feature. You may need to indicate -std=c++17 -lstdc++fs to your compiler.

      -

      +

      Clutchlog needs C++-17 with the filesystem feature. You may need to indicate -std=c++17 -lstdc++fs to some compilers.

      +

      What Clutchlog do not provide at the moment (but may in a near future):

      +
        +
      • Super fast log writing.
        • +
      • Thread safety.
        • +
      +

      What Clutchlog will most certainly never provide:

      +
        +
      • Round-robin log managers.
        • +
      • Duplicated messages management.
        • +
      • External output systems (only allow output stream, you can still do the proxy yourself).
        • +
      • External error handlers (not my job, come on).
        • +
      • Automatic argument parser (please, use a dedicated lib).
        • +
      • Signal handling (WTF would you do that, anyway?).
        • +
      +

      Build and tests

      To use clutchlog, just include its header in your code and either ensure that the NDEBUG preprocessor variable is not set, either define the WITH_CLUTCHLOG preprocessor variable.

      If you're using CMake (or another modern build system), it will unset NDEBUG —and thus enable clutchlog— only for the "Debug" build type, which is usually what you want if you use clutchlog, anyway.

      diff --git a/docs/search/all_1.js b/docs/search/all_1.js index 9ea8637..e39ba04 100644 --- a/docs/search/all_1.js +++ b/docs/search/all_1.js @@ -3,8 +3,11 @@ var searchData= ['clutchdump',['CLUTCHDUMP',['../group__UseMacros.html#ga572e3aa19d8b39e3ed0b9e91961104c2',1,'clutchlog.h']]], ['clutchdump_5fdefault_5fformat',['CLUTCHDUMP_DEFAULT_FORMAT',['../group__DefaultConfigMacros.html#ga27b613c6727857a7cbcd0165d862034e',1,'clutchlog.h']]], ['clutchdump_5fdefault_5fsep',['CLUTCHDUMP_DEFAULT_SEP',['../group__DefaultConfigMacros.html#ga54d29e956575e1c731eab5406135c5df',1,'clutchlog.h']]], + ['clutchfunc',['CLUTCHFUNC',['../group__UseMacros.html#ga9f77cee4f853e582262930c9c17f90ae',1,'clutchlog.h']]], ['clutchloc',['CLUTCHLOC',['../group__UseMacros.html#gae8911119d726a43b77f5781cb5a72813',1,'clutchlog.h']]], ['clutchlog',['clutchlog',['../classclutchlog.html',1,'clutchlog'],['../group__UseMacros.html#ga6f86187e2b35e7e1907d688f504a197d',1,'CLUTCHLOG(): clutchlog.h']]], ['clutchlog_2eh',['clutchlog.h',['../clutchlog_8h.html',1,'']]], + ['clutchlog_5fdefault_5fdepth_5fbuilt_5fnodebug',['CLUTCHLOG_DEFAULT_DEPTH_BUILT_NODEBUG',['../group__DefaultConfigMacros.html#ga8564be479b948ee3052b61783c66d415',1,'clutchlog.h']]], + ['clutchlog_5fdefault_5fdepth_5fmark',['CLUTCHLOG_DEFAULT_DEPTH_MARK',['../group__DefaultConfigMacros.html#ga45c4c964fad4ad1641d5c9c28c4645b9',1,'clutchlog.h']]], ['clutchlog_5fdefault_5fformat',['CLUTCHLOG_DEFAULT_FORMAT',['../group__DefaultConfigMacros.html#ga524c16f280d92ee8ab683162c9ce01fa',1,'clutchlog.h']]] ];