fsfw/datapool/PoolVector.h

/*
 * \file	PoolVector.h
 *
 * \brief	This file contains the PoolVector class, the header only class to handle data pool vectors.
 *
 * \date	10/23/2012
 *
 * \author	Bastian Baetz
 */

#ifndef POOLVECTOR_H_
#define POOLVECTOR_H_

#include <framework/datapool/DataSetIF.h>
#include <framework/datapool/PoolEntry.h>
#include <framework/datapool/PoolVariableIF.h>
#include <framework/serialize/SerializeAdapter.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>

/**
 * \brief	This is the access class for array-type 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- and length-safe access
 * 			to vector-style 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 no array entry in
 * 			the data pool is changed until the commit call is executed.
 * 			There are two template parameters:
 * 	\tparam	T This template parameter specifies the data type of an array entry. Currently, all
 * 			plain data types are supported, but in principle any type is possible.
 * 	\tparam vector_size	This template parameter specifies the vector size of this entry.
 * 			Using a template parameter for this is not perfect, but avoids dynamic memory allocation.
 *	\ingroup data_pool
 */
template<typename T, uint16_t vector_size>
class PoolVector: public PoolVariableIF {
private:
	/**
	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
	 * 			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.
	 */
	ReadWriteMode_t readWriteMode;

protected:
	/**
	 * \brief	This is a call to read the array's values 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 all array values and the valid
	 * 			information to its local attributes. In case of a failure (wrong type, size or
	 * 			pool id not found), the variable is set to zero and invalid.
	 * 			The operation does NOT provide any mutual exclusive protection by itself.
	 */
	ReturnValue_t read() {
		PoolEntry<T>* read_out = ::dataPool.getData<T>(this->dataPoolId,
				vector_size);
		if (read_out != NULL) {
			this->valid = read_out->valid;
			memcpy(this->value, read_out->address, read_out->getByteSize());

			return HasReturnvaluesIF::RETURN_OK;

		} else {
			memset(this->value, 0, vector_size * sizeof(T));
			error << "PoolVector: read of DP Variable 0x" << std::hex
					<< dataPoolId << std::dec << " failed." << std::endl;
			this->valid = INVALID;
			return HasReturnvaluesIF::RETURN_FAILED;
		}
	}
	/**
	 * \brief	The commit call copies the array values back 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.
	 *
	 */
	ReturnValue_t commit() {
		PoolEntry<T>* write_back = ::dataPool.getData<T>(this->dataPoolId,
				vector_size);
		if ((write_back != NULL) && (this->readWriteMode != VAR_READ)) {
			write_back->valid = valid;
			memcpy(write_back->address, this->value, write_back->getByteSize());
			return HasReturnvaluesIF::RETURN_OK;
		} else {
			return HasReturnvaluesIF::RETURN_FAILED;
		}
	}
public:
	/**
	 * \brief	This is the local copy of the data pool entry.
	 * \detials	The user can work on this attribute
	 * 			just like he would on a local array of this type.
	 */
	T value[vector_size];
	/**
	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
	 * 			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.
	 */
	PoolVector(uint32_t set_id, DataSetIF* set,
			ReadWriteMode_t setReadWriteMode) :
			dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
		memset(this->value, 0, vector_size * sizeof(T));
		if (set != NULL) {
			set->registerVariable(this);
		}
	}
	/**
	 * Copy ctor to copy classes containing Pool Variables.
	 */
//	PoolVector(const PoolVector& rhs) {
//		PoolVector<T, vector_size> temp(rhs.dataPoolId, rhs.)
//		memcpy(value, rhs.value, sizeof(T)*vector_size);
//	}
	/**
	 * \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.
	 */
	~PoolVector() {
	}
	;
	/**
	 * \brief	The operation returns the number of array entries in this variable.
	 */
	uint8_t getSize() {
		return vector_size;
	}
	/**
	 * \brief	This operation returns the data pool id of the variable.
	 */
	uint32_t getDataPoolId() const {
		return dataPoolId;
	}
	/**
	 * 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) {
		dataPoolId = poolId;
	}
	/**
	 * This method returns if the variable is write-only, read-write or read-only.
	 */
	ReadWriteMode_t getReadWriteMode() const {
		return readWriteMode;
	}
	;
	/**
	 * \brief	With this call, the valid information of the variable is returned.
	 */
	bool isValid() const {
		if (valid != INVALID)
			return true;
		else
			return false;
	}

	void setValid(uint8_t valid) {
		this->valid = valid;
	}

	uint8_t getValid() {
		return valid;
	}

	T &operator [](int i) {
		return value[i];
	}

	const T &operator [](int i) const {
		return value[i];
	}

	PoolVector<T, vector_size> &operator=(
			PoolVector<T, vector_size> newPoolVector) {

		for (uint16_t i = 0; i < vector_size; i++) {
			this->value[i] = newPoolVector.value[i];
		}
		return *this;
	}

	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
			const size_t max_size, bool bigEndian) const {
		uint16_t i;
		ReturnValue_t result;
		for (i = 0; i < vector_size; i++) {
			result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
					max_size, bigEndian);
			if (result != HasReturnvaluesIF::RETURN_OK) {
				return result;
			}
		}
		return result;
	}

	virtual size_t getSerializedSize() const {
		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
	}

	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
			bool bigEndian) {
		uint16_t i;
		ReturnValue_t result;
		for (i = 0; i < vector_size; i++) {
			result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
					bigEndian);
			if (result != HasReturnvaluesIF::RETURN_OK) {
				return result;
			}
		}
		return result;
	}
};

#endif /* POOLVECTOR_H_ */