MessageHandler.hh

Go to the documentation of this file.

//Copyright 2013 Ben Loer
//This file is part of the ConfigHandler library
//It is released under the terms of the GNU General Public License v3

#ifndef MESSAGE_HANDLER_h
#define MESSAGE_HANDLER_h 1

#include <iostream>
#include <sstream>
#include <set>
#include <queue>
#include <time.h>

//forward declarations needed for boost threads
namespace boost{
  class thread;
  class mutex;
  class condition_variable;
};


enum MESSAGE_LEVEL {DEBUG3=0, DEBUG2, DEBUG, INFO, WARNING, ERROR,
                    CRITICAL, EXCEPTION, N_MESSAGE_LEVELS};
//MESSAGE_LEVEL needs streaming and increment/decrement operators
std::ostream& operator<<(std::ostream& out, const MESSAGE_LEVEL& level);
std::istream& operator>>(std::istream& in, MESSAGE_LEVEL& level);
MESSAGE_LEVEL& operator++(MESSAGE_LEVEL& level);
MESSAGE_LEVEL& operator--(MESSAGE_LEVEL& level);



class Message; //forward declaration

class MessageHandler{
public:
  static MessageHandler* GetInstance(){ return &_instance; }
  void End();
  void Post(std::ostringstream* mgs, MESSAGE_LEVEL level);
  
  template<class MsgAction> 
  void* AddMessenger(MESSAGE_LEVEL thresh,MsgAction act)
  { 
    VMessenger* m = new Messenger<MsgAction>(thresh,act);
    _messengers.insert(m); 
    return m; 
  } 
  void RemoveMessenger(void* m);
  void SetThreshold(MESSAGE_LEVEL thresh, void* messenger=0);
  void UpdateThreshold(){ SetThreshold(_default_threshold); }
  MESSAGE_LEVEL GetDefaultMessageThreshold(){return _default_threshold;}

  class PrintToStream{
    std::ostream& _stream;
    bool _use_color;
  public:
    PrintToStream(std::ostream& out=std::cout, bool use_color=true) : 
      _stream(out),  _use_color(use_color) {}
    void operator()(const std::string& s, MESSAGE_LEVEL level, time_t t);
  };
  
private:
  //private constructor and destructor as per singelton model
  MessageHandler();
  ~MessageHandler();
  
  MessageHandler(const MessageHandler&      ) {}
  MessageHandler& operator=(const MessageHandler& ) {return *this;}
  
  void Deliver(std::ostringstream* msg, MESSAGE_LEVEL level, time_t t=time(0));
  
  //private virtual messenger class; concrete instances hold pointers/objects
  //of delivery functions
  class VMessenger{
  public:
    VMessenger(MESSAGE_LEVEL thresh) : _thresh(thresh) {}
    virtual ~VMessenger() {}
    virtual void Deliver(std::ostringstream*, MESSAGE_LEVEL, time_t) = 0;
    void SetThreshold(MESSAGE_LEVEL thresh){ _thresh = thresh; }
  protected:
    MESSAGE_LEVEL _thresh;
  };
  
  template<class MsgAction> class Messenger : public VMessenger{
  public:
    Messenger(MESSAGE_LEVEL thresh, MsgAction action) : VMessenger(thresh), 
                                                        _action(action) {}
    ~Messenger() {}
    void Deliver(std::ostringstream* msg, MESSAGE_LEVEL level, time_t t)
    { if (level >= _thresh ) _action(msg->str(),level,t);  }
  private:
    MsgAction _action;
  };
  
  std::set<VMessenger*> _messengers;
  static MessageHandler _instance;
  MESSAGE_LEVEL _default_threshold;

  //special members only needed for threading
private:
  struct MsgData{ 
    std::ostringstream* msg; 
    MESSAGE_LEVEL level;
    time_t t; 
    MsgData(std::ostringstream* m, MESSAGE_LEVEL l) : msg(m), level(l) 
    {time(&t);}
  };
  std::queue<MsgData> _inbox;
  bool _kill_thread;
  boost::mutex* _inbox_mutex;
  boost::condition_variable* _message_waiting;
  boost::thread* _delivery_thread;
public:
  void operator()(); 

};


#endif