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)),
      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;
  }
  **buffer = metadataOnly;
  *size += 1;
  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;
    if (*size + 1 > maxSize) {
      **buffer = transmissionMode;
      *size += 1;
      *buffer += 1;
    }
    if (*size + 1 > maxSize) {
      **buffer = closureRequested;
      *size += 1;
      *buffer += 1;
    }
  }
  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) {
  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;
}