118 lines
3.6 KiB
C++
118 lines
3.6 KiB
C++
#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
|
|
#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
|
|
|
|
|
|
template<typename T, uint16_t vectorSize>
|
|
inline GlobPoolVector<T, vectorSize>::GlobPoolVector(uint32_t set_id,
|
|
DataSetIF* set, ReadWriteMode_t setReadWriteMode) :
|
|
dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
|
|
memset(this->value, 0, vectorSize * sizeof(T));
|
|
if (set != nullptr) {
|
|
set->registerVariable(this);
|
|
}
|
|
}
|
|
|
|
|
|
template<typename T, uint16_t vectorSize>
|
|
inline ReturnValue_t GlobPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
|
|
ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
|
|
if(result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = readWithoutLock();
|
|
ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
|
|
if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
|
|
sif::error << "GlobPoolVar::read: Could not unlock global data pool"
|
|
<< std::endl;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
template<typename T, uint16_t vectorSize>
|
|
inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit(
|
|
uint32_t lockTimeout) {
|
|
ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
|
|
if(result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = commitWithoutLock();
|
|
ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
|
|
if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
|
|
sif::error << "GlobPoolVar::read: Could not unlock global data pool"
|
|
<< std::endl;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
template<typename T, uint16_t vectorSize>
|
|
inline ReturnValue_t GlobPoolVector<T, vectorSize>::readWithoutLock() {
|
|
PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
|
|
vectorSize);
|
|
if (read_out != nullptr) {
|
|
this->valid = read_out->valid;
|
|
memcpy(this->value, read_out->address, read_out->getByteSize());
|
|
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
|
|
} else {
|
|
memset(this->value, 0, vectorSize * sizeof(T));
|
|
sif::error << "PoolVector: Read of DP Variable 0x" << std::hex
|
|
<< std::setw(8) << std::setfill('0') << dataPoolId <<
|
|
std::dec << " failed." << std::endl;
|
|
this->valid = INVALID;
|
|
return HasReturnvaluesIF::RETURN_FAILED;
|
|
}
|
|
}
|
|
|
|
template<typename T, uint16_t vectorSize>
|
|
inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
|
|
PoolEntry<T>* writeBack = glob::dataPool.getData<T>(this->dataPoolId,
|
|
vectorSize);
|
|
if ((writeBack != nullptr) && (this->readWriteMode != VAR_READ)) {
|
|
writeBack->valid = valid;
|
|
memcpy(writeBack->address, this->value, writeBack->getByteSize());
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
} else {
|
|
return HasReturnvaluesIF::RETURN_FAILED;
|
|
}
|
|
}
|
|
|
|
template<typename T, uint16_t vectorSize>
|
|
inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
|
|
size_t* size, size_t max_size,
|
|
SerializeIF::Endianness streamEndianness) const {
|
|
uint16_t i;
|
|
ReturnValue_t result;
|
|
for (i = 0; i < vectorSize; i++) {
|
|
result = SerializeAdapter::serialize(&(value[i]), buffer, size,
|
|
max_size, streamEndianness);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
template<typename T, uint16_t vectorSize>
|
|
inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
|
|
return vectorSize * SerializeAdapter::getSerializedSize(value);
|
|
}
|
|
|
|
template<typename T, uint16_t vectorSize>
|
|
inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
|
|
const uint8_t** buffer, size_t* size,
|
|
SerializeIF::Endianness streamEndianness) {
|
|
uint16_t i;
|
|
ReturnValue_t result;
|
|
for (i = 0; i < vectorSize; i++) {
|
|
result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
|
|
streamEndianness);
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
|
return result;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#endif
|