MNMsg.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MN_OSS_MSG_H
#define MN_OSS_MSG_H

#include <config.h>

#include <stdio.h>
#include <errno.h>

#include "mnstream.h"

using std::string;

#define EDLLLOAD        101
#define EDLLUNLOAD      102
#define EDEVFAIL        103

#define MN_LV_INFO  0x00000001
#define MN_LV_WARN  0x00000010
#define MN_LV_ERROR 0x00000100

class MNMutex;

class MNMessage
{
    static bool     _first_time;
    static MNMutex* _coutMutex;
    static MNMutex* _cerrMutex;

    static void init ( );

    static void prt( const char* txt, const char* file, int line, ostrstream& x );

public:
    MNMessage ( );
    ~MNMessage ( );

    static ostream& out ( );
    static ostream& in ( );
    static void info  ( const char* file, int line, ostrstream& x );
    static void err   ( const char* file, int line, ostrstream& x );
    static void warn  ( const char* file, int line, ostrstream& x );
    static void fatal ( const char* file, int line, ostrstream& x );

    static void std_err ( const char* file, int line, int errnum, ostrstream& x );

    static const char* errNo ( );       // calls errNo(errno)
    static const char* errNo ( int r ); // return strings for many errno values
    static const char* herrNo ( int r ); // return strings for many herrno values

    static bool atLevel( long module, int level );

    static long level_from_config( const char* modulename );
};

#define MN_UNCONDITIONAL_MSG(a,what) \
    do { \
        ostrstream mn_msg_x; \
        mn_msg_x << a << ends; \
        MNMessage::what (__FILE__,__LINE__, mn_msg_x); \
        UNFREEZE(mn_msg_x) \
    } while(0)

#define MN_CONDITIONAL_MSG(a,printit,what) \
    do { \
      if ( printit ) { \
        ostrstream mn_msg_x; \
        mn_msg_x << a << ends; \
        MNMessage::what (__FILE__,__LINE__, mn_msg_x); \
        UNFREEZE(mn_msg_x) \
      } \
    } while(0)

#ifndef NDEBUG
#define MN_INFO(msg)  MN_CONDITIONAL_MSG( \
                                   msg, \
                                   mnmsg_fit(MN_LV_INFO), \
                                   info)
#else
#define MN_INFO(msg)
#endif

#define MN_WARN(msg)  MN_CONDITIONAL_MSG( \
                                   msg, \
                                   mnmsg_fit(MN_LV_WARN), \
                                   warn)
#define MN_ERROR(msg) MN_CONDITIONAL_MSG( \
                                   msg, \
                                   mnmsg_fit(MN_LV_ERROR), \
                                   err)
#define MN_FATAL(msg) MN_UNCONDITIONAL_MSG(msg,fatal)

#define MNMSG_USE(name) \
    static bool        mnmsg_first_fit = true; \
    static long        mnmsg_module_level = 0; \
    \
    static inline bool mnmsg_fit( int level ) { \
        if ( ::mnmsg_first_fit ) { \
            ::mnmsg_first_fit    = false; \
            ::mnmsg_module_level = MNMessage::level_from_config(name); \
        } \
        return ( ::mnmsg_module_level & level ); \
    }

#endif /* MN_OSS_MSG_H */

---