Macros.h File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/time.h>
#include <iostream>
#include <fstream>
#include <sys/types.h>
#include <unistd.h>
#include <Nice/Log/External.h>
#include <Nice/Log/Stream.h>

Include dependency graph for Macros.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	LOG_NAME   Nice::Name
#define	NICE_LOG_NAME(x)   Nice::setLogName(x)
#define	LOG_LEVEL(x)   Nice::createStdOut(); Nice::StdOut->setLogLevel(x)
#define	NICE_LOG_USER(x)   Nice::createStdOut(); Nice::StdOut->setUserLogLevel(x)
#define	LOG_OBJ(x)   Nice::createStdOut(); Nice::StdOut->setFunc(x)
#define	LOG_FILE(x)   Nice::createStdOut(); Nice::StdOut->setFile(x)
#define	LOG_STD   Nice::createStdOut(); Nice::StdOut->setFunc(new Nice::StdLogFunction())
#define	LOG_EXT   Nice::createStdOut(); Nice::StdOut->setFunc(new Nice::ExtLogFunction())
#define	LOG_COLOR   Nice::createStdOut(); Nice::StdOut->setFunc(new Nice::StdColorLogFunction())
#define	LOG_STDCOL   Nice::createStdOut(); Nice::StdOut->setFunc(new Nice::StdColorLogFunction())
#define	LOG_EXTCOL   Nice::createStdOut(); Nice::StdOut->setFunc(new Nice::ExtColorLogFunction())
#define	LOG(z, y)
#define	SLOG(z, x, y)
#define	QLOG(z, y)
#define	QSLOG(z, x, y)
#define	ASSERT(z, x, y)   if((x)) LOG(z, y);
#define	F_ASSERT(x, y)
#define	F_LOG(y)
#define	F_SLOG(x, y)
#define	F_RETURN(x, y)
#define	F_QLOG(y)
#define	F_QSLOG(x, y)
#define	A_ASSERT(x, y)
#define	A_LOG(y)
#define	A_SLOG(x, y)
#define	A_RETURN(x, y)
#define	A_QLOG(y)
#define	A_QSLOG(x, y)
#define	C_LOG(y)
#define	C_SLOG(x, y)
#define	C_RETURN(x, y)
#define	C_QLOG(y)
#define	C_QSLOG(x, y)
#define	E_ASSERT(x, y)
#define	E_LOG(y)
#define	E_SLOG(x, y)
#define	E_QLOG(y)
#define	E_QSLOG(x, y)
#define	W_ASSERT(x, y)
#define	W_LOG(y)
#define	W_SLOG(x, y)
#define	W_QLOG(y)
#define	W_QSLOG(x, y)
#define	N_ASSERT(x, y)
#define	N_LOG(y)
#define	N_SLOG(x, y)
#define	N_QLOG(y)
#define	N_QSLOG(x, y)
#define	I_ASSERT(x, y)
#define	I_LOG(y)
#define	I_SLOG(x, y)
#define	I_QLOG(y)
#define	I_QSLOG(x, y)
#define	U1_ASSERT(x, y)   ;
#define	U1_LOG(y)   ;
#define	U1_SLOG(x, y)
#define	U1_QLOG(y)   ;
#define	U1_QSLOG(x, y)
#define	U2_ASSERT(x, y)   ;
#define	U2_LOG(y)   ;
#define	U2_SLOG(x, y)
#define	U2_QLOG(y)   ;
#define	U2_QSLOG(x, y)
#define	U3_ASSERT(x, y)   ;
#define	U3_LOG(y)   ;
#define	U3_SLOG(x, y)
#define	U3_QLOG(y)   ;
#define	U3_QSLOG(x, y)
#define	U4_ASSERT(x, y)   ;
#define	U4_LOG(y)   ;
#define	U4_SLOG(x, y)
#define	U4_QLOG(y)   ;
#define	U4_QSLOG(x, y)
#define	U5_ASSERT(x, y)   ;
#define	U5_LOG(y)   ;
#define	U5_SLOG(x, y)
#define	U5_QLOG(y)   ;
#define	U5_QSLOG(x, y)
#define	U6_ASSERT(x, y)   ;
#define	U6_LOG(y)   ;
#define	U6_SLOG(x, y)
#define	U6_QLOG(y)   ;
#define	U6_QSLOG(x, y)
#define	U7_ASSERT(x, y)   ;
#define	U7_LOG(y)   ;
#define	U7_SLOG(x, y)
#define	U7_QLOG(y)   ;
#define	U7_QSLOG(x, y)
#define	U8_ASSERT(x, y)   ;
#define	U8_LOG(y)   ;
#define	U8_SLOG(x, y)
#define	U8_QLOG(y)   ;
#define	U8_QSLOG(x, y)
#define	U9_ASSERT(x, y)   ;
#define	U9_LOG(y)   ;
#define	U9_SLOG(x, y)
#define	U9_QLOG(y)   ;
#define	U9_QSLOG(x, y)
#define	D_ASSERT(x, y)   ;
#define	D_LOG(y)   ;
#define	D_SLOG(x, y)
#define	D_QLOG(y)   ;
#define	D_QSLOG(x, y)
#define	T_ASSERT(x, y)   ;
#define	T_LOG(y)   ;
#define	T_SLOG(x, y)
#define	T_QLOG(y)   ;
#define	T_QSLOG(x, y)

Macro Definition Documentation

A_ASSERT

#define A_ASSERT	(		x,
			y
	)

Value:

Nice::createStdOut(); if((!(x)) && Nice::LALERT <= Nice::StdOut->m_level) { \
                           Nice::Guard guard(Nice::StdOut->m_mutex); \
                           Nice::StdOut->log(Nice::LALERT, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

A_LOG

#define A_LOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LALERT <= Nice::StdOut->m_level) { \
                           Nice::Guard guard(Nice::StdOut->m_mutex); \
                           Nice::StdOut->log(Nice::LALERT, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

A_QLOG

#define A_QLOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LALERT <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->quick(Nice::LALERT, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

A_QSLOG

#define A_QSLOG	(		x,
			y
	)

Value:

if(Nice::LALERT <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            x.quick(Nice::LALERT, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

A_RETURN

#define A_RETURN	(		x,
			y
	)

Value:

Nice::createStdOut(); if(Nice::LALERT <= Nice::StdOut->m_level) { \
                             Nice::Guard guard(Nice::StdOut->m_mutex); \
                             Nice::StdOut->log(Nice::LALERT, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                              << std::endl; \
                             return (x); }

A_SLOG

#define A_SLOG	(		x,
			y
	)

Value:

if(Nice::LALERT <= x.m_level) { \
                           Nice::Guard guard(x.m_mutex); \
                           x(Nice::LALERT, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

ASSERT

#define ASSERT	(		z,
			x,
			y
	)		if((x)) LOG(z, y);

C_LOG

#define C_LOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LCRITICAL <= Nice::StdOut->m_level) { \
                           Nice::Guard guard(Nice::StdOut->m_mutex); \
                           Nice::StdOut->log(Nice::LCRITICAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

C_QLOG

#define C_QLOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LCRITICAL <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->quick(Nice::LCRITICAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

C_QSLOG

#define C_QSLOG	(		x,
			y
	)

Value:

if(Nice::LCRITICAL <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            x.quick(Nice::LCRITICAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

C_RETURN

#define C_RETURN	(		x,
			y
	)

Value:

Nice::createStdOut(); if(Nice::LCRITICAL <= Nice::StdOut->m_level) { \
                             Nice::Guard guard(Nice::StdOut->m_mutex); \
                             Nice::StdOut->log(Nice::LCRITICAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                              << std::endl; \
                             return (x); }

C_SLOG

#define C_SLOG	(		x,
			y
	)

Value:

if(Nice::LCRITICAL <= x.m_level) { \
                           Nice::Guard guard(x.m_mutex); \
                           x(Nice::LCRITICAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

D_ASSERT

#define D_ASSERT	(		x,
			y
	)		;

D_LOG

#define D_LOG

(

y

)

;

D_QLOG

#define D_QLOG

(

y

)

;

D_QSLOG

#define D_QSLOG	(		x,
			y
	)

D_SLOG

#define D_SLOG	(		x,
			y
	)

E_ASSERT

#define E_ASSERT	(		x,
			y
	)

Value:

Nice::createStdOut(); if((!(x)) && Nice::LERROR <= Nice::StdOut->m_level) { \
                           Nice::Guard guard(Nice::StdOut->m_mutex); \
                           Nice::StdOut->log(Nice::LERROR, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

E_LOG

#define E_LOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LERROR <= Nice::StdOut->m_level) { \
                           Nice::Guard guard(Nice::StdOut->m_mutex); \
                           Nice::StdOut->log(Nice::LERROR, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

E_QLOG

#define E_QLOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LERROR <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->quick(Nice::LERROR, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

E_QSLOG

#define E_QSLOG	(		x,
			y
	)

Value:

if(Nice::LERROR <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            x.quick(Nice::LERROR, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

E_SLOG

#define E_SLOG	(		x,
			y
	)

Value:

if(Nice::LERROR <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            Nice::StdOut->log(Nice::LERROR, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

F_ASSERT

#define F_ASSERT	(		x,
			y
	)

Value:

Nice::createStdOut(); if((!(x)) && Nice::LFATAL <= Nice::StdOut->m_level) { \
                           Nice::Guard guard(Nice::StdOut->m_mutex); \
                           Nice::StdOut->log(Nice::LFATAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

F_LOG

#define F_LOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LFATAL <= Nice::StdOut->m_level) { \
                           Nice::Guard guard(Nice::StdOut->m_mutex); \
                           Nice::StdOut->log(Nice::LFATAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

F_QLOG

#define F_QLOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LFATAL <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->quick(Nice::LFATAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

F_QSLOG

#define F_QSLOG	(		x,
			y
	)

Value:

if(Nice::LFATAL <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            x.quick(Nice::LFATAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

F_RETURN

#define F_RETURN	(		x,
			y
	)

Value:

Nice::createStdOut(); if(Nice::LFATAL <= Nice::StdOut->m_level) { \
                             Nice::Guard guard(Nice::StdOut->m_mutex); \
                             Nice::StdOut->log(Nice::LFATAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                              << std::endl; \
                             return (x); }

F_SLOG

#define F_SLOG	(		x,
			y
	)

Value:

if(Nice::LFATAL <= x.m_level) { \
                           Nice::Guard guard(x.m_mutex); \
                           x(Nice::LFATAL, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

I_ASSERT

#define I_ASSERT	(		x,
			y
	)

Value:

{ Nice::createStdOut(); if((!(x)) && Nice::LINFO <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->log(Nice::LINFO, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }}

I_LOG

#define I_LOG

(

y

)

Value:

{ Nice::createStdOut(); if(Nice::LINFO <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->log(Nice::LINFO, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }}

I_QLOG

#define I_QLOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LINFO <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->quick(Nice::LINFO, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

I_QSLOG

#define I_QSLOG	(		x,
			y
	)

Value:

if(Nice::LINFO <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            x.quick(Nice::LINFO, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

I_SLOG

#define I_SLOG	(		x,
			y
	)

Value:

if(Nice::LINFO <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            Nice::StdOut->log(Nice::LINFO, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

LOG

#define LOG	(		z,
			y
	)

Value:

Nice::createStdOut(); if(z <= Nice::StdOut->m_level) { \
                           Nice::Guard guard(Nice::StdOut->m_mutex);\
                           Nice::StdOut->log(z, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

LOG_COLOR

#define LOG_COLOR   Nice::createStdOut(); Nice::StdOut->setFunc(new Nice::StdColorLogFunction())

LOG_EXT

#define LOG_EXT   Nice::createStdOut(); Nice::StdOut->setFunc(new Nice::ExtLogFunction())

LOG_EXTCOL

#define LOG_EXTCOL   Nice::createStdOut(); Nice::StdOut->setFunc(new Nice::ExtColorLogFunction())

LOG_FILE

#define LOG_FILE

(

x

)

Nice::createStdOut(); Nice::StdOut->setFile(x)

LOG_LEVEL

#define LOG_LEVEL

(

x

)

Nice::createStdOut(); Nice::StdOut->setLogLevel(x)

LOG_NAME

#define LOG_NAME   Nice::Name

LOG_OBJ

#define LOG_OBJ

(

x

)

Nice::createStdOut(); Nice::StdOut->setFunc(x)

LOG_STD

#define LOG_STD   Nice::createStdOut(); Nice::StdOut->setFunc(new Nice::StdLogFunction())

LOG_STDCOL

#define LOG_STDCOL   Nice::createStdOut(); Nice::StdOut->setFunc(new Nice::StdColorLogFunction())

N_ASSERT

#define N_ASSERT	(		x,
			y
	)

Value:

Nice::createStdOut(); if((!(x)) && Nice::LNOTICE <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->log(Nice::LNOTICE, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

N_LOG

#define N_LOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LNOTICE <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->log(Nice::LNOTICE, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

N_QLOG

#define N_QLOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LNOTICE <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->quick(Nice::LNOTICE, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

N_QSLOG

#define N_QSLOG	(		x,
			y
	)

Value:

if(Nice::LNOTICE <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            x.quick(Nice::LNOTICE, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

N_SLOG

#define N_SLOG	(		x,
			y
	)

Value:

if(Nice::LNOTICE <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            Nice::StdOut->log(Nice::LNOTICE, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

NICE_LOG_NAME

#define NICE_LOG_NAME

(

x

)

Nice::setLogName(x)

NICE_LOG_USER

#define NICE_LOG_USER

(

x

)

Nice::createStdOut(); Nice::StdOut->setUserLogLevel(x)

QLOG

#define QLOG	(		z,
			y
	)

Value:

Nice::createStdOut(); if(z <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->quick(z, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

QSLOG

#define QSLOG	(		z,
			x,
			y
	)

Value:

if(z <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            x.quick(z, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

SLOG

#define SLOG	(		z,
			x,
			y
	)

Value:

if(z <= x.m_level) { \
                           Nice::Guard guard(x.m_mutex);\
                           x(z, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

T_ASSERT

#define T_ASSERT	(		x,
			y
	)		;

T_LOG

#define T_LOG

(

y

)

;

T_QLOG

#define T_QLOG

(

y

)

;

T_QSLOG

#define T_QSLOG	(		x,
			y
	)

T_SLOG

#define T_SLOG	(		x,
			y
	)

U1_ASSERT

#define U1_ASSERT	(		x,
			y
	)		;

U1_LOG

#define U1_LOG

(

y

)

;

U1_QLOG

#define U1_QLOG

(

y

)

;

U1_QSLOG

#define U1_QSLOG	(		x,
			y
	)

U1_SLOG

#define U1_SLOG	(		x,
			y
	)

U2_ASSERT

#define U2_ASSERT	(		x,
			y
	)		;

U2_LOG

#define U2_LOG

(

y

)

;

U2_QLOG

#define U2_QLOG

(

y

)

;

U2_QSLOG

#define U2_QSLOG	(		x,
			y
	)

U2_SLOG

#define U2_SLOG	(		x,
			y
	)

U3_ASSERT

#define U3_ASSERT	(		x,
			y
	)		;

U3_LOG

#define U3_LOG

(

y

)

;

U3_QLOG

#define U3_QLOG

(

y

)

;

U3_QSLOG

#define U3_QSLOG	(		x,
			y
	)

U3_SLOG

#define U3_SLOG	(		x,
			y
	)

U4_ASSERT

#define U4_ASSERT	(		x,
			y
	)		;

U4_LOG

#define U4_LOG

(

y

)

;

U4_QLOG

#define U4_QLOG

(

y

)

;

U4_QSLOG

#define U4_QSLOG	(		x,
			y
	)

U4_SLOG

#define U4_SLOG	(		x,
			y
	)

U5_ASSERT

#define U5_ASSERT	(		x,
			y
	)		;

U5_LOG

#define U5_LOG

(

y

)

;

U5_QLOG

#define U5_QLOG

(

y

)

;

U5_QSLOG

#define U5_QSLOG	(		x,
			y
	)

U5_SLOG

#define U5_SLOG	(		x,
			y
	)

U6_ASSERT

#define U6_ASSERT	(		x,
			y
	)		;

U6_LOG

#define U6_LOG

(

y

)

;

U6_QLOG

#define U6_QLOG

(

y

)

;

U6_QSLOG

#define U6_QSLOG	(		x,
			y
	)

U6_SLOG

#define U6_SLOG	(		x,
			y
	)

U7_ASSERT

#define U7_ASSERT	(		x,
			y
	)		;

U7_LOG

#define U7_LOG

(

y

)

;

U7_QLOG

#define U7_QLOG

(

y

)

;

U7_QSLOG

#define U7_QSLOG	(		x,
			y
	)

U7_SLOG

#define U7_SLOG	(		x,
			y
	)

U8_ASSERT

#define U8_ASSERT	(		x,
			y
	)		;

U8_LOG

#define U8_LOG

(

y

)

;

U8_QLOG

#define U8_QLOG

(

y

)

;

U8_QSLOG

#define U8_QSLOG	(		x,
			y
	)

U8_SLOG

#define U8_SLOG	(		x,
			y
	)

U9_ASSERT

#define U9_ASSERT	(		x,
			y
	)		;

U9_LOG

#define U9_LOG

(

y

)

;

U9_QLOG

#define U9_QLOG

(

y

)

;

U9_QSLOG

#define U9_QSLOG	(		x,
			y
	)

U9_SLOG

#define U9_SLOG	(		x,
			y
	)

W_ASSERT

#define W_ASSERT	(		x,
			y
	)

Value:

Nice::createStdOut(); if((!(x)) && Nice::LWARNING <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->log(Nice::LWARNING, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

W_LOG

#define W_LOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LWARNING <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->log(Nice::LWARNING, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }

W_QLOG

#define W_QLOG

(

y

)

Value:

Nice::createStdOut(); if(Nice::LWARNING <= Nice::StdOut->m_level) { \
                            Nice::Guard guard(Nice::StdOut->m_mutex); \
                            Nice::StdOut->quick(Nice::LWARNING, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

W_QSLOG

#define W_QSLOG	(		x,
			y
	)

Value:

if(Nice::LWARNING <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            x.quick(Nice::LWARNING, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__, LOG_NAME, y);}

W_SLOG

#define W_SLOG	(		x,
			y
	)

Value:

if(Nice::LWARNING <= x.m_level) { \
                            Nice::Guard guard(x.m_mutex); \
                            Nice::StdOut->log(Nice::LWARNING, __BASE_FILE__, __LINE__,  __PRETTY_FUNCTION__,  LOG_NAME) << y \
                            << std::endl; }