mohr/fsfw
1
0
Fork 0
forked from fsfw/fsfw
Code Pull Requests Activity

added string LV tests

Browse Source
This commit is contained in:
Robin Müller
2022-08-10 09:39:57 +02:00
parent 507c6ddff1
commit 96dfe46e25
21 changed files with 466 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/fsfw/cfdp.h
View File

@ -4,5 +4,8 @@
#include "cfdp/definitions.h"
#include "cfdp/handler/DestHandler.h"
#include "cfdp/handler/FaultHandlerBase.h"
#include "cfdp/tlv/Lv.h"
#include "cfdp/tlv/StringLv.h"
#include "cfdp/tlv/Tlv.h"
#endif // FSFW_CFDP_H

12
src/fsfw/cfdp/handler/UserBase.cpp
View File

@ -1,3 +1,15 @@
#include "UserBase.h"
#include <array>
#include <iostream>
void cfdp::testFunc() {
std::vector<void*> testVec;
testVec.reserve(10);
std::array<uint8_t, 4> customMsg = {1, 2, 3, 4};
MessageToUserTlv tlv0(customMsg.data(), customMsg.size());
std::cout << testVec.size() << std::endl;
testVec[0] = &tlv0;
FilestoreResponseTlv tlv1();
}
cfdp::UserBase::UserBase(HasFileSystemIF& vfs) : vfs(vfs) {}

6
src/fsfw/cfdp/handler/UserBase.h
View File

@ -3,6 +3,7 @@
#include <optional>
#include <utility>
#include <vector>
#include "StatusReportIF.h"
#include "fsfw/cfdp/VarLenFields.h"
@ -12,6 +13,8 @@
namespace cfdp {
void testFunc();
struct TransactionFinishedParams {
TransactionFinishedParams(TransactionId id, ConditionCode code, FileDeliveryStatus status,
FileDeliveryCode delivCode)
@ -31,7 +34,8 @@ struct MetadataRecvParams {
size_t fileSize;
const char* sourceFileName;
const char* destFileName;
std::pair<uint8_t, MessageToUserTlv**> msgsToUser;
std::vector<MessageToUserTlv*> msgsToUser;
// std::pair<uint8_t, MessageToUserTlv**> msgsToUser;
};
struct FileSegmentRecvdParams {

1
src/fsfw/cfdp/tlv/CMakeLists.txt
View File

@ -5,6 +5,7 @@ target_sources(
FilestoreResponseTlv.cpp
Lv.cpp
Tlv.cpp
StringLv.cpp
FlowLabelTlv.cpp
MessageToUserTlv.cpp
FaultHandlerOverrideTlv.cpp)

11
src/fsfw/cfdp/tlv/Lv.cpp
View File

@ -6,9 +6,8 @@ cfdp::Lv::Lv(const uint8_t* value, size_t size) : value(value, size, true) {
}
}
cfdp::Lv::Lv(const char* value, size_t size)
: value(reinterpret_cast<const uint8_t*>(value), size, true) {
if (size > 0) {
cfdp::Lv::Lv(const std::vector<uint8_t>& data) : value(data.data(), data.size(), true) {
if (!data.empty()) {
zeroLen = false;
}
}
@ -24,11 +23,11 @@ cfdp::Lv::Lv(const Lv& other)
cfdp::Lv& cfdp::Lv::operator=(const Lv& other) {
size_t otherSize = 0;
uint8_t* value = const_cast<uint8_t*>(other.getValue(&otherSize));
if (value == nullptr or otherSize == 0) {
auto* otherVal = const_cast<uint8_t*>(other.getValue(&otherSize));
if (otherVal == nullptr or otherSize == 0) {
this->zeroLen = true;
}
this->value.setBuffer(value, otherSize);
this->value.setBuffer(otherVal, otherSize);
return *this;
}

12
src/fsfw/cfdp/tlv/Lv.h
View File

@ -1,5 +1,7 @@
#ifndef FSFW_SRC_FSFW_CFDP_LV_H_
#define FSFW_SRC_FSFW_CFDP_LV_H_
#ifndef FSFW_CFDP_LV_H_
#define FSFW_CFDP_LV_H_
#include <vector>
#include "fsfw/serialize/SerialBufferAdapter.h"
@ -12,12 +14,10 @@ namespace cfdp {
*/
class Lv : public SerializeIF {
public:
explicit Lv(const std::vector<uint8_t>& data);
Lv(const uint8_t* value, size_t size);
Lv(const char* value, size_t size);
Lv();
// Delete copy ctor and assingment ctor for now because this class contains a reference to
// data
Lv(const Lv&);
Lv& operator=(const Lv&);
@ -51,4 +51,4 @@ class Lv : public SerializeIF {
} // namespace cfdp
#endif /* FSFW_SRC_FSFW_CFDP_LV_H_ */
#endif /* FSFW_CFDP_LV_H_ */

5
src/fsfw/cfdp/tlv/MessageToUserTlv.cpp
View File

@ -1,6 +1,9 @@
#include "MessageToUserTlv.h"
MessageToUserTlv::MessageToUserTlv(uint8_t *value, size_t size)
MessageToUserTlv::MessageToUserTlv(uint8_t* value, size_t size)
: Tlv(cfdp::TlvTypes::MSG_TO_USER, value, size) {}
MessageToUserTlv::MessageToUserTlv() : Tlv() {}
MessageToUserTlv::MessageToUserTlv(const std::vector<uint8_t>& data)
: Tlv(cfdp::TlvTypes::MSG_TO_USER, data.data(), data.size()) {}

3
src/fsfw/cfdp/tlv/MessageToUserTlv.h
View File

@ -1,12 +1,15 @@
#ifndef FSFW_SRC_FSFW_CFDP_TLV_MESSAGETOUSERTLV_H_
#define FSFW_SRC_FSFW_CFDP_TLV_MESSAGETOUSERTLV_H_
#include <vector>
#include "Tlv.h"
class MessageToUserTlv : public cfdp::Tlv {
public:
MessageToUserTlv();
MessageToUserTlv(uint8_t* value, size_t size);
explicit MessageToUserTlv(const std::vector<uint8_t>& data);
private:
};

7
src/fsfw/cfdp/tlv/StringLv.cpp Normal file
View File

@ -0,0 +1,7 @@
#include "StringLv.h"
cfdp::StringLv::StringLv(const std::string& fileName)
: Lv(reinterpret_cast<const uint8_t*>(fileName.data()), fileName.size()) {}
cfdp::StringLv::StringLv(const char* filename, size_t len)
: Lv(reinterpret_cast<const uint8_t*>(filename), len) {}

18
src/fsfw/cfdp/tlv/StringLv.h Normal file
View File

@ -0,0 +1,18 @@
#ifndef FSFW_CFDP_STRINGLV_H
#define FSFW_CFDP_STRINGLV_H
#include <string>
#include "Lv.h"
namespace cfdp {
class StringLv : public Lv {
public:
explicit StringLv(const std::string& fileName);
explicit StringLv(const char* filename, size_t len);
};
} // namespace cfdp
#endif // FSFW_CFDP_STRINGLV_H

27
src/fsfw/serialize/SerialBufferAdapter.cpp
View File

@ -21,15 +21,15 @@ SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer, count_t buffe
bufferLength(bufferLength) {}
template <typename count_t>
SerialBufferAdapter<count_t>::~SerialBufferAdapter() {}
SerialBufferAdapter<count_t>::~SerialBufferAdapter() = default;
template <typename count_t>
ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer_, size_t* size,
size_t maxSize,
Endianness streamEndianness) const {
if (serializeLength) {
ReturnValue_t result =
SerializeAdapter::serialize(&bufferLength, buffer, size, maxSize, streamEndianness);
SerializeAdapter::serialize(&bufferLength, buffer_, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -40,16 +40,16 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t*
}
if (this->constBuffer != nullptr) {
std::memcpy(*buffer, this->constBuffer, bufferLength);
std::memcpy(*buffer_, this->constBuffer, bufferLength);
} else if (this->buffer != nullptr) {
// This will propably be never reached, constBuffer should always be
// set if non-const buffer is set.
std::memcpy(*buffer, this->buffer, bufferLength);
std::memcpy(*buffer_, this->buffer, bufferLength);
} else {
return HasReturnvaluesIF::RETURN_FAILED;
}
*size += bufferLength;
(*buffer) += bufferLength;
(*buffer_) += bufferLength;
return HasReturnvaluesIF::RETURN_OK;
}
@ -63,7 +63,7 @@ size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
}
template <typename count_t>
ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer, size_t* size,
ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer_, size_t* size,
Endianness streamEndianness) {
if (this->buffer == nullptr) {
return HasReturnvaluesIF::RETURN_FAILED;
@ -72,7 +72,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
if (serializeLength) {
count_t lengthField = 0;
ReturnValue_t result =
SerializeAdapter::deSerialize(&lengthField, buffer, size, streamEndianness);
SerializeAdapter::deSerialize(&lengthField, buffer_, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -84,8 +84,8 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
if (bufferLength <= *size) {
*size -= bufferLength;
std::memcpy(this->buffer, *buffer, bufferLength);
(*buffer) += bufferLength;
std::memcpy(this->buffer, *buffer_, bufferLength);
(*buffer_) += bufferLength;
return HasReturnvaluesIF::RETURN_OK;
} else {
return STREAM_TOO_SHORT;
@ -119,10 +119,9 @@ const uint8_t* SerialBufferAdapter<count_t>::getConstBuffer() const {
}
template <typename count_t>
void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer, count_t bufferLength) {
this->buffer = buffer;
this->constBuffer = buffer;
this->bufferLength = bufferLength;
void SerialBufferAdapter<count_t>::setBuffer(const uint8_t* data, count_t len) {
this->constBuffer = data;
this->bufferLength = len;
}
// forward Template declaration for linker

18
src/fsfw/serialize/SerialBufferAdapter.h
View File

@ -40,12 +40,12 @@ class SerialBufferAdapter : public SerializeIF {
*/
SerialBufferAdapter(uint8_t* buffer, count_t bufferLength, bool serializeLength = false);
virtual ~SerialBufferAdapter();
~SerialBufferAdapter() override;
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
Endianness streamEndianness) const override;
ReturnValue_t serialize(uint8_t** buffer_, size_t* size, size_t maxSize,
Endianness streamEndianness) const override;
virtual size_t getSerializedSize() const override;
[[nodiscard]] size_t getSerializedSize() const override;
/**
* @brief This function deserializes a buffer into the member buffer.
@ -53,18 +53,18 @@ class SerialBufferAdapter : public SerializeIF {
* If a length field is present, it is ignored, as the size should have
* been set in the constructor. If the size is not known beforehand,
* consider using SerialFixedArrayListAdapter instead.
* @param buffer [out] Resulting buffer
* @param buffer_ [out] Resulting buffer
* @param size remaining size to deserialize, should be larger than buffer
* + size field size
* @param bigEndian
* @return
*/
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) override;
ReturnValue_t deSerialize(const uint8_t** buffer_, size_t* size,
Endianness streamEndianness) override;
uint8_t* getBuffer();
const uint8_t* getConstBuffer() const;
void setBuffer(uint8_t* buffer, count_t bufferLength);
[[nodiscard]] const uint8_t* getConstBuffer() const;
void setBuffer(const uint8_t* buffer, count_t bufferLength);
private:
bool serializeLength = false;