Diagnostics.h

Go to the documentation of this file.

/*
 * Copyright 2017 Fraunhofer Institute for Manufacturing Engineering and Automation (IPA)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0

 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#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