118 lines
4.1 KiB
C++
118 lines
4.1 KiB
C++
#include "HeaderSerializer.h"
|
|
|
|
#include "HeaderDeserializer.h"
|
|
|
|
HeaderSerializer::HeaderSerializer(PduConfig &pduConf, cfdp::PduType pduType,
|
|
size_t initPduDataFieldLen,
|
|
cfdp::SegmentMetadataFlag segmentMetadataFlag,
|
|
cfdp::SegmentationControl segCtrl)
|
|
: pduType(pduType),
|
|
segmentMetadataFlag(segmentMetadataFlag),
|
|
segmentationCtrl(segCtrl),
|
|
pduDataFieldLen(initPduDataFieldLen),
|
|
pduConf(pduConf) {}
|
|
|
|
ReturnValue_t HeaderSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
|
|
Endianness streamEndianness) const {
|
|
if (buffer == nullptr or size == nullptr) {
|
|
return returnvalue::FAILED;
|
|
}
|
|
if (maxSize < this->getSerializedSize()) {
|
|
return BUFFER_TOO_SHORT;
|
|
}
|
|
**buffer = cfdp::VERSION_BITS | this->pduType << 4 | pduConf.direction << 3 | pduConf.mode << 2 |
|
|
pduConf.crcFlag << 1 | pduConf.largeFile;
|
|
*buffer += 1;
|
|
**buffer = (pduDataFieldLen & 0xff00) >> 8;
|
|
*buffer += 1;
|
|
**buffer = pduDataFieldLen & 0x00ff;
|
|
*buffer += 1;
|
|
**buffer = segmentationCtrl << 7 | pduConf.sourceId.getWidth() << 4 | segmentMetadataFlag << 3 |
|
|
pduConf.seqNum.getWidth();
|
|
*buffer += 1;
|
|
*size += 4;
|
|
ReturnValue_t result = pduConf.sourceId.serialize(buffer, size, maxSize, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = pduConf.seqNum.serialize(buffer, size, maxSize, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = pduConf.destId.serialize(buffer, size, maxSize, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
size_t HeaderSerializer::getSerializedSize() const {
|
|
size_t shit = pduConf.seqNum.getWidth() + pduConf.sourceId.getWidth() * 2 + 4;
|
|
return shit;
|
|
}
|
|
|
|
ReturnValue_t HeaderSerializer::deSerialize(const uint8_t **buffer, size_t *size,
|
|
Endianness streamEndianness) {
|
|
// We could implement this, but I prefer dedicated classes
|
|
return returnvalue::FAILED;
|
|
}
|
|
|
|
size_t HeaderSerializer::getWholePduSize() const {
|
|
// Return size of header plus the PDU data field length
|
|
return pduDataFieldLen + HeaderSerializer::getSerializedSize();
|
|
}
|
|
|
|
size_t HeaderSerializer::getPduDataFieldLen() const { return pduDataFieldLen; }
|
|
|
|
void HeaderSerializer::setPduDataFieldLen(size_t pduDataFieldLen) {
|
|
this->pduDataFieldLen = pduDataFieldLen;
|
|
}
|
|
|
|
void HeaderSerializer::setPduType(cfdp::PduType pduType) { this->pduType = pduType; }
|
|
|
|
void HeaderSerializer::setSegmentMetadataFlag(cfdp::SegmentMetadataFlag segmentMetadataFlag) {
|
|
this->segmentMetadataFlag = segmentMetadataFlag;
|
|
}
|
|
|
|
cfdp::PduType HeaderSerializer::getPduType() const { return pduType; }
|
|
|
|
cfdp::Direction HeaderSerializer::getDirection() const { return pduConf.direction; }
|
|
|
|
cfdp::TransmissionModes HeaderSerializer::getTransmissionMode() const { return pduConf.mode; }
|
|
|
|
bool HeaderSerializer::getCrcFlag() const { return pduConf.crcFlag; }
|
|
|
|
bool HeaderSerializer::getLargeFileFlag() const { return pduConf.largeFile; }
|
|
|
|
cfdp::SegmentationControl HeaderSerializer::getSegmentationControl() const {
|
|
return segmentationCtrl;
|
|
}
|
|
|
|
cfdp::WidthInBytes HeaderSerializer::getLenEntityIds() const { return pduConf.sourceId.getWidth(); }
|
|
|
|
cfdp::WidthInBytes HeaderSerializer::getLenSeqNum() const { return pduConf.seqNum.getWidth(); }
|
|
|
|
cfdp::SegmentMetadataFlag HeaderSerializer::getSegmentMetadataFlag() const {
|
|
return segmentMetadataFlag;
|
|
}
|
|
|
|
void HeaderSerializer::getSourceId(cfdp::EntityId &sourceId) const { sourceId = pduConf.sourceId; }
|
|
|
|
void HeaderSerializer::getDestId(cfdp::EntityId &destId) const { destId = pduConf.destId; }
|
|
|
|
void HeaderSerializer::setSegmentationControl(cfdp::SegmentationControl segmentationControl) {
|
|
this->segmentationCtrl = segmentationControl;
|
|
}
|
|
|
|
void HeaderSerializer::getTransactionSeqNum(cfdp::TransactionSeqNum &seqNum) const {
|
|
seqNum = pduConf.seqNum;
|
|
}
|
|
|
|
bool HeaderSerializer::hasSegmentMetadataFlag() const {
|
|
if (this->segmentMetadataFlag == cfdp::SegmentMetadataFlag::PRESENT) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|