diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h index ef2a82f5c..b9394cfec 100644 --- a/container/FixedArrayList.h +++ b/container/FixedArrayList.h @@ -17,10 +17,11 @@ public: //We could create a constructor to initialize the fixed array list with data and the known size field //so it can be used for serialization too (with SerialFixedArrrayListAdapter) //is this feasible? -// FixedArrayList(T * data_, count_t count): -// ArrayList(data, MAX_SIZE) { -// memcpy(data, data_, count); -// } + FixedArrayList(T * data_, count_t count): + ArrayList(data, MAX_SIZE) { + memcpy(this->data, data_, count); + this->size = count; + } FixedArrayList(const FixedArrayList& other) : ArrayList(data, MAX_SIZE) { diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp index 895e9461d..ab9dae073 100644 --- a/serialize/SerialBufferAdapter.cpp +++ b/serialize/SerialBufferAdapter.cpp @@ -71,6 +71,11 @@ ReturnValue_t SerialBufferAdapter::deSerialize(const uint8_t** buffer, //TODO Ignores Endian flag! if (buffer != NULL) { if(serializeLength){ + // Suggestion (would require removing rest of the block inside this if clause !): + //ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian); + //if (result != HasReturnvaluesIF::RETURN_OK) { + // return result; + //} T serializedSize = AutoSerializeAdapter::getSerializedSize( &bufferLength); if((*size - bufferLength - serializedSize) >= 0){ @@ -113,8 +118,9 @@ const uint8_t * SerialBufferAdapter::getConstBuffer() { } template -void SerialBufferAdapter::setBuffer(uint8_t * buffer_) { +void SerialBufferAdapter::setBuffer(uint8_t * buffer_, T bufferLength_) { buffer = buffer_; + bufferLength = bufferLength_; } diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h index b7729e316..53c5dc72f 100644 --- a/serialize/SerialBufferAdapter.h +++ b/serialize/SerialBufferAdapter.h @@ -58,7 +58,7 @@ public: uint8_t * getBuffer(); const uint8_t * getConstBuffer(); - void setBuffer(uint8_t * buffer_); + void setBuffer(uint8_t * buffer_, T bufferLength_); private: enum bufferType { diff --git a/serialize/SerialBufferAdapter2.h b/serialize/SerialBufferAdapter2.h index a9613d940..59c79dc2e 100644 --- a/serialize/SerialBufferAdapter2.h +++ b/serialize/SerialBufferAdapter2.h @@ -29,12 +29,18 @@ public: * @param bufferLength * @param serializeLength */ - SerialBufferAdapter2(BUFFER_TYPE * buffer_, count_t bufferLength_, bool serializeLength_ = false): - buffer(buffer_),bufferLength(bufferLength_), serializeLength(serializeLength_) { - determineLengthMultiplier(sizeof(count_t)); - if(std::is_const::value) { - isConst = true; - } + SerialBufferAdapter2(void * buffer_, count_t bufferLength_, bool serializeLength_ = false): + bufferLength(bufferLength_), serializeLength(serializeLength_) { + determineLengthInBytes(sizeof(BUFFER_TYPE)); + buffer = reinterpret_cast(buffer_); + constBuffer = NULL; + } + + SerialBufferAdapter2(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false): + bufferLength(bufferLength_), serializeLength(serializeLength_) { + determineLengthInBytes(sizeof(BUFFER_TYPE)); + constBuffer = reinterpret_cast(buffer_); + buffer = NULL; } ReturnValue_t serialize(uint8_t ** buffer, uint32_t* size, @@ -69,9 +75,13 @@ public: ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, bool bigEndian) { //TODO Ignores Endian flag! - //UPDATE: Endian swapper introduced. Must be tested.. if (buffer != NULL) { if(serializeLength){ + // Suggestion (would require removing rest of the block inside this if clause !): + //ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian); + //if (result != HasReturnvaluesIF::RETURN_OK) { + // return result; + //} count_t serializedSize = AutoSerializeAdapter::getSerializedSize( &bufferLength); if((*size - bufferLength - serializedSize) >= 0){ @@ -83,15 +93,8 @@ public: } //No Else If, go on with buffer if (*size - bufferLength >= 0) { - uint8_t tmp [bufferLength]; - uint8_t * pTmp = tmp; - if (bigEndian) { - EndianSwapper::swap(pTmp,*buffer, bufferLength); - } else { - pTmp = const_cast(*buffer); - } *size -= bufferLength; - memcpy(const_cast(reinterpret_cast(this->buffer)), pTmp, bufferLength); + memcpy(this->buffer, *buffer, bufferLength); (*buffer) += bufferLength; return HasReturnvaluesIF::RETURN_OK; } else { @@ -103,24 +106,30 @@ public: } - uint8_t * getBuffer() { - return reinterpret_cast(buffer); + BUFFER_TYPE * getBuffer() { + return reinterpret_cast(buffer); } - void setBuffer(BUFFER_TYPE * buffer_, count_t bufferLength_, bool serializeLength_ = false) { + void setBuffer(void * buffer_, count_t bufferLength_, bool serializeLength_ = false) { buffer = buffer_; bufferLength = bufferLength_; serializeLength = serializeLength_; - determineLengthMultiplier(sizeof(count_t)); + determineLengthInBytes(sizeof(BUFFER_TYPE)); + } + + void setConstBuffer(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false) { + constBuffer = buffer_; + bufferLength = bufferLength_; + serializeLength = serializeLength_; + determineLengthInBytes(sizeof(BUFFER_TYPE)); } private: - BUFFER_TYPE * buffer; + uint8_t * buffer; + const uint8_t * constBuffer; count_t bufferLength; bool serializeLength; - bool isConst = false; - - void determineLengthMultiplier(uint8_t typeSize) { + void determineLengthInBytes(uint8_t typeSize) { switch(typeSize) { case(2): bufferLength *= 2; break; @@ -134,6 +143,4 @@ private: } }; - - #endif /* SERIALBUFFERADAPTER2_H_ */ diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h index f8b2b7302..f6d5ba8ac 100644 --- a/storagemanager/LocalPool.h +++ b/storagemanager/LocalPool.h @@ -39,7 +39,95 @@ public: * @brief This definition generally sets the number of different sized pools. * @details This must be less than the maximum number of pools (currently 0xff). */ -// static const uint32_t NUMBER_OF_POOLS; + // static const uint32_t NUMBER_OF_POOLS; + /** + * @brief This is the default constructor for a pool manager instance. + * @details By passing two arrays of size NUMBER_OF_POOLS, the constructor + * allocates memory (with \c new) for store and size_list. These + * regions are all set to zero on start up. + * @param setObjectId The object identifier to be set. This allows for + * multiple instances of LocalPool in the system. + * @param element_sizes An array of size NUMBER_OF_POOLS in which the size + * of a single element in each pool is determined. + * The sizes must be provided in ascending order. + * + * @param n_elements An array of size NUMBER_OF_POOLS in which the + * number of elements for each pool is determined. + * The position of these values correspond to those in + * element_sizes. + * @param registered Register the pool in object manager or not. Default is false (local pool). + * @param spillsToHigherPools + * A variable to determine whether higher n pools are used if the store is full. + */ + LocalPool(object_id_t setObjectId, + const uint16_t element_sizes[NUMBER_OF_POOLS], + const uint16_t n_elements[NUMBER_OF_POOLS], + bool registered = false, + bool spillsToHigherPools = false); + /** + * @brief In the LocalPool's destructor all allocated memory is freed. + */ + virtual ~LocalPool(void); + + /** + * Add data to local data pool, performs range check + * @param storageId [out] Store ID in which the data will be stored + * @param data + * @param size + * @param ignoreFault + * @return @c RETURN_OK if write was successful + */ + ReturnValue_t addData(store_address_t* storageId, const uint8_t * data, + uint32_t size, bool ignoreFault = false); + + /** + * With this helper method, a free element of \c size is reserved. + * @param storageId [out] storeID of the free element + * @param size The minimum packet size that shall be reserved. + * @param p_data [out] pointer to the pointer of free element + * @param ignoreFault + * @return Returns the storage identifier within the storage or + * StorageManagerIF::INVALID_ADDRESS (in raw). + */ + ReturnValue_t getFreeElement(store_address_t* storageId, + const uint32_t size, uint8_t** p_data, bool ignoreFault = false); + + /** + * Retrieve data from local pool + * @param packet_id + * @param packet_ptr + * @param size [out] Size of retrieved data + * @return @c RETURN_OK if data retrieval was successfull + */ + ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr, + uint32_t* size); + + /** + * Modify data by supplying a packet pointer and using that packet pointer + * to access and modify the pool entry (via *pointer call) + * @param packet_id Store ID of data to modify + * @param packet_ptr [out] pointer to the pool entry to modify + * @param size [out] size of pool entry + * @return + */ + ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr, + uint32_t* size); + virtual ReturnValue_t deleteData(store_address_t); + virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size, + store_address_t* storeId = NULL); + void clearStore(); + ReturnValue_t initialize(); +protected: + /** + * With this helper method, a free element of \c size is reserved. + * @param size The minimum packet size that shall be reserved. + * @param[out] address Storage ID of the reserved data. + * @return - #RETURN_OK on success, + * - the return codes of #getPoolIndex or #findEmpty otherwise. + */ + virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault); + + InternalErrorReporterIF *internalErrorReporter; private: /** * Indicates that this element is free. @@ -121,93 +209,6 @@ private: * - #DATA_STORAGE_FULL if the store is full */ ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element); -protected: - /** - * With this helper method, a free element of \c size is reserved. - * @param size The minimum packet size that shall be reserved. - * @param[out] address Storage ID of the reserved data. - * @return - #RETURN_OK on success, - * - the return codes of #getPoolIndex or #findEmpty otherwise. - */ - virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault); - - InternalErrorReporterIF *internalErrorReporter; -public: - /** - * @brief This is the default constructor for a pool manager instance. - * @details By passing two arrays of size NUMBER_OF_POOLS, the constructor - * allocates memory (with \c new) for store and size_list. These - * regions are all set to zero on start up. - * @param setObjectId The object identifier to be set. This allows for - * multiple instances of LocalPool in the system. - * @param element_sizes An array of size NUMBER_OF_POOLS in which the size - * of a single element in each pool is determined. - * The sizes must be provided in ascending order. - * - * @param n_elements An array of size NUMBER_OF_POOLS in which the - * number of elements for each pool is determined. - * The position of these values correspond to those in - * element_sizes. - * @param registered Register the pool in object manager or not. Default is false (local pool). - * @param spillsToHigherPools - * A variable to determine whether higher n pools are used if the store is full. - */ - LocalPool(object_id_t setObjectId, - const uint16_t element_sizes[NUMBER_OF_POOLS], - const uint16_t n_elements[NUMBER_OF_POOLS], - bool registered = false, - bool spillsToHigherPools = false); - /** - * @brief In the LocalPool's destructor all allocated memory is freed. - */ - virtual ~LocalPool(void); - - /** - * Add data to local data pool, performs range check - * @param storageId [out] Store ID in which the data will be stored - * @param data - * @param size - * @param ignoreFault - * @return @c RETURN_OK if write was successful - */ - ReturnValue_t addData(store_address_t* storageId, const uint8_t * data, - uint32_t size, bool ignoreFault = false); - - /** - * With this helper method, a free element of \c size is reserved. - * - * @param size The minimum packet size that shall be reserved. - * @return Returns the storage identifier within the storage or - * StorageManagerIF::INVALID_ADDRESS (in raw). - */ - ReturnValue_t getFreeElement(store_address_t* storageId, - const uint32_t size, uint8_t** p_data, bool ignoreFault = false); - - /** - * Retrieve data from local pool - * @param packet_id - * @param packet_ptr - * @param size [out] Size of retrieved data - * @return @c RETURN_OK if data retrieval was successfull - */ - ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr, - uint32_t* size); - - /** - * Modify data by supplying a packet pointer and using that packet pointer - * to access and modify the pool entry (via *pointer call) - * @param packet_id Store ID of data to modify - * @param packet_ptr [out] pointer to the pool entry to modify - * @param size [out] size of pool entry - * @return - */ - ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr, - uint32_t* size); - virtual ReturnValue_t deleteData(store_address_t); - virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size, - store_address_t* storeId = NULL); - void clearStore(); - ReturnValue_t initialize(); }; template @@ -304,7 +305,7 @@ template inline LocalPool::LocalPool(object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS], const uint16_t n_elements[NUMBER_OF_POOLS], bool registered, bool spillsToHigherPools) : - SystemObject(setObjectId, registered), spillsToHigherPools(spillsToHigherPools), internalErrorReporter(NULL) { + SystemObject(setObjectId, registered), internalErrorReporter(NULL), spillsToHigherPools(spillsToHigherPools){ for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) { this->element_sizes[n] = element_sizes[n]; this->n_elements[n] = n_elements[n];