---

log.hh

/*
*  Name:      log.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Definitons for logging C++ programs
*  Date:      $Date: 2003/08/08 23:30:34 $
*  Revision:  $Revision: 1.2 $
*
*  Copyright (C) 2000-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  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 2 of the License, or
*  (at your option) any later version.
*
*  This program 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 program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _MPCL_UTIL_LOGGING_LOG__
#define _MPCL_UTIL_LOGGING_LOG__

#include <iomanip>
#include <iostream>
#include <vector>
#include "../../exceptions.hh"
#include "../../system/all.hh"
#include "../../text/string.hh"
#include "../general-functions.hh"


namespace mpcl
{

  namespace util
  {

    namespace logging
    {

      using system::ISystem;
      using text::TString;

      class TBaseLog;

      template <typename TChar, typename TTraits>
      class TLog;

      typedef TBaseLog& (*MManipulator) (TBaseLog&);

      template <typename TChar, typename TTraits>
      TLog<TChar, TTraits>& header (TLog<TChar, TTraits>& rtBASE_LOG);


      TBaseLog& emerg (TBaseLog& rtBASE_LOG);   
      TBaseLog& alert (TBaseLog& rtBASE_LOG);   
      TBaseLog& crit (TBaseLog& rtBASE_LOG);    
      TBaseLog& err (TBaseLog& rtBASE_LOG);     
      TBaseLog& warning (TBaseLog& rtBASE_LOG); 
      TBaseLog& notice (TBaseLog& rtBASE_LOG);  
      TBaseLog& info (TBaseLog& rtBASE_LOG);    
      TBaseLog& debug (TBaseLog& rtBASE_LOG);   



      TBaseLog& authpriv (TBaseLog& rtBASE_LOG); 
      TBaseLog& cron (TBaseLog& rtBASE_LOG);     
      TBaseLog& daemon (TBaseLog& rtBASE_LOG);   
      TBaseLog& kern (TBaseLog& rtBASE_LOG);     
      TBaseLog& local0 (TBaseLog& rtBASE_LOG);   
      TBaseLog& local1 (TBaseLog& rtBASE_LOG);   
      TBaseLog& local2 (TBaseLog& rtBASE_LOG);   
      TBaseLog& local3 (TBaseLog& rtBASE_LOG);   
      TBaseLog& local4 (TBaseLog& rtBASE_LOG);   
      TBaseLog& local5 (TBaseLog& rtBASE_LOG);   
      TBaseLog& local6 (TBaseLog& rtBASE_LOG);   
      TBaseLog& local7 (TBaseLog& rtBASE_LOG);   
      TBaseLog& lpr (TBaseLog& rtBASE_LOG);      
      TBaseLog& mail (TBaseLog& rtBASE_LOG);     
      TBaseLog& news (TBaseLog& rtBASE_LOG);     
      TBaseLog& user (TBaseLog& rtBASE_LOG);     
      TBaseLog& uucp (TBaseLog& rtBASE_LOG);     


      class TBaseLog
      {

        public:

          typedef
            ISystem::ELogFacility
            ELogFacility;

          typedef
            ISystem::ELogLevel
            ELogLevel;


        public:

          virtual void setFacility (ELogFacility eLOG_FACILITY) = 0;

          virtual void setLevel (ELogLevel eLOG_LEVEL) = 0;


        public:

          //
          //  S E L E C T O R S
          //

          virtual ELogLevel getLevel (void) const = 0;

          virtual ELogFacility getFacility (void) const = 0;

      };  // class TBaseLog


      template < typename TChar                             ,
                 typename TTraits = std::char_traits<TChar> >
      class TLogStreambuf                           :
        public TBaseLog                             ,
        public std::basic_streambuf<TChar, TTraits>
      {

        private:

          typedef
            std::vector<std::basic_ostream<TChar, TTraits>*>
            TOstreamVector;


        private:

          ELogFacility   eLogFacility;

          ELogLevel   eLogLevel;

          TOstreamVector   tOstreamVector;

          TString   yLine;


        public:

          //
          //  C O N S T R U C T O R S
          //

          TLogStreambuf (void)                                      :
            TBaseLog                             ()                 ,
            std::basic_streambuf<TChar, TTraits> ()                 ,
            eLogFacility                         (ISystem::eUser)   ,
            eLogLevel                            (ISystem::eNotice) ,
            tOstreamVector                       ()                 ,
            yLine                                ()                 {}

          void also (std::basic_ostream<TChar, TTraits>& rtOSTREAM)
          {
            tOstreamVector.push_back (&rtOSTREAM);
          }

          void erase (const std::basic_ostream<TChar, TTraits>& rktOSTREAM)
            throw (TNotFoundException);

          int overflow (int iCHAR = EOF);

          void setFacility (ELogFacility eLOG_FACILITY)
          {
            eLogFacility = eLOG_FACILITY;
          }

          void setLevel (ELogLevel eLOG_LEVEL)
          {
            eLogLevel = eLOG_LEVEL;
          }

          std::streamsize xsputn (const char* pkcSTRING, std::streamsize zSIZE);


        public:

          //
          //  S E L E C T O R S
          //

          ELogLevel getLevel (void) const
          {
            return eLogLevel;
          }

          ELogFacility getFacility (void) const
          {
            return eLogFacility;
          }

      };  // class TLogStreambuf

      template < typename TChar                             ,
                 typename TTraits = std::char_traits<TChar> >
      class TLog                                  :
        public TBaseLog                           ,
        public std::basic_ostream<TChar, TTraits>
      {

        public:

          using TBaseLog::ELogLevel;


        private:

          TLogStreambuf<TChar, TTraits>   tLogStreambuf;


        public:

          //
          //  C O N S T R U C T O R S
          //

          TLog (void)                                           :
            TBaseLog                           ()               ,
            std::basic_ostream<TChar, TTraits> (&tLogStreambuf) ,
            tLogStreambuf                      ()               {}

          TLog& also (std::basic_ostream<TChar, TTraits>& rtOSTREAM)
          {
            tLogStreambuf.also (rtOSTREAM);
            return *this;
          }

          template <typename TItem>
          void debug (TItem tITEM)
          {
            ELogLevel      eCurrentLogLevel    = getLevel();
            ELogFacility   eCurrentLogFacility = getFacility();

            setLevel (ISystem::eDebug);
            setFacility (ISystem::eUser);
            *this << header << tITEM << std::endl;
            setLevel (eCurrentLogLevel);
            setFacility (eCurrentLogFacility);
          }

          TLog& erase (const std::basic_ostream<TChar, TTraits>& rktOSTREAM)
          {
            tLogStreambuf.erase (rktOSTREAM);
            return *this;
          }

          TLog& operator << (MManipulator mMANIP_FUNCTION)
          {
            (*mMANIP_FUNCTION) (*this);
            return *this;
          }

          TLog& operator << (TLog& (*mMANIP_FUNCTION) (TLog&))
          {
            return (*mMANIP_FUNCTION) (*this);
          }

          void setFacility (ELogFacility eLOG_FACILITY)
          {
            tLogStreambuf.setFacility (eLOG_FACILITY);
          }

          void setLevel (ELogLevel eLOG_LEVEL)
          {
            tLogStreambuf.setLevel (eLOG_LEVEL);
          }


        public:

          //
          //  S E L E C T O R S
          //

          ELogLevel getLevel (void) const
          {
            return tLogStreambuf.getLevel();
          }

          ELogFacility getFacility (void) const
          {
            return tLogStreambuf.getFacility();
          }

      };  // class TLog


      //
      //  E X P O R T E D   V A R I A B L E S
      //

      extern TLog<char>   tLog;

    }  // namespace logging

  }  // namespace util

}  // namespace mpcl


//
//  E X P O R T E D   F U N C T I O N S
//

template <typename TChar, typename TTraits>
mpcl::util::logging::TLog<TChar, TTraits>& mpcl::util::logging::
header (TLog<TChar, TTraits>& rtBASE_LOG)
{

  using system::ISystem;

  switch (rtBASE_LOG.getLevel())
  {
    case ISystem::eEmerg:   rtBASE_LOG << "#EMERG: ";   break;
    case ISystem::eAlert:   rtBASE_LOG << "#ALERT: ";   break;
    case ISystem::eCrit:    rtBASE_LOG << "#CRIT: ";    break;
    case ISystem::eErr:     rtBASE_LOG << "#ERR: ";     break;
    case ISystem::eWarning: rtBASE_LOG << "#WARNING: "; break;
    case ISystem::eNotice:  rtBASE_LOG << "#NOTICE: ";  break;
    case ISystem::eInfo:    rtBASE_LOG << "#INFO: ";    break;
    case ISystem::eDebug:   rtBASE_LOG << "#DEBUG: ";   break;
  }
  return rtBASE_LOG;

}  // header()


//
//  C O N S T R U C T O R S
//

template <typename TChar, typename TTraits>
void mpcl::util::logging::TLogStreambuf<TChar, TTraits>::
erase (const std::basic_ostream<TChar, TTraits>& rktOSTREAM)
  throw (TNotFoundException)
{
 
  typename TOstreamVector::iterator   I;

  I = std::find (tOstreamVector.begin(), tOstreamVector.end(), &rktOSTREAM);
  if ( I == tOstreamVector.end() )
  {
    throw TNotFoundException ("stream not found", __FILE__, __LINE__);
  }
  else
  {
    tOstreamVector.erase (I);
  }

}  // TLogStreambuf::erase()


template <typename TChar, typename TTraits>
int mpcl::util::logging::TLogStreambuf<TChar, TTraits>::
overflow (int iCHAR)
{

  using std::for_each;
  using std::isprint;
  using std::string;
  using system::tSystem;
  using text::Format;

  switch (iCHAR)
  {
    case '\x0':
    case EOF:
    {
      break;
    }
    case '\n':
    {
      tSystem.writeLogEntry (yLine, eLogLevel, eLogFacility);
      for_each ( tOstreamVector.begin()                                              ,
                 tOstreamVector.end()                                                ,
                 MAppend<std::basic_ostream<TChar, TTraits>*, string> (yLine + '\n') );
      yLine.erase();
      break;
    }
    default:
    {
      if ( isprint (iCHAR) )
      {
        yLine += iCHAR;
      }
      else
      {
        yLine += Format ("\\x%x", (unsigned int) iCHAR);
      }
      break;
    }
  }
  return iCHAR;

}  // TLogStreambuf::overflow()


template <typename TChar, typename TTraits>
std::streamsize mpcl::util::logging::TLogStreambuf<TChar, TTraits>::
xsputn (const char* pkcSTRING, std::streamsize zSIZE)
{

  using std::basic_ostream;
  using std::for_each;
  using std::isprint;
  using std::streamsize;
  using std::string;
  using system::tSystem;
  using text::Format;

  if ( !pkcSTRING )
  {
    throw TConstraintException ("null string", __FILE__, __LINE__);
  }
  else
  {
    for (streamsize I = 0; ( ( I < zSIZE ) && *pkcSTRING ) ;++I, ++pkcSTRING)
    {
      if ( *pkcSTRING != '\n' )
      {
        if ( isprint (*pkcSTRING) )
        {
          yLine += *pkcSTRING;
        }
        else
        {
          yLine += Format ("\\x%x", (int) *pkcSTRING);
        }
      }
      else
      {
        tSystem.writeLogEntry (yLine, eLogLevel, eLogFacility);
        for_each ( tOstreamVector.begin()                                         ,
                   tOstreamVector.end()                                           ,
                   MAppend<basic_ostream<TChar, TTraits>*, string> (yLine + '\n') );
        yLine.erase();
      }
    }
  }
  return zSIZE;

}  // TLogStreambuf::xsputn()


#endif  // not _MPCL_UTIL_LOGGING_LOG__

---