MessageService.h

Go to the documentation of this file.

#ifndef MESSAGE_SERVICE_HH
#define MESSAGE_SERVICE_HH

#include <iostream>
#include <sstream>
#include <map>

#include "TString.h"


class MessageSerivce{
  
  private:
  
  static MessageSerivce* s_messageService;
  
  MessageSerivce();
  
  public:
  
  enum ErrorType{WELCOME, ERROR, INFO, VERBOSE, GOODBYE};

  std::ostream& _stream;

  std::map<ErrorType, bool>    _outputOptions;

  std::map<ErrorType, TString> _outputHeaders;
  
  bool _endlCalled;

  bool _printOrNot;

  ErrorType _errorType;
  
  long int _errorCount;

  static MessageSerivce& getMessageService(ErrorType errorType);
  static MessageSerivce& getMessageService();

  void printErrorCount();
  
  template <class T>MessageSerivce  &operator<< (const T &v) 
  { 
  
    if (_printOrNot) {
      if (_endlCalled){
        _stream << _outputHeaders[_errorType];
        if (_errorType == ERROR) _errorCount++;
        _endlCalled = 0;
      }
      _stream << v;
    }
    return *this;
  }
  
  //This allows you to make a custom endl (MessageSerivce::endl).
  //Don't think I need it, but interesting

  // function that takes a custom stream, and returns it
  //typedef MessageSerivce& (*MessageSerivceManipulator)(MessageSerivce&);
  

  // take in a function with the custom signature
  // MessageSerivce& operator<<(MessageSerivceManipulator manip)
  // {
  //   call the function, and return it's value
  //   return manip(*this);
  //  }

  // define the custom endl for this stream.
  // note how it matches the `MessageSerivceManipulator`
  // function signature
  //  static MessageSerivce& endl(MessageSerivce& stream)
  //  {
  // print a new line
  //   std::cout << std::endl;

  // do other stuff with the stream
  // std::cout, for example, will flush the stream
  //   stream << "Called MessageSerivce::endl!" << std::endl;

  //   return stream;
  //  }

  //The following makes endl work


  typedef std::basic_ostream<char, std::char_traits<char> > CoutType;

  typedef CoutType& (*StandardEndLine)(CoutType&);

  MessageSerivce& operator<<(StandardEndLine manip)
  { 
    //SAM -> I'm assuming that when this gets called it's 
    //always endl - I imagine this isn't always the case.
    if (_printOrNot){
      _endlCalled = true;

    // call the function, but we cannot return it's value
      _stream << "\033[0m";
      manip(_stream);
      
    }
    return *this;
  }

  ~MessageSerivce(); 

};

#define WELCOME_LOG MessageSerivce::getMessageService(MessageSerivce::WELCOME)
#define ERROR_LOG   MessageSerivce::getMessageService(MessageSerivce::ERROR  )
#define INFO_LOG    MessageSerivce::getMessageService(MessageSerivce::INFO   )
#define VERBOSE_LOG MessageSerivce::getMessageService(MessageSerivce::VERBOSE)
#define GOODBYE_LOG MessageSerivce::getMessageService(MessageSerivce::GOODBYE)

#define ERROR_COUNT MessageSerivce::getMessageService().printErrorCount();

#endif