fsfw/datapoollocal/LocalPoolDataSetBase.h

143 lines
4.7 KiB
C
Raw Normal View History

2020-09-05 21:59:17 +02:00
#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
#include "HasLocalDataPoolIF.h"
#include "../datapool/DataSetIF.h"
#include "../datapool/PoolDataSetBase.h"
#include "../serialize/SerializeIF.h"
2020-07-14 15:45:03 +02:00
#include <vector>
class LocalDataPoolManager;
/**
* @brief The LocalDataSet class manages a set of locally checked out
* variables for local data pools
* @details
* This class manages a list, where a set of local variables (or pool variables)
* are registered. They are checked-out (i.e. their values are looked
* up and copied) with the read call. After the user finishes working with the
* pool variables, he can write back all variable values to the pool with
* the commit call. The data set manages locking and freeing the local data pools,
* to ensure thread-safety.
*
* An internal state manages usage of this class. Variables may only be
* registered before the read call is made, and the commit call only
* after the read call.
*
* If pool variables are writable and not committed until destruction
* of the set, the DataSet class automatically sets the valid flag in the
* data pool to invalid (without) changing the variable's value.
*
* @ingroup data_pool
*/
2020-08-08 12:51:31 +02:00
class LocalPoolDataSetBase: public PoolDataSetBase {
2020-07-14 15:45:03 +02:00
public:
/**
* @brief Constructor for the creator of local pool data.
*/
2020-08-08 12:51:31 +02:00
LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
2020-08-23 22:33:22 +02:00
uint32_t setId, PoolVariableIF** registeredVariablesArray,
2020-07-14 15:45:03 +02:00
const size_t maxNumberOfVariables);
/**
* @brief Constructor for users of local pool data. The passed pool
* owner should implement the HasHkPoolParametersIF.
2020-07-16 11:45:23 +02:00
* @details
2020-08-23 22:33:22 +02:00
* @param sid Unique identifier of dataset consisting of object ID and
* set ID.
* @param registeredVariablesArray
* @param maxNumberOfVariables
2020-07-14 15:45:03 +02:00
*/
2020-08-23 22:33:22 +02:00
LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
2020-07-14 15:45:03 +02:00
const size_t maxNumberOfVariables);
/**
* @brief The destructor automatically manages writing the valid
* information of variables.
* @details
* In case the data set was read out, but not committed(indicated by state),
* the destructor parses all variables that are still registered to the set.
* For each, the valid flag in the data pool is set to "invalid".
*/
2020-08-08 12:51:31 +02:00
~LocalPoolDataSetBase();
2020-07-14 15:45:03 +02:00
2020-08-08 21:32:15 +02:00
void setValidityBufferGeneration(bool withValidityBuffer);
ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const override;
ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
SerializeIF::Endianness streamEndianness) override;
size_t getSerializedSize() const override;
2020-07-14 15:45:03 +02:00
/**
* Special version of the serilization function which appends a
* validity buffer at the end. Each bit of this validity buffer
* denotes whether the container data set entries are valid from left
* to right, MSB first.
* @param buffer
* @param size
* @param maxSize
* @param bigEndian
* @param withValidityBuffer
* @return
*/
ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
size_t* size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const;
2020-08-08 21:32:15 +02:00
ReturnValue_t deSerializeWithValidityBuffer(const uint8_t** buffer,
size_t *size, SerializeIF::Endianness streamEndianness);
2020-07-14 15:45:03 +02:00
ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
size_t* size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const;
2020-09-10 21:05:50 +02:00
/**
* Set the dataset valid or invalid
* @param setEntriesRecursively
* If this is true, all contained datasets will also be set recursively.
*/
void setValidity(bool valid, bool setEntriesRecursively);
2020-07-14 15:45:03 +02:00
bool isValid() const override;
protected:
2020-08-23 22:33:22 +02:00
sid_t sid;
2020-07-14 15:45:03 +02:00
/**
* If the valid state of a dataset is always relevant to the whole
* data set we can use this flag.
*/
bool valid = false;
2020-08-08 21:32:15 +02:00
bool withValidityBuffer = true;
2020-07-14 15:45:03 +02:00
/**
* @brief This is a small helper function to facilitate locking
* the global data pool.
* @details
* It makes use of the lockDataPool method offered by the DataPool class.
*/
ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
/**
* @brief This is a small helper function to facilitate
* unlocking the global data pool
* @details
* It makes use of the freeDataPoolLock method offered by the DataPool class.
*/
ReturnValue_t unlockDataPool() override;
LocalDataPoolManager* hkManager;
/**
* Set n-th bit of a byte, with n being the position from 0
* (most significant bit) to 7 (least significant bit)
*/
void bitSetter(uint8_t* byte, uint8_t position) const;
2020-08-08 21:32:15 +02:00
bool bitGetter(const uint8_t* byte, uint8_t position) const;
2020-07-14 15:45:03 +02:00
private:
};
2020-09-10 21:05:50 +02:00
2020-09-05 21:59:17 +02:00
#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */