DAEstatus.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include "DAEstatus.h"
#include "icputils.h"

DAEstatus::DAEstatus()
{
    m_severity = SEV_OK;
        m_report_func = &ostreamReportFunction;
        m_report_func_arg = (void*)std::cerr;
        m_report_copy_func = NULL;
        m_report_copy_func_arg = NULL;
        m_report_immediately = false;
        InitializeCriticalSection(&m_critical);
}

DAEstatus::~DAEstatus()
{
        DeleteCriticalSection(&m_critical);
}

int DAEstatus::add(int facility, int severity, int errtype, const std::string& text)
{
        return add(DAEstatus_message(severity, errtype, facility, text));
}

int DAEstatus::add(const DAEstatus_message& mess)
{
        ICPCritical cs(&m_critical);
    m_status_list.push_back(mess);
        int severity = mess.m_severity;
        if (severity%2 == 0) // adding an error condition?
        {
                if (m_severity%2 == 0) // currently an error?
                {
                        m_severity = (severity > m_severity ? severity : m_severity);
                }
                else
                {
                        m_severity = severity;
                }
        }
        if (m_report_copy_func != NULL)
        {
                (*m_report_copy_func)(mess, m_report_copy_func_arg);
        }
        if (m_report_immediately)
        {
                reportAll(false);
        }
        return 0;
}

int DAEstatus::addVa(int facility, int severity, int errtype, const char* format, ... )
{
        int stat;
        va_list ap;
    va_start(ap, format);
        stat = addVaMain(facility, severity, errtype, format, ap);
        va_end(ap);
        return stat;
}

int DAEstatus::addVaMain(int facility, int severity, int errtype, const char* format, va_list ap)
{
        static const int maxlen = 10000;
        char* buffer;
        int stat, len;
        len = _vscprintf(format, ap);
        if ( (len >= 0) && (len < maxlen) )
        {
                buffer = new char[len+1]; // + 1 for NULL
                vsprintf(buffer, format, ap);
                buffer[len] = '\0';             // just in case
                stat = add(facility, severity, errtype, buffer);
                delete []buffer;
        }
        else
        {
                stat = add(facility, severity, errtype, "<invalid vararg error message - probably too long in DAEstatus::addVaMain>");
        }
        return stat;
}


int DAEstatus::addInfo(int facility, const std::string& text)
{
        return add(facility, SEV_INFO, ERRTYPE_NONE, text);
}

int DAEstatus::addInfoVa(int facility, const char* format, ... )
{
        int stat;
        va_list ap;
    va_start(ap, format);
        stat = addVaMain(facility, SEV_INFO, ERRTYPE_NONE, format, ap);
        va_end(ap);
        return stat;
}

int DAEstatus::addWarning(int facility, const std::string& text)
{
        return add(facility, SEV_WARNING, ERRTYPE_NONE, text);
}

int DAEstatus::addWarningVa(int facility, const char* format, ... )
{
        int stat;
        va_list ap;
    va_start(ap, format);
        stat = addVaMain(facility, SEV_WARNING, ERRTYPE_NONE, format, ap);
        va_end(ap);
        return stat;
}

int DAEstatus::addDebug(int facility, const std::string& text)
{
        return add(facility, SEV_DEBUG, ERRTYPE_NONE, text);
}

int DAEstatus::addDebugVa(int facility, const char* format, ... )
{
        int stat;
        va_list ap;
    va_start(ap, format);
        stat = addVaMain(facility, SEV_DEBUG, ERRTYPE_NONE, format, ap);
        va_end(ap);
        return stat;
}

int DAEstatus::add(DAEstatus& dstatus, bool clear)
{
        status_list_t::iterator iter;
        ICPCritical cs(&m_critical);
        for(iter = dstatus.m_status_list.begin(); iter != dstatus.m_status_list.end(); iter++)
        {
                add(*iter);
        }
        cs.unlock();
        if (clear)
        {
                dstatus.clearAll();
        }
        return DAEstatus::Success;
}

int DAEstatus::recalculateSeverity()
{
        m_severity = SEV_OK;
        status_list_t::iterator iter;
        ICPCritical cs(&m_critical);
        for(iter = m_status_list.begin(); iter != m_status_list.end(); ++iter)
        {
                if ( *iter >= m_severity )
                {
                        m_severity = iter->m_severity;
                }
        }
        return 0;
}

bool DAEstatus::check(int severity, int direction) const
{
        return DAEstatus_message::compare(m_severity, severity, direction);
}

int DAEstatus::resetSeverityToAtMost(int severity)
{
        int sev;
        status_list_t::iterator iter;
        ICPCritical cs(&m_critical);
        m_severity = SEV_OK;
        for(iter = m_status_list.begin(); iter != m_status_list.end(); ++iter)
        {
                sev = iter->resetSeverityToAtMost(severity);
                if ( DAEstatus_message::compareGE(sev, m_severity)  )
                {
                        m_severity = sev;
                }
        }
        return 0;
}

int DAEstatus::resetSeverityToAtLeast(int severity)
{
        int sev;
        status_list_t::iterator iter;
        ICPCritical cs(&m_critical);
        m_severity = SEV_OK;
        for(iter = m_status_list.begin(); iter != m_status_list.end(); ++iter)
        {
                sev = iter->resetSeverityToAtLeast(severity);
                if ( DAEstatus_message::compareGE(sev, m_severity) )
                {
                        m_severity = sev;
                }
        }
        return 0;
}

int DAEstatus::clear(int severity, int direction, bool reset_overall_severity)
{
        status_list_t::iterator iter;
        ICPCritical cs(&m_critical);
        iter = m_status_list.begin(); 
        while(iter != m_status_list.end())
        {
                if (iter->check(severity, direction))
                {
                        iter = m_status_list.erase(iter);
                }
                else
                {
                        iter++;
                }
        }
        if (reset_overall_severity)
        {
                recalculateSeverity();
        }
        return 0;
}

int DAEstatus::report(int severity, int direction, bool reset_overall_severity, bool remove_messages)
{
        return report(m_report_func, m_report_func_arg, severity, direction, reset_overall_severity, remove_messages);
}

int DAEstatus::report(DAEreport_func_t* report_func, void* report_func_arg, int severity, int direction, bool reset_overall_severity, bool remove_messages)
{
        status_list_t::iterator iter;
        ICPCritical cs(&m_critical);
        iter = m_status_list.begin();
        while(iter != m_status_list.end())
        {
                if (iter->check(severity, direction))
                {
                        (*report_func)(*iter, report_func_arg);
                        if (remove_messages)
                        {
                                iter = m_status_list.erase(iter);
                        }
                        else
                        {
                                iter++;
                        }
                }
                else
                {
                        iter++;
                }
        }
        if (reset_overall_severity)
        {
                recalculateSeverity();
        }
        return 0;
}

int DAEstatus::report(std::ostream& str, int severity, int direction, bool reset_overall_severity, bool remove_messages)
{
        return report(&ostreamReportFunction, &str, severity, direction, reset_overall_severity, remove_messages);
}

std::ostream& DAEstatus::print(std::ostream& str)
{
        reportAll(str, false, false);
        return str;
}

// DAEstatus_message bits

std::ostream& DAEstatus_message::print(std::ostream& str, bool format_with_T, bool add_cr) const
{
        Poco::StringTokenizer tokenizer(this->str(), "\r\n", Poco::StringTokenizer::TOK_IGNORE_EMPTY /*|Poco::StringTokenizer::TOK_TRIM*/ );
        for (Poco::StringTokenizer::Iterator it = tokenizer.begin(); it != tokenizer.end(); ++it)
        {
                if (it->empty())
                {
                        continue;
                }
                if ( it != tokenizer.begin() )
                {
                        str << (add_cr ? "\r\n" : "\n");
                }
                str << timeStr(format_with_T) << "  " << *it;
        }
        return str;
}

DAEstatus_message::DAEstatus_message(int severity, int errtype, 
                                                                                  int facility, const std::string& text) : 
                        m_severity(severity), m_errtype(errtype), 
                                m_facility(facility), m_text(text), m_time(0) 
{
        time(&m_time);
        if ( !m_text.empty() && (m_text.back() == '\n') )
        {
                m_text.pop_back();
        }
}

 bool DAEstatus_message::compareEQ(int left_sev, int right_sev)
 {
         return left_sev == right_sev;
 }

 // left_sev <= right_sev i.e. error of right_sev or less return true
 bool DAEstatus_message::compareLE(int left_sev, int right_sev)
 {
         if ( (left_sev%2 == 0) && (right_sev %2 == 0) ) // both errors
         {
                 return left_sev <= right_sev;
         }
         else if (left_sev%2 == 0) // left error, right not
         {
                 return false;
         }
         else
         {
                 return true;
         }
 }

 // left_sev >= right_sev i.e. error of right_sev or more return true
 bool DAEstatus_message::compareGE(int left_sev, int right_sev)
 {
         if ( (left_sev%2 == 0) && (right_sev %2 == 0) ) // both errors
         {
                 return left_sev >= right_sev;
         }
         else if (left_sev%2 == 0) // left error, right not
         {
                 return true;
         }
         else
         {
                 return false;
         }
 }


const int DAEstatus::Success = 0;
const int DAEstatus::Failure = 1;