all retval replacements

linux/devices/ploc/PlocSupvHelper.cpp

@@ -30,14 +30,14 @@ ReturnValue_t PlocSupvHelper::initialize() {
   sdcMan = SdCardManager::instance();
   if (sdcMan == nullptr) {
     sif::warning << "PlocSupvHelper::initialize: Invalid SD Card Manager" << std::endl;
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 #endif
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   semaphore.acquire();
   while (true) {
     switch (internalState) {
@@ -47,7 +47,7 @@ ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
       }
       case InternalState::UPDATE: {
         result = executeUpdate();
-        if (result == RETURN_OK) {
+        if (result == returnvalue::OK) {
           triggerEvent(SUPV_UPDATE_SUCCESSFUL, result);
         } else if (result == PROCESS_TERMINATED) {
           // Event already triggered
@@ -64,7 +64,7 @@ ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
       }
       case InternalState::CONTINUE_UPDATE: {
         result = continueUpdate();
-        if (result == RETURN_OK) {
+        if (result == returnvalue::OK) {
           triggerEvent(SUPV_CONTINUE_UPDATE_SUCCESSFUL, result);
         } else if (result == PROCESS_TERMINATED) {
           // Event already triggered
@@ -76,7 +76,7 @@ ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
       }
       case InternalState::REQUEST_EVENT_BUFFER: {
         result = performEventBufferRequest();
-        if (result == RETURN_OK) {
+        if (result == returnvalue::OK) {
           triggerEvent(SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL, result);
         } else if (result == PROCESS_TERMINATED) {
           // Event already triggered
@@ -97,10 +97,10 @@ ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
 ReturnValue_t PlocSupvHelper::setComIF(UartComIF* uartComIF_) {
   if (uartComIF_ == nullptr) {
     sif::warning << "PlocSupvHelper::initialize: Provided invalid uart com if" << std::endl;
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   uartComIF = uartComIF_;
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 void PlocSupvHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
@@ -118,16 +118,16 @@ ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId,
 }
 
 ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
 #ifdef XIPHOS_Q7S
   result = FilesystemHelper::checkPath(params.file);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     sif::warning << "PlocSupvHelper::startUpdate: File " << params.file << " does not exist"
                  << std::endl;
     return result;
   }
   result = FilesystemHelper::fileExists(params.file);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     sif::warning << "PlocSupvHelper::startUpdate: The file " << params.file << " does not exist"
                  << std::endl;
     return result;
@@ -137,7 +137,7 @@ ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) {
   if (not std::filesystem::exists(file)) {
     sif::warning << "PlocSupvHelper::startUpdate: The file " << file << " does not exist"
                  << std::endl;
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 #endif
   update.file = params.file;
@@ -145,7 +145,7 @@ ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) {
   if (params.bytesWritten > update.fullFileSize) {
     sif::warning << "Invalid start bytes counter " << params.bytesWritten
                  << ", smaller than full file length" << update.fullFileSize << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   update.length = update.fullFileSize - params.bytesWritten;
   update.memoryId = params.memId;
@@ -178,7 +178,7 @@ ReturnValue_t PlocSupvHelper::performMemCheck(uint8_t memoryId, uint32_t startAd
   internalState = InternalState::CHECK_MEMORY;
   uartComIF->flushUartTxAndRxBuf(comCookie);
   semaphore.release();
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 void PlocSupvHelper::initiateUpdateContinuation() {
@@ -189,7 +189,7 @@ void PlocSupvHelper::initiateUpdateContinuation() {
 ReturnValue_t PlocSupvHelper::startEventbBufferRequest(std::string path) {
 #ifdef XIPHOS_Q7S
   ReturnValue_t result = FilesystemHelper::checkPath(path);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 #endif
@@ -200,7 +200,7 @@ ReturnValue_t PlocSupvHelper::startEventbBufferRequest(std::string path) {
   internalState = InternalState::REQUEST_EVENT_BUFFER;
   uartComIF->flushUartTxAndRxBuf(comCookie);
   semaphore.release();
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 void PlocSupvHelper::stopProcess() { terminate = true; }
@@ -210,26 +210,26 @@ void PlocSupvHelper::executeFullCheckMemoryCommand() {
   if (update.crcShouldBeChecked) {
     sif::info << "PLOC SUPV Mem Check: Calculating Image CRC" << std::endl;
     result = calcImageCrc();
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       triggerEvent(SUPV_MEM_CHECK_FAIL, result);
       return;
     }
   }
   sif::info << "PLOC SUPV Mem Check: Selecting Memory" << std::endl;
   result = selectMemory();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     triggerEvent(SUPV_MEM_CHECK_FAIL, result);
     return;
   }
   sif::info << "PLOC SUPV Mem Check: Preparing Update" << std::endl;
   result = prepareUpdate();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     triggerEvent(SUPV_MEM_CHECK_FAIL, result);
     return;
   }
   sif::info << "PLOC SUPV Mem Check: Memory Check" << std::endl;
   result = handleCheckMemoryCommand();
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
     triggerEvent(SUPV_MEM_CHECK_OK, result);
   } else {
     triggerEvent(SUPV_MEM_CHECK_FAIL, result);
@@ -237,26 +237,26 @@ void PlocSupvHelper::executeFullCheckMemoryCommand() {
 }
 
 ReturnValue_t PlocSupvHelper::executeUpdate() {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   sif::info << "PLOC SUPV Update MPSoC: Calculating Image CRC" << std::endl;
   result = calcImageCrc();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   sif::info << "PLOC SUPV Update MPSoC: Selecting Memory" << std::endl;
   result = selectMemory();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   sif::info << "PLOC SUPV Update MPSoC: Preparing Update" << std::endl;
   result = prepareUpdate();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (update.deleteMemory) {
     sif::info << "PLOC SUPV Update MPSoC: Erasing Memory" << std::endl;
     result = eraseMemory();
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
   }
@@ -265,7 +265,7 @@ ReturnValue_t PlocSupvHelper::executeUpdate() {
 
 ReturnValue_t PlocSupvHelper::continueUpdate() {
   ReturnValue_t result = prepareUpdate();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   return updateOperation();
@@ -274,7 +274,7 @@ ReturnValue_t PlocSupvHelper::continueUpdate() {
 ReturnValue_t PlocSupvHelper::updateOperation() {
   sif::info << "PlocSupvHelper::performUpdate: Writing Update Packets" << std::endl;
   auto result = writeUpdatePackets();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   sif::info << "PlocSupvHelper::performUpdate: Memory Check" << std::endl;
@@ -282,7 +282,7 @@ ReturnValue_t PlocSupvHelper::updateOperation() {
 }
 
 ReturnValue_t PlocSupvHelper::writeUpdatePackets() {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
 #if OBSW_DEBUG_PLOC_SUPERVISOR == 1
   ProgressPrinter progressPrinter("Supervisor update", update.fullFileSize,
                                   ProgressPrinter::HALF_PERCENT);
@@ -338,13 +338,13 @@ ReturnValue_t PlocSupvHelper::writeUpdatePackets() {
     supv::WriteMemory packet(spParams);
     result = packet.buildPacket(seqFlags, update.sequenceCount, update.memoryId,
                                 update.startAddress + update.bytesWritten, dataLength, tempData);
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       triggerEvent(WRITE_MEMORY_FAILED, buildProgParams1(progPercent, update.sequenceCount),
                    update.bytesWritten);
       return result;
     }
     result = handlePacketTransmission(packet);
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       triggerEvent(WRITE_MEMORY_FAILED, buildProgParams1(progPercent, update.sequenceCount),
                    update.bytesWritten);
       return result;
@@ -366,24 +366,24 @@ uint32_t PlocSupvHelper::buildProgParams1(uint8_t percent, uint16_t seqCount) {
 
 ReturnValue_t PlocSupvHelper::performEventBufferRequest() {
   using namespace supv;
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   resetSpParams();
   RequestLoggingData packet(spParams);
   result = packet.buildPacket(RequestLoggingData::Sa::REQUEST_EVENT_BUFFERS);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = sendCommand(packet);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = handleAck();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result =
       handleTmReception(ccsds::HEADER_LEN, tmBuf.data(), supv::recv_timeout::UPDATE_STATUS_REPORT);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   ploc::SpTmReader spReader(tmBuf.data(), tmBuf.size());
@@ -397,7 +397,7 @@ ReturnValue_t PlocSupvHelper::performEventBufferRequest() {
 
   if (not exeAlreadyReceived) {
     result = handleExe();
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
   }
@@ -407,85 +407,85 @@ ReturnValue_t PlocSupvHelper::performEventBufferRequest() {
 ReturnValue_t PlocSupvHelper::handleRemainingExeReport(ploc::SpTmReader& reader) {
   size_t remBytes = reader.getPacketDataLen() + 1;
   ReturnValue_t result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     sif::warning << "Reading exe failure report failed" << std::endl;
   }
   result = exeReportHandling();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     sif::warning << "Handling exe report failed" << std::endl;
   }
   return result;
 }
 
 ReturnValue_t PlocSupvHelper::selectMemory() {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   resetSpParams();
   supv::MPSoCBootSelect packet(spParams);
   result = packet.buildPacket(update.memoryId);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = handlePacketTransmission(packet);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t PlocSupvHelper::prepareUpdate() {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   resetSpParams();
   supv::ApidOnlyPacket packet(spParams, supv::APID_PREPARE_UPDATE);
   result = packet.buildPacket();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = handlePacketTransmission(packet, PREPARE_UPDATE_EXECUTION_REPORT);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t PlocSupvHelper::eraseMemory() {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   resetSpParams();
   supv::EraseMemory eraseMemory(spParams);
   result = eraseMemory.buildPacket(update.memoryId, update.startAddress + update.bytesWritten,
                                    update.length);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = handlePacketTransmission(eraseMemory, supv::recv_timeout::ERASE_MEMORY);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t PlocSupvHelper::handlePacketTransmission(ploc::SpTcBase& packet,
                                                        uint32_t timeoutExecutionReport) {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   result = sendCommand(packet);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = handleAck();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = handleExe(timeoutExecutionReport);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t PlocSupvHelper::sendCommand(ploc::SpTcBase& packet) {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   rememberApid = packet.getApid();
   result = uartComIF->sendMessage(comCookie, packet.getFullPacket(), packet.getFullPacketLen());
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     sif::warning << "PlocSupvHelper::sendCommand: Failed to send command" << std::endl;
     triggerEvent(SUPV_SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
     return result;
@@ -494,10 +494,10 @@ ReturnValue_t PlocSupvHelper::sendCommand(ploc::SpTcBase& packet) {
 }
 
 ReturnValue_t PlocSupvHelper::handleAck() {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
 
   result = handleTmReception(supv::SIZE_ACK_REPORT);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     triggerEvent(ACK_RECEPTION_FAILURE, result, static_cast<uint32_t>(rememberApid));
     sif::warning << "PlocSupvHelper::handleAck: Error in reception of acknowledgment report"
                  << std::endl;
@@ -505,11 +505,11 @@ ReturnValue_t PlocSupvHelper::handleAck() {
   }
   supv::AcknowledgmentReport ackReport(tmBuf.data(), tmBuf.size());
   result = checkReceivedTm(ackReport);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = ackReport.checkApid();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     if (result == SupvReturnValuesIF::RECEIVED_ACK_FAILURE) {
       triggerEvent(SUPV_ACK_FAILURE_REPORT, static_cast<uint32_t>(ackReport.getRefApid()));
     } else if (result == SupvReturnValuesIF::INVALID_APID) {
@@ -517,14 +517,14 @@ ReturnValue_t PlocSupvHelper::handleAck() {
     }
     return result;
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t PlocSupvHelper::handleExe(uint32_t timeout) {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
 
   result = handleTmReception(supv::SIZE_EXE_REPORT, tmBuf.data(), timeout);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     triggerEvent(EXE_RECEPTION_FAILURE, result, static_cast<uint32_t>(rememberApid));
     sif::warning << "PlocSupvHelper::handleExe: Error in reception of execution report"
                  << std::endl;
@@ -538,11 +538,11 @@ ReturnValue_t PlocSupvHelper::exeReportHandling() {
   supv::ExecutionReport exeReport(tmBuf.data(), tmBuf.size());
 
   ReturnValue_t result = checkReceivedTm(exeReport);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = exeReport.checkApid();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     if (result == SupvReturnValuesIF::RECEIVED_EXE_FAILURE) {
       triggerEvent(SUPV_EXE_FAILURE_REPORT, static_cast<uint32_t>(exeReport.getRefApid()));
     } else if (result == SupvReturnValuesIF::INVALID_APID) {
@@ -555,7 +555,7 @@ ReturnValue_t PlocSupvHelper::exeReportHandling() {
 
 ReturnValue_t PlocSupvHelper::handleTmReception(size_t remainingBytes, uint8_t* readBuf,
                                                 uint32_t timeout) {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   size_t readBytes = 0;
   size_t currentBytes = 0;
   Countdown countdown(timeout);
@@ -564,7 +564,7 @@ ReturnValue_t PlocSupvHelper::handleTmReception(size_t remainingBytes, uint8_t*
   }
   while (!countdown.hasTimedOut()) {
     result = receive(readBuf + readBytes, &currentBytes, remainingBytes);
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     readBytes += currentBytes;
@@ -576,19 +576,19 @@ ReturnValue_t PlocSupvHelper::handleTmReception(size_t remainingBytes, uint8_t*
   if (remainingBytes != 0) {
     sif::warning << "PlocSupvHelper::handleTmReception: Failed to read " << std::dec
                  << remainingBytes << " remaining bytes" << std::endl;
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   return result;
 }
 
 ReturnValue_t PlocSupvHelper::checkReceivedTm(ploc::SpTmReader& reader) {
   ReturnValue_t result = reader.checkSize();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     triggerEvent(SUPV_REPLY_SIZE_MISSMATCH, rememberApid);
     return result;
   }
   result = reader.checkCrc();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid);
     return result;
   }
@@ -596,20 +596,20 @@ ReturnValue_t PlocSupvHelper::checkReceivedTm(ploc::SpTmReader& reader) {
 }
 
 ReturnValue_t PlocSupvHelper::receive(uint8_t* data, size_t* readBytes, size_t requestBytes) {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   uint8_t* buffer = nullptr;
   result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     sif::warning << "PlocSupvHelper::receive: Failed to request reply" << std::endl;
     triggerEvent(SUPV_HELPER_REQUESTING_REPLY_FAILED, result,
                  static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     sif::warning << "PlocSupvHelper::receive: Failed to read received message" << std::endl;
     triggerEvent(SUPV_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(internalState));
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   if (*readBytes > 0) {
     std::memcpy(data, buffer, *readBytes);
@@ -620,13 +620,13 @@ ReturnValue_t PlocSupvHelper::receive(uint8_t* data, size_t* readBytes, size_t r
 }
 
 ReturnValue_t PlocSupvHelper::calcImageCrc() {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   if (update.fullFileSize == 0) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 #ifdef XIPHOS_Q7S
   result = FilesystemHelper::checkPath(update.file);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     sif::warning << "PlocSupvHelper::calcImageCrc: File " << update.file << " does not exist"
                  << std::endl;
     return result;
@@ -666,7 +666,7 @@ ReturnValue_t PlocSupvHelper::calcImageCrc() {
 }
 
 ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   resetSpParams();
   // Will hold status report for later processing
   std::array<uint8_t, 32> statusReportBuf{};
@@ -674,15 +674,15 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
   // Verification of update write procedure
   supv::CheckMemory packet(spParams);
   result = packet.buildPacket(update.memoryId, update.startAddress, update.fullFileSize);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = sendCommand(packet);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = handleAck();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
@@ -697,14 +697,14 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
     size_t remBytes = spReader.getPacketDataLen() + 1;
     result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN,
                                supv::recv_timeout::UPDATE_STATUS_REPORT);
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       sif::warning
           << "PlocSupvHelper::handleCheckMemoryCommand: Failed to receive update status report"
           << std::endl;
       return result;
     }
     result = updateStatusReport.checkCrc();
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       sif::warning << "PlocSupvHelper::handleCheckMemoryCommand: CRC check failed" << std::endl;
       return result;
     }
@@ -714,7 +714,7 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
 
   if (not exeAlreadyHandled) {
     result = handleExe(CRC_EXECUTION_TIMEOUT);
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
   }
@@ -722,12 +722,12 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
   // Now process the status report
   updateStatusReport.setData(statusReportBuf.data(), statusReportBuf.size());
   result = updateStatusReport.parseDataField();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (update.crcShouldBeChecked) {
     result = updateStatusReport.verifycrc(update.crc);
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       sif::warning << "PlocSupvHelper::handleCheckMemoryCommand: CRC failure. Expected CRC 0x"
                    << std::setfill('0') << std::hex << std::setw(4)
                    << static_cast<uint16_t>(update.crc) << " but received CRC 0x" << std::setw(4)
@@ -747,7 +747,7 @@ uint32_t PlocSupvHelper::getFileSize(std::string filename) {
 }
 
 ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reader) {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   std::string filename = Filenaming::generateAbsoluteFilename(
       eventBufferReq.path, eventBufferReq.filename, timestamping);
   std::ofstream file(filename, std::ios_base::app | std::ios_base::out);
@@ -770,14 +770,14 @@ ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reade
       requestLen -= 6;
     }
     result = handleTmReception(requestLen);
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       sif::debug << "PlocSupvHelper::handleEventBufferReception: Failed while trying to read packet"
                  << " " << packetsRead + 1 << std::endl;
       file.close();
       return result;
     }
     ReturnValue_t result = reader.checkCrc();
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid);
       return result;
     }