fsfw/health/HealthTable.cpp

95 lines
2.7 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();
2020-10-29 17:52:28 +01:00
SerializeAdapter::serialize(&count,
&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
2020-10-29 17:52:28 +01:00
for (const auto& health: healthMap) {
SerializeAdapter::serialize(&health.first,
&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
2020-10-29 17:52:28 +01:00
uint8_t healthValue = health.second;
SerializeAdapter::serialize(&healthValue, &pointer, &size,
maxSize, SerializeIF::Endianness::BIG);
}
}
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()) {
result = HasReturnvaluesIF::RETURN_FAILED;
}
*value = *mapIterator;
mapIterator++;
return result;
}