fsfw/src/fsfw/cfdp/handler/PutRequest.cpp

#include "PutRequest.h"

using namespace returnvalue;

cfdp::PutRequest::PutRequest(cfdp::EntityId destId, const uint8_t *msgsToUser,
                             size_t msgsToUserTotalSize, const uint8_t *fsRequests,
                             size_t fsRequestsSize)
    : destId(std::move(destId)),
      destIdWidth(destId.getWidth()),
      metadataOnly(true),
      msgsToUsersTotalSize(msgsToUserTotalSize),
      msgsToUserStartPtr(msgsToUser),
      fsRequestsTotalSize(fsRequestsSize),
      fsRequestStartPtr(fsRequests) {}

[[nodiscard]] bool cfdp::PutRequest::isMetadataOnly() const { return metadataOnly; }

ReturnValue_t cfdp::PutRequest::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                          SerializeIF::Endianness streamEndianness) const {
  ReturnValue_t result = destId.serialize(buffer, size, maxSize, streamEndianness);
  if (result != OK) {
    return result;
  }
  if (*size + getSerializedSize() > maxSize) {
    return SerializeIF::BUFFER_TOO_SHORT;
  }
  result = SerializeAdapter::serialize(&metadataOnly, buffer, size, maxSize, streamEndianness);
  if (result != OK) {
    return result;
  }
  if (!metadataOnly) {
    result = SerializeAdapter::serialize(&sourceNameSize, buffer, size, maxSize, streamEndianness);
    if (result != OK) {
      return result;
    }
    std::memcpy(*buffer, sourceName, sourceNameSize);
    *buffer += sourceNameSize;
    *size += sourceNameSize;
    result = SerializeAdapter::serialize(&destNameSize, buffer, size, maxSize, streamEndianness);
    if (result != OK) {
      return result;
    }
    std::memcpy(*buffer, destName, destNameSize);
    *buffer += destNameSize;
    *size += destNameSize;
    result =
        SerializeAdapter::serialize(&transmissionMode, buffer, size, maxSize, streamEndianness);
    if (result != OK) {
      return result;
    }
    result =
        SerializeAdapter::serialize(&closureRequested, buffer, size, maxSize, streamEndianness);
    if (result != OK) {
      return result;
    }
  }
  result =
      SerializeAdapter::serialize(&msgsToUsersTotalSize, buffer, size, maxSize, streamEndianness);
  if (result != OK) {
    return result;
  }
  std::memcpy(*buffer, msgsToUserStartPtr, msgsToUsersTotalSize);
  *buffer += msgsToUsersTotalSize;
  *size += msgsToUsersTotalSize;

  result =
      SerializeAdapter::serialize(&fsRequestsTotalSize, buffer, size, maxSize, streamEndianness);
  if (result != OK) {
    return result;
  }
  std::memcpy(*buffer, fsRequestStartPtr, fsRequestsTotalSize);
  *buffer += fsRequestsTotalSize;
  *size += fsRequestsTotalSize;
  return OK;
}

ReturnValue_t cfdp::PutRequest::deSerialize(const uint8_t **buffer, size_t *size,
                                            SerializeIF::Endianness streamEndianness) {
  ReturnValue_t result =
      SerializeAdapter::deSerialize(&destIdWidth, buffer, size, streamEndianness);
  if (result != OK) {
    return result;
  }

  result = destId.deSerialize(static_cast<cfdp::WidthInBytes>(destIdWidth), buffer, size,
                              streamEndianness);
  if (result != OK) {
    return result;
  }
  result = SerializeAdapter::deSerialize(&metadataOnly, buffer, size, streamEndianness);
  if (result != OK) {
    return result;
  }
  if (!metadataOnly) {
    result = SerializeAdapter::deSerialize(&sourceNameSize, buffer, size, streamEndianness);
    if (result != OK) {
      return result;
    }
    sourceName = reinterpret_cast<const char *>(*buffer);
    *buffer += sourceNameSize;
    *size += sourceNameSize;
    result = SerializeAdapter::deSerialize(&destNameSize, buffer, size, streamEndianness);
    if (result != OK) {
      return result;
    }
    destName = reinterpret_cast<const char *>(*buffer);
    *buffer += destNameSize;
    *size += destNameSize;
    result = SerializeAdapter::deSerialize(&transmissionMode, buffer, size, streamEndianness);
    if (result != OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&closureRequested, buffer, size, streamEndianness);
    if (result != OK) {
      return result;
    }
  }
  result = SerializeAdapter::deSerialize(&msgsToUsersTotalSize, buffer, size, streamEndianness);
  if (result != OK) {
    return result;
  }
  msgsToUserStartPtr = *buffer;
  *buffer += msgsToUsersTotalSize;
  *size += msgsToUsersTotalSize;

  result = SerializeAdapter::deSerialize(&fsRequestsTotalSize, buffer, size, streamEndianness);
  if (result != OK) {
    return result;
  }
  fsRequestStartPtr = *buffer;
  *buffer += fsRequestsTotalSize;
  *size += fsRequestsTotalSize;
  return OK;
}

size_t cfdp::PutRequest::getSerializedSize() const {
  size_t baseSize = destId.getSerializedSize() + 1;
  if (!metadataOnly) {
    baseSize += sizeof(sourceNameSize) + sourceNameSize + sizeof(destNameSize) + destNameSize + 2;
  }
  baseSize += sizeof(msgsToUsersTotalSize) + msgsToUsersTotalSize + sizeof(fsRequestsTotalSize) +
              fsRequestsTotalSize;
  return baseSize;
}