rvlog.h

h.248协议源码

	{include: rvlog.h}
	{description:
		{p: Log general information at level 3.}
	}
	{proto: void rvLogInfo3(RvLog* l, const char* text);}
	{params:
		{param: {n: l} {d: A pointer to the log.}}
		{param: {n: text} {d: Associated text.}}
	}
}
$*/
/*$
{function:
	{name: rvLogInt3 }	
	{class: RvLog}	
	{include: rvlog.h}
	{description:
		{p: Log an integer name value pair as an informational level 3.}
	}
	{proto: void rvLogInt3(RvLog* l, const char* name, int value, int radix);}
	{params:
		{param: {n: l} {d: A pointer to the log.}}
		{param: {n: name} {d: The variable's name. }}
		{param: {n: value} {d: The variable's integrer value.}}
		{param: {n: radix} {d: The base that the varialbe's value will be display in.}}
	}
}
$*/
/*$
{function:
	{name: rvLogStr3 }	
	{class: RvLog}	
	{include: rvlog.h}
	{description:
		{p: Log an string name value pair as an informational level 3.}
	}
	{proto: void rvLogStr3(RvLog* l, const char* name, const char* value);}
	{params:
		{param: {n: l} {d: A pointer to the log.}}
		{param: {n: name} {d: The variable's name. }}
		{param: {n: value} {d: The variable's string value.}}
	}
}
$*/
/* INFO3 logging */
#if (RV_LOGMASK & RV_LOGLEVEL_INFO3)
#	define rvLogInfo3(l, txt)			(rvLogText_(l, RV_LOGLEVEL_INFO3, (txt)))
#	define rvLogInt3(l, n, v, r)		(rvLogInt_(l, RV_LOGLEVEL_INFO3, (n), (v), (r)))
#	define rvLogStr3(l, n, v)			(rvLogStr_(l, RV_LOGLEVEL_INFO3, (n), (v)))
#else
#	define rvLogInfo3(l, txt)
#	define rvLogInt3(l, n, v, r)
#	define rvLogStr3(l, n, v)	
#endif

/*$
{function:
	{name: rvLogInfo4 }	
	{class: RvLog}	
	{include: rvlog.h}
	{description:
		{p: Log general information at level 4.}
	}
	{proto: void rvLogInfo4(RvLog* l, const char* text);}
	{params:
		{param: {n: l} {d: A pointer to the log.}}
		{param: {n: text} {d: Associated text.}}
	}
}
$*/
/*$
{function:
	{name: rvLogInt4 }	
	{class: RvLog}	
	{include: rvlog.h}
	{description:
		{p: Log an integer name value pair as an informational level 4.}
	}
	{proto: void rvLogInt4(RvLog* l, const char* name, int value, int radix);}
	{params:
		{param: {n: l} {d: A pointer to the log.}}
		{param: {n: name} {d: The variable's name. }}
		{param: {n: value} {d: The variable's integrer value.}}
		{param: {n: radix} {d: The base that the varialbe's value will be display in.}}
	}
}
$*/
/*$
{function:
	{name: rvLogStr4 }	
	{class: RvLog}	
	{include: rvlog.h}
	{description:
		{p: Log an string name value pair as an informational level 4.}
	}
	{proto: void rvLogStr4(RvLog* l, const char* name, const char* value);}
	{params:
		{param: {n: l} {d: A pointer to the log.}}
		{param: {n: name} {d: The variable's name. }}
		{param: {n: value} {d: The variable's string value.}}
	}
}
$*/
/* INFO4 logging */
#if (RV_LOGMASK & RV_LOGLEVEL_INFO4)
#	define rvLogInfo4(l, txt)			(rvLogText_(l, RV_LOGLEVEL_INFO4, (txt)))
#	define rvLogInt4(l, n, v, r)		(rvLogInt_(l, RV_LOGLEVEL_INFO4, (n), (v), (r)))
#	define rvLogStr4(l, n, v)			(rvLogStr_(l, RV_LOGLEVEL_INFO4, (n), (v)))
#else
#	define rvLogInfo4(l, txt)
#	define rvLogInt4(l, n, v, r)
#	define rvLogStr4(l, n, v)	
#endif

#if (RV_LOGMASK != RV_LOGMASK_NONE)

#define RV_LOG_TIMESTAMP_BUFSIZE 30

/*$
{type:
	{name: RvLogRecord}
    {superpackage: Kernel}
	{include: rvlog.h}
	{description:	
		{p: Describes a log record.  A log record records a runtime event.  
		  A log record contains the following information:}
        {bulletlist:
		    {item: timestamp - The time at which the event occurred.}
		    {item: thread name - The name of the thread in which the event took place.}
		    {item: level - The log level of the event.}
		    {item: text - A text string supplied when the event was logged.}
        }
	}
	{methods:
		{method: RvLogRecord* rvLogRecordConstruct(RvLogRecord* r, RvLogLevel level, const char* text);}
		{method: const char* rvLogRecordGetTimeAsString(const RvLogRecord* r, char* buf);}
		{method: const char* rvLogRecordGetThreadName(const RvLogRecord* r);}
		{method: RvLogLevel rvLogRecordGetLevel(const RvLogRecord* r);}
		{method: const char* rvLogRecordGetLevelString(const RvLogRecord *rec);}
		{method: const char* rvLogRecordGetText(const RvLogRecord* r);}
	}
    {see_also:
        {n: RvLogLevel}
    }
}
$*/
typedef struct {
	RvTimespec timestamp;
	char threadName[32];
	RvLogLevel level;
	const char* text;
} RvLogRecord;

RvLogRecord* rvLogRecordConstruct(RvLogRecord* r, RvLogLevel level, 
  const char* text);
const char* rvLogRecordGetTimeAsString(const RvLogRecord* lr, OUT char* buf);

/*$
{function:
	{name: rvLogRecordGetThreadName }	
	{class: RvLogRecord}	
	{include: rvlog.h}
	{description:
		{p: Get the thread name of a log record.}
	}
	{proto: const char* rvLogRecordGetThreadName(RvLogRecord* r);}
	{params:
		{param: {n: r} {d: A pointer to the log record.}}
	}
	{returns: The thread name of the log record as a string. }
}
$*/
#define rvLogRecordGetThreadName(lr)	((lr)->threadName)

/*$
{function:
	{name: rvLogRecordGetLevel }	
	{class: RvLogRecord}	
	{include: rvlog.h}
	{description:
		{p: Get the log level of a log record.}
	}
	{proto: RvLogLevel rvLogRecordGetLevel(RvLogRecord* r);}
	{params:
		{param: {n: r} {d: A pointer to the log record.}}
	}
	{returns: The log level of the log record. }
}
$*/
#define rvLogRecordGetLevel(lr)			((lr)->level)
const char* rvLogRecordGetLevelString(const RvLogRecord *rec);

/*$
{function:
	{name: rvLogRecordGetText }	
	{class: RvLogRecord}	
	{include: rvlog.h}
	{description:
		{p: Get the associated text of a log record.}
	}
	{proto: const char* rvLogRecordGetText(RvLogRecord* r);}
	{params:
		{param: {n: r} {d: A pointer to the log record.}}
	}
	{returns: The associated text of the log record. }
}
$*/
#define rvLogRecordGetText(lr)			((lr)->text)

/*$
{type:
	{name: RvLogListener}
    {superpackage: Kernel}
	{include: rvlog.h}
	{description:	
		{p: Describes a log listener.  A log listener is used to filter and process
		    log records in a user specified manner. To use a RvLogListener you should
            construct it with your callback function, then register the RvLogListener with
            an RvLog object.}
	}
	{methods:
		{method: RvLogListener* rvLogListenerConstruct(RvLogListener* li, RvLogMask mask, 
		  void (*output)(const RvLogRecord*, void*), void* data);}
		{method: void rvLogListenerDestruct(RvLogListener* li);}
		{method: RvLogMask rvLogListenerSetMask(RvLogListener* li, RvLogMask mask);}
		{method: RvLogMask rvLogListenerGetMask(RvLogListener* li);}
	}
    {see_also:
        {n: RvLog}
        {n: RvLogRecord}
        {n: RvLogMask}
		{n: RvStdioLog}
		{n: RvFileLog}
    }
    {examples:
        {example:
            {description:
		        {p: Here are some code snippets demostrating how to construct 
                    a RvLogListener with a custom handler and register it with 
                    a log.}
            }
            {code:
#include "rvlog.h"

void MyLogHandler(RvLog* log, const RvLogRecord* rec, void* data)
\{
    printf("%s", rvLogRecordGetText(rec));
\}

RvLogListener listener;

rvLogListenerConstruct(&listener,RV_LOGLEVEL_ERROR|RV_LOGLEVEL_WARNING, MyLogHandler,(void*)0);

rvLogRegisterListener(&log, &listener);

            }
        }
    }
}
$*/
typedef struct {
	RvLogMask mask;
	void (*output)(const RvLogRecord* rec, void* data);
	void* data;
} RvLogListener;

RvLogListener* rvLogListenerConstruct(RvLogListener* li, RvLogMask mask, 
  void (*output)(const RvLogRecord*, void*), void* data);

/*$
{function:
	{name: rvLogListenerDestruct }	
	{class: RvLogListener}	
	{include: rvlog.h}
	{description:
		{p: Destruct an instance of a log listener.}
	}
	{proto: void rvLogListenerDestruct(RvLogListener* li); }
	{params:
		{param: {n: li} {d: The log listener. }}
	}
}
$*/
#define rvLogListenerDestruct(li) 
RvLogMask rvLogListenerSetMask(RvLogListener* li, RvLogMask mask);
RvLogMask rvLogListenerGetMask(RvLogListener* li);


/*$
{type:
	{name: RvLog}
    {superpackage: Kernel}
	{include: rvlog.h}
	{description:	
		{p: Describes a log.  A log manages runtime error and debug information.}
	}
	{methods:
		{method: RvLog* rvLogConstruct(RvLog* l);}
		{method: void rvLogDestruct(RvLog* l);}
		{method: rvLogGetMask(RvLog* l);}
		{method: RvLogMask rvLogSetMask(RvLog* l, RvLogMask mask);}
		{method: void rvLogRegisterListener(RvLog* l, RvLogListener* li);}
		{method: void rvLogUnregisterListener(RvLog* l, RvLogListener* li);}
		{method: void rvLogFatal(RvLog* l, const char* text);}
		{method: void rvLogError(RvLog* l, const char* text);}
		{method: void rvLogWarning(RvLog* l, const char* text);}
		{method: void rvLogSend(RvLog* l, const char* msg);}
		{method: void rvLogReceive(RvLog* l, const char* msg);}
		{method: void rvLogEnter(RvLog* l, const char* fn);}
		{method: void rvLogLeave(RvLog* l, const char* fn);}
		{method: void rvLogInfo1(RvLog* l, const char* text);}
		{method: void rvLogInfo2(RvLog* l, const char* text);}
		{method: void rvLogInfo3(RvLog* l, const char* text);}
		{method: void rvLogInfo4(RvLog* l, const char* text);}
		{method: void rvLogInt1(RvLog* l, const char* name, int value, int radix);}
		{method: void rvLogInt2(RvLog* l, const char* name, int value, int radix);}
		{method: void rvLogInt3(RvLog* l, const char* name, int value, int radix);}
		{method: void rvLogInt4(RvLog* l, const char* name, int value, int radix);}
		{method: void rvLogStr1(RvLog* l, const char* name, const char* value);}
		{method: void rvLogStr2(RvLog* l, const char* name, const char* value);}
		{method: void rvLogStr3(RvLog* l, const char* name, const char* value);}
		{method: void rvLogStr4(RvLog* l, const char* name, const char* value);}
	}
    {see_also:
        {n: RvLogRecord}
        {n: RvLogMask}
        {n: RvLogListener}
    }
}
$*/
typedef struct {
	RvMutex_ mutex;
	RvLogMask mask;
	RvPtrList listeners;
} RvLog;

RvLog* rvLogConstruct(RvLog* l);
void rvLogDestruct(RvLog* l);
/*$
{function:
	{name: rvLogGetMask }	
	{class: RvLog}	
	{include: rvlog.h}
	{description:
		{p: Get the log mask of the log.}
	}
	{proto: RvLogMask rvLogGetMask(RvLog* l);}
	{params:
		{param: {n: l} {d: A pointer to the log.}}
	}
	{returns: The log mask of the log. }
}
$*/
#define rvLogGetMask(l)					((l)->mask)
RvLogMask rvLogSetMask(RvLog* l, RvLogMask mask);
void rvLogRegisterListener(RvLog* l, RvLogListener* li);
void rvLogUnregisterListener(RvLog* l, RvLogListener* li);

/* Standard listeners - Deprecated */
void rvLogStdio(const RvLogRecord* rec, void* data);
void rvLogFile(const RvLogRecord* rec, void* data);

/* Private */
void rvLogInt_(RvLog* log, RvLogLevel level, const char* name, int value, int radix);
void rvLogStr_(RvLog* log, RvLogLevel level, const char* name, const char* value);
void rvLogText_(RvLog* log, RvLogLevel level, const char* text);

#else

/* Public */
typedef int RvLog;
typedef int RvLogListener;
typedef int RvLogRecord;

extern char* rvNullString;

#define rvLogRecordGetTime(lr)				(rvNullString)
#define rvLogRecordGetThreadName(lr)		(rvNullString)
#define rvLogRecordGetLevel(lr)				(RV_LOGMASK_NONE)
#define rvLogRecordGetText(lr)				(rvNullString)

#define rvLogListenerConstruct(li, m, f, d)	(li)
#define rvLogListenerDestruct(li) 
#define rvLogListenerSetMask(li, m)			(RV_LOGMASK_NONE)
#define rvLogListenerGetMask(li)			(RV_LOGMASK_NONE)

#define rvLogConstruct(l)					(l)
#define rvLogDestruct(l)
#define rvLogGetMask(l)						(RV_LOGMASK_NONE)
#define rvLogSetMask(l, mask)				(RV_LOGMASK_NONE)
#define rvLogRegisterListener(l, li)
#define rvLogUnregisterListener(l, li)

#endif

extern RvLog rvLog;

#if defined(__cplusplus)
}
#endif 

#endif