/home/vlg/develop/libASSA/libassa/assa/Logger_Impl.h

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                              Logger_Impl.h
//------------------------------------------------------------------------------
// $Id: Logger_Impl.h,v 1.9 2006/07/20 02:30:54 vlg Exp $
//------------------------------------------------------------------------------
//  Copyright (c) 2001 by Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------
#ifndef LOGGER_IMPL_H
#define LOGGER_IMPL_H

#include <errno.h>
#include <string>

#if defined(sun)
#include <sys/varargs.h>        // va_list
#endif

#if defined (__CYGWIN32__) || defined (__NetBSD__) || defined (WIN32)
# include <stdarg.h>
#endif

#if defined(WIN32)
#    include <winsock2.h>       /* select(3) */
#endif

/* Also defined in winsock.h, winsock2.h, gmon.h and in cygwin's sys/types 
*/
#if !defined ( _BSDTYPES_DEFINED )

typedef unsigned char   u_char;
typedef unsigned short  u_short;
typedef unsigned int    u_int;
typedef unsigned long   u_long;

#define _BSDTYPES_DEFINED

#endif /* ! def _BSDTYPES_DEFINED  */

using std::string;
using std::ostream;

#include "assa/LogMask.h"

#if defined (WIN32)

typedef SOCKET handler_t;
#define BAD_HANDLER INVALID_SOCKET

#define EINPROGRESS   WSAEINPROGRESS   /* A blocking Winsock call is in
                                        * progress, or the service provider
                                        * is still process a callback function.
                                        */
#define EWOULDBLOCK   WSAEWOULDBLOCK   /* The socket is marked as nonblocking
                                        * and the connection cannot be completed
                                        * immediately.
                                        */
#define EISCONN       WSAEISCONN

#define ENOTSOCK      WSAENOTSOCK      /* The descriptor is not a socket.
                                        */
#define ECONNREFUSED  WSAECONNREFUSED  /* The attempt to connect was
                                        * forcefully rejected.
                                        */
#define ETIMEDOUT     WSAETIMEDOUT     /* An attempt to connect timed out
                                        * without establishing connection.
                                        */
#else    /*--- POSIX ---*/

#define BAD_HANDLER -1
typedef int handler_t;

#endif  // ifdef WIN32


namespace ASSA {

class Reactor;

//---------------------------------------------------------------------------
// Utilities that don't fit anywhere else
//---------------------------------------------------------------------------

    inline bool is_valid_handler (handler_t socket_) 
    {
        return (socket_ != BAD_HANDLER);
    }

    inline void disable_handler (handler_t& socket_)
    {
        socket_ = BAD_HANDLER;
    }

    inline int get_errno ()
    {
        int myerrno;
#if defined (WIN32)
        myerrno = WSAGetLastError ();
#else
        myerrno = errno;
#endif
        return myerrno;
    }       

    inline void set_errno (int new_errno_)
    {
#if defined (WIN32)
        WSASetLastError (new_errno_); 
#else
        errno = new_errno_;
#endif
    }       

//---------------------------------------------------------------------------
// Class Logger_Impl
//---------------------------------------------------------------------------

class Logger_Impl {
public:
    static const unsigned int LOGGER_MAXLINE = 6660;

public:
    Logger_Impl ();
    virtual ~Logger_Impl () { /* empty */ }

    void enable_group  (Group g_)  { m_groups |= g_;  }
    void disable_group (Group g_)  { m_groups &= ~g_; }

    void enable_groups  (u_long g_)  { m_groups |= g_;  }
    void disable_groups (u_long g_)  { m_groups &= ~g_; }

    void enable_all_groups  (void) { m_groups = ASSA::ALL;  }
    void disable_all_groups (void) { m_groups = 0;    }

    bool group_enabled (Group g_) const { return (m_groups & g_); }

    void enable_timestamp  (void)       { m_tmflg = true;  }
    void disable_timestamp (void)       { m_tmflg = false; }
    bool timestamp_enabled (void) const { return m_tmflg;  }
    void set_timezone      (int zone_)  { m_tz = zone_;    }

    void    set_indent_step (u_short step_) { m_indent_step = step_; }
    u_short get_indent_step (void) const    { return m_indent_step;  }

    virtual int log_open (u_long groups_);

    virtual int log_open (const char* logfname_, 
                          u_long groups_, 
                          u_long maxsize_);

    virtual int log_open (const char*  appname_,
                          const char* logfname_, 
                          u_long        groups_, 
                          u_long       maxsize_,
                          Reactor*     reactor_);

    virtual int  log_close  (void) = 0;
    virtual void log_resync (void) { /* empty */ }

    virtual int log_msg (Group g_, 
                         size_t indent_level_, 
                         const string& func_name_, 
                         size_t expected_sz_,
                         const char* fmt_, 
                         va_list) = 0;

    virtual int log_func (Group g_, 
                          size_t indent_level_, 
                          const string& func_name_, 
                          marker_t type_) = 0;
protected:
    virtual u_short add_timestamp    (ostream& sink_);
    virtual u_short indent_func_name (ostream& sink_, 
                                      const string& funcname_,
                                      size_t indent_level_,
                                      marker_t type_);

    char* format_msg (size_t expected_sz_, 
                      const char*    fmt_, 
                      va_list        vap_,
                      bool&      release_);

protected:
    static char m_msgbuf [LOGGER_MAXLINE];

    u_short m_indent_step;

    u_long m_groups;

    string m_logfname;

    bool   m_tmflg;

    int    m_tz;
};

inline
Logger_Impl::
Logger_Impl () 
    : m_indent_step (1), 
      m_groups (0), 
      m_tmflg (false), 
      m_tz (1)
{
    /* no-op */
}

inline int 
Logger_Impl::
log_open (u_long /* groups_ */)
{
    errno = ENOSYS;
    return -1;
}

inline int 
Logger_Impl::
log_open (const char*, /* logfname_ */
          u_long,      /* groups_ */
          u_long       /* maxsize_ */)
{
    errno = ENOSYS;
    return -1;
}

inline int 
Logger_Impl::
log_open (const char*, /* appname_  */
          const char*, /* logfname_ */
          u_long,      /* groups_   */
          u_long,      /* maxsize_  */
          Reactor*     /* reactor_  */)
{
    errno = ENOSYS;
    return -1;
}

} // end namespace ASSA

#endif /* LOGGER_IMPL_H */

---