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 {
  if (buffer == nullptr or size == nullptr) {
    return FAILED;
  }
  if (*size + getSerializedSize() > maxSize) {
    return SerializeIF::BUFFER_TOO_SHORT;
  }
  ReturnValue_t result = destId.serializeAsLv(buffer, size, maxSize);
  if (result != OK) {
    return result;
  }
  result = SerializeAdapter::serialize(&metadataOnly, buffer, size, maxSize, streamEndianness);
  if (result != OK) {
    return result;
  }
  if (!metadataOnly) {
    result = sourceName.serialize(buffer, size, maxSize, streamEndianness);
    if (result != OK) {
      return result;
    }
    result = destName.serialize(buffer, size, maxSize, streamEndianness);
    if (result != OK) {
      return result;
    }
    result =
        SerializeAdapter::serialize(&hasTransmissionMode, buffer, size, maxSize, streamEndianness);
    if (result != OK) {
      return result;
    }
    result =
        SerializeAdapter::serialize(&transmissionMode, buffer, size, maxSize, streamEndianness);
    if (result != OK) {
      return result;
    }
    result =
        SerializeAdapter::serialize(&hasClosureRequested, 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) {
  if (buffer == nullptr or size == nullptr) {
    return FAILED;
  }
  ReturnValue_t result = destId.deSerializeFromLv(buffer, size);
  if (result != OK) {
    return result;
  }
  result = SerializeAdapter::deSerialize(&metadataOnly, buffer, size, streamEndianness);
  if (result != OK) {
    return result;
  }
  if (!metadataOnly) {
    result = sourceName.deSerialize(buffer, size, streamEndianness);
    if (result != OK) {
      return result;
    }
    result = destName.deSerialize(buffer, size, streamEndianness);
    if (result != OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&transmissionMode, buffer, size, streamEndianness);
    if (result != OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&hasClosureRequested, 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 {
  // Entity ID LV (1 leading size byte) and the metadata only flag.
  size_t baseSize = 1 + destId.getSerializedSize() + 1;
  if (!metadataOnly) {
    baseSize += sourceName.getSerializedSize() + destName.getSerializedSize() + 2;
  }
  baseSize += sizeof(msgsToUsersTotalSize) + msgsToUsersTotalSize + sizeof(fsRequestsTotalSize) +
              fsRequestsTotalSize;
  return baseSize;
}

void cfdp::PutRequest::setSourceAndDestName(cfdp::StringLv &sourceName_,
                                            cfdp::StringLv &destName_) {
  this->sourceName = sourceName_;
  this->destName = destName_;
}

const cfdp::StringLv &cfdp::PutRequest::getSourceName() const { return sourceName; }

const cfdp::StringLv &cfdp::PutRequest::getDestName() const { return destName; }

const cfdp::EntityId &cfdp::PutRequest::getDestId() const { return destId; }

void cfdp::PutRequest::setDestId(cfdp::EntityId id) { destId = std::move(id); }