store helper

src/fsfw/serialize/SerializeIF.h

@@ -64,7 +64,7 @@ class SerializeIF {
   /**
    * Forwards to regular @serialize call with network endianness
    */
-  virtual ReturnValue_t serializeNe(uint8_t** buffer, size_t* size, size_t maxSize) {
+  virtual ReturnValue_t serializeNe(uint8_t **buffer, size_t *size, size_t maxSize) {
     return serialize(buffer, size, maxSize, SerializeIF::Endianness::NETWORK);
   }
   /**
@@ -105,13 +105,13 @@ class SerializeIF {
   /**
    * Forwards to regular @deSerialize call with network endianness
    */
-  virtual ReturnValue_t deSerializeNe(const uint8_t** buffer, size_t* size) {
+  virtual ReturnValue_t deSerializeNe(const uint8_t **buffer, size_t *size) {
     return deSerialize(buffer, size, SerializeIF::Endianness::NETWORK);
   }
   /**
    * If endianness is not explicitly specified, use machine endianness
    */
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size) {
+  virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size) {
     return deSerialize(buffer, size, SerializeIF::Endianness::MACHINE);
   }
 

src/fsfw/tmtcpacket/ccsds/PacketSeqCtrl.h

@@ -12,6 +12,10 @@ struct PacketSeqCtrl : public SerializeIF {
   PacketSeqCtrl(ccsds::SequenceFlags seqFlags, uint16_t seqCount)
       : seqFlags(seqFlags), seqCount(seqCount) {}
 
+  bool operator==(const PacketSeqCtrl &other) const {
+    return seqCount == other.seqCount and seqFlags == other.seqFlags;
+  }
+
   /**
    * NOTE: If the sequence control has an invalid value, the invalid bits will be cut off
    * @return

src/fsfw/tmtcpacket/ccsds/SpacePacketCreator.cpp

@@ -81,3 +81,5 @@ void SpacePacketCreator::setPacketType(ccsds::PacketType type) {
   params.packetId.packetType = type;
 }
 bool SpacePacketCreator::operator==(const SpacePacketCreator &other) const { return false; }
+
+SpacePacketCreator::operator bool() const { return isValid(); }

src/fsfw/tmtcpacket/ccsds/SpacePacketCreator.h

@@ -26,6 +26,7 @@ class SpacePacketCreator : public SpacePacketIF, public SerializeIF {
   explicit SpacePacketCreator(SpacePacketParams params);
 
   bool operator==(const SpacePacketCreator &other) const;
+  explicit operator bool() const;
 
   SpacePacketCreator(ccsds::PacketType packetType, bool secHeaderFlag, uint16_t apid,
                      ccsds::SequenceFlags seqFlags, uint16_t seqCount, uint16_t dataLen,

src/fsfw/tmtcservices/TmStoreHelper.cpp

@@ -14,13 +14,10 @@ TmStoreHelper::TmStoreHelper(uint16_t defaultApid, StorageManagerIF* tmStore) :
 }
 
 ReturnValue_t TmStoreHelper::preparePacket(uint8_t service, uint8_t subservice, uint16_t counter) {
-  // TODO: Implement
-  // creator.setApid(apid);
   PusTmParams& params = creator.getParams();
   params.secHeader.service = service;
   params.secHeader.subservice = subservice;
   params.secHeader.messageTypeCounter = counter;
-  // TODO: Implement serialize and then serialize into the store
   return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -31,22 +28,21 @@ const store_address_t& TmStoreHelper::getCurrentAddr() const { return currentAdd
 ReturnValue_t TmStoreHelper::deletePacket() { return tmStore->deleteData(currentAddr); }
 
 void TmStoreHelper::setSourceDataRaw(const uint8_t* data, size_t len) {
-  PusTmParams& params = creator.getParams();
-  params.dataWrapper.type = ecss::DataTypes::RAW;
-  params.dataWrapper.dataUnion.raw.data = data;
-  params.dataWrapper.dataUnion.raw.len = len;
+  creator.setRawUserData(data, len);
 }
 
 void TmStoreHelper::setSourceDataSerializable(SerializeIF* serializable) {
-  PusTmParams& params = creator.getParams();
-  params.dataWrapper.type = ecss::DataTypes::SERIALIZABLE;
-  params.dataWrapper.dataUnion.serializable = serializable;
+  creator.setSerializableUserData(serializable);
 }
 
 ReturnValue_t TmStoreHelper::addPacketToStore() {
   creator.updateSpLengthField();
   uint8_t* dataPtr;
-  tmStore->getFreeElement(&currentAddr, creator.getSerializedSize(), &dataPtr);
+  ReturnValue_t result =
+      tmStore->getFreeElement(&currentAddr, creator.getSerializedSize(), &dataPtr);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
   size_t serLen = 0;
   return creator.serialize(&dataPtr, &serLen, creator.getSerializedSize(),
                            SerializeIF::Endianness::NETWORK);
@@ -55,4 +51,5 @@ ReturnValue_t TmStoreHelper::addPacketToStore() {
 void TmStoreHelper::setTimeStamper(TimeStamperIF* timeStamper_) {
   creator.setTimeStamper(timeStamper_);
 }
+
 void TmStoreHelper::setApid(uint16_t apid) { creator.setApid(apid); }