Verbose.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__VERBOSE__HH
#define __DIADES__UTILS__VERBOSE__HH

#include<boost/format.hpp>
#include <iostream>
#include <sstream>
#include <string>
#include "Functors.hh"

using std::ostream;
using std::string;
using std::stringstream;

namespace Diades
{
  namespace Utils
  {     

        typedef enum { VbNothing, VbOutput, VbProcess, VbCritical, VbError, VbWarning, VbInfo, VbDebug } VerboseLevel;
  };

};

namespace Diades
{
  namespace Utils
  {     

        typedef boost::format Msg;
        
        
        
        
        
        template<typename InputIterator,
                         typename Predicate >
        class ToStream
        {
        public:
          typedef InputIterator Iterator;
          ~ToStream(){}

          ToStream(InputIterator first, InputIterator last, Predicate pred)
          {
                stringstream newStream;
                newStream << "{ ";
                for(; first != last; ++first)
                  {
                        if(pred(*first))
                          {
                                newStream << *first << " ";
                          }
                  }
                newStream << "}";
                _stream = newStream.str();
          }

          
          ToStream(const ToStream & ts):_stream(ts._stream){}
          friend ostream & operator << (ostream & os, const ToStream & ts)
          {
                os << ts._stream;
                return os;
          }
        private:
          string _stream;
        };



        class Verbose
        {
        public:
          typedef VerboseLevel Level;

          static Level currentLevel;

          Verbose():_fmt(),_level(VbNothing){}
          
          Verbose(Level level, const char * msg ) : _fmt(msg), _level(level) {}

          ~Verbose();
         
          template <typename T> 
          Verbose & operator %(T value)
          {
#ifndef __NO__VERBOSE
        _fmt % value;
#endif
        return *this;
          }    
         
        protected:
          boost::format _fmt;
          Level _level;

        };
  };
};



template<Diades::Utils::VerboseLevel level>
Diades::Utils::Verbose verbose(const char * msg)
{
#ifdef __NO__VERBOSE
  return Diades::Utils::Verbose();
#else
  return Diades::Utils::Verbose(level,msg);
#endif
}

inline void setVerboseLevel(Diades::Utils::VerboseLevel level)
{
  Diades::Utils::Verbose::currentLevel = level;
}



template<typename InputIterator>
Diades::Utils::ToStream<InputIterator,Diades::Utils::AlwaysTrue<typename InputIterator::reference> > toStream(InputIterator first, InputIterator last)
{
  return Diades::Utils::ToStream<InputIterator,Diades::Utils::AlwaysTrue<typename InputIterator::reference> >(first,last,Diades::Utils::AlwaysTrue<typename InputIterator::reference>());
}


template<typename InputIterator,typename Predicate>
Diades::Utils::ToStream<InputIterator,Predicate> toStream(InputIterator first, InputIterator last, Predicate predicate)
{
  return Diades::Utils::ToStream<InputIterator,Predicate>(first,last,predicate);
}


#endif