nasa/fprime
1
0
Fork 0
mirror of https://github.com/nasa/fprime.git synced 2025-12-10 00:44:37 -06:00
Code Issues Packages Projects Releases 34 Wiki Activity

Add code formatting check to CI (#3778)

Browse Source 
* Format Fw/Buffer Fw/Cmd and Fw/Com

* add code format check

* fix branch to pull from

* debug

* uninstall before install

* Use pip3

* debug with tmate

* put fprime-tools dep in req.txt

* test

* req hash

* setup python first

* use nasa pointer

* Revert "Format Fw/Buffer Fw/Cmd and Fw/Com"

This reverts commit b4968ec6805006a99bd2a01c0a28fe6fb5f6430f.

* Format Fw/Buffer Fw/Cmd and Fw/Com

* Update to fprime-tools 4.0.0a2

* Use env var for readability

* naming

* Add clang-format to requirements.txt

* Skip clang-format requirement on armv7l platform
This commit is contained in:
Thomas Boyer-Chammard 2025-06-24 12:18:34 -07:00 committed by GitHub
parent 1e0ea6cb20
commit 1a07c847b1
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 365 additions and 365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/build-test-rhel8.yml vendored
View File

@ -6,7 +6,7 @@ name: CI [RHEL8]
# events but only for the master branch
on:
push:
branches: [ devel, release/**, ci/** ]
branches: [ devel, release/** ]
pull_request:
# The branches below must be a subset of the branches above
branches: [ devel, release/** ]

38
.github/workflows/format-check.yml vendored Normal file
View File

@ -0,0 +1,38 @@
name: "Code Format Check"
on:
push:
branches: [ devel, release/**, ci/** ]
pull_request:
# The branches below must be a subset of the branches above
branches: [ devel, release/** ]
paths-ignore:
- 'docs/**'
- '**.md'
- '.github/actions/spelling/**'
- '.github/ISSUE_TEMPLATE/**'
jobs:
cpp-formatting:
name: C++ Formatting
runs-on: ubuntu-22.04
steps:
- name: "Checkout F´ Repository"
uses: actions/checkout@v4
with:
fetch-depth: 0
submodules: true
- name: "Setup Python"
uses: actions/setup-python@v5
with:
python-version: 3.12
- uses: ./.github/actions/setup
- name: "Check C++ Formatting"
env:
CHECKED_DIRS: >-
Fw/Buffer
Fw/Cmd
Fw/Com
run: |
fprime-util format --check --dirs $CHECKED_DIRS
shell: bash

56
Fw/Buffer/Buffer.cpp
View File

@ -10,41 +10,28 @@
//
// ======================================================================
#include <Fw/Buffer/Buffer.hpp>
#include <Fw/Types/Assert.hpp>
#include <Fw/FPrimeBasicTypes.hpp>
#include <Fw/Types/Assert.hpp>
#if FW_SERIALIZABLE_TO_STRING
#include <Fw/Types/String.hpp>
#include <Fw/Types/String.hpp>
#endif
#include <cstring>
namespace Fw {
Buffer::Buffer(): Serializable(),
m_serialize_repr(),
m_bufferData(nullptr),
m_size(0),
m_context(0xFFFFFFFF)
{}
Buffer::Buffer() : Serializable(), m_serialize_repr(), m_bufferData(nullptr), m_size(0), m_context(0xFFFFFFFF) {}
Buffer::Buffer(const Buffer& src) : Serializable(),
m_serialize_repr(),
m_bufferData(src.m_bufferData),
m_size(src.m_size),
m_context(src.m_context)
{
if(src.m_bufferData != nullptr){
Buffer::Buffer(const Buffer& src)
: Serializable(), m_serialize_repr(), m_bufferData(src.m_bufferData), m_size(src.m_size), m_context(src.m_context) {
if (src.m_bufferData != nullptr) {
this->m_serialize_repr.setExtBuffer(src.m_bufferData, src.m_size);
}
}
Buffer::Buffer(U8* data, SizeType size, U32 context) : Serializable(),
m_serialize_repr(),
m_bufferData(data),
m_size(size),
m_context(context)
{
if(m_bufferData != nullptr){
Buffer::Buffer(U8* data, SizeType size, U32 context)
: Serializable(), m_serialize_repr(), m_bufferData(data), m_size(size), m_context(context) {
if (m_bufferData != nullptr) {
this->m_serialize_repr.setExtBuffer(this->m_bufferData, this->m_size);
}
}
@ -58,7 +45,8 @@ Buffer& Buffer::operator=(const Buffer& src) {
}
bool Buffer::operator==(const Buffer& src) const {
return (this->m_bufferData == src.m_bufferData) && (this->m_size == src.m_size) && (this->m_context == src.m_context);
return (this->m_bufferData == src.m_bufferData) && (this->m_size == src.m_size) &&
(this->m_context == src.m_context);
}
bool Buffer::isValid() const {
@ -106,7 +94,8 @@ void Buffer::set(U8* const data, const SizeType size, const U32 context) {
Fw::ExternalSerializeBufferWithMemberCopy Buffer::getSerializer() {
if (this->isValid()) {
Fw::ExternalSerializeBufferWithMemberCopy esb(this->m_bufferData, static_cast<Fw::Serializable::SizeType>(this->m_size));
Fw::ExternalSerializeBufferWithMemberCopy esb(this->m_bufferData,
static_cast<Fw::Serializable::SizeType>(this->m_size));
esb.resetSer();
return esb;
} else {
@ -116,7 +105,8 @@ Fw::ExternalSerializeBufferWithMemberCopy Buffer::getSerializer() {
Fw::ExternalSerializeBufferWithMemberCopy Buffer::getDeserializer() {
if (this->isValid()) {
Fw::ExternalSerializeBufferWithMemberCopy esb(this->m_bufferData, static_cast<Fw::Serializable::SizeType>(this->m_size));
Fw::ExternalSerializeBufferWithMemberCopy esb(this->m_bufferData,
static_cast<Fw::Serializable::SizeType>(this->m_size));
Fw::SerializeStatus stat = esb.setBuffLen(static_cast<Fw::Serializable::SizeType>(this->m_size));
FW_ASSERT(stat == Fw::FW_SERIALIZE_OK);
return esb;
@ -187,17 +177,17 @@ Fw::SerializeStatus Buffer::deserialize(Fw::SerializeBufferBase& buffer) {
#if FW_SERIALIZABLE_TO_STRING
void Buffer::toString(Fw::StringBase& text) const {
static const char * formatString = "(data = %p, size = %u, context = %u)";
static const char* formatString = "(data = %p, size = %u, context = %u)";
text.format(formatString, this->m_bufferData, this->m_size, this->m_context);
}
#endif
#ifdef BUILD_UT
std::ostream& operator<<(std::ostream& os, const Buffer& obj) {
Fw::String str;
obj.toString(str);
os << str.toChar();
return os;
}
std::ostream& operator<<(std::ostream& os, const Buffer& obj) {
Fw::String str;
obj.toString(str);
os << str.toChar();
return os;
}
#endif
} // end namespace Fw
} // end namespace Fw

44
Fw/Buffer/Buffer.hpp
View File

@ -15,15 +15,17 @@
#include <Fw/FPrimeBasicTypes.hpp>
#include <Fw/Types/Serializable.hpp>
#if FW_SERIALIZABLE_TO_STRING
#include <Fw/Types/StringType.hpp>
#ifdef BUILD_UT
#include <iostream>
#include <Fw/Types/String.hpp>
#endif
#include <Fw/Types/StringType.hpp>
#ifdef BUILD_UT
#include <Fw/Types/String.hpp>
#include <iostream>
#endif
#endif
// Forward declaration for UTs
namespace Fw { class BufferTester; }
namespace Fw {
class BufferTester;
}
namespace Fw {
@ -43,17 +45,15 @@ namespace Fw {
//! prevent excessive copying.
//!
class Buffer : public Fw::Serializable {
friend class Fw::BufferTester;
friend class Fw::BufferTester;
public:
public:
//! The size type for a buffer
using SizeType = U32;
enum {
SERIALIZED_SIZE = sizeof(SizeType) + sizeof(U32) + sizeof(U8*), //!< Size of Fw::Buffer when serialized
NO_CONTEXT = 0xFFFFFFFF //!< Value representing no context
SERIALIZED_SIZE = sizeof(SizeType) + sizeof(U32) + sizeof(U8*), //!< Size of Fw::Buffer when serialized
NO_CONTEXT = 0xFFFFFFFF //!< Value representing no context
};
//! Construct a buffer with no context nor data
@ -73,7 +73,7 @@ public:
//! \param data: data pointer to wrap
//! \param size: size of data located at data pointer
//! \param context: user-specified context to track creation. Default: no context
Buffer(U8* data, SizeType size, U32 context=NO_CONTEXT);
Buffer(U8* data, SizeType size, U32 context = NO_CONTEXT);
//! Assignment operator to set given buffer's members from another without copying wrapped data
//!
@ -110,7 +110,6 @@ public:
//! \return representation of the wrapped data to aid in serializing to it
ExternalSerializeBufferWithMemberCopy getSerializer();
//! Returns a ExternalSerializeBufferWithMemberCopy representation of the wrapped data for deserializing
//!
//! \warning The entire buffer (up to getSize) is available for deserialization.
@ -138,7 +137,6 @@ public:
//! \return: status of serialization
Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer);
// ----------------------------------------------------------------------
// Accessor functions
// ----------------------------------------------------------------------
@ -175,7 +173,7 @@ public:
//! \param data: data pointer to wrap
//! \param size: size of data located at data pointer
//! \param context: user-specified context to track creation. Default: no context
void set(U8* data, SizeType size, U32 context=NO_CONTEXT);
void set(U8* data, SizeType size, U32 context = NO_CONTEXT);
#if FW_SERIALIZABLE_TO_STRING || BUILD_UT
//! Supports writing this buffer to a string representation
@ -188,13 +186,11 @@ public:
friend std::ostream& operator<<(std::ostream& os, const Buffer& obj);
#endif
private:
Fw::ExternalSerializeBuffer m_serialize_repr; //<! Representation for serialization and deserialization functions
U8* m_bufferData; //<! data - A pointer to the data
SizeType m_size; //<! size - The data size in bytes
U32 m_context; //!< Creation context for disposal
private:
Fw::ExternalSerializeBuffer m_serialize_repr; //<! Representation for serialization and deserialization functions
U8* m_bufferData; //<! data - A pointer to the data
SizeType m_size; //<! size - The data size in bytes
U32 m_context; //!< Creation context for disposal
};
} // end namespace Fw
} // end namespace Fw
#endif /* BUFFER_HPP_ */

232
Fw/Buffer/test/ut/TestBuffer.cpp
View File

@ -1,144 +1,137 @@
//
// Created by mstarch on 11/13/20.
//
#include "Fw/Buffer/Buffer.hpp"
#include <Fw/FPrimeBasicTypes.hpp>
#include <gtest/gtest.h>
#include <Fw/FPrimeBasicTypes.hpp>
#include "Fw/Buffer/Buffer.hpp"
#include "Fw/Types/test/ut/SerializeBufferBaseTester.hpp"
namespace Fw {
class BufferTester{
class BufferTester {
public:
// ----------------------------------------------------------------------
// Construction and destruction
// ----------------------------------------------------------------------
BufferTester() {}
~BufferTester() {}
public:
// ----------------------------------------------------------------------
// Construction and destruction
// ----------------------------------------------------------------------
BufferTester()
{
}
// ----------------------------------------------------------------------
// Tests
// ----------------------------------------------------------------------
void test_basic() {
U8 data[100];
U8 faux[100];
Fw::Buffer buffer;
// Check basic guarantees
ASSERT_EQ(buffer.m_context, Fw::Buffer::NO_CONTEXT);
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);
ASSERT_EQ(buffer.getData(), data);
ASSERT_EQ(buffer.getSize(), sizeof(data));
ASSERT_EQ(buffer.getContext(), 1234);
~BufferTester()
{
}
// Test set method is equivalent
Fw::Buffer buffer_set;
buffer_set.set(data, sizeof(data), 1234);
ASSERT_EQ(buffer_set, buffer);
// ----------------------------------------------------------------------
// Tests
// ----------------------------------------------------------------------
void test_basic() {
U8 data[100];
U8 faux[100];
Fw::Buffer buffer;
// Check basic guarantees
ASSERT_EQ(buffer.m_context, Fw::Buffer::NO_CONTEXT);
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);
ASSERT_EQ(buffer.getData(), data);
ASSERT_EQ(buffer.getSize(), sizeof(data));
ASSERT_EQ(buffer.getContext(), 1234);
// Check constructors and assignments
Fw::Buffer buffer_new(buffer);
ASSERT_EQ(buffer_new.getData(), data);
ASSERT_EQ(buffer_new.getSize(), sizeof(data));
ASSERT_EQ(buffer_new.getContext(), 1234);
ASSERT_EQ(buffer, buffer_new);
// Test set method is equivalent
Fw::Buffer buffer_set;
buffer_set.set(data, sizeof(data), 1234);
ASSERT_EQ(buffer_set, buffer);
// Creating empty buffer
Fw::Buffer testBuffer(nullptr, 0);
ASSERT_EQ(testBuffer.getData(), nullptr);
ASSERT_EQ(testBuffer.getSize(), 0);
// Check constructors and assignments
Fw::Buffer buffer_new(buffer);
ASSERT_EQ(buffer_new.getData(), data);
ASSERT_EQ(buffer_new.getSize(), sizeof(data));
ASSERT_EQ(buffer_new.getContext(), 1234);
ASSERT_EQ(buffer, buffer_new);
// Assignment operator with transitivity
Fw::Buffer buffer_assignment1, buffer_assignment2;
ASSERT_NE(buffer_assignment1.getData(), data);
ASSERT_NE(buffer_assignment1.getSize(), sizeof(data));
ASSERT_NE(buffer_assignment1.getContext(), 1234);
ASSERT_NE(buffer_assignment2.getData(), data);
ASSERT_NE(buffer_assignment2.getSize(), sizeof(data));
ASSERT_NE(buffer_assignment2.getContext(), 1234);
buffer_assignment1 = buffer_assignment2 = buffer;
ASSERT_EQ(buffer_assignment1.getData(), data);
ASSERT_EQ(buffer_assignment1.getSize(), sizeof(data));
ASSERT_EQ(buffer_assignment1.getContext(), 1234);
ASSERT_EQ(buffer_assignment2.getData(), data);
ASSERT_EQ(buffer_assignment2.getSize(), sizeof(data));
ASSERT_EQ(buffer_assignment2.getContext(), 1234);
// Creating empty buffer
Fw::Buffer testBuffer(nullptr,0);
ASSERT_EQ(testBuffer.getData(), nullptr);
ASSERT_EQ(testBuffer.getSize(), 0);
// Check modifying the copies does not destroy
buffer_new.setSize(0);
buffer_new.setData(faux);
buffer_new.setContext(22222);
buffer_assignment1.setSize(0);
buffer_assignment1.setData(faux);
buffer_assignment1.setContext(22222);
buffer_assignment2.setSize(0);
buffer_assignment2.setData(faux);
buffer_assignment2.setContext(22222);
// Assignment operator with transitivity
Fw::Buffer buffer_assignment1, buffer_assignment2;
ASSERT_NE(buffer_assignment1.getData(), data);
ASSERT_NE(buffer_assignment1.getSize(), sizeof(data));
ASSERT_NE(buffer_assignment1.getContext(), 1234);
ASSERT_NE(buffer_assignment2.getData(), data);
ASSERT_NE(buffer_assignment2.getSize(), sizeof(data));
ASSERT_NE(buffer_assignment2.getContext(), 1234);
buffer_assignment1 = buffer_assignment2 = buffer;
ASSERT_EQ(buffer_assignment1.getData(), data);
ASSERT_EQ(buffer_assignment1.getSize(), sizeof(data));
ASSERT_EQ(buffer_assignment1.getContext(), 1234);
ASSERT_EQ(buffer_assignment2.getData(), data);
ASSERT_EQ(buffer_assignment2.getSize(), sizeof(data));
ASSERT_EQ(buffer_assignment2.getContext(), 1234);
ASSERT_EQ(buffer.getData(), data);
ASSERT_EQ(buffer.getSize(), sizeof(data));
ASSERT_EQ(buffer.getContext(), 1234);
}
// Check modifying the copies does not destroy
buffer_new.setSize(0);
buffer_new.setData(faux);
buffer_new.setContext(22222);
buffer_assignment1.setSize(0);
buffer_assignment1.setData(faux);
buffer_assignment1.setContext(22222);
buffer_assignment2.setSize(0);
buffer_assignment2.setData(faux);
buffer_assignment2.setContext(22222);
void test_representations() {
U8 data[100];
Fw::Buffer buffer;
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);
ASSERT_EQ(buffer.getData(), data);
ASSERT_EQ(buffer.getSize(), sizeof(data));
ASSERT_EQ(buffer.getContext(), 1234);
}
// Test serialization and that it stops before overflowing
auto serializer = buffer.getSerializer();
for (U32 i = 0; i < sizeof(data) / 4; i++) {
ASSERT_EQ(serializer.serialize(i), Fw::FW_SERIALIZE_OK);
}
Fw::SerializeStatus stat = serializer.serialize(100);
ASSERT_NE(stat, Fw::FW_SERIALIZE_OK);
void test_representations() {
U8 data[100];
Fw::Buffer buffer;
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);
// And that another call to repr resets it
serializer.resetSer();
ASSERT_EQ(serializer.serialize(0), Fw::FW_SERIALIZE_OK);
// Test serialization and that it stops before overflowing
auto serializer = buffer.getSerializer();
for (U32 i = 0; i < sizeof(data)/4; i++) {
ASSERT_EQ(serializer.serialize(i), Fw::FW_SERIALIZE_OK);
}
Fw::SerializeStatus stat = serializer.serialize(100);
ASSERT_NE(stat, Fw::FW_SERIALIZE_OK);
// Now deserialize all the things
auto deserializer = buffer.getDeserializer();
U32 out;
for (U32 i = 0; i < sizeof(data) / 4; i++) {
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
ASSERT_EQ(i, out);
}
ASSERT_NE(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
deserializer.setBuffLen(buffer.getSize());
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
ASSERT_EQ(0, out);
}
// And that another call to repr resets it
serializer.resetSer();
ASSERT_EQ(serializer.serialize(0), Fw::FW_SERIALIZE_OK);
void test_serialization() {
U8 data[100];
U8 wire[100];
// Now deserialize all the things
auto deserializer = buffer.getDeserializer();
U32 out;
for (U32 i = 0; i < sizeof(data)/4; i++) {
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
ASSERT_EQ(i, out);
}
ASSERT_NE(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
deserializer.setBuffLen(buffer.getSize());
ASSERT_EQ(deserializer.deserialize(out), Fw::FW_SERIALIZE_OK);
ASSERT_EQ(0, out);
}
Fw::Buffer buffer;
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);
void test_serialization() {
U8 data[100];
U8 wire[100];
Fw::ExternalSerializeBuffer externalSerializeBuffer(wire, sizeof(wire));
externalSerializeBuffer.serialize(buffer);
Fw::SerializeBufferBaseTester::verifySerLocLT(externalSerializeBuffer, sizeof(data));
Fw::Buffer buffer;
buffer.setData(data);
buffer.setSize(sizeof(data));
buffer.setContext(1234);
Fw::ExternalSerializeBuffer externalSerializeBuffer(wire, sizeof(wire));
externalSerializeBuffer.serialize(buffer);
Fw::SerializeBufferBaseTester::verifySerLocLT(externalSerializeBuffer, sizeof(data));
Fw::Buffer buffer_new;
externalSerializeBuffer.deserialize(buffer_new);
ASSERT_EQ(buffer_new, buffer);
}
};
}
Fw::Buffer buffer_new;
externalSerializeBuffer.deserialize(buffer_new);
ASSERT_EQ(buffer_new, buffer);
}
};
} // namespace Fw
TEST(Nominal, BasicBuffer) {
Fw::BufferTester tester;
@ -155,8 +148,7 @@ TEST(Nominal, Serialization) {
tester.test_serialization();
}
int main(int argc, char **argv) {
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

59
Fw/Cmd/CmdArgBuffer.cpp
View File

@ -3,43 +3,40 @@
namespace Fw {
CmdArgBuffer::CmdArgBuffer(const U8 *args, FwSizeType size) {
SerializeStatus stat = this->setBuff(args,size);
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<FwAssertArgType>(stat));
}
CmdArgBuffer::CmdArgBuffer(const U8* args, FwSizeType size) {
SerializeStatus stat = this->setBuff(args, size);
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
CmdArgBuffer::CmdArgBuffer() {
}
CmdArgBuffer::CmdArgBuffer() {}
CmdArgBuffer::~CmdArgBuffer() {
}
CmdArgBuffer::~CmdArgBuffer() {}
CmdArgBuffer::CmdArgBuffer(const CmdArgBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = this->setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<FwAssertArgType>(stat));
}
CmdArgBuffer::CmdArgBuffer(const CmdArgBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = this->setBuff(other.m_bufferData, other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
CmdArgBuffer& CmdArgBuffer::operator=(const CmdArgBuffer& other) {
if(this == &other) {
return *this;
}
SerializeStatus stat = this->setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<FwAssertArgType>(stat));
CmdArgBuffer& CmdArgBuffer::operator=(const CmdArgBuffer& other) {
if (this == &other) {
return *this;
}
FwSizeType CmdArgBuffer::getBuffCapacity() const {
return sizeof(this->m_bufferData);
}
const U8* CmdArgBuffer::getBuffAddr() const {
return this->m_bufferData;
}
U8* CmdArgBuffer::getBuffAddr() {
return this->m_bufferData;
}
SerializeStatus stat = this->setBuff(other.m_bufferData, other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
return *this;
}
FwSizeType CmdArgBuffer::getBuffCapacity() const {
return sizeof(this->m_bufferData);
}
const U8* CmdArgBuffer::getBuffAddr() const {
return this->m_bufferData;
}
U8* CmdArgBuffer::getBuffAddr() {
return this->m_bufferData;
}
} // namespace Fw

43
Fw/Cmd/CmdArgBuffer.hpp
View File

@ -13,33 +13,32 @@
#define FW_CMD_ARG_BUFFER_HPP
#include <Fw/FPrimeBasicTypes.hpp>
#include <Fw/Types/Serializable.hpp>
#include <Fw/Types/SerIds.hpp>
#include <Fw/Types/Serializable.hpp>
namespace Fw {
class CmdArgBuffer final : public SerializeBufferBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_CMD_BUFF, //!< type id for CmdArgBuffer
SERIALIZED_SIZE = FW_CMD_ARG_BUFFER_MAX_SIZE + sizeof(I32) //!< size when serialized. Buffer + size of buffer
};
CmdArgBuffer(const U8 *args, FwSizeType size); //!< buffer source constructor
CmdArgBuffer(); //!< default constructor
CmdArgBuffer(const CmdArgBuffer& other); //!< other arg buffer constructor
virtual ~CmdArgBuffer(); //!< destructor
CmdArgBuffer& operator=(const CmdArgBuffer& other); //!< Equal operator
FwSizeType getBuffCapacity() const; //!< return capacity of buffer (how much it can hold)
U8* getBuffAddr(); //!< return address of buffer (non const version)
const U8* getBuffAddr() const; //!< return address of buffer (const version)
private:
U8 m_bufferData[FW_CMD_ARG_BUFFER_MAX_SIZE]; //!< command argument buffer
class CmdArgBuffer final : public SerializeBufferBase {
public:
enum {
SERIALIZED_TYPE_ID = FW_TYPEID_CMD_BUFF, //!< type id for CmdArgBuffer
SERIALIZED_SIZE = FW_CMD_ARG_BUFFER_MAX_SIZE + sizeof(I32) //!< size when serialized. Buffer + size of buffer
};
}
CmdArgBuffer(const U8* args, FwSizeType size); //!< buffer source constructor
CmdArgBuffer(); //!< default constructor
CmdArgBuffer(const CmdArgBuffer& other); //!< other arg buffer constructor
virtual ~CmdArgBuffer(); //!< destructor
CmdArgBuffer& operator=(const CmdArgBuffer& other); //!< Equal operator
FwSizeType getBuffCapacity() const; //!< return capacity of buffer (how much it can hold)
U8* getBuffAddr(); //!< return address of buffer (non const version)
const U8* getBuffAddr() const; //!< return address of buffer (const version)
private:
U8 m_bufferData[FW_CMD_ARG_BUFFER_MAX_SIZE]; //!< command argument buffer
};
} // namespace Fw
#endif

72
Fw/Cmd/CmdPacket.cpp
View File

@ -11,55 +11,49 @@
namespace Fw {
CmdPacket::CmdPacket() : m_opcode(0) {
this->m_type = ComPacketType::FW_PACKET_COMMAND;
}
CmdPacket::CmdPacket() : m_opcode(0) {
this->m_type = ComPacketType::FW_PACKET_COMMAND;
}
CmdPacket::~CmdPacket() {
}
CmdPacket::~CmdPacket() {}
SerializeStatus CmdPacket::serialize(SerializeBufferBase& buffer) const {
// Shouldn't be called
FW_ASSERT(0);
return FW_SERIALIZE_OK; // for compiler
}
SerializeStatus CmdPacket::deserialize(SerializeBufferBase& buffer) {
SerializeStatus stat = ComPacket::deserializeBase(buffer);
if (stat != FW_SERIALIZE_OK) {
return stat;
}
// double check packet type
if (this->m_type != ComPacketType::FW_PACKET_COMMAND) {
return FW_DESERIALIZE_TYPE_MISMATCH;
}
stat = buffer.deserialize(this->m_opcode);
if (stat != FW_SERIALIZE_OK) {
return stat;
}
// if non-empty, copy data
if (buffer.getBuffLeft()) {
// copy the serialized arguments to the buffer
stat = buffer.copyRaw(this->m_argBuffer,buffer.getBuffLeft());
}
SerializeStatus CmdPacket::serialize(SerializeBufferBase& buffer) const {
// Shouldn't be called
FW_ASSERT(0);
return FW_SERIALIZE_OK; // for compiler
}
SerializeStatus CmdPacket::deserialize(SerializeBufferBase& buffer) {
SerializeStatus stat = ComPacket::deserializeBase(buffer);
if (stat != FW_SERIALIZE_OK) {
return stat;
}
FwOpcodeType CmdPacket::getOpCode() const {
return this->m_opcode;
// double check packet type
if (this->m_type != ComPacketType::FW_PACKET_COMMAND) {
return FW_DESERIALIZE_TYPE_MISMATCH;
}
CmdArgBuffer& CmdPacket::getArgBuffer() {
return this->m_argBuffer;
stat = buffer.deserialize(this->m_opcode);
if (stat != FW_SERIALIZE_OK) {
return stat;
}
// if non-empty, copy data
if (buffer.getBuffLeft()) {
// copy the serialized arguments to the buffer
stat = buffer.copyRaw(this->m_argBuffer, buffer.getBuffLeft());
}
return stat;
}
FwOpcodeType CmdPacket::getOpCode() const {
return this->m_opcode;
}
CmdArgBuffer& CmdPacket::getArgBuffer() {
return this->m_argBuffer;
}
} /* namespace Fw */

27
Fw/Cmd/CmdPacket.hpp
View File

@ -8,26 +8,25 @@
#ifndef CMDPACKET_HPP_
#define CMDPACKET_HPP_
#include <Fw/Com/ComPacket.hpp>
#include <Fw/Cmd/CmdArgBuffer.hpp>
#include <Fw/Com/ComPacket.hpp>
namespace Fw {
class CmdPacket : public ComPacket {
public:
class CmdPacket : public ComPacket {
public:
CmdPacket();
virtual ~CmdPacket();
CmdPacket();
virtual ~CmdPacket();
SerializeStatus serialize(SerializeBufferBase& buffer) const; //!< serialize contents
SerializeStatus deserialize(SerializeBufferBase& buffer);
FwOpcodeType getOpCode() const;
CmdArgBuffer& getArgBuffer();
SerializeStatus serialize(SerializeBufferBase& buffer) const; //!< serialize contents
SerializeStatus deserialize(SerializeBufferBase& buffer);
FwOpcodeType getOpCode() const;
CmdArgBuffer& getArgBuffer();
protected:
FwOpcodeType m_opcode;
CmdArgBuffer m_argBuffer;
};
protected:
FwOpcodeType m_opcode;
CmdArgBuffer m_argBuffer;
};
} /* namespace Fw */

59
Fw/Com/ComBuffer.cpp
View File

@ -3,43 +3,40 @@
namespace Fw {
ComBuffer::ComBuffer(const U8 *args, FwSizeType size) {
SerializeStatus stat = SerializeBufferBase::setBuff(args,size);
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<FwAssertArgType>(stat));
}
ComBuffer::ComBuffer(const U8* args, FwSizeType size) {
SerializeStatus stat = SerializeBufferBase::setBuff(args, size);
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
ComBuffer::ComBuffer() {
}
ComBuffer::ComBuffer() {}
ComBuffer::~ComBuffer() {
}
ComBuffer::~ComBuffer() {}
ComBuffer::ComBuffer(const ComBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<FwAssertArgType>(stat));
}
ComBuffer::ComBuffer(const ComBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
ComBuffer& ComBuffer::operator=(const ComBuffer& other) {
if(this == &other) {
return *this;
}
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<FwAssertArgType>(stat));
ComBuffer& ComBuffer::operator=(const ComBuffer& other) {
if (this == &other) {
return *this;
}
FwSizeType ComBuffer::getBuffCapacity() const {
return sizeof(this->m_bufferData);
}
const U8* ComBuffer::getBuffAddr() const {
return this->m_bufferData;
}
U8* ComBuffer::getBuffAddr() {
return this->m_bufferData;
}
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
return *this;
}
FwSizeType ComBuffer::getBuffCapacity() const {
return sizeof(this->m_bufferData);
}
const U8* ComBuffer::getBuffAddr() const {
return this->m_bufferData;
}
U8* ComBuffer::getBuffAddr() {
return this->m_bufferData;
}
} // namespace Fw

41
Fw/Com/ComBuffer.hpp
View File

@ -17,28 +17,27 @@
namespace Fw {
class ComBuffer final : public SerializeBufferBase {
public:
enum {
SERIALIZED_TYPE_ID = 1010,
SERIALIZED_SIZE = FW_COM_BUFFER_MAX_SIZE + sizeof(FwBuffSizeType) // size of buffer + storage of size word
};
ComBuffer(const U8 *args, FwSizeType size);
ComBuffer();
ComBuffer(const ComBuffer& other);
virtual ~ComBuffer();
ComBuffer& operator=(const ComBuffer& other);
FwSizeType getBuffCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;
private:
U8 m_bufferData[FW_COM_BUFFER_MAX_SIZE]; // packet data buffer
class ComBuffer final : public SerializeBufferBase {
public:
enum {
SERIALIZED_TYPE_ID = 1010,
SERIALIZED_SIZE = FW_COM_BUFFER_MAX_SIZE + sizeof(FwBuffSizeType) // size of buffer + storage of size word
};
}
ComBuffer(const U8* args, FwSizeType size);
ComBuffer();
ComBuffer(const ComBuffer& other);
virtual ~ComBuffer();
ComBuffer& operator=(const ComBuffer& other);
FwSizeType getBuffCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;
private:
U8 m_bufferData[FW_COM_BUFFER_MAX_SIZE]; // packet data buffer
};
} // namespace Fw
#endif

27
Fw/Com/ComPacket.cpp
View File

@ -9,24 +9,21 @@
namespace Fw {
ComPacket::ComPacket() : m_type(ComPacketType::FW_PACKET_UNKNOWN) {
}
ComPacket::ComPacket() : m_type(ComPacketType::FW_PACKET_UNKNOWN) {}
ComPacket::~ComPacket() {
}
ComPacket::~ComPacket() {}
SerializeStatus ComPacket::serializeBase(SerializeBufferBase& buffer) const {
return buffer.serialize(static_cast<FwPacketDescriptorType>(this->m_type));
}
SerializeStatus ComPacket::serializeBase(SerializeBufferBase& buffer) const {
return buffer.serialize(static_cast<FwPacketDescriptorType>(this->m_type));
}
SerializeStatus ComPacket::deserializeBase(SerializeBufferBase& buffer) {
FwPacketDescriptorType serVal;
SerializeStatus stat = buffer.deserialize(serVal);
if (FW_SERIALIZE_OK == stat) {
this->m_type = static_cast<ComPacketType>(serVal);
}
return stat;
SerializeStatus ComPacket::deserializeBase(SerializeBufferBase& buffer) {
FwPacketDescriptorType serVal;
SerializeStatus stat = buffer.deserialize(serVal);
if (FW_SERIALIZE_OK == stat) {
this->m_type = static_cast<ComPacketType>(serVal);
}
return stat;
}
} /* namespace Fw */

25
Fw/Com/ComPacket.hpp
View File

@ -16,20 +16,21 @@
namespace Fw {
// This type is defined in config/ComCfg.fpp
using ComPacketType = ComCfg::APID::T;
// This type is defined in config/ComCfg.fpp
using ComPacketType = ComCfg::APID::T;
class ComPacket: public Serializable {
public:
class ComPacket : public Serializable {
public:
ComPacket();
virtual ~ComPacket();
ComPacket();
virtual ~ComPacket();
protected:
ComPacketType m_type;
SerializeStatus serializeBase(SerializeBufferBase& buffer) const ; // called by derived classes to serialize common fields
SerializeStatus deserializeBase(SerializeBufferBase& buffer); // called by derived classes to deserialize common fields
};
protected:
ComPacketType m_type;
SerializeStatus serializeBase(
SerializeBufferBase& buffer) const; // called by derived classes to serialize common fields
SerializeStatus deserializeBase(
SerializeBufferBase& buffer); // called by derived classes to deserialize common fields
};
} /* namespace Fw */

5
requirements.txt
View File

@ -8,8 +8,9 @@ Brotli==1.1.0
certifi==2024.8.30
chardet==5.2.0
charset-normalizer==3.4.0
# no pre-built wheels for armv7l - only needed for code formatting so skip it on armv7l
clang-format==20.1.6 ; platform_machine != "armv7l"
click==8.1.7
# CMake versions prior to 3.24.2 were not signed correctly for modern macOS versions
cmake==3.26.0
colorlog==6.8.2
cookiecutter==2.6.0
@ -36,7 +37,7 @@ fprime-fpp-to-json==3.0.0a12
fprime-fpp-to-xml==3.0.0a12
fprime-fpp-to-layout==3.0.0a12
fprime-gds==4.0.0a3
fprime-tools==4.0.0a1
fprime-tools==4.0.0a2
fprime-visual==1.0.2
gcovr==8.2
idna==3.10