fsfw/health/HealthTable.cpp

111 lines
3.2 KiB
C++
Raw Normal View History

2020-08-13 20:53:35 +02:00
#include "HealthTable.h"
2021-03-09 11:30:00 +01:00
#include "../ipc/MutexGuard.h"
2020-08-13 20:53:35 +02:00
#include "../ipc/MutexFactory.h"
2020-10-29 17:52:28 +01:00
#include "../serialize/SerializeAdapter.h"
HealthTable::HealthTable(object_id_t objectid) :
SystemObject(objectid) {
mutex = MutexFactory::instance()->createMutex();;
mapIterator = healthMap.begin();
}
2020-11-02 15:00:01 +01:00
void HealthTable::setMutexTimeout(MutexIF::TimeoutType timeoutType,
uint32_t timeoutMs) {
this->timeoutType = timeoutType;
this->mutexTimeoutMs = timeoutMs;
}
HealthTable::~HealthTable() {
MutexFactory::instance()->deleteMutex(mutex);
}
ReturnValue_t HealthTable::registerObject(object_id_t object,
HasHealthIF::HealthState initilialState) {
if (healthMap.count(object) != 0) {
return HasReturnvaluesIF::RETURN_FAILED;
}
2020-10-29 17:52:28 +01:00
healthMap.emplace(object, initilialState);
return HasReturnvaluesIF::RETURN_OK;
}
void HealthTable::setHealth(object_id_t object,
HasHealthIF::HealthState newState) {
2021-03-09 11:25:13 +01:00
MutexGuard(mutex, timeoutType, mutexTimeoutMs);
HealthMap::iterator iter = healthMap.find(object);
if (iter != healthMap.end()) {
iter->second = newState;
}
}
HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
2021-03-09 11:25:13 +01:00
MutexGuard(mutex, timeoutType, mutexTimeoutMs);
HealthMap::iterator iter = healthMap.find(object);
if (iter != healthMap.end()) {
state = iter->second;
}
return state;
}
bool HealthTable::hasHealth(object_id_t object) {
2021-03-09 11:25:13 +01:00
MutexGuard(mutex, timeoutType, mutexTimeoutMs);
HealthMap::iterator iter = healthMap.find(object);
if (iter != healthMap.end()) {
2020-10-29 17:52:28 +01:00
return true;
}
2020-10-29 17:52:28 +01:00
return false;
}
size_t HealthTable::getPrintSize() {
2021-03-09 11:25:13 +01:00
MutexGuard(mutex, timeoutType, mutexTimeoutMs);
2020-10-29 17:52:28 +01:00
uint32_t size = healthMap.size() * sizeof(object_id_t) +
sizeof(HasHealthIF::HealthState) + sizeof(uint16_t);
return size;
}
void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
2021-03-09 11:25:13 +01:00
MutexGuard(mutex, timeoutType, mutexTimeoutMs);
size_t size = 0;
uint16_t count = healthMap.size();
2021-04-11 21:54:48 +02:00
ReturnValue_t result = SerializeAdapter::serialize(&count,
&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
2021-04-11 21:54:48 +02:00
if(result != HasReturnvaluesIF::RETURN_OK) {
#if FSFW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "HealthTable::printAll: Serialization of health table failed" << std::endl;
#else
sif::printWarning("HealthTable::printAll: Serialization of health table failed\n");
#endif
#endif /* FSFW_VERBOSE_LEVEL >= 1 */
return;
}
2020-10-29 17:52:28 +01:00
for (const auto& health: healthMap) {
2021-04-11 21:54:48 +02:00
result = SerializeAdapter::serialize(&health.first,
&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
2021-04-11 21:54:48 +02:00
if(result != HasReturnvaluesIF::RETURN_OK) {
return;
}
2020-10-29 17:52:28 +01:00
uint8_t healthValue = health.second;
2021-04-11 21:54:48 +02:00
result = SerializeAdapter::serialize(&healthValue, &pointer, &size,
maxSize, SerializeIF::Endianness::BIG);
2021-04-11 21:54:48 +02:00
if(result != HasReturnvaluesIF::RETURN_OK) {
return;
}
}
}
2020-10-29 17:52:28 +01:00
ReturnValue_t HealthTable::iterate(HealthEntry *value, bool reset) {
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
2021-03-09 11:25:13 +01:00
MutexGuard(mutex, timeoutType, mutexTimeoutMs);
if (reset) {
mapIterator = healthMap.begin();
}
if (mapIterator == healthMap.end()) {
2021-04-11 21:54:48 +02:00
return HasReturnvaluesIF::RETURN_FAILED;
}
*value = *mapIterator;
mapIterator++;
return result;
}