util/liblogger/flex_ostreambuf.h

// copyright 2009 t. schneider tes@mit.edu
//
// this file is part of flex-ostream, a terminal display library
// that provides an ostream with both terminal display and file logging
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software.  If not, see <http://www.gnu.org/licenses/>.

#ifndef FlexOStreamBuf20091110H
#define FlexOStreamBuf20091110H

#include <iostream>
#include <sstream>
#include <vector>
#include <deque>
#include <cstdio>

#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>

#include "term_color.h"

class Group;

namespace goby
{
    namespace util
    {

        class FlexNCurses;

        struct Logger
        {
            static boost::mutex mutex;
            enum Verbosity { quiet, warn, verbose, debug, gui };
        };        
        
        
        class FlexOStreamBuf : public std::streambuf
        {
          public:
            FlexOStreamBuf();
            ~FlexOStreamBuf();
            
            int sync();

            int overflow(int c = EOF);
            
            void name(const std::string & s)
            { name_ = s; }

            void add_stream(Logger::Verbosity verbosity, std::ostream* os);            

            bool is_quiet()
            { return is_quiet_; }    

            bool is_gui()
            { return is_gui_; }
            
            void group_name(const std::string & s)
            { group_name_ = s; }

            void set_die_flag(bool b)
            { die_flag_ = b; }

            void set_debug_flag(bool b)
            { debug_flag_ = b; }

            void set_warn_flag(bool b)
            { warn_flag_ = b; }

            void add_group(const std::string& name, Group g);

            std::string color2esc_code(Colors::Color color)
            { return TermColor::esc_code_from_col(color); }

            void refresh();
          private:
            void display(std::string& s);    
            void strip_escapes(std::string& s);
            
          private:
            std::deque<std::string> buffer_;
            
            class StreamConfig
            {
              public:
                StreamConfig(std::ostream* os, Logger::Verbosity verbosity)
                    : os_(os),
                    verbosity_(verbosity)
                    { }
                
                void set_verbosity(Logger::Verbosity verbosity) {  verbosity_ = verbosity; }

                std::ostream* os() const { return os_; }
                Logger::Verbosity verbosity() const { return verbosity_; }
                
              private:
                std::ostream* os_;
                Logger::Verbosity verbosity_;
            };
            
            std::string name_;
            std::string group_name_;
    
            std::map<std::string, Group> groups_;

            bool die_flag_;
            bool warn_flag_;
            bool debug_flag_;

#if HAS_NCURSES
            FlexNCurses* curses_;
#endif            
            boost::shared_ptr<boost::thread> input_thread_;

            boost::posix_time::ptime start_time_;

            std::vector<StreamConfig> streams_;

            bool is_quiet_;
            bool is_gui_;
        };
    }
}
#endif