vlog.cxx

RTP协议

    LogMap::iterator	it = log_.find(priority);
    Sptr<PriorityLog> nullLog = 0;
    Sptr<PriorityLog> log = ( it == log_.end() ? nullLog : (*it).second );
    if ( log != 0 )
    {
	switch ( priority )
	{
    	    case LOG_EMERG:
	    {
	    	if ( emergency_ != 0 )
		{
    		    emergency_->off();
		}
	    	break;
	    }
    	    case LOG_ALERT:
	    {
	    	if ( alert_ != 0 )
		{
    		    alert_->off();
		}
	    	break;
	    }
    	    case LOG_CRIT:
	    {
	    	if ( critical_ != 0 )
		{
    		    critical_->off();
		}
	    	break;
    	    }
    	    case LOG_ERR:
	    {
	    	if ( error_ != 0 )
		{
    		    error_->off();
		}
	    	break;
	    }
    	    case LOG_WARNING:
	    {
	    	if ( warning_ != 0 )
		{
    		    warning_->off();
		}
	    	break;
	    }
    	    case LOG_NOTICE:
	    {
	    	if ( notice_ != 0 )
		{
    		    notice_->off();
		}
	    	break;
	    }
    	    case LOG_INFO:
	    {
	    	if ( info_ != 0 )
		{
    		    info_->off();
		}
	    	break;
	    }
    	    case LOG_DEBUG:
	    {
	    	if ( debug_ != 0 )
		{
    		    debug_->off();
		}
	    	break;
	    }
    	    case LOG_DEBUG_STACK:
	    {
	    	if ( debugStack_ != 0 )
		{
    		    debugStack_->off();
		}
	    	break;
	    }
    	    case LOG_DEBUG_OPER:
	    {
	    	if ( debugOper_ != 0 )
		{
    		    debugOper_->off();
		}
	    	break;
	    }
    	    case LOG_DEBUG_HB:
	    {
	    	if ( debugHB_ != 0 )
		{
    		    debugHB_->off();
		}
	    	break;
	    }
	    default:
	    {
	    	break;
	    }
	}
    }
}

PriorityLog &	    	    
VLog::logEmergency()
{
    assert( VLog::null_ != 0 );
    
    if ( emergency_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_EMERG);
        emergency_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *emergency_ );
}


PriorityLog &	    	    
VLog::logAlert()
{
    assert( VLog::null_ != 0 );

    if ( alert_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_ALERT);
        alert_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *alert_ );
}


PriorityLog &	    	    
VLog::logCritical()
{
    assert( VLog::null_ != 0 );

    if ( critical_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_CRIT);
        critical_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *critical_ );
}


PriorityLog &	    	    
VLog::logError()
{
    assert( VLog::null_ != 0 );

    if ( error_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_ERR);
        error_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *error_ );
}


PriorityLog &	    	    
VLog::logWarning()
{
    assert( VLog::null_ != 0 );

    if ( warning_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_WARNING);
        warning_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *warning_ );
}


PriorityLog &	    	    
VLog::logNotice()
{
    assert( VLog::null_ != 0 );

    if ( notice_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_NOTICE);
        notice_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *notice_ );
}


PriorityLog &	    	    
VLog::logInfo()
{
    assert( VLog::null_ != 0 );

    if ( info_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_INFO);
        info_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *info_ );
}


PriorityLog &	    	    
VLog::logDebug()
{
    assert( VLog::null_ != 0 );

    if ( debug_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_DEBUG);
        debug_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *debug_ );
}


PriorityLog &	    	    
VLog::logDebugStack()
{
    assert( VLog::null_ != 0 );

    if ( debugStack_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_DEBUG_STACK);
        debugStack_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *debugStack_ );
}


PriorityLog &	    	    
VLog::logDebugOper()
{
    assert( VLog::null_ != 0 );

    if ( debugOper_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_DEBUG_OPER);
        debugOper_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *debugOper_ );
}


PriorityLog &	    	    
VLog::logDebugHB()
{
    assert( VLog::null_ != 0 );

    if ( debugHB_ == 0 )
    {
    	Sptr<PriorityLog> log = getLog(LOG_DEBUG_HB);
        debugHB_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
    }
    
    return ( *debugHB_ );
}


PriorityLog &	    
VLog::logTrace()
{
    assert( VLog::null_ != 0 );

    return ( trace_ ? logDebugStack() : *VLog::null_ );
}


PriorityLog &	    
VLog::logVerbose()
{
    assert( VLog::null_ != 0 );

    return ( verbose_ ? logDebugStack() : *VLog::null_ );
}


const char *        
VLog::logName(int logLevel)
{
    switch ( logLevel )
    {
        case LOG_EMERG:         return "LOG_EMERG";
        case LOG_ALERT:         return "LOG_ALERT";
        case LOG_CRIT:          return "LOG_CRIT";
        case LOG_ERR:           return "LOG_ERR";
        case LOG_WARNING:       return "LOG_WARNING";
        case LOG_NOTICE:        return "LOG_NOTICE";
        case LOG_INFO:          return "LOG_INFO";
        case LOG_DEBUG:         return "LOG_DEBUG";
        case LOG_DEBUG_STACK:   return "LOG_DEBUG_STACK";
        case LOG_DEBUG_OPER:    return "LOG_DEBUG_OPER";
        case LOG_DEBUG_HB:      return "LOG_DEBUG_HB";
        case LOG_TRACE:         return "LOG_TRACE";
        case LOG_VERBOSE:       return "LOG_VERBOSE";
    }    
    return ( "LOG_UNKNOWN" );
}


int                 
VLog::logValue(const char * name)
{
    string  log_emerg("log_emerg"),             emerg("emerg"),
            log_alert("log_alert"),             alert("alert"),
            log_crit("log_crit"),               crit("crit"),          
            log_err("log_err"),                 err("error"),           
            log_warning("log_warning"),         warning("warn"),       
            log_notice("log_notice"),           notice("notice"),        
            log_info("log_info"),               info("info"),          
            log_debug("log_debug"),             debug("debug"),         
            log_debug_stack("log_debug_stack"), debug_stack("debug_stack"),   
            log_debug_oper("log_debug_oper"),   debug_oper("debug_oper"),    
            log_debug_hb("log_debug_hb"),       debug_hb("debug_hb"),      
            log_trace("log_trace"),             trace("trace"),         
            log_verbose("log_verbose"),         verbose("verbose");    

    string  logname(name);
    size_t size = logname.size();
    for ( size_t i = 0; i < size; i++ )
    {
        logname[i] = tolower(logname[i]);
    }

    if ( log_verbose == logname || verbose == logname )
    {
        return LOG_VERBOSE;
    }
    if ( log_trace == logname || trace == logname )
    {
        return LOG_TRACE;
    }
    if ( log_debug_hb == logname || debug_hb == logname )
    {
        return LOG_DEBUG_HB;
    }
    if ( log_debug_oper == logname || debug_oper == logname )
    {
        return LOG_DEBUG_OPER;
    }
    if ( log_debug_stack == logname || debug_stack == logname )
    {
        return LOG_DEBUG_STACK;
    }
    if ( log_debug == logname || debug == logname )
    {
        return LOG_DEBUG;
    }
    if ( log_info == logname || info == logname )
    {
        return LOG_INFO;
    }
    if ( log_notice == logname || notice == logname )
    {
        return LOG_NOTICE;
    }
    if ( log_warning == logname || warning == logname )
    {
        return LOG_WARNING;
    }
    if ( log_err == logname || err == logname )
    {
        return LOG_ERR;
    }
    if ( log_crit == logname || crit == logname )
    {
        return LOG_CRIT;
    }
    if ( log_alert == logname || alert == logname )
    {
        return LOG_ALERT;
    }
    if ( log_emerg == logname || emerg == logname )
    {
        return LOG_EMERG;
    }
    return ( LOG_WARNING );
}


int                 
VLog::logValue(const string & name)
{
    return ( logValue(name.c_str()) );
}