Actually, not that horrible, thanks to sed

This commit is contained in:
Uli 2020-04-21 22:28:43 +02:00
parent a42832ca01
commit 6553450b4b
51 changed files with 458 additions and 566 deletions

View File

@ -71,18 +71,18 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
CommandMessage reply; CommandMessage reply;
store_address_t storeAddress; store_address_t storeAddress;
uint8_t *dataPtr; uint8_t *dataPtr;
uint32_t maxSize = data->getSerializedSize(); size_t maxSize = data->getSerializedSize();
if (maxSize == 0) { if (maxSize == 0) {
//No error, there's simply nothing to report. //No error, there's simply nothing to report.
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
uint32_t size = 0; size_t size = 0;
ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize, ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
&dataPtr); &dataPtr);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = data->serialize(&dataPtr, &size, maxSize, true); result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
ipcStore->deleteData(storeAddress); ipcStore->deleteData(storeAddress);
return result; return result;

View File

@ -4,30 +4,31 @@
#include <framework/action/HasActionsIF.h> #include <framework/action/HasActionsIF.h>
#include <framework/objectmanager/ObjectManagerIF.h> #include <framework/objectmanager/ObjectManagerIF.h>
CommandActionHelper::CommandActionHelper(CommandsActionsIF* setOwner) : CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
owner(setOwner), queueToUse(NULL), ipcStore( owner(setOwner), queueToUse(NULL), ipcStore(
NULL), commandCount(0), lastTarget(0) { NULL), commandCount(0), lastTarget(0) {
} }
CommandActionHelper::~CommandActionHelper() { CommandActionHelper::~CommandActionHelper() {
} }
ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
ActionId_t actionId, SerializeIF* data) { ActionId_t actionId, SerializeIF *data) {
HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo); HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
if (receiver == NULL) { if (receiver == NULL) {
return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS; return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
} }
store_address_t storeId; store_address_t storeId;
uint8_t* storePointer; uint8_t *storePointer;
uint32_t maxSize = data->getSerializedSize(); size_t maxSize = data->getSerializedSize();
ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize, ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
&storePointer); &storePointer);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
uint32_t size = 0; size_t size = 0;
result = data->serialize(&storePointer, &size, maxSize, true); result = data->serialize(&storePointer, &size, maxSize,
SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -35,11 +36,11 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
} }
ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
ActionId_t actionId, const uint8_t* data, uint32_t size) { ActionId_t actionId, const uint8_t *data, uint32_t size) {
// if (commandCount != 0) { // if (commandCount != 0) {
// return CommandsFunctionsIF::ALREADY_COMMANDING; // return CommandsFunctionsIF::ALREADY_COMMANDING;
// } // }
HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo); HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
if (receiver == NULL) { if (receiver == NULL) {
return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS; return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
} }
@ -71,13 +72,13 @@ ReturnValue_t CommandActionHelper::initialize() {
} }
queueToUse = owner->getCommandQueuePtr(); queueToUse = owner->getCommandQueuePtr();
if(queueToUse == NULL){ if (queueToUse == NULL) {
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) { ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
if (reply->getSender() != lastTarget) { if (reply->getSender() != lastTarget) {
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
@ -88,7 +89,8 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
case ActionMessage::COMPLETION_FAILED: case ActionMessage::COMPLETION_FAILED:
commandCount--; commandCount--;
owner->completionFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getReturnCode(reply)); owner->completionFailedReceived(ActionMessage::getActionId(reply),
ActionMessage::getReturnCode(reply));
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
case ActionMessage::STEP_SUCCESS: case ActionMessage::STEP_SUCCESS:
owner->stepSuccessfulReceived(ActionMessage::getActionId(reply), owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
@ -96,11 +98,13 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
case ActionMessage::STEP_FAILED: case ActionMessage::STEP_FAILED:
commandCount--; commandCount--;
owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply), owner->stepFailedReceived(ActionMessage::getActionId(reply),
ActionMessage::getStep(reply),
ActionMessage::getReturnCode(reply)); ActionMessage::getReturnCode(reply));
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
case ActionMessage::DATA_REPLY: case ActionMessage::DATA_REPLY:
extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply)); extractDataForOwner(ActionMessage::getActionId(reply),
ActionMessage::getStoreId(reply));
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
default: default:
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
@ -111,8 +115,9 @@ uint8_t CommandActionHelper::getCommandCount() const {
return commandCount; return commandCount;
} }
void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) { void CommandActionHelper::extractDataForOwner(ActionId_t actionId,
const uint8_t * data = NULL; store_address_t storeId) {
const uint8_t *data = NULL;
uint32_t size = 0; uint32_t size = 0;
ReturnValue_t result = ipcStore->getData(storeId, &data, &size); ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {

View File

@ -148,22 +148,22 @@ public:
return theMap.maxSize(); return theMap.maxSize();
} }
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&this->_size, ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
uint32_t i = 0; uint32_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
result = SerializeAdapter::serialize(&theMap[i].first, buffer, result = SerializeAdapter::serialize(&theMap[i].first, buffer,
size, max_size, bigEndian); size, maxSize, streamEndianness);
result = SerializeAdapter::serialize(&theMap[i].second, buffer, size, result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
++i; ++i;
} }
return result; return result;
} }
virtual uint32_t getSerializedSize() const { virtual size_t getSerializedSize() const {
uint32_t printSize = sizeof(_size); uint32_t printSize = sizeof(_size);
uint32_t i = 0; uint32_t i = 0;
@ -176,19 +176,19 @@ public:
return printSize; return printSize;
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size, ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
buffer, size, bigEndian); buffer, size, streamEndianness);
if (this->_size > theMap.maxSize()) { if (this->_size > theMap.maxSize()) {
return SerializeIF::TOO_MANY_ELEMENTS; return SerializeIF::TOO_MANY_ELEMENTS;
} }
uint32_t i = 0; uint32_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
result = SerializeAdapter::deSerialize(&theMap[i].first, buffer, result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
size, bigEndian); size, streamEndianness);
result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size, result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
bigEndian); streamEndianness);
++i; ++i;
} }
return result; return result;

View File

@ -68,46 +68,46 @@ public:
return this->storedPackets; return this->storedPackets;
} }
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,max_size,bigEndian); ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = indexType.serialize(buffer,size,max_size,bigEndian); result = indexType.serialize(buffer,size,maxSize,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
return result; return result;
} }
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian){ Endianness streamEndianness){
ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian); ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = indexType.deSerialize(buffer,size,bigEndian); result = indexType.deSerialize(buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = SerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian); result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian); result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
return result; return result;
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress); uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
size += indexType.getSerializedSize(); size += indexType.getSerializedSize();
size += SerializeAdapter::getSerializedSize(&this->size); size += SerializeAdapter::getSerializedSize(&this->size);
@ -485,22 +485,22 @@ public:
* Parameters according to HasSerializeIF * Parameters according to HasSerializeIF
* @param buffer * @param buffer
* @param size * @param size
* @param max_size * @param maxSize
* @param bigEndian * @param streamEndianness
* @return * @return
*/ */
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const{ size_t maxSize, Endianness streamEndianness) const{
uint8_t* crcBuffer = *buffer; uint8_t* crcBuffer = *buffer;
uint32_t oldSize = *size; uint32_t oldSize = *size;
if(additionalInfo!=NULL){ if(additionalInfo!=NULL){
additionalInfo->serialize(buffer,size,max_size,bigEndian); additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
} }
ReturnValue_t result = currentWriteBlock->serialize(buffer,size,max_size,bigEndian); ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
@ -508,14 +508,14 @@ public:
uint32_t i = 0; uint32_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
result = SerializeAdapter::serialize(&this->entries[i], buffer, size, result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
++i; ++i;
} }
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize)); uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
result = SerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
return result; return result;
} }
@ -524,7 +524,7 @@ public:
* Get the serialized Size of the index * Get the serialized Size of the index
* @return The serialized size of the index * @return The serialized size of the index
*/ */
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
uint32_t size = 0; uint32_t size = 0;
if(additionalInfo!=NULL){ if(additionalInfo!=NULL){
@ -542,28 +542,28 @@ public:
* CRC Has to be checked before! * CRC Has to be checked before!
* @param buffer * @param buffer
* @param size * @param size
* @param bigEndian * @param streamEndianness
* @return * @return
*/ */
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian){ Endianness streamEndianness){
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
if(additionalInfo!=NULL){ if(additionalInfo!=NULL){
result = additionalInfo->deSerialize(buffer,size,bigEndian); result = additionalInfo->deSerialize(buffer,size,streamEndianness);
} }
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
Index<T> tempIndex; Index<T> tempIndex;
result = tempIndex.deSerialize(buffer,size,bigEndian); result = tempIndex.deSerialize(buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
uint32_t tempSize = 0; uint32_t tempSize = 0;
result = SerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian); result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
@ -574,7 +574,7 @@ public:
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
result = SerializeAdapter::deSerialize( result = SerializeAdapter::deSerialize(
&this->entries[i], buffer, size, &this->entries[i], buffer, size,
bigEndian); streamEndianness);
++i; ++i;
} }
if(result != HasReturnvaluesIF::RETURN_OK){ if(result != HasReturnvaluesIF::RETURN_OK){

View File

@ -39,10 +39,10 @@ PoolEntryIF* DataPool::getRawData( uint32_t data_pool_id ) {
} }
} }
//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t max_size ) { //uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t maxSize ) {
// std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id ); // std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
// if ( it != this->data_pool.end() ) { // if ( it != this->data_pool.end() ) {
// if ( it->second->getByteSize() <= max_size ) { // if ( it->second->getByteSize() <= maxSize ) {
// *size = it->second->getByteSize(); // *size = it->second->getByteSize();
// memcpy( address, it->second->getRawData(), *size ); // memcpy( address, it->second->getRawData(), *size );
// return DP_SUCCESSFUL; // return DP_SUCCESSFUL;

View File

@ -261,7 +261,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
//identical to ParameterHelper::sendParameter() //identical to ParameterHelper::sendParameter()
ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id, ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
const DataPoolParameterWrapper* wrapper) { const DataPoolParameterWrapper* wrapper) {
uint32_t serializedSize = wrapper->getSerializedSize(); size_t serializedSize = wrapper->getSerializedSize();
uint8_t *storeElement; uint8_t *storeElement;
store_address_t address; store_address_t address;
@ -272,10 +272,10 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
return result; return result;
} }
uint32_t storeElementSize = 0; size_t storeElementSize = 0;
result = wrapper->serialize(&storeElement, &storeElementSize, result = wrapper->serialize(&storeElement, &storeElementSize,
serializedSize, true); serializedSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
storage->deleteData(address); storage->deleteData(address);

View File

@ -36,22 +36,22 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
} }
ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer, ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
uint32_t* size, const uint32_t max_size, bool bigEndian) const { size_t* size, size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result; ReturnValue_t result;
result = SerializeAdapter::serialize(&type, buffer, size, max_size, result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&columns, buffer, size, result = SerializeAdapter::serialize(&columns, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&rows, buffer, size, max_size, result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -60,7 +60,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
DataSet mySet; DataSet mySet;
PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ); PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
mySet.read(); mySet.read();
result = raw.serialize(buffer,size,max_size,bigEndian); result = raw.serialize(buffer,size,maxSize,streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK){ if (result != HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
@ -69,8 +69,8 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
} }
//same as ParameterWrapper //same as ParameterWrapper
uint32_t DataPoolParameterWrapper::getSerializedSize() const { size_t DataPoolParameterWrapper::getSerializedSize() const {
uint32_t serializedSize = 0; size_t serializedSize = 0;
serializedSize += type.getSerializedSize(); serializedSize += type.getSerializedSize();
serializedSize += sizeof(rows); serializedSize += sizeof(rows);
serializedSize += sizeof(columns); serializedSize += sizeof(columns);
@ -80,7 +80,7 @@ uint32_t DataPoolParameterWrapper::getSerializedSize() const {
} }
ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer, ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian) { size_t* size, Endianness streamEndianness) {
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }

View File

@ -11,13 +11,13 @@ public:
ReturnValue_t set(uint8_t domainId, uint16_t parameterId); ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const override;
virtual uint32_t getSerializedSize() const; virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
ReturnValue_t copyFrom(const ParameterWrapper *from, ReturnValue_t copyFrom(const ParameterWrapper *from,
uint16_t startWritingAtIndex); uint16_t startWritingAtIndex);

View File

@ -106,12 +106,12 @@ uint8_t DataSet::lockDataPool() {
return ::dataPool.lockDataPool(); return ::dataPool.lockDataPool();
} }
ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = RETURN_FAILED; ReturnValue_t result = RETURN_FAILED;
for (uint16_t count = 0; count < fill_count; count++) { for (uint16_t count = 0; count < fill_count; count++) {
result = registeredVariables[count]->serialize(buffer, size, max_size, result = registeredVariables[count]->serialize(buffer, size, maxSize,
bigEndian); streamEndianness);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
@ -119,8 +119,8 @@ ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size,
return result; return result;
} }
uint32_t DataSet::getSerializedSize() const { size_t DataSet::getSerializedSize() const {
uint32_t size = 0; size_t size = 0;
for (uint16_t count = 0; count < fill_count; count++) { for (uint16_t count = 0; count < fill_count; count++) {
size += registeredVariables[count]->getSerializedSize(); size += registeredVariables[count]->getSerializedSize();
} }
@ -136,12 +136,12 @@ void DataSet::setValid(uint8_t valid) {
} }
} }
ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = RETURN_FAILED; ReturnValue_t result = RETURN_FAILED;
for (uint16_t count = 0; count < fill_count; count++) { for (uint16_t count = 0; count < fill_count; count++) {
result = registeredVariables[count]->deSerialize(buffer, size, result = registeredVariables[count]->deSerialize(buffer, size,
bigEndian); streamEndianness);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }

View File

@ -146,13 +146,13 @@ public:
*/ */
void setValid(uint8_t valid); void setValid(uint8_t valid);
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const override;
uint32_t getSerializedSize() const; size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
}; };

View File

@ -69,12 +69,12 @@ uint8_t* PoolRawAccess::getEntry() {
} }
ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer, ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
uint32_t* writtenBytes, uint32_t max_size) { uint32_t* writtenBytes, uint32_t maxSize) {
uint8_t* data_ptr = getEntry(); uint8_t* data_ptr = getEntry();
// debug << "PoolRawAccess::getEntry: Array position: " << index * size_of_type << " Size of T: " << (int)size_of_type << " ByteSize: " << byte_size << " Position: " << *size << std::endl; // debug << "PoolRawAccess::getEntry: Array position: " << index * size_of_type << " Size of T: " << (int)size_of_type << " ByteSize: " << byte_size << " Position: " << *size << std::endl;
if (typeSize == 0) if (typeSize == 0)
return DATA_POOL_ACCESS_FAILED; return DATA_POOL_ACCESS_FAILED;
if (typeSize > max_size) if (typeSize > maxSize)
return INCORRECT_SIZE; return INCORRECT_SIZE;
#ifndef BYTE_ORDER_SYSTEM #ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined #error BYTE_ORDER_SYSTEM not defined
@ -149,7 +149,7 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const { size_t maxSize, Endianness streamEndianness) const {
//TODO integer overflow //TODO integer overflow
if (typeSize + *size <= maxSize) { if (typeSize + *size <= maxSize) {
#error use endian swapper #warning use endian swapper
if (1) { if (1) {
#ifndef BYTE_ORDER_SYSTEM #ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined #error BYTE_ORDER_SYSTEM not defined

View File

@ -90,15 +90,15 @@ public:
* \details It makes use of the getEntry call of this function, but additionally flips the * \details It makes use of the getEntry call of this function, but additionally flips the
* bytes to big endian, which is the default for external communication (as House- * bytes to big endian, which is the default for external communication (as House-
* keeping telemetry). To achieve this, the data is copied directly to the passed * keeping telemetry). To achieve this, the data is copied directly to the passed
* buffer, if it fits in the given max_size. * buffer, if it fits in the given maxSize.
* \param buffer A pointer to a buffer to write to * \param buffer A pointer to a buffer to write to
* \param writtenBytes The number of bytes written is returned with this value. * \param writtenBytes The number of bytes written is returned with this value.
* \param max_size The maximum size that the function may write to buffer. * \param maxSize The maximum size that the function may write to buffer.
* \return - \c RETURN_OK if entry could be acquired * \return - \c RETURN_OK if entry could be acquired
* - \c RETURN_FAILED else. * - \c RETURN_FAILED else.
*/ */
ReturnValue_t getEntryEndianSafe(uint8_t *buffer, uint32_t *size, ReturnValue_t getEntryEndianSafe(uint8_t *buffer, uint32_t *size,
uint32_t max_size); uint32_t maxSize);
/** /**
* With this method, the content can be set from a big endian buffer safely. * With this method, the content can be set from a big endian buffer safely.
* @param buffer Pointer to the data to set * @param buffer Pointer to the data to set

View File

@ -195,12 +195,12 @@ public:
} }
virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
size_t max_size, Endianness streamEndianness) const override { size_t maxSize, Endianness streamEndianness) const override {
return SerializeAdapter::serialize<T>(&value, buffer, size, max_size, return SerializeAdapter::serialize<T>(&value, buffer, size, maxSize,
streamEndianness); streamEndianness);
} }
virtual uint32_t getSerializedSize() const override { virtual size_t getSerializedSize() const override {
return SerializeAdapter::getSerializedSize(&value); return SerializeAdapter::getSerializedSize(&value);
} }

View File

@ -197,13 +197,13 @@ public:
return *this; return *this;
} }
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
uint16_t i; uint16_t i;
ReturnValue_t result; ReturnValue_t result;
for (i = 0; i < vector_size; i++) { for (i = 0; i < vector_size; i++) {
result = SerializeAdapter::serialize(&(value[i]), buffer, size, result = SerializeAdapter::serialize(&(value[i]), buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -211,17 +211,17 @@ public:
return result; return result;
} }
virtual uint32_t getSerializedSize() const { virtual size_t getSerializedSize() const {
return vector_size * SerializeAdapter::getSerializedSize(value); return vector_size * SerializeAdapter::getSerializedSize(value);
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
uint16_t i; uint16_t i;
ReturnValue_t result; ReturnValue_t result;
for (i = 0; i < vector_size; i++) { for (i = 0; i < vector_size; i++) {
result = SerializeAdapter::deSerialize(&(value[i]), buffer, size, result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }

View File

@ -12,35 +12,35 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
} }
ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer, ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
uint32_t* size, const uint32_t max_size, bool bigEndian) const { size_t* size, size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&objectId, ReturnValue_t result = SerializeAdapter::serialize(&objectId,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&actionId, buffer, result = SerializeAdapter::serialize(&actionId, buffer,
size, max_size, bigEndian); size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return data->serialize(buffer, size, max_size, bigEndian); return data->serialize(buffer, size, maxSize, streamEndianness);
} }
uint32_t DeviceTmReportingWrapper::getSerializedSize() const { size_t DeviceTmReportingWrapper::getSerializedSize() const {
return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize(); return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
} }
ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer, ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian) { size_t* size, Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&objectId, ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
buffer, size, bigEndian); buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&actionId, buffer, result = SerializeAdapter::deSerialize(&actionId, buffer,
size, bigEndian); size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return data->deSerialize(buffer, size, bigEndian); return data->deSerialize(buffer, size, streamEndianness);
} }

View File

@ -11,13 +11,13 @@ public:
SerializeIF *data); SerializeIF *data);
virtual ~DeviceTmReportingWrapper(); virtual ~DeviceTmReportingWrapper();
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const override;
virtual uint32_t getSerializedSize() const; virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
private: private:
object_id_t objectId; object_id_t objectId;
ActionId_t actionId; ActionId_t actionId;

View File

@ -11,16 +11,16 @@ class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
public: public:
EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) { } EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) { }
virtual ~EventRangeMatcherBase() { } virtual ~EventRangeMatcherBase() { }
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
return rangeMatcher.serialize(buffer, size, max_size, bigEndian); return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
return rangeMatcher.getSerializedSize(); return rangeMatcher.getSerializedSize();
} }
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
return rangeMatcher.deSerialize(buffer, size, bigEndian); return rangeMatcher.deSerialize(buffer, size, streamEndianness);
} }
protected: protected:
RangeMatcher<T> rangeMatcher; RangeMatcher<T> rangeMatcher;

View File

@ -59,8 +59,8 @@ uint8_t Type::getSize() const {
} }
} }
ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
uint8_t ptc; uint8_t ptc;
uint8_t pfc; uint8_t pfc;
ReturnValue_t result = getPtcPfc(&ptc, &pfc); ReturnValue_t result = getPtcPfc(&ptc, &pfc);
@ -68,36 +68,36 @@ ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
return result; return result;
} }
result = SerializeAdapter::serialize(&ptc, buffer, size, max_size, result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&pfc, buffer, size, max_size, result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
bigEndian); streamEndianness);
return result; return result;
} }
uint32_t Type::getSerializedSize() const { size_t Type::getSerializedSize() const {
uint8_t dontcare = 0; uint8_t dontcare = 0;
return 2 * SerializeAdapter::getSerializedSize(&dontcare); return 2 * SerializeAdapter::getSerializedSize(&dontcare);
} }
ReturnValue_t Type::deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
uint8_t ptc; uint8_t ptc;
uint8_t pfc; uint8_t pfc;
ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer, ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
size, bigEndian); size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&pfc, buffer, size, result = SerializeAdapter::deSerialize(&pfc, buffer, size,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }

View File

@ -1,104 +0,0 @@
#include <framework/globalfunctions/conversion.h>
#include <framework/osal/Endiness.h>
#include <cstring>
//SHOULDDO: This shall be optimized (later)!
void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size ) {
buffer[0] = (value & 0xFF00) >> 8;
buffer[1] = (value & 0x00FF);
*size += 2;
}
void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size ) {
buffer[0] = (value & 0xFF000000) >> 24;
buffer[1] = (value & 0x00FF0000) >> 16;
buffer[2] = (value & 0x0000FF00) >> 8;
buffer[3] = (value & 0x000000FF);
*size +=4;
}
void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size ) {
buffer[0] = (value & 0xFF00) >> 8;
buffer[1] = (value & 0x00FF);
*size += 2;
}
void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size ) {
buffer[0] = (value & 0xFF000000) >> 24;
buffer[1] = (value & 0x00FF0000) >> 16;
buffer[2] = (value & 0x0000FF00) >> 8;
buffer[3] = (value & 0x000000FF);
*size += 4;
}
//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size ) {
// buffer[0] = (value & 0xFF00000000000000) >> 56;
// buffer[1] = (value & 0x00FF000000000000) >> 48;
// buffer[2] = (value & 0x0000FF0000000000) >> 40;
// buffer[3] = (value & 0x000000FF00000000) >> 32;
// buffer[4] = (value & 0x00000000FF000000) >> 24;
// buffer[5] = (value & 0x0000000000FF0000) >> 16;
// buffer[6] = (value & 0x000000000000FF00) >> 8;
// buffer[7] = (value & 0x00000000000000FF);
// *size+=8;
//}
//
//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size ) {
// buffer[0] = (value & 0xFF00000000000000) >> 56;
// buffer[1] = (value & 0x00FF000000000000) >> 48;
// buffer[2] = (value & 0x0000FF0000000000) >> 40;
// buffer[3] = (value & 0x000000FF00000000) >> 32;
// buffer[4] = (value & 0x00000000FF000000) >> 24;
// buffer[5] = (value & 0x0000000000FF0000) >> 16;
// buffer[6] = (value & 0x000000000000FF00) >> 8;
// buffer[7] = (value & 0x00000000000000FF);
// *size+=8;
//}
void convertToByteStream( float in_value, uint8_t* buffer, uint32_t* size ) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
union float_union {
float value;
uint8_t chars[4];
};
float_union temp;
temp.value = in_value;
buffer[0] = temp.chars[3];
buffer[1] = temp.chars[2];
buffer[2] = temp.chars[1];
buffer[3] = temp.chars[0];
*size += 4;
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(buffer, &in_value, sizeof(in_value));
*size += sizeof(in_value);
#endif
}
void convertToByteStream( double in_value, uint8_t* buffer, uint32_t* size ) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
union double_union {
double value;
uint8_t chars[8];
};
double_union temp;
temp.value = in_value;
buffer[0] = temp.chars[7];
buffer[1] = temp.chars[6];
buffer[2] = temp.chars[5];
buffer[3] = temp.chars[4];
buffer[4] = temp.chars[3];
buffer[5] = temp.chars[2];
buffer[6] = temp.chars[1];
buffer[7] = temp.chars[0];
*size += 8;
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(buffer, &in_value, sizeof(in_value));
*size += sizeof(in_value);
#endif
}

View File

@ -1,24 +0,0 @@
#ifndef CONVERSION_H_
#define CONVERSION_H_
#include <stdint.h>
void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size );
void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size );
void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size );
void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size );
//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size );
//
//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size );
void convertToByteStream( float value, uint8_t* buffer, uint32_t* size );
void convertToByteStream( double value, uint8_t* buffer, uint32_t* size );
#endif /* CONVERSION_H_ */

View File

@ -45,38 +45,38 @@ public:
return matchSubtree(iter, number); return matchSubtree(iter, number);
} }
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
iterator iter = this->begin(); iterator iter = this->begin();
uint8_t count = this->countRight(iter); uint8_t count = this->countRight(iter);
ReturnValue_t result = SerializeAdapter::serialize(&count, ReturnValue_t result = SerializeAdapter::serialize(&count,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
if (iter == this->end()) { if (iter == this->end()) {
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
result = iter->serialize(buffer, size, max_size, bigEndian); result = iter->serialize(buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
if (maxDepth > 0) { if (maxDepth > 0) {
MatchTree<T> temp(iter.left(), maxDepth - 1); MatchTree<T> temp(iter.left(), maxDepth - 1);
result = temp.serialize(buffer, size, max_size, bigEndian); result = temp.serialize(buffer, size, maxSize, streamEndianness);
} }
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
iter = iter.right(); iter = iter.right();
while (iter != this->end()) { while (iter != this->end()) {
result = iter->serialize(buffer, size, max_size, bigEndian); result = iter->serialize(buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
if (maxDepth > 0) { if (maxDepth > 0) {
MatchTree<T> temp(iter.left(), maxDepth - 1); MatchTree<T> temp(iter.left(), maxDepth - 1);
result = temp.serialize(buffer, size, max_size, bigEndian); result = temp.serialize(buffer, size, maxSize, streamEndianness);
} }
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
@ -86,7 +86,7 @@ public:
return result; return result;
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const override {
//Analogous to serialize! //Analogous to serialize!
uint32_t size = 1; //One for count uint32_t size = 1; //One for count
iterator iter = this->begin(); iterator iter = this->begin();
@ -115,8 +115,8 @@ public:
return size; return size;
} }
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { SerializeIF::Endianness streamEndianness) override {
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }

View File

@ -26,23 +26,23 @@ public:
} }
} }
ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t max_size, ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const override { SerializeIF::Endianness streamEndianness) const override {
ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer, ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
size, max_size, streamEndianness); size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&upperBound, buffer, size, result = SerializeAdapter::serialize(&upperBound, buffer, size,
max_size, streamEndianness); maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return SerializeAdapter::serialize(&inverted, buffer, size, max_size, return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
streamEndianness); streamEndianness);
} }
uint32_t getSerializedSize() const override { size_t getSerializedSize() const override {
return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool); return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
} }

View File

@ -63,21 +63,21 @@ bool HealthTable::hasHealth(object_id_t object) {
return exits; return exits;
} }
void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) { void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
mutex->lockMutex(MutexIF::NO_TIMEOUT); mutex->lockMutex(MutexIF::NO_TIMEOUT);
uint32_t size = 0; size_t size = 0;
uint16_t count = healthMap.size(); uint16_t count = healthMap.size();
ReturnValue_t result = SerializeAdapter::serialize(&count, ReturnValue_t result = SerializeAdapter::serialize(&count,
&pointer, &size, maxSize, true); &pointer, &size, maxSize, SerializeIF::Endianness::BIG);
HealthMap::iterator iter; HealthMap::iterator iter;
for (iter = healthMap.begin(); for (iter = healthMap.begin();
iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK; iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
++iter) { ++iter) {
result = SerializeAdapter::serialize(&iter->first, result = SerializeAdapter::serialize(&iter->first,
&pointer, &size, maxSize, true); &pointer, &size, maxSize, SerializeIF::Endianness::BIG);
uint8_t health = iter->second; uint8_t health = iter->second;
result = SerializeAdapter::serialize(&health, &pointer, &size, result = SerializeAdapter::serialize(&health, &pointer, &size,
maxSize, true); maxSize, SerializeIF::Endianness::BIG);
} }
mutex->unlockMutex(); mutex->unlockMutex();
} }

View File

@ -21,7 +21,7 @@ public:
virtual HasHealthIF::HealthState getHealth(object_id_t); virtual HasHealthIF::HealthState getHealth(object_id_t);
virtual uint32_t getPrintSize(); virtual uint32_t getPrintSize();
virtual void printAll(uint8_t *pointer, uint32_t maxSize); virtual void printAll(uint8_t *pointer, size_t maxSize);
protected: protected:
MutexIF* mutex; MutexIF* mutex;

View File

@ -17,7 +17,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
} }
store_address_t storeId; store_address_t storeId;
uint8_t* dataTarget = NULL; uint8_t* dataTarget = NULL;
uint32_t maxSize = data->getSerializedSize(); size_t maxSize = data->getSerializedSize();
if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) { if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
return MonitoringIF::INVALID_SIZE; return MonitoringIF::INVALID_SIZE;
} }
@ -26,8 +26,8 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
uint32_t size = 0; size_t size = 0;
result = data->serialize(&dataTarget, &size, maxSize, true); result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }

View File

@ -89,15 +89,15 @@ void CpuUsage::clear() {
threadData.clear(); threadData.clear();
} }
ReturnValue_t CpuUsage::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize( ReturnValue_t result = SerializeAdapter::serialize(
&timeSinceLastReset, buffer, size, max_size, bigEndian); &timeSinceLastReset, buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer, return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
size, max_size, bigEndian); size, maxSize, streamEndianness);
} }
uint32_t CpuUsage::getSerializedSize() const { uint32_t CpuUsage::getSerializedSize() const {
@ -109,37 +109,37 @@ uint32_t CpuUsage::getSerializedSize() const {
return size; return size;
} }
ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize( ReturnValue_t result = SerializeAdapter::deSerialize(
&timeSinceLastReset, buffer, size, bigEndian); &timeSinceLastReset, buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer, return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
size, bigEndian); size, streamEndianness);
} }
ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&id, buffer, ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
size, max_size, bigEndian); size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
if (*size + MAX_LENGTH_OF_THREAD_NAME > max_size) { if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
return BUFFER_TOO_SHORT; return BUFFER_TOO_SHORT;
} }
memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME); memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
*size += MAX_LENGTH_OF_THREAD_NAME; *size += MAX_LENGTH_OF_THREAD_NAME;
*buffer += MAX_LENGTH_OF_THREAD_NAME; *buffer += MAX_LENGTH_OF_THREAD_NAME;
result = SerializeAdapter::serialize(&timeRunning, result = SerializeAdapter::serialize(&timeRunning,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&percentUsage, result = SerializeAdapter::serialize(&percentUsage,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -158,9 +158,9 @@ uint32_t CpuUsage::ThreadData::getSerializedSize() const {
} }
ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer, ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian) { int32_t* size, Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer, ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
size, bigEndian); size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -170,12 +170,12 @@ ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME); memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
*buffer -= MAX_LENGTH_OF_THREAD_NAME; *buffer -= MAX_LENGTH_OF_THREAD_NAME;
result = SerializeAdapter::deSerialize(&timeRunning, result = SerializeAdapter::deSerialize(&timeRunning,
buffer, size, bigEndian); buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&percentUsage, result = SerializeAdapter::deSerialize(&percentUsage,
buffer, size, bigEndian); buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }

View File

@ -18,13 +18,13 @@ public:
float timeRunning; float timeRunning;
float percentUsage; float percentUsage;
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const override;
virtual uint32_t getSerializedSize() const; virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
}; };
CpuUsage(); CpuUsage();
@ -41,13 +41,13 @@ public:
void clear(); void clear();
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const override;
virtual uint32_t getSerializedSize() const; virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
}; };
#endif /* CPUUSAGE_H_ */ #endif /* CPUUSAGE_H_ */

View File

@ -83,7 +83,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id, ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
const ParameterWrapper* description) { const ParameterWrapper* description) {
uint32_t serializedSize = description->getSerializedSize(); size_t serializedSize = description->getSerializedSize();
uint8_t *storeElement; uint8_t *storeElement;
store_address_t address; store_address_t address;
@ -94,10 +94,10 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
return result; return result;
} }
uint32_t storeElementSize = 0; size_t storeElementSize = 0;
result = description->serialize(&storeElement, &storeElementSize, result = description->serialize(&storeElement, &storeElementSize,
serializedSize, true); serializedSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
storage->deleteData(address); storage->deleteData(address);

View File

@ -2,41 +2,41 @@
ParameterWrapper::ParameterWrapper() : ParameterWrapper::ParameterWrapper() :
pointsToStream(false), type(Type::UNKNOWN_TYPE), rows(0), columns(0), data( pointsToStream(false), type(Type::UNKNOWN_TYPE), rows(0), columns(0), data(
NULL), readonlyData(NULL) { NULL), readonlyData(NULL) {
} }
ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns, ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
void* data) : void *data) :
pointsToStream(false), type(type), rows(rows), columns(columns), data( pointsToStream(false), type(type), rows(rows), columns(columns), data(
data), readonlyData(data) { data), readonlyData(data) {
} }
ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns, ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
const void* data) : const void *data) :
pointsToStream(false), type(type), rows(rows), columns(columns), data( pointsToStream(false), type(type), rows(rows), columns(columns), data(
NULL), readonlyData(data) { NULL), readonlyData(data) {
} }
ParameterWrapper::~ParameterWrapper() { ParameterWrapper::~ParameterWrapper() {
} }
ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result; ReturnValue_t result;
result = SerializeAdapter::serialize(&type, buffer, size, max_size, result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&columns, buffer, size, result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
max_size, bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&rows, buffer, size, max_size, result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -47,28 +47,33 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
} }
switch (type) { switch (type) {
case Type::UINT8_T: case Type::UINT8_T:
result = serializeData<uint8_t>(buffer, size, max_size, bigEndian); result = serializeData<uint8_t>(buffer, size, maxSize,
streamEndianness);
break; break;
case Type::INT8_T: case Type::INT8_T:
result = serializeData<int8_t>(buffer, size, max_size, bigEndian); result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
break; break;
case Type::UINT16_T: case Type::UINT16_T:
result = serializeData<uint16_t>(buffer, size, max_size, bigEndian); result = serializeData<uint16_t>(buffer, size, maxSize,
streamEndianness);
break; break;
case Type::INT16_T: case Type::INT16_T:
result = serializeData<int16_t>(buffer, size, max_size, bigEndian); result = serializeData<int16_t>(buffer, size, maxSize,
streamEndianness);
break; break;
case Type::UINT32_T: case Type::UINT32_T:
result = serializeData<uint32_t>(buffer, size, max_size, bigEndian); result = serializeData<uint32_t>(buffer, size, maxSize,
streamEndianness);
break; break;
case Type::INT32_T: case Type::INT32_T:
result = serializeData<int32_t>(buffer, size, max_size, bigEndian); result = serializeData<int32_t>(buffer, size, maxSize,
streamEndianness);
break; break;
case Type::FLOAT: case Type::FLOAT:
result = serializeData<float>(buffer, size, max_size, bigEndian); result = serializeData<float>(buffer, size, maxSize, streamEndianness);
break; break;
case Type::DOUBLE: case Type::DOUBLE:
result = serializeData<double>(buffer, size, max_size, bigEndian); result = serializeData<double>(buffer, size, maxSize, streamEndianness);
break; break;
default: default:
result = UNKNOW_DATATYPE; result = UNKNOW_DATATYPE;
@ -77,7 +82,7 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
return result; return result;
} }
uint32_t ParameterWrapper::getSerializedSize() const { size_t ParameterWrapper::getSerializedSize() const {
uint32_t serializedSize = 0; uint32_t serializedSize = 0;
serializedSize += type.getSerializedSize(); serializedSize += type.getSerializedSize();
serializedSize += sizeof(rows); serializedSize += sizeof(rows);
@ -88,14 +93,14 @@ uint32_t ParameterWrapper::getSerializedSize() const {
} }
template<typename T> template<typename T>
ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, uint32_t* size, ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
const T *element = (const T*) readonlyData; const T *element = (const T*) readonlyData;
ReturnValue_t result; ReturnValue_t result;
uint16_t dataSize = columns * rows; uint16_t dataSize = columns * rows;
while (dataSize != 0) { while (dataSize != 0) {
result = SerializeAdapter::serialize(element, buffer, size, max_size, result = SerializeAdapter::serialize(element, buffer, size, maxSize,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -111,21 +116,21 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
uint8_t fromColumns) { uint8_t fromColumns) {
//treat from as a continuous Stream as we copy all of it //treat from as a continuous Stream as we copy all of it
const uint8_t *fromAsStream = (const uint8_t *) from; const uint8_t *fromAsStream = (const uint8_t*) from;
int32_t streamSize = fromRows * fromColumns * sizeof(T); size_t streamSize = fromRows * fromColumns * sizeof(T);
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) { for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
//get the start element of this row in data //get the start element of this row in data
T *dataWithDataType = ((T *) data) T *dataWithDataType = ((T*) data)
+ (((startingRow + fromRow) * columns) + startingColumn); + (((startingRow + fromRow) * columns) + startingColumn);
for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) { for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
result = SerializeAdapter::deSerialize( result = SerializeAdapter::deSerialize(
dataWithDataType + fromColumn, &fromAsStream, &streamSize, dataWithDataType + fromColumn, &fromAsStream, &streamSize,
true); SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -136,13 +141,14 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
} }
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer, ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
int32_t* size, bool bigEndian) { size_t *size, Endianness streamEndianness) {
return deSerialize(buffer, size, bigEndian, 0); return deSerialize(buffer, size, streamEndianness, 0);
} }
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer, ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
int32_t* size, bool bigEndian, uint16_t startWritingAtIndex) { size_t *size, Endianness streamEndianness,
uint16_t startWritingAtIndex) {
ParameterWrapper streamDescription; ParameterWrapper streamDescription;
ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size); ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@ -153,26 +159,26 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
return copyFrom(&streamDescription, startWritingAtIndex); return copyFrom(&streamDescription, startWritingAtIndex);
} }
ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize, ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
const uint8_t **remainingStream, int32_t *remainingSize) { const uint8_t **remainingStream, size_t *remainingSize) {
ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream, ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
&streamSize, true); &streamSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&columns, &stream, result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
&streamSize, true); SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize, result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
true); SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
int32_t dataSize = type.getSize() * rows * columns; size_t dataSize = type.getSize() * rows * columns;
if (streamSize < dataSize) { if (streamSize < dataSize) {
return SerializeIF::STREAM_TOO_SHORT; return SerializeIF::STREAM_TOO_SHORT;
@ -194,7 +200,7 @@ ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from, ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
uint16_t startWritingAtIndex) { uint16_t startWritingAtIndex) {
if (data == NULL) { if (data == NULL) {
return READONLY; return READONLY;
@ -261,7 +267,7 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
} }
} else { } else {
//need a type to do arithmetic //need a type to do arithmetic
uint8_t *toDataWithType = (uint8_t *) data; uint8_t *toDataWithType = (uint8_t*) data;
for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) { for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
memcpy( memcpy(
toDataWithType toDataWithType

View File

@ -25,16 +25,16 @@ public:
const void *data); const void *data);
virtual ~ParameterWrapper(); virtual ~ParameterWrapper();
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const override;
virtual uint32_t getSerializedSize() const; virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian, uint16_t startWritingAtIndex = 0); Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
template<typename T> template<typename T>
ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const { ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const {
@ -111,8 +111,8 @@ public:
void setMatrix(const T& member) { void setMatrix(const T& member) {
this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0])); this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
} }
ReturnValue_t set(const uint8_t *stream, int32_t streamSize, ReturnValue_t set(const uint8_t *stream, size_t streamSize,
const uint8_t **remainingStream = NULL, int32_t *remainingSize = const uint8_t **remainingStream = NULL, size_t *remainingSize =
NULL); NULL);
ReturnValue_t copyFrom(const ParameterWrapper *from, ReturnValue_t copyFrom(const ParameterWrapper *from,
@ -128,8 +128,8 @@ private:
const void *readonlyData; const void *readonlyData;
template<typename T> template<typename T>
ReturnValue_t serializeData(uint8_t** buffer, uint32_t* size, ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const;
template<typename T> template<typename T>
ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn, ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,

View File

@ -86,12 +86,12 @@ ReturnValue_t Fuse::check() {
return result; return result;
} }
ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = RETURN_FAILED; ReturnValue_t result = RETURN_FAILED;
for (DeviceList::const_iterator iter = devices.begin(); for (DeviceList::const_iterator iter = devices.begin();
iter != devices.end(); iter++) { iter != devices.end(); iter++) {
result = (*iter)->serialize(buffer, size, max_size, bigEndian); result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
@ -99,7 +99,7 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
return RETURN_OK; return RETURN_OK;
} }
uint32_t Fuse::getSerializedSize() const { size_t Fuse::getSerializedSize() const {
uint32_t size = 0; uint32_t size = 0;
for (DeviceList::const_iterator iter = devices.begin(); for (DeviceList::const_iterator iter = devices.begin();
iter != devices.end(); iter++) { iter != devices.end(); iter++) {
@ -108,12 +108,12 @@ uint32_t Fuse::getSerializedSize() const {
return size; return size;
} }
ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = RETURN_FAILED; ReturnValue_t result = RETURN_FAILED;
for (DeviceList::iterator iter = devices.begin(); iter != devices.end(); for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
iter++) { iter++) {
result = (*iter)->deSerialize(buffer, size, bigEndian); result = (*iter)->deSerialize(buffer, size, streamEndianness);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }

View File

@ -11,14 +11,15 @@
#include <framework/parameters/ParameterHelper.h> #include <framework/parameters/ParameterHelper.h>
#include <list> #include <list>
namespace Factory{ namespace Factory {
void setStaticFrameworkObjectIds(); void setStaticFrameworkObjectIds();
} }
class Fuse: public SystemObject, class Fuse: public SystemObject,
public HasHealthIF, public HasHealthIF,
public HasReturnvaluesIF, public HasReturnvaluesIF,
public ReceivesParameterMessagesIF { public ReceivesParameterMessagesIF,
public SerializeIF {
friend void (Factory::setStaticFrameworkObjectIds)(); friend void (Factory::setStaticFrameworkObjectIds)();
private: private:
static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
@ -40,7 +41,7 @@ public:
Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids, Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
float maxCurrent, uint16_t confirmationCount = 2); float maxCurrent, uint16_t confirmationCount = 2);
virtual ~Fuse(); virtual ~Fuse();
void addDevice(PowerComponentIF* set); void addDevice(PowerComponentIF *set);
float getPower(); float getPower();
bool isPowerValid(); bool isPowerValid();
@ -49,11 +50,11 @@ public:
uint8_t getFuseId() const; uint8_t getFuseId() const;
ReturnValue_t initialize(); ReturnValue_t initialize();
DeviceList devices; DeviceList devices;
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
const uint32_t max_size, bool bigEndian) const; SerializeIF::Endianness streamEndianness) const override;
uint32_t getSerializedSize() const; size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
bool bigEndian); SerializeIF::Endianness streamEndianness) override;
void setAllMonitorsToUnchecked(); void setAllMonitorsToUnchecked();
ReturnValue_t performOperation(uint8_t opCode); ReturnValue_t performOperation(uint8_t opCode);
MessageQueueId_t getCommandQueue() const; MessageQueueId_t getCommandQueue() const;
@ -62,13 +63,13 @@ public:
HasHealthIF::HealthState getHealth(); HasHealthIF::HealthState getHealth();
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId, ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper, ParameterWrapper *parameterWrapper,
const ParameterWrapper *newValues, uint16_t startAtIndex); const ParameterWrapper *newValues, uint16_t startAtIndex);
private: private:
uint8_t oldFuseState; uint8_t oldFuseState;
uint8_t fuseId; uint8_t fuseId;
PowerSwitchIF* powerIF; //could be static in our case. PowerSwitchIF *powerIF; //could be static in our case.
AbsLimitMonitor<float> currentLimit; AbsLimitMonitor<float> currentLimit;
class PowerMonitor: public MonitorReporter<float> { class PowerMonitor: public MonitorReporter<float> {
public: public:
@ -88,11 +89,11 @@ private:
PIDReader<float> current; PIDReader<float> current;
PIDReader<uint8_t> state; PIDReader<uint8_t> state;
db_float_t power; db_float_t power;
MessageQueueIF* commandQueue; MessageQueueIF *commandQueue;
ParameterHelper parameterHelper; ParameterHelper parameterHelper;
HealthHelper healthHelper; HealthHelper healthHelper;
static object_id_t powerSwitchId; static object_id_t powerSwitchId;
void calculatePowerLimits(float* low, float* high); void calculatePowerLimits(float *low, float *high);
void calculateFusePower(); void calculateFusePower();
void checkFuseState(); void checkFuseState();
void reportEvents(Event event); void reportEvents(Event event);

View File

@ -17,18 +17,18 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
twoSwitches), min(min), max(max), moduleId(moduleId) { twoSwitches), min(min), max(max), moduleId(moduleId) {
} }
ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&min, buffer, ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
size, max_size, bigEndian); size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return SerializeAdapter::serialize(&max, buffer, size, max_size, return SerializeAdapter::serialize(&max, buffer, size, maxSize,
bigEndian); streamEndianness);
} }
uint32_t PowerComponent::getSerializedSize() const { size_t PowerComponent::getSerializedSize() const {
return sizeof(min) + sizeof(max); return sizeof(min) + sizeof(max);
} }
@ -56,14 +56,14 @@ float PowerComponent::getMax() {
return max; return max;
} }
ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer, ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
size, bigEndian); size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return SerializeAdapter::deSerialize(&max, buffer, size, bigEndian); return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
} }
ReturnValue_t PowerComponent::getParameter(uint8_t domainId, ReturnValue_t PowerComponent::getParameter(uint8_t domainId,

View File

@ -19,13 +19,13 @@ public:
float getMin(); float getMin();
float getMax(); float getMax();
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const override;
uint32_t getSerializedSize() const; size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId, ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper, ParameterWrapper *parameterWrapper,

View File

@ -20,25 +20,25 @@ public:
SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) { SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
} }
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
return serialize(adaptee, buffer, size, max_size, bigEndian); return serialize(adaptee, buffer, size, maxSize, streamEndianness);
} }
static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size, static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) { size_t maxSize, Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::serialize(&list->size, ReturnValue_t result = SerializeAdapter::serialize(&list->size,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
count_t i = 0; count_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
result = SerializeAdapter::serialize(&list->entries[i], buffer, size, result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
++i; ++i;
} }
return result; return result;
} }
virtual uint32_t getSerializedSize() const { virtual size_t getSerializedSize() const {
return getSerializedSize(adaptee); return getSerializedSize(adaptee);
} }
@ -53,16 +53,16 @@ public:
return printSize; return printSize;
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
return deSerialize(adaptee, buffer, size, bigEndian); return deSerialize(adaptee, buffer, size, streamEndianness);
} }
static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size, static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
count_t tempSize = 0; count_t tempSize = 0;
ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize, ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
buffer, size, bigEndian); buffer, size, streamEndianness);
if (tempSize > list->maxSize()) { if (tempSize > list->maxSize()) {
return SerializeIF::TOO_MANY_ELEMENTS; return SerializeIF::TOO_MANY_ELEMENTS;
} }
@ -71,7 +71,7 @@ public:
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
result = SerializeAdapter::deSerialize( result = SerializeAdapter::deSerialize(
&list->front()[i], buffer, size, &list->front()[i], buffer, size,
bigEndian); streamEndianness);
++i; ++i;
} }
return result; return result;

View File

@ -22,19 +22,19 @@ SerialBufferAdapter<T>::~SerialBufferAdapter() {
} }
template<typename T> template<typename T>
ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
uint32_t serializedLength = bufferLength; uint32_t serializedLength = bufferLength;
if (serializeLength) { if (serializeLength) {
serializedLength += SerializeAdapter::getSerializedSize( serializedLength += SerializeAdapter::getSerializedSize(
&bufferLength); &bufferLength);
} }
if (*size + serializedLength > max_size) { if (*size + serializedLength > maxSize) {
return BUFFER_TOO_SHORT; return BUFFER_TOO_SHORT;
} else { } else {
if (serializeLength) { if (serializeLength) {
SerializeAdapter::serialize(&bufferLength, buffer, size, SerializeAdapter::serialize(&bufferLength, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
} }
if (this->constBuffer != NULL) { if (this->constBuffer != NULL) {
memcpy(*buffer, this->constBuffer, bufferLength); memcpy(*buffer, this->constBuffer, bufferLength);
@ -50,7 +50,7 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
} }
template<typename T> template<typename T>
uint32_t SerialBufferAdapter<T>::getSerializedSize() const { size_t SerialBufferAdapter<T>::getSerializedSize() const {
if (serializeLength) { if (serializeLength) {
return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength); return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
} else { } else {
@ -59,7 +59,7 @@ uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
} }
template<typename T> template<typename T>
ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer, ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian) { size_t* size, Endianness streamEndianness) {
//TODO Ignores Endian flag! //TODO Ignores Endian flag!
if (buffer != NULL) { if (buffer != NULL) {
if(serializeLength){ if(serializeLength){

View File

@ -16,13 +16,13 @@ public:
virtual ~SerialBufferAdapter(); virtual ~SerialBufferAdapter();
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const override;
virtual uint32_t getSerializedSize() const; virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
private: private:
bool serializeLength; bool serializeLength;
const uint8_t *constBuffer; const uint8_t *constBuffer;

View File

@ -13,16 +13,16 @@ public:
template<typename... Args> template<typename... Args>
SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) { SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
} }
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, max_size, bigEndian); return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, maxSize, streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
return SerialArrayListAdapter<T, count_t>::getSerializedSize(this); return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
} }
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, bigEndian); return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, streamEndianness);
} }
}; };

View File

@ -26,7 +26,7 @@ public:
streamEndianness); streamEndianness);
} }
uint32_t getSerializedSize() const override { size_t getSerializedSize() const override {
return SerializeAdapter::getSerializedSize(&entry); return SerializeAdapter::getSerializedSize(&entry);
} }

View File

@ -28,7 +28,7 @@ public:
} }
virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
size_t max_size, Endianness streamEndianness) const = 0; size_t maxSize, Endianness streamEndianness) const = 0;
virtual size_t getSerializedSize() const = 0; virtual size_t getSerializedSize() const = 0;

View File

@ -13,7 +13,7 @@ Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
false), uptimeStartTable(0), currentTargetTable(), targetMode( false), uptimeStartTable(0), currentTargetTable(), targetMode(
0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables( 0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore( maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
NULL) NULL)
#ifdef USE_MODESTORE #ifdef USE_MODESTORE
,modeStore(NULL) ,modeStore(NULL)
#endif #endif
@ -75,7 +75,8 @@ void Subsystem::performChildOperation() {
if (isInTransition) { if (isInTransition) {
if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
if (currentSequenceIterator.value == NULL) { //we're through with this sequence if (currentSequenceIterator.value == NULL) { //we're through with this sequence
if (checkStateAgainstTable(currentTargetTable, targetSubmode) == RETURN_OK) { if (checkStateAgainstTable(currentTargetTable, targetSubmode)
== RETURN_OK) {
setMode(targetMode, targetSubmode); setMode(targetMode, targetSubmode);
isInTransition = false; isInTransition = false;
return; return;
@ -86,7 +87,8 @@ void Subsystem::performChildOperation() {
} }
} }
if (currentSequenceIterator->checkSuccess()) { if (currentSequenceIterator->checkSuccess()) {
if (checkStateAgainstTable(getCurrentTable(), targetSubmode) != RETURN_OK) { if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
!= RETURN_OK) {
transitionFailed(TABLE_CHECK_FAILED, transitionFailed(TABLE_CHECK_FAILED,
currentSequenceIterator->getTableId()); currentSequenceIterator->getTableId());
return; return;
@ -117,7 +119,8 @@ void Subsystem::performChildOperation() {
childrenChangedHealth = false; childrenChangedHealth = false;
startTransition(mode, submode); startTransition(mode, submode);
} else if (childrenChangedMode) { } else if (childrenChangedMode) {
if (checkStateAgainstTable(currentTargetTable, submode) != RETURN_OK) { if (checkStateAgainstTable(currentTargetTable, submode)
!= RETURN_OK) {
triggerEvent(CANT_KEEP_MODE, mode, submode); triggerEvent(CANT_KEEP_MODE, mode, submode);
cantKeepMode(); cantKeepMode();
} }
@ -147,7 +150,7 @@ HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
} }
} }
ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) { ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
ReturnValue_t result; ReturnValue_t result;
switch (message->getCommand()) { switch (message->getCommand()) {
case HealthMessage::HEALTH_INFO: { case HealthMessage::HEALTH_INFO: {
@ -168,12 +171,13 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
&sizeRead); &sizeRead);
if (result == RETURN_OK) { if (result == RETURN_OK) {
Mode_t fallbackId; Mode_t fallbackId;
int32_t size = sizeRead; size_t size = sizeRead;
result = SerializeAdapter::deSerialize(&fallbackId, result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
&pointer, &size, true); SerializeIF::Endianness::BIG);
if (result == RETURN_OK) { if (result == RETURN_OK) {
result = SerialArrayListAdapter<ModeListEntry>::deSerialize( result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
&sequence, &pointer, &size, true); &sequence, &pointer, &size,
SerializeIF::Endianness::BIG);
if (result == RETURN_OK) { if (result == RETURN_OK) {
result = addSequence(&sequence, result = addSequence(&sequence,
ModeSequenceMessage::getSequenceId(message), ModeSequenceMessage::getSequenceId(message),
@ -193,9 +197,9 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
ModeSequenceMessage::getStoreAddress(message), &pointer, ModeSequenceMessage::getStoreAddress(message), &pointer,
&sizeRead); &sizeRead);
if (result == RETURN_OK) { if (result == RETURN_OK) {
int32_t size = sizeRead; size_t size = sizeRead;
result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table, result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
&pointer, &size, true); &pointer, &size, SerializeIF::Endianness::BIG);
if (result == RETURN_OK) { if (result == RETURN_OK) {
result = addTable(&table, result = addTable(&table,
ModeSequenceMessage::getSequenceId(message)); ModeSequenceMessage::getSequenceId(message));
@ -339,7 +343,7 @@ void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
} }
} }
ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry>* sequence, ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) { Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
ReturnValue_t result; ReturnValue_t result;
@ -507,7 +511,7 @@ MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
} }
ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode, ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
uint32_t* msToReachTheMode) { uint32_t *msToReachTheMode) {
//Need to accept all submodes to be able to inherit submodes //Need to accept all submodes to be able to inherit submodes
// if (submode != SUBMODE_NONE) { // if (submode != SUBMODE_NONE) {
// return INVALID_SUBMODE; // return INVALID_SUBMODE;
@ -599,15 +603,15 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
} }
void Subsystem::sendSerializablesAsCommandMessage(Command_t command, void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
SerializeIF** elements, uint8_t count) { SerializeIF **elements, uint8_t count) {
ReturnValue_t result; ReturnValue_t result;
uint32_t maxSize = 0; size_t maxSize = 0;
for (uint8_t i = 0; i < count; i++) { for (uint8_t i = 0; i < count; i++) {
maxSize += elements[i]->getSerializedSize(); maxSize += elements[i]->getSerializedSize();
} }
uint8_t *storeBuffer; uint8_t *storeBuffer;
store_address_t address; store_address_t address;
uint32_t size = 0; size_t size = 0;
result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer); result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
@ -615,7 +619,8 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
return; return;
} }
for (uint8_t i = 0; i < count; i++) { for (uint8_t i = 0; i < count; i++) {
elements[i]->serialize(&storeBuffer, &size, maxSize, true); elements[i]->serialize(&storeBuffer, &size, maxSize,
SerializeIF::Endianness::BIG);
} }
CommandMessage reply; CommandMessage reply;
ModeSequenceMessage::setModeSequenceMessage(&reply, command, address); ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);

View File

@ -18,65 +18,65 @@ public:
uint8_t value3; uint8_t value3;
uint8_t value4; uint8_t value4;
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result; ReturnValue_t result;
result = SerializeAdapter::serialize(&value1, buffer, size, result = SerializeAdapter::serialize(&value1, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&value2, buffer, size, result = SerializeAdapter::serialize(&value2, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&value3, buffer, size, result = SerializeAdapter::serialize(&value3, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::serialize(&value4, buffer, size, result = SerializeAdapter::serialize(&value4, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
return result; return result;
} }
virtual uint32_t getSerializedSize() const { virtual size_t getSerializedSize() const {
return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4); return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result; ReturnValue_t result;
result = SerializeAdapter::deSerialize(&value1, buffer, size, result = SerializeAdapter::deSerialize(&value1, buffer, size,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&value2, buffer, size, result = SerializeAdapter::deSerialize(&value2, buffer, size,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&value3, buffer, size, result = SerializeAdapter::deSerialize(&value3, buffer, size,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&value4, buffer, size, result = SerializeAdapter::deSerialize(&value4, buffer, size,
bigEndian); streamEndianness);
return result; return result;
} }

View File

@ -46,15 +46,15 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
if (size != 4 * sizeof(parameters.lowerOpLimit)) { if (size != 4 * sizeof(parameters.lowerOpLimit)) {
return MonitoringIF::INVALID_SIZE; return MonitoringIF::INVALID_SIZE;
} }
int32_t readSize = size; size_t readSize = size;
SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data, SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data,
&readSize, true); &readSize, SerializeIF::Endianness::BIG);
SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data, SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data,
&readSize, true); &readSize, SerializeIF::Endianness::BIG);
SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data, SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data,
&readSize, true); &readSize, SerializeIF::Endianness::BIG);
SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data, SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data,
&readSize, true); &readSize, SerializeIF::Endianness::BIG);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }

View File

@ -32,31 +32,31 @@ public:
} }
uint16_t apid; uint16_t apid;
uint16_t ssc; uint16_t ssc;
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&apid, ReturnValue_t result = SerializeAdapter::serialize(&apid,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return SerializeAdapter::serialize(&ssc, buffer, size, return SerializeAdapter::serialize(&ssc, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
return sizeof(apid) + sizeof(ssc); return sizeof(apid) + sizeof(ssc);
} }
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&apid, ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
buffer, size, bigEndian); buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return SerializeAdapter::deSerialize(&ssc, buffer, size, return SerializeAdapter::deSerialize(&ssc, buffer, size,
bigEndian); streamEndianness);
} }
}; };
@ -218,33 +218,33 @@ public:
} }
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian); ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){ if(result!=HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){ if(result!=HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = SerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){ if(result!=HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){ if(result!=HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = SerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){ if(result!=HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp)); SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
return adapter.serialize(buffer,size,max_size,bigEndian); return adapter.serialize(buffer,size,maxSize,streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
uint32_t size = 0; uint32_t size = 0;
size += SerializeAdapter::getSerializedSize(&apid); size += SerializeAdapter::getSerializedSize(&apid);
size += SerializeAdapter::getSerializedSize(&sourceSequenceCount); size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
@ -257,35 +257,35 @@ public:
}; };
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer, ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
size, bigEndian); size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer, result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
size, bigEndian); size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&serviceType, buffer, size, result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&serviceSubtype, buffer, result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
size, bigEndian); size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = SerializeAdapter::deSerialize(&subCounter, buffer, size, result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp)); SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
return adapter.deSerialize(buffer,size,bigEndian); return adapter.deSerialize(buffer,size,streamEndianness);
} }
private: private:

View File

@ -22,16 +22,16 @@ public:
return false; return false;
} }
} }
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
return SerializeAdapter::serialize(&apid, buffer, size, max_size, bigEndian); return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
return SerializeAdapter::getSerializedSize(&apid); return SerializeAdapter::getSerializedSize(&apid);
} }
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
return SerializeAdapter::deSerialize(&apid, buffer, size, bigEndian); return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
} }
}; };

View File

@ -22,16 +22,16 @@ public:
return false; return false;
} }
} }
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
return SerializeAdapter::serialize(&service, buffer, size, max_size, bigEndian); return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
return SerializeAdapter::getSerializedSize(&service); return SerializeAdapter::getSerializedSize(&service);
} }
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
return SerializeAdapter::deSerialize(&service, buffer, size, bigEndian); return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
} }
}; };

View File

@ -20,16 +20,16 @@ public:
return false; return false;
} }
} }
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
return SerializeAdapter::serialize(&subService, buffer, size, max_size, bigEndian); return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
return SerializeAdapter::getSerializedSize(&subService); return SerializeAdapter::getSerializedSize(&subService);
} }
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
return SerializeAdapter::deSerialize(&subService, buffer, size, bigEndian); return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
} }
private: private:
uint8_t subService; uint8_t subService;

View File

@ -10,14 +10,14 @@ TmPacketStored::TmPacketStored(store_address_t setAddress) :
} }
TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service, TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
uint8_t subservice, uint8_t packetSubcounter, const uint8_t* data, uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
uint32_t size, const uint8_t* headerData, uint32_t headerSize) : uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
TmPacketBase(NULL) { TmPacketBase(NULL) {
storeAddress.raw = StorageManagerIF::INVALID_ADDRESS; storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
if (!checkAndSetStore()) { if (!checkAndSetStore()) {
return; return;
} }
uint8_t* pData = NULL; uint8_t *pData = NULL;
ReturnValue_t returnValue = store->getFreeElement(&storeAddress, ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData); (TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
@ -34,21 +34,21 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
} }
TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service, TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
uint8_t subservice, uint8_t packetSubcounter, SerializeIF* content, uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
SerializeIF* header) : SerializeIF *header) :
TmPacketBase(NULL) { TmPacketBase(NULL) {
storeAddress.raw = StorageManagerIF::INVALID_ADDRESS; storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
if (!checkAndSetStore()) { if (!checkAndSetStore()) {
return; return;
} }
uint32_t sourceDataSize = 0; size_t sourceDataSize = 0;
if (content != NULL) { if (content != NULL) {
sourceDataSize += content->getSerializedSize(); sourceDataSize += content->getSerializedSize();
} }
if (header != NULL) { if (header != NULL) {
sourceDataSize += header->getSerializedSize(); sourceDataSize += header->getSerializedSize();
} }
uint8_t* p_data = NULL; uint8_t *p_data = NULL;
ReturnValue_t returnValue = store->getFreeElement(&storeAddress, ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data); (TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
if (returnValue != store->RETURN_OK) { if (returnValue != store->RETURN_OK) {
@ -56,13 +56,15 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
} }
setData(p_data); setData(p_data);
initializeTmPacket(apid, service, subservice, packetSubcounter); initializeTmPacket(apid, service, subservice, packetSubcounter);
uint8_t* putDataHere = getSourceData(); uint8_t *putDataHere = getSourceData();
uint32_t size = 0; size_t size = 0;
if (header != NULL) { if (header != NULL) {
header->serialize(&putDataHere, &size, sourceDataSize, true); header->serialize(&putDataHere, &size, sourceDataSize,
SerializeIF::Endianness::BIG);
} }
if (content != NULL) { if (content != NULL) {
content->serialize(&putDataHere, &size, sourceDataSize, true); content->serialize(&putDataHere, &size, sourceDataSize,
SerializeIF::Endianness::BIG);
} }
setPacketDataLength( setPacketDataLength(
sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1); sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
@ -80,7 +82,7 @@ void TmPacketStored::deletePacket() {
void TmPacketStored::setStoreAddress(store_address_t setAddress) { void TmPacketStored::setStoreAddress(store_address_t setAddress) {
storeAddress = setAddress; storeAddress = setAddress;
const uint8_t* temp_data = NULL; const uint8_t *temp_data = NULL;
uint32_t temp_size; uint32_t temp_size;
if (!checkAndSetStore()) { if (!checkAndSetStore()) {
return; return;
@ -106,8 +108,8 @@ bool TmPacketStored::checkAndSetStore() {
return true; return true;
} }
StorageManagerIF* TmPacketStored::store = NULL; StorageManagerIF *TmPacketStored::store = NULL;
InternalErrorReporterIF* TmPacketStored::internalErrorReporter = NULL; InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination, ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
MessageQueueId_t sentFrom, bool doErrorReporting) { MessageQueueId_t sentFrom, bool doErrorReporting) {
@ -116,7 +118,8 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
TmTcMessage tmMessage(getStoreAddress()); TmTcMessage tmMessage(getStoreAddress());
ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination, &tmMessage, sentFrom); ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
&tmMessage, sentFrom);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
deletePacket(); deletePacket();
if (doErrorReporting) { if (doErrorReporting) {

View File

@ -235,9 +235,9 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
object_id_t objectId, const uint8_t *data, uint32_t dataLen) { object_id_t objectId, const uint8_t *data, uint32_t dataLen) {
uint8_t buffer[sizeof(object_id_t)]; uint8_t buffer[sizeof(object_id_t)];
uint8_t* pBuffer = buffer; uint8_t* pBuffer = buffer;
uint32_t size = 0; size_t size = 0;
SerializeAdapter::serialize(&objectId, &pBuffer, &size, SerializeAdapter::serialize(&objectId, &pBuffer, &size,
sizeof(object_id_t), true); sizeof(object_id_t), SerializeIF::Endianness::BIG);
TmPacketStored tmPacketStored(this->apid, this->service, subservice, TmPacketStored tmPacketStored(this->apid, this->service, subservice,
this->tmPacketCounter, data, dataLen, buffer, size); this->tmPacketCounter, data, dataLen, buffer, size);
ReturnValue_t result = tmPacketStored.sendPacket( ReturnValue_t result = tmPacketStored.sendPacket(

View File

@ -33,7 +33,7 @@ PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl, uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1, ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
uint32_t parameter2) { uint32_t parameter2) {
uint8_t* data = this->getBuffer(); uint8_t *data = this->getBuffer();
data[messageSize] = set_report_id; data[messageSize] = set_report_id;
messageSize += sizeof(set_report_id); messageSize += sizeof(set_report_id);
data[messageSize] = ackFlags; data[messageSize] = ackFlags;
@ -109,12 +109,12 @@ PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
reportSize(0), pBuffer(reportBuffer) { reportSize(0), pBuffer(reportBuffer) {
//Serialization won't fail, because we know the necessary max-size of the buffer. //Serialization won't fail, because we know the necessary max-size of the buffer.
SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize, SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
sizeof(reportBuffer), true); sizeof(reportBuffer), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize(&setSequenceControl, &pBuffer, SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
&reportSize, sizeof(reportBuffer), true); sizeof(reportBuffer), SerializeIF::Endianness::BIG);
if (setStep != 0) { if (setStep != 0) {
SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize, SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
sizeof(reportBuffer), true); sizeof(reportBuffer), SerializeIF::Endianness::BIG);
} }
} }
@ -136,25 +136,25 @@ PusFailureReport::PusFailureReport(uint16_t setPacketId,
reportSize(0), pBuffer(reportBuffer) { reportSize(0), pBuffer(reportBuffer) {
//Serialization won't fail, because we know the necessary max-size of the buffer. //Serialization won't fail, because we know the necessary max-size of the buffer.
SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize, SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
sizeof(reportBuffer), true); sizeof(reportBuffer), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize(&setSequenceControl, &pBuffer, SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
&reportSize, sizeof(reportBuffer), true); sizeof(reportBuffer), SerializeIF::Endianness::BIG);
if (setStep != 0) { if (setStep != 0) {
SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize, SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
sizeof(reportBuffer), true); sizeof(reportBuffer), SerializeIF::Endianness::BIG);
} }
SerializeAdapter::serialize(&setErrorCode, &pBuffer, SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
&reportSize, sizeof(reportBuffer), true); sizeof(reportBuffer), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize, SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
sizeof(reportBuffer), true); sizeof(reportBuffer), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize, SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
sizeof(reportBuffer), true); sizeof(reportBuffer), SerializeIF::Endianness::BIG);
} }
PusFailureReport::~PusFailureReport() { PusFailureReport::~PusFailureReport() {
} }
uint32_t PusFailureReport::getSize() { size_t PusFailureReport::getSize() {
return reportSize; return reportSize;
} }

View File

@ -49,7 +49,7 @@ class PusSuccessReport {
private: private:
static const uint16_t MAX_SIZE = 7; static const uint16_t MAX_SIZE = 7;
uint8_t reportBuffer[MAX_SIZE]; uint8_t reportBuffer[MAX_SIZE];
uint32_t reportSize; size_t reportSize;
uint8_t * pBuffer; uint8_t * pBuffer;
public: public:
PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl, PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
@ -63,14 +63,14 @@ class PusFailureReport {
private: private:
static const uint16_t MAX_SIZE = 16; static const uint16_t MAX_SIZE = 16;
uint8_t reportBuffer[MAX_SIZE]; uint8_t reportBuffer[MAX_SIZE];
uint32_t reportSize; size_t reportSize;
uint8_t * pBuffer; uint8_t * pBuffer;
public: public:
PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl, PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
ReturnValue_t setErrorCode, uint8_t setStep = 0, ReturnValue_t setErrorCode, uint8_t setStep = 0,
uint32_t parameter1 = 0, uint32_t parameter2 = 0); uint32_t parameter1 = 0, uint32_t parameter2 = 0);
~PusFailureReport(); ~PusFailureReport();
uint32_t getSize(); size_t getSize();
uint8_t* getReport(); uint8_t* getReport();
}; };