---

XANAVerbose.h

Go to the documentation of this file.

#ifndef XANAVERBOSE_H
#define XANAVERBOSE_H

#include <iosfwd>

#include<string>

class XANAVerbose {

public:
  enum FilterLevel {DebugLevel=1, TestLevel=5, InfoLevel=8, SilentLevel=9999}; 

  enum { nFilterLevel=4};


  static const FilterLevel * levels();

  static const std::string * levelNames();

  static const FilterLevel & level(const std::string & name);

  static const std::string & levelName(int il);
  
public:
  static std::ostream & out;

  explicit XANAVerbose(int il=TestLevel);

  XANAVerbose & operator()(int il=TestLevel) { level_=il; return *this;}

  XANAVerbose & operator()(const std::string& il) { level_=level(il); return *this;}
  
  operator bool() const { return verbose_ && (level_ >= filter_);}

  void verbose();

  void silent();

  void setFilterLevel(int il=TestLevel);
  int getFilterLevel() const;

  // int level() const { return level_;}
  

private:

  bool verbose_;
  int filter_;
  int level_;
};

#include <ostream>

inline std::ostream & operator<<(std::ostream& o, const XANAVerbose& v) {
  
  return v ? o : XANAVerbose::out;

}

/*
namespace Capri {
  
  namespace Streams {
    
    extern std::ostream cout;
    extern std::ostream cerr;
    extern std::ostream clog;
    
    void redirect(std::streambuf* outbuf,
                  std::streambuf* errbuf, 
                  std::streambuf* logbuf);
    
    void redirect(std::ostream & iout,
                  std::ostream & ierr, 
                  std::ostream & ilog);
    
    
    extern std::ostream infoOut, testOut, debugOut;
    
    class LogStreams {
    public:
      
      LogStreams(std::ostream & iinfo,
                 std::ostream & itest, 
                 std::ostream & idebug);
      
      std::streambuf* rbuf() { return outbuf;}
      
      void set(std::ostream & s, bool yes);
      
      void on(bool info=true, bool test=false, bool debug=false);
      
      void on(const std::string & level);

      void on(XANAVerbose::FilterLevel level);

      void silent() {on(false,false,false);}

      void redirect(std::streambuf* obuf);

    private:
      std::ostream & infoS;
      std::ostream & testS; 
      std::ostream & debugS;

      std::streambuf* outbuf;
    };
    

    class UserLogStreams {
    public:
      // controlled streams
      std::ostream infoOut, testOut, debugOut;
      

    public:
      UserLogStreams();
      void redirect(std::streambuf* outbuf);
 
      std::streambuf* rbuf() { return streams().rbuf();}
 
      Capri::Streams::LogStreams & streams() { return streams_;}


    private:
      LogStreams streams_;
    };

    
    extern LogStreams defaultStreams;  
    
  }
}

using Capri::Streams::infoOut;
using Capri::Streams::testOut; 
using Capri::Streams::debugOut;
using Capri::Streams::defaultStreams;
  
#ifndef  XANAVerbose_CC
  extern XANAVerbose infoV, testV, debugV;
#endif
*/  
#endif // XANAVERBOSE_H

---