debugstream.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_DEBUGSTREAM_HH
#define DUNE_DEBUGSTREAM_HH
 
#include <iostream>
#include <stack>
 
#include <dune/common/exceptions.hh>
 
namespace Dune {
 
  typedef unsigned int DebugLevel;
 
  template <DebugLevel current, DebugLevel threshold>
  struct greater_or_equal {
    static const bool value = (current >= threshold);
  };
 
 
  template <DebugLevel current, DebugLevel mask>
  struct common_bits {
    enum {value = ((current & mask)!=0) };
  };
 
 
  class DebugStreamError : public IOError {};
 
  class StreamWrap {
  public:
    StreamWrap(std::ostream& _out) : out(_out) { };
    std::ostream& out;
    StreamWrap *next;
  };
 
  class DebugStreamState {
    // !!! should be protected somehow but that won't be easy
  public:
    StreamWrap* current;
 
    bool _active;
 
    bool _tied;
 
    unsigned int _tied_streams;
  };
 
  template <DebugLevel thislevel = 1,
      DebugLevel dlevel = 1,
      DebugLevel alevel = 1,
      template<DebugLevel, DebugLevel> class activator = greater_or_equal>
  class DebugStream : public DebugStreamState {
  public:
    DebugStream(std::ostream& out = std::cerr) {
      // start a new list of streams
      current = new StreamWrap(out);
      current->next = 0;
 
      // check if we are above the default activation level
      _active = activator<thislevel,alevel>::value;
 
      // we're not tied to another DebugStream
      _tied = false;
 
      // no child streams yet
      _tied_streams = 0;
    };
 
    DebugStream (DebugStreamState& master,
                 std::ostream& fallback = std::cerr)
    {
      // start a new list of streams
      current = new StreamWrap(fallback);
      current->next = 0;
 
      // check if we are above the default activation level
      _active = activator<thislevel,alevel>::value;
      _tied_streams = 0;
 
      // tie to the provided stream
      _tied = true;
      tiedstate = &master;
      tiedstate->_tied_streams++;
    };
 
    ~DebugStream()
#if HAVE_NOEXCEPT_SPECIFIER
      noexcept(false)
#endif
    {
      // untie
      if (_tied)
        tiedstate->_tied_streams--;
      else {
        // check if somebody still ties to us...
        if (_tied_streams != 0)
          DUNE_THROW(DebugStreamError,
                     "There are streams still tied to this stream!");
      };
 
      // remove ostream-stack
      while (current != 0) {
        StreamWrap *s = current;
        current = current->next;
        delete s;
      };
    };
 
    template <class T>
    DebugStream& operator<<(const T data) {
      // remove the following code if stream wasn't compiled active
      if (activator<thislevel, dlevel>::value) {
        if (! _tied) {
          if (_active)
            current->out << data;
        } else {
          if (_active && tiedstate->_active)
            tiedstate->current->out << data;
        };
      };
 
      return *this;
    }
 
    DebugStream& operator<<(const int data) {
      // remove the following code if stream wasn't compiled active
      if (activator<thislevel, dlevel>::value) {
        if (! _tied) {
          if (_active)
            current->out << data;
        } else {
          if (_active && tiedstate->_active)
            tiedstate->current->out << data;
        };
      };
 
      return *this;
    }
 
    DebugStream& operator<<(std::ostream& (*f)(std::ostream&)) {
      if (activator<thislevel, dlevel>::value) {
        if (! _tied) {
          if (_active)
            f(current->out);
        } else {
          if (_active && tiedstate->_active)
            f(tiedstate->current->out);
        };
      }
 
      return *this;
    };
 
    DebugStream& flush() {
      if (activator<thislevel, dlevel>::value) {
        if (! _tied) {
          if (_active)
            current->out.flush();
        } else {
          if (_active && tiedstate->_active)
            tiedstate->current->out.flush();
        };
      }
 
      return *this;
    };
 
    void push(bool b) {
      // are we at all active?
      if (activator<thislevel,alevel>::value) {
        _actstack.push(_active);
        _active = b;
      } else {
        // stay off
        _actstack.push(false);
      };
    };
 
    void pop() throw(DebugStreamError) {
      if (_actstack.empty())
        DUNE_THROW(DebugStreamError, "No previous activation setting!");
 
      _active = _actstack.top();
      _actstack.pop();
    };
 
    bool active() const {
      return activator<thislevel, dlevel>::value && _active;
    };
 
    void attach(std::ostream& stream) {
      if (_tied)
        DUNE_THROW(DebugStreamError, "Cannot attach to a tied stream!");
 
      StreamWrap* newcurr = new StreamWrap(stream);
      newcurr->next = current;
      current = newcurr;
    };
 
    void detach() throw(DebugStreamError) {
      if (current->next == 0)
        DUNE_THROW(DebugStreamError, "Cannot detach initial stream!");
      if (_tied)
        DUNE_THROW(DebugStreamError, "Cannot detach a tied stream!");
 
      StreamWrap* old = current;
      current = current->next;
      delete old;
    };
 
    // \brief Tie a stream to this one.
    void tie(DebugStreamState& to) throw(DebugStreamError) {
      if (to._tied)
        DUNE_THROW(DebugStreamError, "Cannot tie to an already tied stream!");
      if (_tied)
        DUNE_THROW(DebugStreamError, "Stream already tied: untie first!");
 
      _tied = true;
      tiedstate = &to;
 
      // tell master class
      tiedstate->_tied_streams++;
    };
 
    void untie() throw(DebugStreamError) {
      if(! _tied)
        DUNE_THROW(DebugStreamError, "Cannot untie, stream is not tied!");
 
      tiedstate->_tied_streams--;
      _tied = false;
      tiedstate = 0;
    };
 
  private:
    DebugStreamState* tiedstate;
 
    std::stack<bool> _actstack;
  };
 
}
 
 
#endif