92 lines
2.3 KiB
C++
92 lines
2.3 KiB
C++
#include "Lv.h"
|
|
|
|
cfdp::Lv::Lv(const uint8_t* value, size_t size) : value(value, size, true) {
|
|
if (size > 0) {
|
|
zeroLen = false;
|
|
}
|
|
}
|
|
|
|
cfdp::Lv::Lv(const std::vector<uint8_t>& data) : value(data.data(), data.size(), true) {
|
|
if (!data.empty()) {
|
|
zeroLen = false;
|
|
}
|
|
}
|
|
|
|
cfdp::Lv::Lv() : value(static_cast<uint8_t*>(nullptr), 0, true) {}
|
|
|
|
cfdp::Lv::Lv(const Lv& other)
|
|
: value(other.value.getConstBuffer(), other.value.getSerializedSize() - 1, true) {
|
|
if (other.value.getSerializedSize() - 1 > 0) {
|
|
zeroLen = false;
|
|
}
|
|
}
|
|
|
|
cfdp::Lv& cfdp::Lv::operator=(const Lv& other) {
|
|
size_t otherSize = 0;
|
|
auto* otherVal = const_cast<uint8_t*>(other.getValue(&otherSize));
|
|
if (otherVal == nullptr or otherSize == 0) {
|
|
this->zeroLen = true;
|
|
}
|
|
this->value.setConstBuffer(otherVal, otherSize);
|
|
return *this;
|
|
}
|
|
|
|
ReturnValue_t cfdp::Lv::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
|
|
Endianness streamEndianness) const {
|
|
if (maxSize < 1) {
|
|
return BUFFER_TOO_SHORT;
|
|
}
|
|
if (buffer == nullptr or size == nullptr) {
|
|
return returnvalue::FAILED;
|
|
}
|
|
if (zeroLen) {
|
|
**buffer = 0;
|
|
*size += 1;
|
|
*buffer += 1;
|
|
return returnvalue::OK;
|
|
}
|
|
return value.serialize(buffer, size, maxSize, streamEndianness);
|
|
}
|
|
|
|
size_t cfdp::Lv::getSerializedSize() const {
|
|
if (zeroLen) {
|
|
return 1;
|
|
} else if (value.getConstBuffer() == nullptr) {
|
|
return 0;
|
|
}
|
|
return value.getSerializedSize();
|
|
}
|
|
|
|
ReturnValue_t cfdp::Lv::deSerialize(const uint8_t** buffer, size_t* size,
|
|
Endianness streamEndianness) {
|
|
if (buffer == nullptr or size == nullptr) {
|
|
return returnvalue::FAILED;
|
|
}
|
|
if (*size < 1) {
|
|
return SerializeIF::STREAM_TOO_SHORT;
|
|
}
|
|
size_t lengthField = **buffer;
|
|
if (lengthField == 0) {
|
|
zeroLen = true;
|
|
*buffer += 1;
|
|
*size -= 1;
|
|
return returnvalue::OK;
|
|
} else if (*size < lengthField + 1) {
|
|
return SerializeIF::STREAM_TOO_SHORT;
|
|
}
|
|
zeroLen = false;
|
|
// Zero-copy implementation
|
|
value.setConstBuffer(*buffer + 1, lengthField);
|
|
*buffer += 1 + lengthField;
|
|
*size -= 1 + lengthField;
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
const uint8_t* cfdp::Lv::getValue(size_t* size) const {
|
|
if (size != nullptr) {
|
|
// Length without length field
|
|
*size = value.getSerializedSize() - 1;
|
|
}
|
|
return value.getConstBuffer();
|
|
}
|