DAEstatus.h

Go to the documentation of this file.

#ifndef DAE_STATUS
#define DAE_STATUS

#include "DAEstatus_codes.h"

class DAEstatus;

class DAEstatus_message
{
        friend class DAEstatus;
private:
        int m_severity;
        int m_errtype;
        int m_facility;
        std::string m_text;
        time_t m_time;

        static void make_iso_time(time_t time, char* buffer, int len, bool format_with_T)
        {
                struct tm *tm_struct;
                buffer[0] = '\0';
                tm_struct = localtime(&time);
                if (tm_struct != 0)
                {
                        if (format_with_T)
                        {
                                strftime(buffer, len, "%Y-%m-%dT%H:%M:%S", tm_struct);
                        }
                        else
                        {
                                strftime(buffer, len, "%Y-%m-%d %H:%M:%S", tm_struct);
                        }
                }
                else
                {
                        strncpy(buffer, "<UNKNOWN>", len);
                }
                buffer[len-1] = '\0';
        }

public:
        DAEstatus_message() : m_severity(0), m_errtype(0), m_facility(0), m_time(0) { time(&m_time); }
        DAEstatus_message(int severity, int errtype, int facility, const std::string& text);
        std::ostream& print(std::ostream& str, bool format_with_T = false, bool add_cr = false) const;
        bool checkEQ(int severity) const { return compareEQ(m_severity, severity); }
        bool checkLE(int severity) const { return compareLE(m_severity, severity); }
        bool checkGE(int severity) const { return compareGE(m_severity, severity); }
        bool check(int severity, int direction) const { return compare(m_severity, severity, direction); }
        bool operator==(int severity) const { return checkEQ(severity); }
        bool operator!=(int severity) const { return !checkEQ(severity); }
        bool operator<=(int severity) const { return checkLE(severity); }
        bool operator>=(int severity) const { return checkGE(severity); }
        static bool compareEQ(int left_sev, int right_sev);
        static bool compareLE(int left_sev, int right_sev);
        static bool compareGE(int left_sev, int right_sev);
        static bool compare(int left_sev, int right_sev, int direction);
        int resetSeverityToAtMost(int severity) 
        { 
                if (!compareLE(m_severity, severity)) 
                { 
                        m_severity = severity; 
                } 
                return m_severity; 
        }

        int resetSeverityToAtLeast(int severity) 
        { 
                if (compareLE(m_severity, severity)) 
                { 
                        m_severity = severity; 
                } 
                return m_severity; 
        }

        std::string timeStr(bool format_with_T) const
        {
                char time_buffer[128];
                make_iso_time(m_time, time_buffer, sizeof(time_buffer), format_with_T);
                return time_buffer;
        }

        std::string str() const
        {
                return m_text;
        }
};

inline bool DAEstatus_message::compare(int left_sev, int right_sev, int direction)
{
        switch(direction)
        {
                case SEV_LE:
                        return compareLE(left_sev, right_sev);
                        break;

                case SEV_EQ:
                        return compareEQ(left_sev, right_sev);
                        break;

                case SEV_GE:
                        return compareGE(left_sev, right_sev);
                        break;

                case SEV_ALL:
                        return true;
                        break;

                default:
                        break;
        }
        return false;
}

inline std::ostream& operator<<(std::ostream& str, const DAEstatus_message& sm)
{
        return sm.print(str);
}

typedef int DAEreport_func_t(const DAEstatus_message& mess, void* arg);

class DAEstatus
{
private:
        typedef std::list<DAEstatus_message> status_list_t;
        status_list_t m_status_list;
    int m_severity;
        DAEreport_func_t* m_report_func;
        void* m_report_func_arg;
        DAEreport_func_t* m_report_copy_func;
        void* m_report_copy_func_arg;
        bool m_report_immediately;
        CRITICAL_SECTION m_critical;

        DAEstatus(const DAEstatus&) { }
        void operator=(const DAEstatus&) { }    

public:
        DAEstatus();
        ~DAEstatus();
        static const int Success;
        static const int Failure;
        int severity() { return m_severity; }
        bool OK() { return check(SEV_WARNING, SEV_LE); }
        int result() { return ( OK() ? Success : Failure ); }
        int size() { return static_cast<int>(m_status_list.size()); } 
        bool operator==(int severity) const { return check(severity, SEV_EQ); }
        bool operator!=(int severity) const { return !check(severity, SEV_EQ); }
        bool operator<=(int severity) const { return check(severity, SEV_LE); }
        bool operator>=(int severity) const { return check(severity, SEV_GE); }

        int add(DAEstatus& dstatus, bool clear);
        int add(const DAEstatus_message& mess);
        int add(int facility, int severity, int errtype, const std::string& text); 
        int addVa(int facility, int severity, int errtype, const char* format, ... ); 
//      int addHrVa(int facility, int severity, int errtype, HRESULT hr, const char* format, ... ); 
        int addInfo(int facility, const std::string& text);
        int addInfoVa(int facility, const char* format, ... );
        int addWarning(int facility, const std::string& text);
        int addWarningVa(int facility, const char* format, ... );
        int addDebug(int facility, const std::string& text);
        int addDebugVa(int facility, const char* format, ... );
        void reportImmediately(bool value) { m_report_immediately = value; } 
        bool check(int severity, int direction) const;
        int clear(int severity, int direction, bool reset_overall_severity = true);
        int clearAll(bool reset_overall_severity = true) { return clear(SEV_OK, SEV_ALL, reset_overall_severity); }
        int report(int severity, int direction, bool reset_overall_severity = true, bool remove_messages = true);
        int report(std::ostream& str, int severity, int direction, bool reset_overall_severity = true, bool remove_messages = true);
        int report(DAEreport_func_t* report_func, void* report_arg, int severity, int direction, bool reset_overall_severity = true, bool remove_messages = true);
        int reportAll(bool reset_overall_severity = true, bool remove_messages = true) { return report(SEV_OK, SEV_ALL, reset_overall_severity, remove_messages); }
        int reportAll(std::ostream& str, bool reset_overall_severity = true, bool remove_messages = true) { return report(str, SEV_OK, SEV_ALL, reset_overall_severity, remove_messages); }
        int reportAll(DAEreport_func_t* report_func, void* report_arg, bool reset_overall_severity = true, bool remove_messages = true) { return report(report_func, report_arg, SEV_OK, SEV_ALL, reset_overall_severity, remove_messages); }

        int resetSeverityToAtMost(int severity);
        int resetSeverityToAtLeast(int severity);

        std::ostream& print(std::ostream& str);

        int setReportFunction(DAEreport_func_t* report_func, void* arg)
        {
                m_report_func = report_func;
                m_report_func_arg = arg;
                return 0;
        }

        int setReportCopyFunction(DAEreport_func_t* report_func, void* arg)
        {
                m_report_copy_func = report_func;
                m_report_copy_func_arg = arg;
                return 0;
        }

        static int ostreamReportFunction(const DAEstatus_message& mess, void* arg)
        {
                std::ostream* pStr = (std::ostream*)arg;
                (*pStr) << mess << '\n';
                return 0;
        }


protected:
        int addVaMain(int facility, int severity, int errtype, const char* format, va_list ap);
        int recalculateSeverity();
};


inline std::ostream& operator<<(std::ostream& str, DAEstatus& s)
{
        return s.print(str);
}


// error macros
#define STATUS_CHECK_HR(a, status) \
    hr = (a); \
    if (FAILED(hr)) { \
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, \
                "%s %d %s failed error 0x%.8x", __FILE__, __LINE__ , #a , hr); \
        }

#endif /* DAE_STATUS */