internal housekeeping packet finished

datapoollocal/LocalPoolDataSetBase.cpp

@@ -72,6 +72,36 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
     return result;
 }
 
+ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
+        const uint8_t **buffer, size_t *size,
+        SerializeIF::Endianness streamEndianness) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        result = registeredVariables[count]->deSerialize(buffer, size,
+                        streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    // could be made more efficient but make it work first
+    for (uint16_t count = 0; count < fillCount; count++) {
+        // set validity buffer here.
+        bool nextVarValid = this->bitGetter(*buffer +
+                validBufferIndex, validBufferIndexBit);
+        registeredVariables[count]->setValid(nextVarValid);
+
+        if(validBufferIndexBit == 7) {
+            validBufferIndex ++;
+            validBufferIndexBit = 0;
+        }
+        else {
+            validBufferIndexBit ++;
+        }
+    }
+    return result;
+}
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->unlockMutex();
@@ -102,6 +132,55 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     *byte |= 1 << shiftNumber;
 }
 
+size_t LocalPoolDataSetBase::getSerializedSize() const {
+    if(withValidityBuffer) {
+        uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+        return validityMaskSize + PoolDataSetBase::getSerializedSize();
+    }
+    else {
+        return PoolDataSetBase::getSerializedSize();
+    }
+}
+
+void LocalPoolDataSetBase::setValidityBufferGeneration(
+        bool withValidityBuffer) {
+    this->withValidityBuffer = withValidityBuffer;
+}
+
+ReturnValue_t LocalPoolDataSetBase::deSerialize(const uint8_t **buffer,
+        size_t *size, SerializeIF::Endianness streamEndianness) {
+    if(withValidityBuffer) {
+        return this->deSerializeWithValidityBuffer(buffer, size,
+                streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
+    }
+}
+
+ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
+        size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+    if(withValidityBuffer) {
+        return this->serializeWithValidityBuffer(buffer, size,
+                maxSize, streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::serialize(buffer, size, maxSize,
+                streamEndianness);
+    }
+}
+
+bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte, uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        return false;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    return *byte & (1 << shiftNumber);
+}
+
 bool LocalPoolDataSetBase::isValid() const {
     return this->valid;
 }
+
+