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) {}

cfdp::PutRequest::PutRequest(cfdp::EntityId destId, cfdp::StringLv &sourceName,
                             cfdp::StringLv &destName)
    : destId(std::move(destId)), sourceName(std::move(sourceName)), destName(std::move(destName)) {}

[[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(&hasTransmissionMode, 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() + 4;
  }
  baseSize += sizeof(msgsToUsersTotalSize) + msgsToUsersTotalSize + sizeof(fsRequestsTotalSize) +
              fsRequestsTotalSize;
  return baseSize;
}

void cfdp::PutRequest::setSourceAndDestName(cfdp::StringLv &sourceName_,
                                            cfdp::StringLv &destName_) {
  metadataOnly = false;
  this->sourceName = std::move(sourceName_);
  this->destName = std::move(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); }

void cfdp::PutRequest::setTransmissionMode(cfdp::TransmissionMode transmissionMode_) {
  this->transmissionMode = transmissionMode_;
  hasTransmissionMode = true;
}

void cfdp::PutRequest::clearTransmissionMode() { hasTransmissionMode = false; }

void cfdp::PutRequest::clearClosureRequest() { hasClosureRequested = false; }

void cfdp::PutRequest::setClosureRequest(bool closureRequested_) {
  this->closureRequested = closureRequested_;
  hasClosureRequested = true;
}

const uint8_t *cfdp::PutRequest::getMessagesToUser(size_t &totalSize) {
  totalSize = this->msgsToUsersTotalSize;
  return msgsToUserStartPtr;
}

bool cfdp::PutRequest::getClosureRequested(bool &closureRequested_) const {
  if (hasClosureRequested) {
    closureRequested_ = this->closureRequested;
  }
  return hasClosureRequested;
}

bool cfdp::PutRequest::getTransmissionMode(cfdp::TransmissionMode &mode) const {
  if (hasTransmissionMode) {
    mode = static_cast<cfdp::TransmissionMode>(this->transmissionMode);
  }
  return hasTransmissionMode;
}