LogLevels.hpp

Go to the documentation of this file.

#ifndef _loglevels_hpp_
#define _loglevels_hpp_

#include <iostream>
#include <stdint.h>



template< typename U>
void insert ( std::ostream& aStr , const U& aU )
{
  aStr << aU;
}

// NOTE: the log_insert_warning is defined to bridge between the compilers used on Linux and OSX.
// While on linux the 'warning' attribute is defined, it is not in OSX 10.9 clang.
// On the other hand clang's 'deprecated' is messageless in g++, while it supports messages in clang.
// To make the story short, log_insert_warning uses the most appropriated attribute for the system in use.
#ifndef __clang__
#define log_insert_warning warning
#else
#define log_insert_warning deprecated
#endif

__attribute__ ( ( log_insert_warning ( "Insertion of integer types can result in implicit casts. Consider using the Integer() formatter instead" ) ) )
void insert ( std::ostream& aStr , const uint32_t& aUint ) ;

__attribute__ ( ( log_insert_warning ( "Insertion of integer types can result in implicit casts. Consider using the Integer() formatter instead" ) ) )
void insert ( std::ostream& aStr , const int32_t& aInt );

__attribute__ ( ( log_insert_warning ( "Insertion of boolean types can result in implicit casts. Consider using the Boolean() formatter instead" ) ) )
void insert ( std::ostream& aStr , const bool& aBool );


namespace uhal
{

  template< typename T >
  class BaseLogLevel
  {
    protected:
      typedef void ( *fPtr ) ( std::ostream& aStr );

      BaseLogLevel ( std::ostream& aStr , fPtr aHeadFunction , fPtr aTailFunction ) : mStr ( aStr ) , mHeadFunction ( aHeadFunction ) , mTailFunction ( aTailFunction )
      {}

    public:
      T& operator() ()
      {
        return static_cast<T&> ( *this );
      }

      T& head()
      {
        mHeadFunction ( mStr );
        return static_cast<T&> ( *this );
      }

      T& tail()
      {
        mTailFunction ( mStr );
        return static_cast<T&> ( *this );
      }

      std::ostream& stream()
      {
        return mStr;
      }

    private:
      std::ostream& mStr;
      fPtr mHeadFunction;
      fPtr mTailFunction;

  };




  class FatalLevel : public BaseLogLevel< FatalLevel >
  {
      typedef BaseLogLevel< FatalLevel > Base;

    public:
      FatalLevel ( std::ostream& aStr = std::cout , Base::fPtr aHeadFunction = FatalLevel::colour_head, Base::fPtr aTailFunction = FatalLevel::colour_tail );

      static void colour_head ( std::ostream& aStr );
      static void colour_tail ( std::ostream& aStr );
  };

  extern FatalLevel Fatal;


  class ErrorLevel : public BaseLogLevel< ErrorLevel >
  {
      typedef BaseLogLevel< ErrorLevel > Base;

    public:
      ErrorLevel ( std::ostream& aStr = std::cout , Base::fPtr aHeadFunction = ErrorLevel::colour_head, Base::fPtr aTailFunction = ErrorLevel::colour_tail );

      static void colour_head ( std::ostream& aStr );
      static void colour_tail ( std::ostream& aStr );
  };

  extern ErrorLevel Error;



  class WarningLevel : public BaseLogLevel< WarningLevel >
  {
      typedef BaseLogLevel< WarningLevel > Base;

    public:
      WarningLevel ( std::ostream& aStr = std::cout , Base::fPtr aHeadFunction = WarningLevel::colour_head, Base::fPtr aTailFunction = WarningLevel::colour_tail );

      static void colour_head ( std::ostream& aStr );
      static void colour_tail ( std::ostream& aStr );
  };

  extern WarningLevel Warning;

  class NoticeLevel : public BaseLogLevel< NoticeLevel >
  {

      typedef BaseLogLevel< NoticeLevel > Base;

    public:
      NoticeLevel ( std::ostream& aStr = std::cout , Base::fPtr aHeadFunction = NoticeLevel::colour_head, Base::fPtr aTailFunction = NoticeLevel::colour_tail );

      static void colour_head ( std::ostream& aStr );
      static void colour_tail ( std::ostream& aStr );
  };

  extern NoticeLevel Notice;

  class InfoLevel : public BaseLogLevel< InfoLevel >
  {
      typedef BaseLogLevel< InfoLevel > Base;

    public:
      InfoLevel ( std::ostream& aStr = std::cout , Base::fPtr aHeadFunction = InfoLevel::colour_head, Base::fPtr aTailFunction = InfoLevel::colour_tail );

      static void colour_head ( std::ostream& aStr );
      static void colour_tail ( std::ostream& aStr );
  };

  extern InfoLevel Info;

  class DebugLevel : public BaseLogLevel< DebugLevel >
  {
      typedef BaseLogLevel< DebugLevel > Base;

    public:
      DebugLevel ( std::ostream& aStr = std::cout , Base::fPtr aHeadFunction = DebugLevel::colour_head, Base::fPtr aTailFunction = DebugLevel::colour_tail );

      static void colour_head ( std::ostream& aStr );
      static void colour_tail ( std::ostream& aStr );
  };

  extern DebugLevel Debug;



}



#endif