145 lines
5.1 KiB
C++
145 lines
5.1 KiB
C++
#ifndef msgPrintControl_H
|
|
#define msgPrintControl_H
|
|
|
|
#include <asynDriver.h>
|
|
#include <string.h>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
|
|
/**
|
|
* @brief Class to identify a message print location. See the docstring of
|
|
* `msgPrintControl` on how to use this key.
|
|
*
|
|
*/
|
|
class msgPrintControlKey {
|
|
public:
|
|
std::string controller_;
|
|
// -1 is a non-axis specific message
|
|
int axisNo_;
|
|
const char *functionName_;
|
|
int line_;
|
|
|
|
msgPrintControlKey(char *controller_, int axisNo, const char *fileName,
|
|
int line);
|
|
|
|
bool operator==(const msgPrintControlKey &other) const {
|
|
return axisNo_ == other.axisNo_ && line_ == other.line_ &&
|
|
strcmp(functionName_, other.functionName_) == 0 &&
|
|
controller_ == other.controller_;
|
|
}
|
|
|
|
void format(char *buffer, size_t bufferSize);
|
|
};
|
|
|
|
/**
|
|
* @brief Implementation of the hash functionality for msgPrintControlKey
|
|
*
|
|
*/
|
|
namespace std {
|
|
template <> struct hash<msgPrintControlKey> {
|
|
size_t operator()(const msgPrintControlKey &obj) const {
|
|
// Combine the hashes of the members (x and y)
|
|
size_t h1 = std::hash<std::string>{}(obj.controller_);
|
|
size_t h2 = hash<int>{}(obj.axisNo_);
|
|
size_t h3 = std::hash<const char *>{}(obj.functionName_);
|
|
size_t h4 = hash<int>{}(obj.line_);
|
|
// Combine the hashes (simple XOR and shifting technique)
|
|
return h1 ^ (h2 << 1) ^ (h3 << 2) ^ (h4 << 3);
|
|
}
|
|
};
|
|
} // namespace std
|
|
|
|
/**
|
|
* @brief Class to control the number of repetitions of error messages
|
|
*
|
|
* This class is used to prevent excessive repetitions of identical error
|
|
* messages. For example, if the communication between a controller and an
|
|
* axis fails, a corresponding error message is created in each poll. This
|
|
* could "flood" the IOC shell with noise. To prevent this, this class keeps
|
|
* track of the number of subsequent error message repetition. Each message is
|
|
* uniquely identified by "msgPrintControlKey". The function shouldBePrinted
|
|
* can be used in order to see if a message should be printed or not:
|
|
*
|
|
* ```
|
|
* const char* controller = "MCU" // Name of the controller
|
|
* int axisNo = 0; // Number of the axis
|
|
* bool wantToPrint = evaluateConditions(...); *
|
|
* if (msgPrintControl.shouldBePrinted(controller, axisNo, __PRETTY_FUNCTION__,
|
|
* __LINE__, wantToPrint)) { asynPrint(...)
|
|
* }
|
|
*
|
|
* ```
|
|
*/
|
|
class msgPrintControl {
|
|
public:
|
|
msgPrintControl(size_t maxRepetitions);
|
|
|
|
/**
|
|
* @brief Checks if the error message associated with "key" has been printed
|
|
* more than "maxRepetitions_" times in a row. If yes, returns false,
|
|
* otherwise true. Counter is reset if wantToPrint is false.
|
|
*
|
|
* If the conditions for printing a message are met, "wantToPrint" must be
|
|
* set to true. The function then checks if "maxRepetitions_" has been
|
|
* exceeded. If yes, the function returns no, indicating that the message
|
|
* should not be printed. If no, the number of repetitions stored in the map
|
|
* is incremented and the function returns true, indicating that the message
|
|
* should be printed.
|
|
*
|
|
* If the conditions for printing a message are not met, "wantToPrint" must
|
|
* be set to false. This resets the map entry.
|
|
*
|
|
* @param key Key associated with the message, used to
|
|
* identify individual messages
|
|
* @param wantToPrint If the message associated with key should be
|
|
* printed, this value should be true, otherwise false.
|
|
* @param pasynUser If the problem has been resolved (wantToPrint =
|
|
* false), a corresponding status message is printed using the given
|
|
* asynUser. If this pointer is a nullptr, no message is printed.
|
|
* @return bool If true, the message should be printed, if
|
|
* false, it should not.
|
|
*/
|
|
bool shouldBePrinted(msgPrintControlKey &key, bool wantToPrint,
|
|
asynUser *pasynUser);
|
|
|
|
/**
|
|
* @brief Like `shouldBePrinted(msgPrintControlKey key, bool wantToPrint)`,
|
|
* but constructs the key from the first four arguments.
|
|
*
|
|
* @param controller_
|
|
* @param axisNo
|
|
* @param fileName
|
|
* @param line
|
|
* @param wantToPrint
|
|
* @param pasynUser
|
|
*/
|
|
bool shouldBePrinted(char *controller, int axisNo, const char *functionName,
|
|
int line, bool wantToPrint, asynUser *pasynUser);
|
|
|
|
/**
|
|
* @brief Reset the error message count incremented in shouldBePrinted for
|
|
* the given key
|
|
*
|
|
* @param key Key associated with the message, used to
|
|
* identify individual messages
|
|
* @param pasynUser If the problem has been resolved (wantToPrint =
|
|
* false), a corresponding status message is printed using the given
|
|
* asynUser. If this pointer is a nullptr, no message is printed.
|
|
*/
|
|
void resetCount(msgPrintControlKey &key, asynUser *pasynUser);
|
|
|
|
/**
|
|
* @brief Maximum number of times a message is printed before it is
|
|
* suppressed.
|
|
*
|
|
*/
|
|
size_t maxRepetitions_;
|
|
|
|
char *getSuffix();
|
|
|
|
private:
|
|
std::unordered_map<msgPrintControlKey, size_t> map_;
|
|
char suffix_[200] = {0};
|
|
};
|
|
|
|
#endif |