logstream.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2017 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii__logstream_h
#define dealii__logstream_h

#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/smartpointer.h>
#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/thread_local_storage.h>

#include <string>
#include <stack>
#include <map>
#include <cmath>
#include <sstream>

#ifdef DEAL_II_HAVE_SYS_TIMES_H
#  include <sys/times.h>
#else
struct tms
{
  int tms_utime, tms_stime, tms_cutime, tms_cstime;
};
#endif


DEAL_II_NAMESPACE_OPEN

class LogStream : public Subscriptor
{
public:
  class Prefix
  {
  public:
    Prefix(const std::string &text);

    Prefix(const std::string &text,
           LogStream &stream);

    ~Prefix ();

  private:
    SmartPointer<LogStream,LogStream::Prefix> stream;
  };


  LogStream ();


  ~LogStream();


  void attach (std::ostream &o,
               const bool    print_job_id = true);


  void detach ();


  void test_mode (const bool on = true,
                  const double double_threshold = 1.e-10,
                  const float float_threshold = 1.e-7f,
                  const double offset = 1.e-7);


  std::ostream &get_console ();


  std::ostream &get_file_stream ();


  bool has_file () const;


  void log_cerr ();


  const std::string &get_prefix () const;


  void push (const std::string &text);


  void pop ();


  unsigned int depth_console (const unsigned int n);


  unsigned int depth_file (const unsigned int n);


  bool log_execution_time (const bool flag);


  bool log_time_differences (const bool flag);


  void timestamp();


  bool log_thread_id (const bool flag);


  void threshold_double(const double t);


  void threshold_float(const float t);


  std::streamsize precision (const std::streamsize prec);


  std::streamsize width (const std::streamsize wide);


  std::ios::fmtflags flags(const std::ios::fmtflags f);


  LogStream &operator << (const double t);


  LogStream &operator << (const float t);


  LogStream &operator<< (std::ostream& (*p) (std::ostream &));


  std::size_t memory_consumption () const;

private:


  std::stack<std::string> &get_prefixes() const;

  mutable Threads::ThreadLocalStorage<std::stack<std::string> > prefixes;

  std::ostream  *std_out;

  std::ostream  *file;

  unsigned int std_depth;

  unsigned int file_depth;

  bool print_utime;

  bool diff_utime;

  double last_time;

  double double_threshold;

  float float_threshold;

  double offset;

  bool print_thread_id;

  double reference_time_val;

  struct tms reference_tms;

  std::streambuf *old_cerr;

  bool at_newline;

  void print_line_head ();

  std::ostringstream &get_stream();

  Threads::ThreadLocalStorage<std_cxx11::shared_ptr<std::ostringstream> > outstreams;

  template <typename T> friend LogStream &operator << (LogStream &log, const T &t);
};


/* ----------------------------- Inline functions and templates ---------------- */


template <typename T>
inline
LogStream &operator<< (LogStream &log, const T &t)
{
  // print to the internal stringstream
  log.get_stream() << t;
  return log;
}


inline
std::ostringstream &
LogStream::get_stream()
{
  // see if we have already created this stream. if not, do so and
  // set the default flags (why we set these flags is lost to
  // history, but this is what we need to keep several hundred tests
  // from producing different output)
  //
  // note that in all of this we need not worry about thread-safety
  // because we operate on a thread-local object and by definition
  // there can only be one access at a time
  if (outstreams.get().get() == 0)
    {
      outstreams.get().reset (new std::ostringstream);
      outstreams.get()->setf(std::ios::showpoint | std::ios::left);
    }

  // then return the stream
  return *outstreams.get();
}




inline
LogStream &
LogStream::operator<< (const double t)
{
  std::ostringstream &stream = get_stream();

  // drop small numbers or skew them away from zero.
  // we have to make sure that we don't catch NaN's and +-Inf's with the
  // test, because for these denormals all comparisons are always false.
  if (! numbers::is_finite(t))
    stream << t;
  else if (std::fabs(t) < double_threshold)
    stream << '0';
  else
    stream << t*(1.+offset);

  return *this;
}



inline
LogStream &
LogStream::operator<< (const float t)
{
  std::ostringstream &stream = get_stream();

  // we have to make sure that we don't catch NaN's and +-Inf's with the
  // test, because for these denormals all comparisons are always false.
  // thus, for a NaN, both t<=0 and t>=0 are false at the same time, which
  // can't be said for any other number
  if (! (t<=0) && !(t>=0))
    stream << t;
  else if (std::fabs(t) < float_threshold)
    stream << '0';
  else
    stream << t*(1.+offset);

  return *this;
}


inline
LogStream::Prefix::Prefix(const std::string &text, LogStream &s)
  :
  stream(&s)
{
  stream->push(text);
}


inline
LogStream::Prefix::~Prefix()
{
  stream->pop();
}


extern LogStream deallog;


inline
LogStream::Prefix::Prefix(const std::string &text)
  :
  stream(&deallog)
{
  stream->push(text);
}


DEAL_II_NAMESPACE_CLOSE

#endif