214 lines
7.1 KiB
C++
214 lines
7.1 KiB
C++
#ifndef GLOBALPOOLVARIABLE_H_
|
|
#define GLOBALPOOLVARIABLE_H_
|
|
|
|
#include "../datapool/DataSetIF.h"
|
|
#include "../datapoolglob/GlobalDataPool.h"
|
|
#include "../datapool/PoolVariableIF.h"
|
|
#include "../datapool/PoolEntry.h"
|
|
#include "../serialize/SerializeAdapter.h"
|
|
#include "../serviceinterface/ServiceInterfaceStream.h"
|
|
|
|
template<typename T, uint8_t n_var> class PoolVarList;
|
|
|
|
|
|
/**
|
|
* @brief This is the access class for non-array data pool entries.
|
|
*
|
|
* @details
|
|
* To ensure safe usage of the data pool, operation is not done directly
|
|
* on the data pool entries, but on local copies. This class provides simple
|
|
* type-safe access to single data pool entries (i.e. entries with length = 1).
|
|
* The class can be instantiated as read-write and read only.
|
|
* It provides a commit-and-roll-back semantic, which means that the
|
|
* variable's value in the data pool is not changed until the
|
|
* commit call is executed.
|
|
* @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
|
|
*/
|
|
template<typename T>
|
|
class GlobPoolVar: public PoolVariableIF {
|
|
template<typename U, uint8_t n_var> friend class PoolVarList;
|
|
static_assert(not std::is_same<T, bool>::value,
|
|
"Do not use boolean for the PoolEntry type, use uint8_t instead!"
|
|
"There is no boolean type in CCSDS.");
|
|
public:
|
|
/**
|
|
* @brief In the constructor, the variable can register itself in a
|
|
* DataSet (if nullptr is not passed).
|
|
* @details
|
|
* It DOES NOT fetch the current value from the data pool, but
|
|
* sets the value attribute to default (0).
|
|
* The value is fetched within the read() operation.
|
|
* @param set_id This is the id in the global data pool
|
|
* this instance of the access class corresponds to.
|
|
* @param dataSet The data set in which the variable shall register
|
|
* itself. If NULL, the variable is not registered.
|
|
* @param setWritable If this flag is set to true, changes in the value
|
|
* attribute can be written back to the data pool, otherwise not.
|
|
*/
|
|
GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
|
|
ReadWriteMode_t setReadWriteMode);
|
|
|
|
/**
|
|
* @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;
|
|
|
|
/**
|
|
* @brief Copy ctor to copy classes containing Pool Variables.
|
|
* (Robin): This only copies member variables, which is done
|
|
* by the default copy ctor. maybe we can ommit this ctor?
|
|
*/
|
|
GlobPoolVar(const GlobPoolVar& rhs);
|
|
|
|
/**
|
|
* @brief The classes destructor is empty.
|
|
* @details If commit() was not called, the local value is
|
|
* discarded and not written back to the data pool.
|
|
*/
|
|
~GlobPoolVar() {}
|
|
|
|
/**
|
|
* @brief This is a call to read the value from the global data pool.
|
|
* @details
|
|
* When executed, this operation tries to fetch the pool entry with matching
|
|
* data pool id from the global data pool and copies the value and the valid
|
|
* information to its local attributes. In case of a failure (wrong type or
|
|
* pool id not found), the variable is set to zero and invalid.
|
|
* The read call is protected with a lock.
|
|
* It is recommended to use DataSets to read and commit multiple variables
|
|
* at once to avoid the overhead of unnecessary lock und unlock operations.
|
|
*/
|
|
ReturnValue_t read(uint32_t lockTimeout) override;
|
|
/**
|
|
* @brief The commit call writes back the variable's value to the data pool.
|
|
* @details
|
|
* It checks type and size, as well as if the variable is writable. If so,
|
|
* the value is copied and the valid flag is automatically set to "valid".
|
|
* The operation does NOT provide any mutual exclusive protection by itself.
|
|
* The commit call is protected with a lock.
|
|
* It is recommended to use DataSets to read and commit multiple variables
|
|
* at once to avoid the overhead of unnecessary lock und unlock operations.
|
|
*/
|
|
ReturnValue_t commit(uint32_t lockTimeout) override;
|
|
|
|
protected:
|
|
/**
|
|
* @brief Like #read, but without a lock protection of the global pool.
|
|
* @details
|
|
* The operation does NOT provide any mutual exclusive protection by itself.
|
|
* This can be used if the lock is handled externally to avoid the overhead
|
|
* of consecutive lock und unlock operations.
|
|
* Declared protected to discourage free public usage.
|
|
*/
|
|
ReturnValue_t readWithoutLock() override;
|
|
/**
|
|
* @brief Like #commit, but without a lock protection of the global pool.
|
|
* @details
|
|
* The operation does NOT provide any mutual exclusive protection by itself.
|
|
* This can be used if the lock is handled externally to avoid the overhead
|
|
* of consecutive lock und unlock operations.
|
|
* Declared protected to discourage free public usage.
|
|
*/
|
|
ReturnValue_t commitWithoutLock() override;
|
|
/**
|
|
* @brief To access the correct data pool entry on read and commit calls,
|
|
* the data pool is stored.
|
|
*/
|
|
uint32_t dataPoolId;
|
|
|
|
/**
|
|
* @brief The valid information as it was stored in the data pool is
|
|
* copied to this attribute.
|
|
*/
|
|
uint8_t valid;
|
|
|
|
/**
|
|
* @brief The information whether the class is read-write or read-only
|
|
* is stored here.
|
|
*/
|
|
pool_rwm_t readWriteMode;
|
|
|
|
/**
|
|
* Empty ctor for List initialization
|
|
*/
|
|
GlobPoolVar();
|
|
public:
|
|
/**
|
|
* \brief This operation returns the data pool id of the variable.
|
|
*/
|
|
uint32_t getDataPoolId() const override;
|
|
|
|
/**
|
|
* This method returns if the variable is write-only, read-write or read-only.
|
|
*/
|
|
ReadWriteMode_t getReadWriteMode() const override;
|
|
/**
|
|
* This operation sets the data pool id of the variable.
|
|
* The method is necessary to set id's of data pool member variables with bad initialization.
|
|
*/
|
|
void setDataPoolId(uint32_t poolId);
|
|
|
|
/**
|
|
* \brief With this call, the valid information of the variable is returned.
|
|
*/
|
|
bool isValid() const override;
|
|
|
|
uint8_t getValid();
|
|
|
|
void setValid(bool valid) override;
|
|
|
|
operator T() {
|
|
return value;
|
|
}
|
|
|
|
operator T() const {
|
|
return value;
|
|
}
|
|
|
|
GlobPoolVar<T> &operator=(T newValue) {
|
|
value = newValue;
|
|
return *this;
|
|
}
|
|
|
|
GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
|
|
value = newPoolVariable.value;
|
|
return *this;
|
|
}
|
|
|
|
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
|
const size_t max_size,
|
|
SerializeIF::Endianness streamEndianness) const override {
|
|
return SerializeAdapter::serialize(&value, buffer, size, max_size,
|
|
streamEndianness);
|
|
}
|
|
|
|
virtual size_t getSerializedSize() const {
|
|
return SerializeAdapter::getSerializedSize(&value);
|
|
}
|
|
|
|
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
|
SerializeIF::Endianness streamEndianness) {
|
|
return SerializeAdapter::deSerialize(&value, buffer, size,
|
|
streamEndianness);
|
|
}
|
|
};
|
|
|
|
#include "../datapoolglob/GlobalPoolVariable.tpp"
|
|
|
|
typedef GlobPoolVar<uint8_t> gp_bool_t;
|
|
typedef GlobPoolVar<uint8_t> gp_uint8_t;
|
|
typedef GlobPoolVar<uint16_t> gp_uint16_t;
|
|
typedef GlobPoolVar<uint32_t> gp_uint32_t;
|
|
typedef GlobPoolVar<int8_t> gp_int8_t;
|
|
typedef GlobPoolVar<int16_t> gp_int16_t;
|
|
typedef GlobPoolVar<int32_t> gp_int32_t;
|
|
typedef GlobPoolVar<float> gp_float_t;
|
|
typedef GlobPoolVar<double> gp_double_t;
|
|
|
|
#endif /* POOLVARIABLE_H_ */
|