commoncpp/applog.h

Go to the documentation of this file.

// Copyright (C) 2005-2014 Angelo Naselli, Penta Engineering s.r.l.
//
// 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.
//
// 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 Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// Common C++.  If you copy code from other releases into a copy of GNU
// Common C++, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU Common C++, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#ifndef COMMONCPP_APPLOG_H_
#define COMMONCPP_APPLOG_H_

#ifndef COMMONCPP_SLOG_H_
#include <commoncpp/slog.h>
#endif

#ifndef COMMONCPP_EXCEPTION_H_
#include <commoncpp/exception.h>
#endif

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

NAMESPACE_COMMONCPP
using namespace std;
class __EXPORT HEXdump
{
  protected:
    std::string _str;

  public:
    // max_len: max number of bytes to be printed. 0 prints all.
    HEXdump(const unsigned char *buffer, int buff_len, int max_len = 200);

    virtual ~HEXdump() { _str = string();}

    const char * c_str() const
    {
      return _str.c_str();
    }

    std::string str()
    {
      return _str;
    }

    friend std::ostream& operator<< (std::ostream& out, const HEXdump &hd)
    {
      out << hd.c_str();
      return out;
    }

};

#ifdef  CCXX_EXCEPTIONS

class __EXPORT AppLogException : public ost::Exception
{
  public:
    AppLogException(const char *what_arg) : ost::Exception(what_arg) {};

};
#endif

class AppLogPrivate;

class __EXPORT AppLog : protected streambuf, public ostream
{
  protected:
    // d pointer
    AppLogPrivate *d;
    void writeLog(bool endOfLine = true);
    static std::map<string, Slog::Level> *assoc;

  public:
    class __EXPORT Ident
    {
      private:
        std::string _ident;
      public:

        Ident() {};

        ~Ident() {};

        Ident(Ident& id) {_ident = id._ident;}

        Ident(const char *str) : _ident(str) {};

        std::string& str() {return _ident;}

        Ident& operator= (std::string &st) {_ident = st; return *this;}

        Ident& operator= (const char str[]) {_ident = str; return *this;}

        const char* c_str() {return _ident.c_str();}
    };

#ifndef _MSWINDOWS_

    AppLog(const char* logFileName = NULL, bool logDirectly = false , bool usePipe = false);
#else

    AppLog(const char* logFileName = NULL, bool logDirectly = false);
#endif

    virtual ~AppLog();

    void subscribe();

    void unsubscribe();

#ifndef _MSWINDOWS_

    void logFileName(const char* FileName, bool logDirectly = false, bool usePipe = false);
#else

    void logFileName(const char* FileName, bool logDirectly = false);
#endif

    void close(void);

    void level(Slog::Level enable);

    void clogEnable(bool en = true);

    void slogEnable(bool en = true);

    void identLevel(const char *ident, Slog::Level level);

    void open(const char *ident);

    virtual int overflow(int c);

    virtual int sync();

    void emerg(const char *format, ...);

    void alert(const char *format, ...);

    void critical(const char *format, ...);

    void error(const char *format, ...);

    void warn(const char *format, ...);

    void notice(const char *format, ...);

    void info(const char *format, ...);

    void debug(const char *format, ...);

    AppLog &operator()(const char *ident, Slog::Level level = Slog::levelError);

    inline AppLog& operator()(Ident &ident)
    {
      open(ident.c_str());
      return *this;
    }

    AppLog &operator()(Slog::Level level);

    AppLog& operator<< (AppLog& (*pfManipulator)(AppLog&));

    AppLog& operator<< (ostream& (*pfManipulator)(ostream&));

    friend  ostream& operator << (ostream &os, AppLog & al)
    {
      return al;
    }

    inline AppLog& operator<< (Ident &ident)
    {
      open(ident.c_str());
      return *this;
    }


    inline AppLog &warn(void)
    {return operator()(Slog::levelWarning);}

    AppLog &error(void)
    { return operator()(Slog::levelError);}

    inline AppLog &debug(void)
    {return operator()(Slog::levelDebug);}

    inline AppLog &emerg(void)
    {return operator()(Slog::levelEmergency);}

    inline AppLog &alert(void)
    {return operator()(Slog::levelAlert);}

    inline AppLog &critical(void)
    {return operator()(Slog::levelCritical);}

    inline AppLog &notice(void)
    {return operator()(Slog::levelNotice);}

    inline AppLog &info(void)
    {return operator()(Slog::levelInfo);}

    static Slog::Level levelTranslate(string name)
    {
    std::map<string, Slog::Level>::iterator  it = assoc->find(name);
    return (it != assoc->end()) ? it->second : Slog::levelEmergency;
    }

};

__EXPORT inline AppLog &debug(AppLog& sl)
{return sl.operator()(Slog::levelDebug);}

__EXPORT inline AppLog &warn(AppLog& sl)
{return sl.operator()(Slog::levelWarning);}

__EXPORT inline AppLog &error(AppLog& sl)
{ return sl.operator()(Slog::levelError);}

__EXPORT inline AppLog &emerg(AppLog& sl)
{return sl.operator()(Slog::levelEmergency);}

__EXPORT inline AppLog &alert(AppLog& sl)
{return sl.operator()(Slog::levelAlert);}

__EXPORT inline AppLog &critical(AppLog& sl)
{return sl.operator()(Slog::levelCritical);}

__EXPORT inline AppLog &notice(AppLog& sl)
{return sl.operator()(Slog::levelNotice);}

__EXPORT inline AppLog &info(AppLog& sl)
{return sl.operator()(Slog::levelInfo);}

__EXPORT extern AppLog alog;

END_NAMESPACE

#endif //___APPLOG_H___

---