fsfw/datapoollocal/LocalPoolVector.tpp

#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_

#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
#error Include LocalPoolVector.h before LocalPoolVector.tpp!
#endif

template<typename T, uint16_t vectorSize>
inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
        HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
        pool_rwm_t setReadWriteMode):
        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}

template<typename T, uint16_t vectorSize>
inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}

template<typename T, uint16_t vectorSize>
inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
                dataSet, setReadWriteMode) {}

template<typename T, uint16_t vectorSize>
inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
    return readWithoutLock();
}
template<typename T, uint16_t vectorSize>
inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
        object_id_t targetObjectId = hkManager->getCreatorObjectId();
        reportReadCommitError("LocalPoolVector",
                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
                localPoolId);
        return PoolVariableIF::INVALID_READ_WRITE_MODE;
    }

    PoolEntry<T>* poolEntry = nullptr;
    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
            &poolEntry);
    memset(this->value, 0, vectorSize * sizeof(T));

    if(result != RETURN_OK) {
        object_id_t targetObjectId = hkManager->getCreatorObjectId();
        reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
                localPoolId);
        return result;
    }
    std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
    this->valid = poolEntry->getValid();
    return RETURN_OK;
}

template<typename T, uint16_t vectorSize>
inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
    this->setValid(valid);
    return commit(timeoutType, timeoutMs);
}

template<typename T, uint16_t vectorSize>
inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
    return commitWithoutLock();
}

template<typename T, uint16_t vectorSize>
inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
    if(readWriteMode == pool_rwm_t::VAR_READ) {
        object_id_t targetObjectId = hkManager->getCreatorObjectId();
        reportReadCommitError("LocalPoolVector",
                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
                localPoolId);
        return PoolVariableIF::INVALID_READ_WRITE_MODE;
    }
    PoolEntry<T>* poolEntry = nullptr;
    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
            &poolEntry);
    if(result != RETURN_OK) {
        object_id_t targetObjectId = hkManager->getCreatorObjectId();
        reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
                localPoolId);
        return result;
    }
    std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
    poolEntry->setValid(this->valid);
    return RETURN_OK;
}

template<typename T, uint16_t vectorSize>
inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
    if(i < vectorSize) {
        return value[i];
    }
    // If this happens, I have to set some value. I consider this
    // a configuration error, but I wont exit here.
#if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
            " last value!" << std::endl;
#else
    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
            " last value!\n");
#endif
    return value[vectorSize - 1];
}

template<typename T, uint16_t vectorSize>
inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
    if(i < vectorSize) {
        return value[i];
    }
    // If this happens, I have to set some value. I consider this
    // a configuration error, but I wont exit here.
#if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
            " last value!" << std::endl;
#else
    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
            " last value!\n");
#endif
    return value[vectorSize - 1];
}

template<typename T, uint16_t vectorSize>
inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
        size_t* size, size_t maxSize,
        SerializeIF::Endianness streamEndianness) const {
    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
    for (uint16_t i = 0; i < vectorSize; i++) {
        result = SerializeAdapter::serialize(&(value[i]), buffer, size,
                maxSize, streamEndianness);
        if (result != HasReturnvaluesIF::RETURN_OK) {
            break;
        }
    }
    return result;
}

template<typename T, uint16_t vectorSize>
inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
    return vectorSize * SerializeAdapter::getSerializedSize(value);
}

template<typename T, uint16_t vectorSize>
inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
        const uint8_t** buffer, size_t* size,
        SerializeIF::Endianness streamEndianness) {
    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
    for (uint16_t i = 0; i < vectorSize; i++) {
        result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
                streamEndianness);
        if (result != HasReturnvaluesIF::RETURN_OK) {
            break;
        }
    }
    return result;
}

#if FSFW_CPP_OSTREAM_ENABLED == 1
template<typename T, uint16_t vectorSize>
inline std::ostream& operator<< (std::ostream &out,
        const LocalPoolVector<T, vectorSize> &var) {
    out << "Vector: [";
    for(int i = 0;i < vectorSize; i++) {
        out << var.value[i];
        if(i < vectorSize - 1) {
            out << ", ";
        }
    }
    out << "]";
    return out;
}
#endif

#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_ */