Diagnostics.h

Go to the documentation of this file.

#ifndef __DIAGNOSTICS_H_
#define __DIAGNOSTICS_H_

#include <chrono>
#include <deque>

class ErrorcodeReport                                           // Errorcode from library
{       
        public:
        bool Code_Exists;                                               // true when errorcode returned 
        int ErrorCode;                                                  // code number                          
        std::string Errorcode_Namespace;                // namespace of the code (for lookup) 
        
        ErrorcodeReport():
                Code_Exists(false), ErrorCode(0), Errorcode_Namespace("") {};                   
};

class DiagnosticStatus 
{       
        public:
        short Level;                                                    // 0 = OK, 1 = WARN, 2=ERROR            
        std::string Message;                                    // Description of the error
        std::string Recommendation;                             // Possible solutions for the user
        ErrorcodeReport Errorcode_Report;               // Errorcode that is returned from a function

        std::chrono::time_point<std::chrono::system_clock> Time;        // time when status is reported
        
        DiagnosticStatus():
                Level(0), Message(""), Recommendation(""), Time(std::chrono::system_clock::now()) {};
};

class Diagnosics
{

        /*TODO: - select format for errorlookups (.h, .txt, yaml) 
         *              - implement report status 
         *              - implement read methodes
         *              - implement QueLength methodes
         */
public:

        Diagnosics()
        {       
                m_StatusQueLength = 5;          // 5 is default value

                // initialize member variabeles
                m_StatusList = new std::deque<DiagnosticStatus>[m_StatusQueLength];
                
                // initialize default ok return value (default 0)               
                m_Default_Ok_Value = 0; 

                //TODO: read in errorcode lists 
                
        }

        ~Diagnosics()
        {
                delete m_StatusList; 
        };
        
        /*******************************************|
        |                       Useage interface                                |
        |*******************************************/

        
        void ReportStatus(short Level, std::string Message)
        {       
                DiagnosticStatus NewStatus; 
                
                NewStatus.Level = Level; 
                NewStatus.Time = std::chrono::system_clock::now();              
                NewStatus.Message = Message;
                
                m_StatusList->push_front(NewStatus); 
                m_StatusList->pop_back();
        }
        
        void ReportStatus(short Level, std::string Message, std::string Recommendation)
        {
                DiagnosticStatus NewStatus; 
                
                NewStatus.Level = Level; 
                NewStatus.Time = std::chrono::system_clock::now();              
                NewStatus.Message = Message;
                NewStatus.Message = Recommendation;
                
                m_StatusList->push_front(NewStatus); 
                m_StatusList->pop_back();
        }

        void ReportStatus(short Level, int Errorcode, std::string Errorcode_Namespace, std::string Recommendation)
        {
                DiagnosticStatus NewStatus; 
                
                NewStatus.Level = Level; 
                NewStatus.Time = std::chrono::system_clock::now(); 
                
                //TODO: generate message from errorcode

                NewStatus.Message = Recommendation;

                m_StatusList->push_front(NewStatus); 
                m_StatusList->pop_back();
        }
        
        void ReportStatus(int Errorcode, std::string Errorcode_Namespace)
        {
                DiagnosticStatus NewStatus; 
                
                //TODO: get message from errorcodelist

                NewStatus.Time = std::chrono::system_clock::now(); 

                m_StatusList->push_front(NewStatus); 
                m_StatusList->pop_back();
        }

        

        void ReadActualStatus(short* Level, std::string* Message, std::string* Recommendation)
        {
                DiagnosticStatus ActualStatus = m_StatusList->at(0);
                
                // resize strings for the size of the upcoming message 
                Message->clear();
                Recommendation->clear(); 
                
                // write output
                Level = (short*) ActualStatus.Level;    
                Message->append(ActualStatus.Message);
                Recommendation->append(ActualStatus.Recommendation);
        }

        int ReadActualStatusLevel()
        {       
                DiagnosticStatus ActualStatus = m_StatusList->at(0);
                return ActualStatus.Level; 
        }

        std::string ReadActualStatusMessage()
        {
                DiagnosticStatus ActualStatus = m_StatusList->at(0);
                return ActualStatus.Message;
        }

        std::string ReadActualStatusRecommendation()
        {
                DiagnosticStatus ActualStatus = m_StatusList->at(0);
                return ActualStatus.Recommendation;
        }

        /*******************************************|
        |                       Configurations                                  |
        |*******************************************/
 
        
        int GetActualStatusQueLength()
        {
                return m_StatusQueLength; 
        }

        void SetMaxStatusQueLength(int StatusQueLength)
        {
                m_StatusQueLength = StatusQueLength;    
        }

        int GetMaxStatusQueLength()
        {
                return m_StatusQueLength;
        }


        
        int GetDefaultOKValue()
        {
                return m_Default_Ok_Value = 0;
        }

        void SetDefaultOKValue(int Default_Ok_Value)
        {
                m_Default_Ok_Value = Default_Ok_Value;
        }

private:
        
        std::deque<DiagnosticStatus> *m_StatusList;     // List that holds the last status messages in a deque

        int m_StatusQueLength;                                          // maximal length of status que
        int m_Default_Ok_Value;                                         // is used for check if return value needs to
                                                                                                // be reported
        
};

#endif