104 lines
3.1 KiB
C++
104 lines
3.1 KiB
C++
#pragma once
|
|
|
|
#include <framework/datapool/PoolVariableIF.h>
|
|
#include <framework/datapool/DataSetIF.h>
|
|
|
|
#include <framework/housekeeping/HousekeepingManager.h>
|
|
|
|
#include <map>
|
|
/**
|
|
* @brief This is the access class for non-array local data pool entries.
|
|
*
|
|
* @details
|
|
*
|
|
* @tparam T The template parameter sets the type of the variable.
|
|
* Currently, all plain data types are supported, but in principle
|
|
* any type is possible.
|
|
* @ingroup data_pool
|
|
*/
|
|
|
|
/**
|
|
* @brief Local Pool Variable class which is used to access the local pools.
|
|
* @details This class is not stored in the map. Instead, it is used to access
|
|
* the pool entries by using a pointer to the map storing the pool
|
|
* entries. It can also be used to organize these pool entries
|
|
* into data sets.
|
|
* @tparam T
|
|
*/
|
|
template<typename T>
|
|
class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
|
|
public:
|
|
static constexpr lp_id_t INVALID_POOL_ID = 0xFFFFFFFF;
|
|
|
|
/**
|
|
* This constructor is used by the data creators to have pool variable
|
|
* instances which can also be stored in datasets.
|
|
* @param set_id
|
|
* @param setReadWriteMode
|
|
* @param localPoolMap
|
|
* @param dataSet
|
|
*/
|
|
LocalPoolVar(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
|
|
pool_rwm_t setReadWriteMode, DataSetIF* dataSet = nullptr);
|
|
|
|
/**
|
|
* This constructor is used by data users like controllers to have
|
|
* access to the local pool variables of data creators by supplying
|
|
* the respective creator object ID.
|
|
* @param poolId
|
|
* @param poolOwner
|
|
* @param setReadWriteMode
|
|
* @param dataSet
|
|
*/
|
|
LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
|
|
pool_rwm_t setReadWriteMode, DataSetIF* dataSet = nullptr);
|
|
|
|
virtual~ LocalPoolVar() {};
|
|
|
|
/**
|
|
* @brief This is the local copy of the data pool entry.
|
|
* @details The user can work on this attribute
|
|
* just like he would on a simple local variable.
|
|
*/
|
|
T value = 0;
|
|
|
|
ReturnValue_t commit() override;
|
|
ReturnValue_t read() override;
|
|
pool_rwm_t getReadWriteMode() const override;
|
|
uint32_t getDataPoolId() const override;
|
|
bool isValid() const override;
|
|
void setValid(uint8_t validity) override;
|
|
|
|
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
|
const size_t max_size, bool bigEndian) const override;
|
|
virtual size_t getSerializedSize() const override;
|
|
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
|
bool bigEndian) override;
|
|
private:
|
|
lp_id_t localPoolId = INVALID_POOL_ID;
|
|
pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
|
|
bool valid = false;
|
|
|
|
bool objectValid = true;
|
|
//! Pointer to the class which manages the HK pool.
|
|
HousekeepingManager* hkManager;
|
|
};
|
|
|
|
#include <framework/datapoollocal/LocalPoolVariable.tpp>
|
|
template<class T>
|
|
using lp_variable = LocalPoolVar<T>;
|
|
|
|
using lp_bool_t = LocalPoolVar<bool>;
|
|
using lp_uint8_t = LocalPoolVar<uint8_t>;
|
|
using lp_uint16_t = LocalPoolVar<uint16_t>;
|
|
using lp_uint32_t = LocalPoolVar<uint32_t>;
|
|
using lp_uint64_t = LocalPoolVar<uint64_t>;
|
|
using lp_int8_t = LocalPoolVar<int8_t>;
|
|
using lp_int16_t = LocalPoolVar<int16_t>;
|
|
using lp_int32_t = LocalPoolVar<int32_t>;
|
|
using lp_int64_t = LocalPoolVar<int64_t>;
|
|
using lp_float_t = LocalPoolVar<float>;
|
|
using lp_double_t = LocalPoolVar<double>;
|
|
|
|
|