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

Created new SerialBufferBase as a parent of SerializeBufferBase (now renamed LinearBufferBase). (#4288)

Browse Source 
* Created new SerialBufferBase as a parent of SerializeBufferBase. Renaming interface functions to be less confusing.

* Deprecating copyRawOffset. No direct use-cases in F' core.

* Make SerialBufferBase a true pure virtual interface.

* Changing Serializable to work with SerialBufferBase parent interface.

* Changing copyRaw and copyRawOffset to work with SerialBufferBase

* Updating documentation for SerialBufferBase usage

* Adding some documentation. Adding missing ASSERT in copyRaw. Fixing some bugs that new ASSERT uncovered.

* Renaming SerializeBufferBase to LinearBufferBase. Add a using declaration to maintain backwards compatability. Properly mark LinearBufferBase functions as override.

* Filling in the rest of the docstrings for the classes in Serializable

* Removing redundant virtual keyword on override function

* Applying clang formatting

* Incorporating PR comments

* Fix compile issues

* Bump version to alpha

* Format

* v

---------

Co-authored-by: M Starch <LeStarch@googlemail.com>
This commit is contained in:
Vince Woo 2025-11-06 16:23:20 -08:00 committed by GitHub
parent b254e981a1
commit 48e4720419
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
127 changed files with 2026 additions and 692 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Drv/Ports/DataTypes/DataBuffer.cpp
View File

@ -13,7 +13,7 @@ DataBuffer::DataBuffer() {}
DataBuffer::~DataBuffer() {}
DataBuffer::DataBuffer(const DataBuffer& other) : Fw::SerializeBufferBase() {
Fw::SerializeStatus stat = Fw::SerializeBufferBase::setBuff(other.m_data, other.getBuffLength());
Fw::SerializeStatus stat = Fw::SerializeBufferBase::setBuff(other.m_data, other.getSize());
FW_ASSERT(Fw::FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
@ -22,15 +22,19 @@ DataBuffer& DataBuffer::operator=(const DataBuffer& other) {
return *this;
}
Fw::SerializeStatus stat = Fw::SerializeBufferBase::setBuff(other.m_data, other.getBuffLength());
Fw::SerializeStatus stat = Fw::SerializeBufferBase::setBuff(other.m_data, other.getSize());
FW_ASSERT(Fw::FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
return *this;
}
FwSizeType DataBuffer::getBuffCapacity() const {
FwSizeType DataBuffer::getCapacity() const {
return sizeof(this->m_data);
}
FwSizeType DataBuffer::getBuffCapacity() const {
return this->getCapacity();
}
const U8* DataBuffer::getBuffAddr() const {
return this->m_data;
}

4
Drv/Ports/DataTypes/DataBuffer.hpp
View File

@ -20,7 +20,9 @@ class DataBuffer : public Fw::SerializeBufferBase {
virtual ~DataBuffer();
DataBuffer& operator=(const DataBuffer& other);
FwSizeType getBuffCapacity() const; // !< returns capacity, not current size, of buffer
DEPRECATED(FwSizeType getBuffCapacity() const, "Use getCapacity() instead");
FwSizeType getCapacity() const;
U8* getBuffAddr();
const U8* getBuffAddr() const;

24
FppTestProject/FppTest/component/active/ActiveTest.cpp
View File

@ -25,38 +25,38 @@ ActiveTest ::~ActiveTest() {}
// Handler implementations for user-defined serial input ports
// ----------------------------------------------------------------------
void ActiveTest ::serialAsync_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& Buffer //!< The serialization buffer
void ActiveTest ::serialAsync_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& Buffer //!< The serialization buffer
) {
this->serializeStatus = this->serialOut_out(portNum, Buffer);
}
void ActiveTest ::serialAsyncAssert_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& Buffer //!< The serialization buffer
void ActiveTest ::serialAsyncAssert_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& Buffer //!< The serialization buffer
) {
this->serializeStatus = this->serialOut_out(SerialPortIndex::ENUM, Buffer);
}
void ActiveTest ::serialAsyncBlockPriority_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& Buffer //!< The serialization buffer
void ActiveTest ::serialAsyncBlockPriority_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& Buffer //!< The serialization buffer
) {
this->serializeStatus = this->serialOut_out(SerialPortIndex::ARRAY, Buffer);
}
void ActiveTest ::serialAsyncDropPriority_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& Buffer //!< The serialization buffer
void ActiveTest ::serialAsyncDropPriority_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& Buffer //!< The serialization buffer
) {
this->serializeStatus = this->serialOut_out(SerialPortIndex::STRUCT, Buffer);
}
void ActiveTest ::serialGuarded_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& Buffer //!< The serialization buffer
void ActiveTest ::serialGuarded_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& Buffer //!< The serialization buffer
) {
this->serializeStatus = this->serialOut_out(portNum, Buffer);
}
void ActiveTest ::serialSync_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& Buffer //!< The serialization buffer
void ActiveTest ::serialSync_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& Buffer //!< The serialization buffer
) {
this->serializeStatus = this->serialOut_out(portNum, Buffer);
}

24
FppTestProject/FppTest/component/active/ActiveTest.hpp
View File

@ -34,33 +34,33 @@ class ActiveTest : public ActiveTestComponentBase {
// ----------------------------------------------------------------------
//! Handler implementation for serialAsync
void serialAsync_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& buffer //!< The serialization buffer
void serialAsync_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& buffer //!< The serialization buffer
) override;
//! Handler implementation for serialAsyncAssert
void serialAsyncAssert_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& buffer //!< The serialization buffer
void serialAsyncAssert_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& buffer //!< The serialization buffer
) override;
//! Handler implementation for serialAsyncBlockPriority
void serialAsyncBlockPriority_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& buffer //!< The serialization buffer
void serialAsyncBlockPriority_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& buffer //!< The serialization buffer
) override;
//! Handler implementation for serialAsyncDropPriority
void serialAsyncDropPriority_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& buffer //!< The serialization buffer
void serialAsyncDropPriority_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& buffer //!< The serialization buffer
) override;
//! Handler implementation for serialGuarded
void serialGuarded_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& buffer //!< The serialization buffer
void serialGuarded_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& buffer //!< The serialization buffer
) override;
//! Handler implementation for serialSync
void serialSync_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& buffer //!< The serialization buffer
void serialSync_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& buffer //!< The serialization buffer
) override;
private:

4
FppTestProject/FppTest/component/active/test/ut/ActiveTestTester.cpp
View File

@ -130,7 +130,7 @@ Fw::SerializeStatus ActiveTestTester::ActiveTestComponentBaseParamExternalDelega
const FwPrmIdType base_id,
const FwPrmIdType local_id,
const Fw::ParamValid prmStat,
Fw::SerializeBufferBase& buff) {
Fw::SerialBufferBase& buff) {
Fw::SerializeStatus stat;
(void)base_id;
@ -171,7 +171,7 @@ Fw::SerializeStatus ActiveTestTester::ActiveTestComponentBaseParamExternalDelega
Fw::SerializeStatus ActiveTestTester::ActiveTestComponentBaseParamExternalDelegate ::serializeParam(
const FwPrmIdType base_id,
const FwPrmIdType local_id,
Fw::SerializeBufferBase& buff) const {
Fw::SerialBufferBase& buff) const {
Fw::SerializeStatus stat;
(void)base_id;

9
FppTestProject/FppTest/component/active/test/ut/ActiveTestTester.hpp
View File

@ -226,14 +226,13 @@ class ActiveTestTester : public ActiveTestGTestBase {
const FwPrmIdType base_id, //!< The component base parameter ID to deserialize
const FwPrmIdType local_id, //!< The parameter local ID to deserialize
const Fw::ParamValid prmStat, //!< The parameter validity status
Fw::SerializeBufferBase& buff //!< The buffer containing the parameter to deserialize
Fw::SerialBufferBase& buff //!< The buffer containing the parameter to deserialize
) override;
//! Parameter serialization function for external parameter unit testing
Fw::SerializeStatus serializeParam(
const FwPrmIdType base_id, //!< The component base parameter ID to serialize
const FwPrmIdType local_id, //!< The parameter local ID to serialize
Fw::SerializeBufferBase& buff //!< The buffer to serialize the parameter into
Fw::SerializeStatus serializeParam(const FwPrmIdType base_id, //!< The component base parameter ID to serialize
const FwPrmIdType local_id, //!< The parameter local ID to serialize
Fw::SerialBufferBase& buff //!< The buffer to serialize the parameter into
) const override;
};

4
FppTestProject/FppTest/component/passive/test/ut/PassiveTestTester.cpp
View File

@ -129,7 +129,7 @@ Fw::SerializeStatus PassiveTestTester::PassiveTestComponentBaseParamExternalDele
const FwPrmIdType base_id,
const FwPrmIdType local_id,
const Fw::ParamValid prmStat,
Fw::SerializeBufferBase& buff) {
Fw::SerialBufferBase& buff) {
Fw::SerializeStatus stat;
(void)base_id;
@ -170,7 +170,7 @@ Fw::SerializeStatus PassiveTestTester::PassiveTestComponentBaseParamExternalDele
Fw::SerializeStatus PassiveTestTester::PassiveTestComponentBaseParamExternalDelegate ::serializeParam(
const FwPrmIdType base_id,
const FwPrmIdType local_id,
Fw::SerializeBufferBase& buff) const {
Fw::SerialBufferBase& buff) const {
Fw::SerializeStatus stat;
(void)base_id;

9
FppTestProject/FppTest/component/passive/test/ut/PassiveTestTester.hpp
View File

@ -210,14 +210,13 @@ class PassiveTestTester : public PassiveTestGTestBase {
const FwPrmIdType base_id, //!< The component base parameter ID to deserialize
const FwPrmIdType local_id, //!< The parameter local ID to deserialize
const Fw::ParamValid prmStat, //!< The parameter validity status
Fw::SerializeBufferBase& buff //!< The buffer containing the parameter to deserialize
Fw::SerialBufferBase& buff //!< The buffer containing the parameter to deserialize
) override;
//! Parameter serialization function for external parameter unit testing
Fw::SerializeStatus serializeParam(
const FwPrmIdType base_id, //!< The component base parameter ID to serialize
const FwPrmIdType local_id, //!< The parameter local ID to serialize
Fw::SerializeBufferBase& buff //!< The buffer to serialize the parameter into
Fw::SerializeStatus serializeParam(const FwPrmIdType base_id, //!< The component base parameter ID to serialize
const FwPrmIdType local_id, //!< The parameter local ID to serialize
Fw::SerialBufferBase& buff //!< The buffer to serialize the parameter into
) const override;
};

4
FppTestProject/FppTest/component/queued/test/ut/QueuedTestTester.cpp
View File

@ -130,7 +130,7 @@ Fw::SerializeStatus QueuedTestTester::QueuedTestComponentBaseParamExternalDelega
const FwPrmIdType base_id,
const FwPrmIdType local_id,
const Fw::ParamValid prmStat,
Fw::SerializeBufferBase& buff) {
Fw::SerialBufferBase& buff) {
Fw::SerializeStatus stat;
(void)base_id;
@ -171,7 +171,7 @@ Fw::SerializeStatus QueuedTestTester::QueuedTestComponentBaseParamExternalDelega
Fw::SerializeStatus QueuedTestTester::QueuedTestComponentBaseParamExternalDelegate ::serializeParam(
const FwPrmIdType base_id,
const FwPrmIdType local_id,
Fw::SerializeBufferBase& buff) const {
Fw::SerialBufferBase& buff) const {
Fw::SerializeStatus stat;
(void)base_id;

13
FppTestProject/FppTest/component/queued/test/ut/QueuedTestTester.hpp
View File

@ -82,8 +82,8 @@ class QueuedTestTester : public QueuedTestGTestBase {
//! Handler for from_serialOut
//!
void from_serialOut_handler(FwIndexType portNum, //!< The port number
Fw::SerializeBufferBase& Buffer //!< The serialization buffer
void from_serialOut_handler(FwIndexType portNum, //!< The port number
Fw::LinearBufferBase& Buffer //!< The serialization buffer
);
public:
@ -227,14 +227,13 @@ class QueuedTestTester : public QueuedTestGTestBase {
const FwPrmIdType base_id, //!< The component base parameter ID to deserialize
const FwPrmIdType local_id, //!< The parameter local ID to deserialize
const Fw::ParamValid prmStat, //!< The parameter validity status
Fw::SerializeBufferBase& buff //!< The buffer containing the parameter to deserialize
Fw::SerialBufferBase& buff //!< The buffer containing the parameter to deserialize
) override;
//! Parameter serialization function for external parameter unit testing
Fw::SerializeStatus serializeParam(
const FwPrmIdType base_id, //!< The component base parameter ID to serialize
const FwPrmIdType local_id, //!< The parameter local ID to serialize
Fw::SerializeBufferBase& buff //!< The buffer to serialize the parameter into
Fw::SerializeStatus serializeParam(const FwPrmIdType base_id, //!< The component base parameter ID to serialize
const FwPrmIdType local_id, //!< The parameter local ID to serialize
Fw::SerialBufferBase& buff //!< The buffer to serialize the parameter into
) const override;
};

10
FppTestProject/FppTest/component/tests/TesterHandlers.cpp
View File

@ -139,23 +139,23 @@ void Tester ::from_serialOut_handler(FwIndexType portNum, //!< The p
break;
case SerialPortIndex::PRIMITIVE:
status = Buffer.copyRaw(this->primitiveBuf, Buffer.getBuffCapacity());
status = Buffer.copyRaw(this->primitiveBuf, Buffer.getDeserializeSizeLeft());
break;
case SerialPortIndex::STRING:
status = Buffer.copyRaw(this->stringBuf, Buffer.getBuffCapacity());
status = Buffer.copyRaw(this->stringBuf, Buffer.getDeserializeSizeLeft());
break;
case SerialPortIndex::ENUM:
status = Buffer.copyRaw(this->enumBuf, Buffer.getBuffCapacity());
status = Buffer.copyRaw(this->enumBuf, Buffer.getDeserializeSizeLeft());
break;
case SerialPortIndex::ARRAY:
status = Buffer.copyRaw(this->arrayBuf, Buffer.getBuffCapacity());
status = Buffer.copyRaw(this->arrayBuf, Buffer.getDeserializeSizeLeft());
break;
case SerialPortIndex::STRUCT:
status = Buffer.copyRaw(this->structBuf, Buffer.getBuffCapacity());
status = Buffer.copyRaw(this->structBuf, Buffer.getDeserializeSizeLeft());
break;
}

4
FppTestProject/FppTest/state_machine/internal/harness/TestAbsType.hpp
View File

@ -48,14 +48,14 @@ struct TestAbsType final : public Fw::Serializable {
//! Serialize function
//! \return Status
Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& sbb, //!< The serialize buffer base
Fw::SerializeStatus serializeTo(Fw::SerialBufferBase& sbb, //!< The serialize buffer base
Fw::Endianness mode = Fw::Endianness::BIG) const final {
return sbb.serializeFrom(this->m_data, mode);
}
//! Deserialize method
//! \return status
Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& sbb, //!< The serialize buffer base
Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase& sbb, //!< The serialize buffer base
Fw::Endianness mode = Fw::Endianness::BIG) final {
return sbb.deserializeTo(this->m_data, mode);
}

2
FppTestProject/FppTest/state_machine/internal_instance/choice/ChoiceToChoiceTester.cpp
View File

@ -77,7 +77,7 @@ void ChoiceToChoiceTester ::smChoiceChoiceToChoice_stateMachineOverflowHook(SmId
this->m_hookCalled = true;
ASSERT_EQ(smId, SmId::smChoiceChoiceToChoice);
ASSERT_EQ(static_cast<SmChoice_ChoiceToChoice::Signal>(signal), SmChoice_ChoiceToChoice::Signal::s);
ASSERT_EQ(buffer.getBuffLeft(), 0);
ASSERT_EQ(buffer.getDeserializeSizeLeft(), 0);
}
// ----------------------------------------------------------------------

2
FppTestProject/FppTest/state_machine/internal_instance/initial/NestedTester.cpp
View File

@ -43,7 +43,7 @@ void NestedTester::FppTest_SmInstanceInitial_Nested_Nested_action_a(
void NestedTester ::smInitialNested_stateMachineOverflowHook(SmId smId,
FwEnumStoreType signal,
Fw::SerializeBufferBase& buffer) {
Fw::SerialBufferBase& buffer) {
// Nothing to do
}

6
FppTestProject/FppTest/state_machine/internal_instance/initial/NestedTester.hpp
View File

@ -78,9 +78,9 @@ class NestedTester : public NestedComponentBase {
// ----------------------------------------------------------------------
//! Overflow hook implementation for smInitialNested
void smInitialNested_stateMachineOverflowHook(SmId smId, //!< The state machine ID
FwEnumStoreType signal, //!< The signal
Fw::SerializeBufferBase& buffer //!< The message buffer
void smInitialNested_stateMachineOverflowHook(SmId smId, //!< The state machine ID
FwEnumStoreType signal, //!< The signal
Fw::SerialBufferBase& buffer //!< The message buffer
) override;
public:

9
FppTestProject/FppTest/state_machine/internal_instance/state/BasicGuardTestAbsTypeTester.cpp
View File

@ -53,17 +53,16 @@ bool BasicGuardTestAbsTypeTester::FppTest_SmState_BasicGuardTestAbsType_guard_g(
// Overflow hook implementations for internal state machines
// ----------------------------------------------------------------------
void BasicGuardTestAbsTypeTester::smStateBasicGuardTestAbsType_stateMachineOverflowHook(
SmId smId,
FwEnumStoreType signal,
Fw::SerializeBufferBase& buffer) {
void BasicGuardTestAbsTypeTester::smStateBasicGuardTestAbsType_stateMachineOverflowHook(SmId smId,
FwEnumStoreType signal,
Fw::SerialBufferBase& buffer) {
this->m_hookCalled = true;
ASSERT_EQ(smId, SmId::smStateBasicGuardTestAbsType);
ASSERT_EQ(static_cast<SmState_BasicGuardTestAbsType::Signal>(signal), SmState_BasicGuardTestAbsType::Signal::s);
SmHarness::TestAbsType value;
const auto status = buffer.deserializeTo(value);
ASSERT_EQ(status, Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buffer.getBuffLeft(), 0);
ASSERT_EQ(buffer.getDeserializeSizeLeft(), 0);
ASSERT_EQ(value, this->m_value);
}

6
FppTestProject/FppTest/state_machine/internal_instance/state/BasicGuardTestAbsTypeTester.hpp
View File

@ -83,9 +83,9 @@ class BasicGuardTestAbsTypeTester : public BasicGuardTestAbsTypeComponentBase {
// ----------------------------------------------------------------------
//! Overflow hook implementation for smStateBasicGuardTestAbsType
void smStateBasicGuardTestAbsType_stateMachineOverflowHook(SmId smId, //!< The state machine ID
FwEnumStoreType signal, //!< The signal
Fw::SerializeBufferBase& buffer //!< The message buffer
void smStateBasicGuardTestAbsType_stateMachineOverflowHook(SmId smId, //!< The state machine ID
FwEnumStoreType signal, //!< The signal
Fw::SerialBufferBase& buffer //!< The message buffer
) override;
public:

2
FppTestProject/FppTest/struct/NonPrimitiveStructTest.cpp
View File

@ -259,7 +259,7 @@ TEST_F(NonPrimitiveStructTest, Serialization) {
status = buf.serializeFrom(s);
ASSERT_EQ(status, Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buf.getBuffLength(), serializedSize);
ASSERT_EQ(buf.getSize(), serializedSize);
// Deserialize
status = buf.deserializeTo(sCopy);

2
FppTestProject/FppTest/struct/PrimitiveStructTest.cpp
View File

@ -171,7 +171,7 @@ TEST_F(PrimitiveStructTest, Serialization) {
status = buf.serializeFrom(s);
ASSERT_EQ(status, Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buf.getBuffLength(), Primitive::SERIALIZED_SIZE);
ASSERT_EQ(buf.getSize(), Primitive::SERIALIZED_SIZE);
// Deserialize
status = buf.deserializeTo(sCopy);

4
FppTestProject/FppTest/typed_tests/ArrayTest.hpp
View File

@ -182,7 +182,7 @@ TYPED_TEST_P(ArrayTest, Serialization) {
status = buf.serializeFrom(a);
ASSERT_EQ(status, Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buf.getBuffLength(), serializedSize);
ASSERT_EQ(buf.getSize(), serializedSize);
// Deserialize
status = buf.deserializeTo(aCopy);
@ -199,7 +199,7 @@ TYPED_TEST_P(ArrayTest, Serialization) {
status = buf2.serializeFrom(a);
ASSERT_NE(status, Fw::FW_SERIALIZE_OK);
ASSERT_NE(buf2.getBuffLength(), serializedSize);
ASSERT_NE(buf2.getSize(), serializedSize);
// Deserialize
status = buf2.deserializeTo(aCopy2);

4
FppTestProject/FppTest/typed_tests/EnumTest.hpp
View File

@ -168,12 +168,12 @@ TYPED_TEST_P(EnumTest, Serialization) {
status = buf.serializeFrom(validEnum);
ASSERT_EQ(status, Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buf.getBuffLength(), sizeof(typename TypeParam::SerialType));
ASSERT_EQ(buf.getSize(), sizeof(typename TypeParam::SerialType));
status = buf.serializeFrom(invalidEnum);
ASSERT_EQ(status, Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buf.getBuffLength(), sizeof(typename TypeParam::SerialType) * 2);
ASSERT_EQ(buf.getSize(), sizeof(typename TypeParam::SerialType) * 2);
// Deserialize the enums
status = buf.deserializeTo(validEnumCopy);

4
Fw/Buffer/Buffer.cpp
View File

@ -113,7 +113,7 @@ Fw::ExternalSerializeBufferWithMemberCopy Buffer::getDeserializer() {
}
}
Fw::SerializeStatus Buffer::serializeTo(Fw::SerializeBufferBase& buffer, Fw::Endianness mode) const {
Fw::SerializeStatus Buffer::serializeTo(Fw::SerialBufferBase& buffer, Fw::Endianness mode) const {
Fw::SerializeStatus stat;
#if FW_SERIALIZATION_TYPE_ID
stat = buffer.serializeFrom(static_cast<U32>(Buffer::TYPE_ID));
@ -136,7 +136,7 @@ Fw::SerializeStatus Buffer::serializeTo(Fw::SerializeBufferBase& buffer, Fw::End
return stat;
}
Fw::SerializeStatus Buffer::deserializeFrom(Fw::SerializeBufferBase& buffer, Fw::Endianness mode) {
Fw::SerializeStatus Buffer::deserializeFrom(Fw::SerialBufferBase& buffer, Fw::Endianness mode) {
Fw::SerializeStatus stat;
#if FW_SERIALIZATION_TYPE_ID

4
Fw/Buffer/Buffer.hpp
View File

@ -134,7 +134,7 @@ class Buffer : public Fw::Serializable {
//! or the serialize buffer base representation and serialize from that.
//! \param serialBuffer: serialize buffer to write data into
//! \return: status of serialization
Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& serialBuffer,
Fw::SerializeStatus serializeTo(Fw::SerialBufferBase& serialBuffer,
Fw::Endianness mode = Fw::Endianness::BIG) const;
//! Deserializes this buffer from a SerializeBufferBase
@ -145,7 +145,7 @@ class Buffer : public Fw::Serializable {
//! or the serialize buffer base representation and deserialize from that.
//! \param buffer: serialize buffer to read data into
//! \return: status of serialization
Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG);
Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG);
// ----------------------------------------------------------------------
// Accessor functions

4
Fw/Buffer/docs/sdd.md
View File

@ -93,3 +93,7 @@ sb.deserializeTo(my_byte);
sb.deserializeTo(my_data, Fw::Endianness::LITTLE);
sb.deserializeTo(my_byte, Fw::Endianness::LITTLE);
```
The objects returned by `getSerializer()` and `getDeserializer()` implement the `Fw::SerialBufferBase` interface. This
allows them to be passed directly to `Fw::Serializable::serializeTo` and `Fw::Serializable::deserializeFrom` on
user-defined serializable types.

10
Fw/Cmd/CmdArgBuffer.cpp
View File

@ -13,7 +13,7 @@ CmdArgBuffer::CmdArgBuffer() {}
CmdArgBuffer::~CmdArgBuffer() {}
CmdArgBuffer::CmdArgBuffer(const CmdArgBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = this->setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = this->setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
@ -22,15 +22,19 @@ CmdArgBuffer& CmdArgBuffer::operator=(const CmdArgBuffer& other) {
return *this;
}
SerializeStatus stat = this->setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = this->setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
return *this;
}
FwSizeType CmdArgBuffer::getBuffCapacity() const {
FwSizeType CmdArgBuffer::getCapacity() const {
return sizeof(this->m_bufferData);
}
FwSizeType CmdArgBuffer::getBuffCapacity() const {
return this->getCapacity();
}
const U8* CmdArgBuffer::getBuffAddr() const {
return this->m_bufferData;
}

8
Fw/Cmd/CmdArgBuffer.hpp
View File

@ -31,9 +31,11 @@ class CmdArgBuffer final : public SerializeBufferBase {
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)
DEPRECATED(FwSizeType getBuffCapacity() const, "Use getCapacity() instead");
FwSizeType getCapacity() 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

8
Fw/Cmd/CmdPacket.cpp
View File

@ -18,13 +18,13 @@ CmdPacket::CmdPacket() : m_opcode(0) {
CmdPacket::~CmdPacket() {}
// New serialization interface methods
SerializeStatus CmdPacket::serializeTo(SerializeBufferBase& buffer, Fw::Endianness mode) const {
SerializeStatus CmdPacket::serializeTo(SerialBufferBase& buffer, Fw::Endianness mode) const {
// Shouldn't be called, no use case for serializing CmdPackets in FSW (currently)
FW_ASSERT(0);
return FW_SERIALIZE_OK; // for compiler
}
SerializeStatus CmdPacket::deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode) {
SerializeStatus CmdPacket::deserializeFrom(SerialBufferBase& buffer, Fw::Endianness mode) {
SerializeStatus stat = ComPacket::deserializeBase(buffer);
if (stat != FW_SERIALIZE_OK) {
return stat;
@ -41,9 +41,9 @@ SerializeStatus CmdPacket::deserializeFrom(SerializeBufferBase& buffer, Fw::Endi
}
// if non-empty, copy data
if (buffer.getBuffLeft()) {
if (buffer.getDeserializeSizeLeft()) {
// copy the serialized arguments to the buffer
stat = buffer.copyRaw(this->m_argBuffer, buffer.getBuffLeft());
stat = buffer.copyRaw(this->m_argBuffer, buffer.getDeserializeSizeLeft());
}
return stat;

4
Fw/Cmd/CmdPacket.hpp
View File

@ -19,8 +19,8 @@ class CmdPacket : public ComPacket {
virtual ~CmdPacket();
// New serialization interface methods
SerializeStatus serializeTo(SerializeBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG) const;
SerializeStatus deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG);
SerializeStatus serializeTo(SerialBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG) const override;
SerializeStatus deserializeFrom(SerialBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG) override;
FwOpcodeType getOpCode() const;
CmdArgBuffer& getArgBuffer();

10
Fw/Com/ComBuffer.cpp
View File

@ -13,7 +13,7 @@ ComBuffer::ComBuffer() {}
ComBuffer::~ComBuffer() {}
ComBuffer::ComBuffer(const ComBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
@ -22,15 +22,19 @@ ComBuffer& ComBuffer::operator=(const ComBuffer& other) {
return *this;
}
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
return *this;
}
FwSizeType ComBuffer::getBuffCapacity() const {
FwSizeType ComBuffer::getCapacity() const {
return sizeof(this->m_bufferData);
}
FwSizeType ComBuffer::getBuffCapacity() const {
return this->getCapacity();
}
const U8* ComBuffer::getBuffAddr() const {
return this->m_bufferData;
}

4
Fw/Com/ComBuffer.hpp
View File

@ -30,7 +30,9 @@ class ComBuffer final : public SerializeBufferBase {
virtual ~ComBuffer();
ComBuffer& operator=(const ComBuffer& other);
FwSizeType getBuffCapacity() const; // !< returns capacity, not current size, of buffer
DEPRECATED(FwSizeType getBuffCapacity() const, "Use getCapacity() instead");
FwSizeType getCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;

4
Fw/Com/ComPacket.cpp
View File

@ -13,11 +13,11 @@ ComPacket::ComPacket() : m_type(ComPacketType::FW_PACKET_UNKNOWN) {}
ComPacket::~ComPacket() {}
SerializeStatus ComPacket::serializeBase(SerializeBufferBase& buffer) const {
SerializeStatus ComPacket::serializeBase(SerialBufferBase& buffer) const {
return buffer.serializeFrom(static_cast<FwPacketDescriptorType>(this->m_type));
}
SerializeStatus ComPacket::deserializeBase(SerializeBufferBase& buffer) {
SerializeStatus ComPacket::deserializeBase(SerialBufferBase& buffer) {
FwPacketDescriptorType serVal;
SerializeStatus stat = buffer.deserializeTo(serVal);
if (FW_SERIALIZE_OK == stat) {

4
Fw/Com/ComPacket.hpp
View File

@ -27,9 +27,9 @@ class ComPacket : public Serializable {
protected:
ComPacketType m_type;
SerializeStatus serializeBase(
SerializeBufferBase& buffer) const; // called by derived classes to serialize common fields
SerialBufferBase& buffer) const; // called by derived classes to serialize common fields
SerializeStatus deserializeBase(
SerializeBufferBase& buffer); // called by derived classes to deserialize common fields
SerialBufferBase& buffer); // called by derived classes to deserialize common fields
};
} /* namespace Fw */

3
Fw/Comp/ActiveComponentBase.cpp
View File

@ -7,7 +7,8 @@ namespace Fw {
class ActiveComponentExitSerializableBuffer : public Fw::SerializeBufferBase {
public:
FwSizeType getBuffCapacity() const { return sizeof(m_buff); }
DEPRECATED(FwSizeType getBuffCapacity() const, "Use getCapacity() instead");
FwSizeType getCapacity() const { return sizeof(m_buff); }
U8* getBuffAddr() { return m_buff; }

2
Fw/Dp/DpContainer.cpp
View File

@ -212,7 +212,7 @@ void DpContainer::setDataHash(Utils::HashBuffer hash) {
static_cast<FwAssertArgType>(dataHashOffset + HASH_DIGEST_LENGTH),
static_cast<FwAssertArgType>(bufferSize));
ExternalSerializeBuffer serialBuffer(dataHashAddr, HASH_DIGEST_LENGTH);
hash.resetSer();
hash.resetDeser();
const Fw::SerializeStatus status = hash.copyRaw(serialBuffer, HASH_DIGEST_LENGTH);
FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
}

6
Fw/Dp/test/ut/DpContainerTester.hpp
View File

@ -27,13 +27,13 @@ class DpContainerTester {
}
static bool verifyDataBufferCapacity(const Fw::DpContainer& container, FwSizeType expectedCapacity) {
return container.m_dataBuffer.getBuffCapacity() == expectedCapacity;
return container.m_dataBuffer.getCapacity() == expectedCapacity;
}
static bool isDataBufferEmpty(const Fw::DpContainer& container) {
const Fw::SerializeBufferBase& buffer = container.m_dataBuffer;
const FwSizeType buffLength = buffer.getBuffLength();
const FwSizeType buffLeft = buffer.getBuffLeft();
const FwSizeType buffLength = buffer.getSize();
const FwSizeType buffLeft = buffer.getDeserializeSizeLeft();
return buffLength == 0 && buffLeft == 0;
}

2
Fw/FilePacket/CancelPacket.cpp
View File

@ -31,7 +31,7 @@ SerializeStatus FilePacket::CancelPacket ::toBuffer(Buffer& buffer) const {
SerializeStatus FilePacket::CancelPacket ::fromSerialBuffer(SerialBuffer& serialBuffer) {
FW_ASSERT(this->m_header.m_type == T_CANCEL);
if (serialBuffer.getBuffLeft() != 0) {
if (serialBuffer.getDeserializeSizeLeft() != 0) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}

2
Fw/FilePacket/DataPacket.cpp
View File

@ -48,7 +48,7 @@ SerializeStatus FilePacket::DataPacket ::fromSerialBuffer(SerialBuffer& serialBu
return status;
}
if (serialBuffer.getBuffLeft() != this->m_dataSize) {
if (serialBuffer.getDeserializeSizeLeft() != this->m_dataSize) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}

16
Fw/Fpy/StatementArgBuffer.cpp
View File

@ -14,7 +14,7 @@ StatementArgBuffer::StatementArgBuffer() {}
StatementArgBuffer::~StatementArgBuffer() {}
StatementArgBuffer::StatementArgBuffer(const StatementArgBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
@ -23,15 +23,19 @@ StatementArgBuffer& StatementArgBuffer::operator=(const StatementArgBuffer& othe
return *this;
}
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
return *this;
}
Serializable::SizeType StatementArgBuffer::getBuffCapacity() const {
Serializable::SizeType StatementArgBuffer::getCapacity() const {
return sizeof(this->m_bufferData);
}
Serializable::SizeType StatementArgBuffer::getBuffCapacity() const {
return this->getCapacity();
}
const U8* StatementArgBuffer::getBuffAddr() const {
return this->m_bufferData;
}
@ -41,7 +45,7 @@ U8* StatementArgBuffer::getBuffAddr() {
}
bool StatementArgBuffer::operator==(const StatementArgBuffer& other) const {
if (this->getBuffLength() != other.getBuffLength()) {
if (this->getSize() != other.getSize()) {
return false;
}
@ -51,7 +55,7 @@ bool StatementArgBuffer::operator==(const StatementArgBuffer& other) const {
FW_ASSERT(us);
FW_ASSERT(them);
for (Serializable::SizeType byte = 0; byte < this->getBuffLength(); byte++) {
for (Serializable::SizeType byte = 0; byte < this->getSize(); byte++) {
if (us[byte] != them[byte]) {
return false;
}
@ -63,7 +67,7 @@ bool StatementArgBuffer::operator==(const StatementArgBuffer& other) const {
#if FW_SERIALIZABLE_TO_STRING
void StatementArgBuffer::toString(Fw::StringBase& text) const {
static const char* formatString = "(data = %p, size = %" PRI_FwSizeType ")";
text.format(formatString, &this->m_bufferData, this->getBuffLength());
text.format(formatString, &this->m_bufferData, this->getSize());
}
#endif
} // namespace Fw

4
Fw/Fpy/StatementArgBuffer.hpp
View File

@ -20,7 +20,9 @@ class StatementArgBuffer : public SerializeBufferBase {
virtual ~StatementArgBuffer();
StatementArgBuffer& operator=(const StatementArgBuffer& other);
Serializable::SizeType getBuffCapacity() const; // !< returns capacity, not current size, of buffer
DEPRECATED(Serializable::SizeType getBuffCapacity() const, "Use getCapacity() instead");
Serializable::SizeType getCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;
bool operator==(const StatementArgBuffer& other) const;

10
Fw/Log/AmpcsEvrLogPacket.cpp
View File

@ -16,7 +16,7 @@ AmpcsEvrLogPacket::AmpcsEvrLogPacket() : m_eventID(0), m_overSeqNum(0), m_catSeq
}
AmpcsEvrLogPacket::~AmpcsEvrLogPacket() {}
SerializeStatus AmpcsEvrLogPacket::serializeTo(SerializeBufferBase& buffer) const {
SerializeStatus AmpcsEvrLogPacket::serializeTo(SerialBufferBase& buffer) const {
SerializeStatus stat;
stat = buffer.serializeFrom(this->m_taskName, AMPCS_EVR_TASK_NAME_LEN, Fw::Serialization::OMIT_LENGTH);
@ -39,14 +39,12 @@ SerializeStatus AmpcsEvrLogPacket::serializeTo(SerializeBufferBase& buffer) cons
return stat;
}
return buffer.serializeFrom(this->m_logBuffer.getBuffAddr(), m_logBuffer.getBuffLength(),
Fw::Serialization::OMIT_LENGTH);
return buffer.serializeFrom(this->m_logBuffer.getBuffAddr(), m_logBuffer.getSize(), Fw::Serialization::OMIT_LENGTH);
}
SerializeStatus AmpcsEvrLogPacket::deserializeFrom(SerializeBufferBase& buffer) {
SerializeStatus AmpcsEvrLogPacket::deserializeFrom(SerialBufferBase& buffer) {
FwSizeType len;
SerializeStatus stat;
SerializeStatus stat;
len = AMPCS_EVR_TASK_NAME_LEN;
@ -70,7 +68,7 @@ SerializeStatus AmpcsEvrLogPacket::deserializeFrom(SerializeBufferBase& buffer)
return stat;
}
FwSizeType size = buffer.getBuffLeft();
FwSizeType size = buffer.getDeserializeSizeLeft();
stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), size, true);
if (stat == FW_SERIALIZE_OK) {
// Shouldn't fail

4
Fw/Log/AmpcsEvrLogPacket.hpp
View File

@ -23,8 +23,8 @@ class AmpcsEvrLogPacket : public ComPacket {
AmpcsEvrLogPacket();
virtual ~AmpcsEvrLogPacket();
SerializeStatus serializeTo(SerializeBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const; //!< serialize contents
SerializeStatus serializeTo(SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override; //!< serialize contents
SerializeStatus deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG);
void setTaskName(U8* taskName, U8 len);

10
Fw/Log/LogBuffer.cpp
View File

@ -13,7 +13,7 @@ LogBuffer::LogBuffer() {}
LogBuffer::~LogBuffer() {}
LogBuffer::LogBuffer(const LogBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
@ -22,15 +22,19 @@ LogBuffer& LogBuffer::operator=(const LogBuffer& other) {
return *this;
}
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
return *this;
}
FwSizeType LogBuffer::getBuffCapacity() const {
FwSizeType LogBuffer::getCapacity() const {
return sizeof(this->m_bufferData);
}
FwSizeType LogBuffer::getBuffCapacity() const {
return this->getCapacity();
}
const U8* LogBuffer::getBuffAddr() const {
return this->m_bufferData;
}

4
Fw/Log/LogBuffer.hpp
View File

@ -28,7 +28,9 @@ class LogBuffer final : public SerializeBufferBase {
virtual ~LogBuffer();
LogBuffer& operator=(const LogBuffer& other);
FwSizeType getBuffCapacity() const; // !< returns capacity, not current size, of buffer
DEPRECATED(FwSizeType getBuffCapacity() const, "Use getCapacity() instead");
FwSizeType getCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;

9
Fw/Log/LogPacket.cpp
View File

@ -16,7 +16,7 @@ LogPacket::LogPacket() : m_id(0) {
LogPacket::~LogPacket() {}
SerializeStatus LogPacket::serializeTo(SerializeBufferBase& buffer, Fw::Endianness mode) const {
SerializeStatus LogPacket::serializeTo(SerialBufferBase& buffer, Fw::Endianness mode) const {
SerializeStatus stat = ComPacket::serializeBase(buffer);
if (stat != FW_SERIALIZE_OK) {
return stat;
@ -33,11 +33,10 @@ SerializeStatus LogPacket::serializeTo(SerializeBufferBase& buffer, Fw::Endianne
}
// We want to add data but not size for the ground software
return buffer.serializeFrom(this->m_logBuffer.getBuffAddr(), m_logBuffer.getBuffLength(),
Fw::Serialization::OMIT_LENGTH);
return buffer.serializeFrom(this->m_logBuffer.getBuffAddr(), m_logBuffer.getSize(), Fw::Serialization::OMIT_LENGTH);
}
SerializeStatus LogPacket::deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode) {
SerializeStatus LogPacket::deserializeFrom(SerialBufferBase& buffer, Fw::Endianness mode) {
SerializeStatus stat = deserializeBase(buffer);
if (stat != FW_SERIALIZE_OK) {
return stat;
@ -54,7 +53,7 @@ SerializeStatus LogPacket::deserializeFrom(SerializeBufferBase& buffer, Fw::Endi
}
// remainder of buffer must be telemetry value
FwSizeType size = buffer.getBuffLeft();
FwSizeType size = buffer.getDeserializeSizeLeft();
stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), size, Fw::Serialization::OMIT_LENGTH);
if (stat == FW_SERIALIZE_OK) {
// Shouldn't fail

4
Fw/Log/LogPacket.hpp
View File

@ -19,9 +19,9 @@ class LogPacket : public ComPacket {
LogPacket();
virtual ~LogPacket();
SerializeStatus serializeTo(SerializeBufferBase& buffer,
SerializeStatus serializeTo(SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override; //!< serialize contents
SerializeStatus deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG) override;
SerializeStatus deserializeFrom(SerialBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG) override;
void setId(FwEventIdType id);
void setLogBuffer(const LogBuffer& buffer);

2
Fw/Port/InputPortBase.hpp
View File

@ -15,7 +15,7 @@ class InputPortBase : public PortBase {
#if FW_PORT_SERIALIZATION
virtual SerializeStatus invokeSerial(
SerializeBufferBase& buffer) = 0; // !< invoke the port with a serialized version of the call
LinearBufferBase& buffer) = 0; // !< invoke the port with a serialized version of the call
#endif
protected:

2
Fw/Port/InputSerializePort.cpp
View File

@ -14,7 +14,7 @@ void InputSerializePort::init() {
InputPortBase::init();
}
SerializeStatus InputSerializePort::invokeSerial(SerializeBufferBase& buffer) {
SerializeStatus InputSerializePort::invokeSerial(LinearBufferBase& buffer) {
FW_ASSERT(this->m_comp);
FW_ASSERT(this->m_func);

4
Fw/Port/InputSerializePort.hpp
View File

@ -17,11 +17,11 @@ class InputSerializePort final : public InputPortBase {
void init() override;
SerializeStatus invokeSerial(
SerializeBufferBase& buffer) override; // !< invoke the port with a serialized version of the call
LinearBufferBase& buffer) override; // !< invoke the port with a serialized version of the call
typedef void (*CompFuncPtr)(Fw::PassiveComponentBase* callComp,
FwIndexType portNum,
SerializeBufferBase& arg); //!< port callback definition
LinearBufferBase& arg); //!< port callback definition
void addCallComp(Fw::PassiveComponentBase* callComp, CompFuncPtr funcPtr); //!< call to register a component
protected:

10
Fw/Prm/PrmBuffer.cpp
View File

@ -13,7 +13,7 @@ ParamBuffer::ParamBuffer() {}
ParamBuffer::~ParamBuffer() {}
ParamBuffer::ParamBuffer(const ParamBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
@ -22,15 +22,19 @@ ParamBuffer& ParamBuffer::operator=(const ParamBuffer& other) {
return *this;
}
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
return *this;
}
FwSizeType ParamBuffer::getBuffCapacity() const {
FwSizeType ParamBuffer::getCapacity() const {
return sizeof(this->m_bufferData);
}
FwSizeType ParamBuffer::getBuffCapacity() const {
return this->getCapacity();
}
const U8* ParamBuffer::getBuffAddr() const {
return this->m_bufferData;
}

4
Fw/Prm/PrmBuffer.hpp
View File

@ -36,7 +36,9 @@ class ParamBuffer final : public SerializeBufferBase {
virtual ~ParamBuffer();
ParamBuffer& operator=(const ParamBuffer& other);
FwSizeType getBuffCapacity() const; // !< returns capacity, not current size, of buffer
DEPRECATED(FwSizeType getBuffCapacity() const, "Use getCapacity() instead");
FwSizeType getCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;

4
Fw/Prm/PrmExternalTypes.hpp
View File

@ -31,7 +31,7 @@ class ParamExternalDelegate {
virtual SerializeStatus deserializeParam(const FwPrmIdType base_id,
const FwPrmIdType local_id,
const ParamValid prmStat,
SerializeBufferBase& buff) = 0;
SerialBufferBase& buff) = 0;
//! Serialize a parameter into a parameter buffer
//!
@ -42,7 +42,7 @@ class ParamExternalDelegate {
//! \return: The status of the serialize operation
virtual SerializeStatus serializeParam(const FwPrmIdType base_id,
const FwPrmIdType local_id,
SerializeBufferBase& buff) const = 0;
SerialBufferBase& buff) const = 0;
};
} // namespace Fw

6
Fw/SerializableFile/SerializableFile.cpp
View File

@ -39,7 +39,7 @@ SerializableFile::Status SerializableFile::load(const char* fileName, Serializab
return FILE_OPEN_ERROR;
}
FwSizeType length = this->m_buffer.getBuffCapacity();
FwSizeType length = this->m_buffer.getCapacity();
status = file.read(this->m_buffer.getBuffAddr(), length, Os::File::WaitType::NO_WAIT);
if (Os::File::OP_OK != status) {
file.close();
@ -71,9 +71,9 @@ SerializableFile::Status SerializableFile::save(const char* fileName, Serializab
return FILE_OPEN_ERROR;
}
FwSizeType length = this->m_buffer.getBuffLength();
FwSizeType length = this->m_buffer.getSize();
status = file.write(this->m_buffer.getBuffAddr(), length);
if ((Os::File::OP_OK != status) || (length != this->m_buffer.getBuffLength())) {
if ((Os::File::OP_OK != status) || (length != this->m_buffer.getSize())) {
file.close();
return FILE_WRITE_ERROR;
}

14
Fw/Sm/SmSignalBuffer.cpp
View File

@ -16,9 +16,9 @@ SmSignalBuffer::~SmSignalBuffer() {}
SmSignalBuffer::SmSignalBuffer(const SmSignalBuffer& other) : Fw::SerializeBufferBase(), m_bufferData{} {
FW_ASSERT(other.getBuffAddr() != nullptr);
FW_ASSERT(other.getBuffLength() <= sizeof(this->m_bufferData));
FW_ASSERT(other.getSize() <= sizeof(this->m_bufferData));
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
@ -28,17 +28,21 @@ SmSignalBuffer& SmSignalBuffer::operator=(const SmSignalBuffer& other) {
}
FW_ASSERT(other.getBuffAddr() != nullptr);
FW_ASSERT(other.getBuffLength() <= sizeof(this->m_bufferData));
FW_ASSERT(other.getSize() <= sizeof(this->m_bufferData));
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
return *this;
}
Serializable::SizeType SmSignalBuffer::getBuffCapacity() const {
Serializable::SizeType SmSignalBuffer::getCapacity() const {
return sizeof(this->m_bufferData);
}
Serializable::SizeType SmSignalBuffer::getBuffCapacity() const {
return this->getCapacity();
}
const U8* SmSignalBuffer::getBuffAddr() const {
return this->m_bufferData;
}

4
Fw/Sm/SmSignalBuffer.hpp
View File

@ -28,7 +28,9 @@ class SmSignalBuffer final : public SerializeBufferBase {
virtual ~SmSignalBuffer();
SmSignalBuffer& operator=(const SmSignalBuffer& other);
Serializable::SizeType getBuffCapacity() const; // !< returns capacity, not current size, of buffer
DEPRECATED(Serializable::SizeType getBuffCapacity() const, "Use getCapacity() instead");
Serializable::SizeType getCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;

4
Fw/Time/Time.cpp
View File

@ -77,11 +77,11 @@ bool Time::operator<=(const Time& other) const {
return ((LT == c) or (EQ == c));
}
SerializeStatus Time::serializeTo(SerializeBufferBase& buffer, Fw::Endianness mode) const {
SerializeStatus Time::serializeTo(SerialBufferBase& buffer, Fw::Endianness mode) const {
return this->m_val.serializeTo(buffer, mode);
}
SerializeStatus Time::deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode) {
SerializeStatus Time::deserializeFrom(SerialBufferBase& buffer, Fw::Endianness mode) {
return this->m_val.deserializeFrom(buffer, mode);
}

4
Fw/Time/Time.hpp
View File

@ -36,9 +36,9 @@ class Time : public Serializable {
TimeBase getTimeBase()
const; // !< Time base of time. This is project specific and is meant for indicating different sources of time
FwTimeContextStoreType getContext() const; // !< get the context value
SerializeStatus serializeTo(SerializeBufferBase& buffer,
SerializeStatus serializeTo(SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override; // !< Serialize method
SerializeStatus deserializeFrom(SerializeBufferBase& buffer,
SerializeStatus deserializeFrom(SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) override; // !< Deserialize method
bool operator==(const Time& other) const;
bool operator!=(const Time& other) const;

4
Fw/Time/TimeInterval.cpp
View File

@ -53,12 +53,12 @@ bool TimeInterval::operator<=(const TimeInterval& other) const {
return ((LT == c) or (EQ == c));
}
SerializeStatus TimeInterval::serializeTo(SerializeBufferBase& buffer, Fw::Endianness mode) const {
SerializeStatus TimeInterval::serializeTo(SerialBufferBase& buffer, Fw::Endianness mode) const {
// Use TimeIntervalValue's built-in serialization
return this->m_val.serializeTo(buffer, mode);
}
SerializeStatus TimeInterval::deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode) {
SerializeStatus TimeInterval::deserializeFrom(SerialBufferBase& buffer, Fw::Endianness mode) {
// Use TimeIntervalValue's built-in deserialization
return this->m_val.deserializeFrom(buffer, mode);
}

4
Fw/Time/TimeInterval.hpp
View File

@ -30,9 +30,9 @@ class TimeInterval : public Serializable {
U32 getSeconds() const; // !< Gets seconds part of time
U32 getUSeconds() const; // !< Gets microseconds part of time
SerializeStatus serializeTo(SerializeBufferBase& buffer,
SerializeStatus serializeTo(SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override; // !< Serialize method
SerializeStatus deserializeFrom(SerializeBufferBase& buffer,
SerializeStatus deserializeFrom(SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) override; // !< Deserialize method
void add(U32 seconds, U32 mseconds); // !< Add seconds and microseconds to existing time interval
bool operator==(const TimeInterval& other) const;

10
Fw/Tlm/TlmBuffer.cpp
View File

@ -13,7 +13,7 @@ TlmBuffer::TlmBuffer() {}
TlmBuffer::~TlmBuffer() {}
TlmBuffer::TlmBuffer(const TlmBuffer& other) : Fw::SerializeBufferBase() {
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
}
@ -22,15 +22,19 @@ TlmBuffer& TlmBuffer::operator=(const TlmBuffer& other) {
return *this;
}
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getBuffLength());
SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData, other.getSize());
FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
return *this;
}
FwSizeType TlmBuffer::getBuffCapacity() const {
FwSizeType TlmBuffer::getCapacity() const {
return sizeof(this->m_bufferData);
}
FwSizeType TlmBuffer::getBuffCapacity() const {
return this->getCapacity();
}
const U8* TlmBuffer::getBuffAddr() const {
return this->m_bufferData;
}

4
Fw/Tlm/TlmBuffer.hpp
View File

@ -27,7 +27,9 @@ class TlmBuffer final : public SerializeBufferBase {
virtual ~TlmBuffer();
TlmBuffer& operator=(const TlmBuffer& other);
FwSizeType getBuffCapacity() const; // !< returns capacity, not current size, of buffer
DEPRECATED(FwSizeType getBuffCapacity() const, "Use getCapacity() instead");
FwSizeType getCapacity() const; // !< returns capacity, not current size, of buffer
U8* getBuffAddr();
const U8* getBuffAddr() const;

16
Fw/Tlm/TlmPacket.cpp
View File

@ -62,8 +62,8 @@ void TlmPacket::setBuffer(Fw::ComBuffer& buffer) {
SerializeStatus TlmPacket::addValue(FwChanIdType id, Time& timeTag, TlmBuffer& buffer) {
// check to make sure there is room for all the fields
FwSizeType left = this->m_tlmBuffer.getBuffCapacity() - this->m_tlmBuffer.getBuffLength();
if ((sizeof(FwChanIdType) + Time::SERIALIZED_SIZE + buffer.getBuffLength()) > left) {
FwSizeType left = this->m_tlmBuffer.getCapacity() - this->m_tlmBuffer.getSize();
if ((sizeof(FwChanIdType) + Time::SERIALIZED_SIZE + buffer.getSize()) > left) {
return Fw::FW_SERIALIZE_NO_ROOM_LEFT;
}
@ -82,8 +82,7 @@ SerializeStatus TlmPacket::addValue(FwChanIdType id, Time& timeTag, TlmBuffer& b
}
// telemetry buffer
stat =
this->m_tlmBuffer.serializeFrom(buffer.getBuffAddr(), buffer.getBuffLength(), Fw::Serialization::OMIT_LENGTH);
stat = this->m_tlmBuffer.serializeFrom(buffer.getBuffAddr(), buffer.getSize(), Fw::Serialization::OMIT_LENGTH);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
@ -125,25 +124,24 @@ SerializeStatus TlmPacket::extractValue(FwChanIdType& id, Time& timeTag, TlmBuff
return Fw::FW_SERIALIZE_OK;
}
SerializeStatus TlmPacket::serializeTo(SerializeBufferBase& buffer, Fw::Endianness mode) const {
SerializeStatus TlmPacket::serializeTo(SerialBufferBase& buffer, Fw::Endianness mode) const {
// serialize the number of packets
SerializeStatus stat = buffer.serializeFrom(this->m_numEntries, mode);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// Serialize the ComBuffer
return buffer.serializeFrom(this->m_tlmBuffer.getBuffAddr(), m_tlmBuffer.getBuffLength(),
Fw::Serialization::OMIT_LENGTH);
return buffer.serializeFrom(this->m_tlmBuffer.getBuffAddr(), m_tlmBuffer.getSize(), Fw::Serialization::OMIT_LENGTH);
}
SerializeStatus TlmPacket::deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode) {
SerializeStatus TlmPacket::deserializeFrom(SerialBufferBase& buffer, Fw::Endianness mode) {
// deserialize the number of packets
SerializeStatus stat = buffer.deserializeTo(this->m_numEntries, mode);
if (stat != Fw::FW_SERIALIZE_OK) {
return stat;
}
// deserialize the channel value entry buffers
FwSizeType size = buffer.getBuffLeft();
FwSizeType size = buffer.getDeserializeSizeLeft();
stat = buffer.deserializeTo(this->m_tlmBuffer.getBuffAddr(), size, Fw::Serialization::OMIT_LENGTH);
if (stat == FW_SERIALIZE_OK) {
// Shouldn't fail

4
Fw/Tlm/TlmPacket.hpp
View File

@ -22,9 +22,9 @@ class TlmPacket : public ComPacket {
//! Destructor
virtual ~TlmPacket();
SerializeStatus serializeTo(SerializeBufferBase& buffer,
SerializeStatus serializeTo(SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override; //!< serialize contents
SerializeStatus deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG) override;
SerializeStatus deserializeFrom(SerialBufferBase& buffer, Fw::Endianness mode = Fw::Endianness::BIG) override;
//! Add telemetry value to buffer.
SerializeStatus addValue(FwChanIdType id, Time& timeTag, TlmBuffer& buffer);
//! extract telemetry value - since there are potentially multiple channel values in the packet,

4
Fw/Types/PolyType.cpp
View File

@ -480,7 +480,7 @@ bool PolyType::operator<=(const PolyType& other) const {
return (this->operator<(other)) || (this->operator==(other));
}
SerializeStatus PolyType::serializeTo(SerializeBufferBase& buffer, Fw::Endianness mode) const {
SerializeStatus PolyType::serializeTo(SerialBufferBase& buffer, Fw::Endianness mode) const {
// store type
SerializeStatus stat = buffer.serializeFrom(static_cast<FwEnumStoreType>(this->m_dataType), mode);
if (stat != FW_SERIALIZE_OK) {
@ -539,7 +539,7 @@ SerializeStatus PolyType::serializeTo(SerializeBufferBase& buffer, Fw::Endiannes
return stat;
}
SerializeStatus PolyType::deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode) {
SerializeStatus PolyType::deserializeFrom(SerialBufferBase& buffer, Fw::Endianness mode) {
// get type
FwEnumStoreType des;
SerializeStatus stat = buffer.deserializeTo(des, mode);

4
Fw/Types/PolyType.hpp
View File

@ -103,9 +103,9 @@ class PolyType : public Serializable {
bool operator==(const PolyType& other) const; //!< PolyType operator==
bool operator!=(const PolyType& other) const; //!< PolyType operator!=
SerializeStatus serializeTo(SerializeBufferBase& buffer,
SerializeStatus serializeTo(SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override; //!< Serialize function
SerializeStatus deserializeFrom(SerializeBufferBase& buffer,
SerializeStatus deserializeFrom(SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) override; //!< Deserialize function
private:

6
Fw/Types/SerialBuffer.cpp
View File

@ -17,10 +17,14 @@ namespace Fw {
SerialBuffer ::SerialBuffer(U8* const data, const FwSizeType capacity) : m_data(data), m_capacity(capacity) {}
FwSizeType SerialBuffer ::getBuffCapacity() const {
FwSizeType SerialBuffer ::getCapacity() const {
return m_capacity;
}
FwSizeType SerialBuffer ::getBuffCapacity() const {
return this->getCapacity();
}
U8* SerialBuffer ::getBuffAddr() {
return m_data;
}

3
Fw/Types/SerialBuffer.hpp
View File

@ -38,7 +38,8 @@ class SerialBuffer final : public SerializeBufferBase {
// Pure virtual methods from SerializeBufferBase
// ----------------------------------------------------------------------
FwSizeType getBuffCapacity() const;
DEPRECATED(FwSizeType getBuffCapacity() const, "Use getCapacity() instead");
FwSizeType getCapacity() const;
U8* getBuffAddr();

291
Fw/Types/Serializable.cpp
View File

@ -37,32 +37,34 @@ std::ostream& operator<<(std::ostream& os, const Serializable& val) {
}
#endif
SerializeBufferBase::SerializeBufferBase() : m_serLoc(0), m_deserLoc(0) {}
SerialBufferBase::~SerialBufferBase() {}
SerializeBufferBase::~SerializeBufferBase() {}
LinearBufferBase::LinearBufferBase() : m_serLoc(0), m_deserLoc(0) {}
void SerializeBufferBase::copyFrom(const SerializeBufferBase& src) {
LinearBufferBase::~LinearBufferBase() {}
void LinearBufferBase::copyFrom(const LinearBufferBase& src) {
this->m_serLoc = src.m_serLoc;
this->m_deserLoc = src.m_deserLoc;
FW_ASSERT(src.getBuffAddr());
FW_ASSERT(this->getBuffAddr());
// destination has to be same or bigger
FW_ASSERT(src.getBuffLength() <= this->getBuffCapacity(), static_cast<FwAssertArgType>(src.getBuffLength()),
static_cast<FwAssertArgType>(this->getBuffLength()));
FW_ASSERT(src.getSize() <= this->getCapacity(), static_cast<FwAssertArgType>(src.getSize()),
static_cast<FwAssertArgType>(this->getSize()));
(void)memcpy(this->getBuffAddr(), src.getBuffAddr(), static_cast<size_t>(this->m_serLoc));
}
// Copy constructor doesn't make sense in this virtual class as there is nothing to copy. Derived classes should
// call the empty constructor and then call their own copy function
SerializeBufferBase& SerializeBufferBase::operator=(const SerializeBufferBase& src) { // lgtm[cpp/rule-of-two]
LinearBufferBase& LinearBufferBase::operator=(const LinearBufferBase& src) { // lgtm[cpp/rule-of-two]
this->copyFrom(src);
return *this;
}
// serialization routines
SerializeStatus SerializeBufferBase::serializeFrom(U8 val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(val)) - 1 >= this->getBuffCapacity()) {
SerializeStatus LinearBufferBase::serializeFrom(U8 val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(val)) - 1 >= this->getCapacity()) {
return FW_SERIALIZE_NO_ROOM_LEFT;
}
FW_ASSERT(this->getBuffAddr());
@ -73,13 +75,13 @@ SerializeStatus SerializeBufferBase::serializeFrom(U8 val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::serializeFrom(I8 val, Endianness mode) {
SerializeStatus LinearBufferBase::serializeFrom(I8 val, Endianness mode) {
return serializeFrom(static_cast<U8>(val), mode);
}
#if FW_HAS_16_BIT == 1
SerializeStatus SerializeBufferBase::serializeFrom(U16 val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(val)) - 1 >= this->getBuffCapacity()) {
SerializeStatus LinearBufferBase::serializeFrom(U16 val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(val)) - 1 >= this->getCapacity()) {
return FW_SERIALIZE_NO_ROOM_LEFT;
}
FW_ASSERT(this->getBuffAddr());
@ -103,13 +105,13 @@ SerializeStatus SerializeBufferBase::serializeFrom(U16 val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::serializeFrom(I16 val, Endianness mode) {
SerializeStatus LinearBufferBase::serializeFrom(I16 val, Endianness mode) {
return serializeFrom(static_cast<U16>(val), mode);
}
#endif
#if FW_HAS_32_BIT == 1
SerializeStatus SerializeBufferBase::serializeFrom(U32 val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(val)) - 1 >= this->getBuffCapacity()) {
SerializeStatus LinearBufferBase::serializeFrom(U32 val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(val)) - 1 >= this->getCapacity()) {
return FW_SERIALIZE_NO_ROOM_LEFT;
}
FW_ASSERT(this->getBuffAddr());
@ -137,14 +139,14 @@ SerializeStatus SerializeBufferBase::serializeFrom(U32 val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::serializeFrom(I32 val, Endianness mode) {
SerializeStatus LinearBufferBase::serializeFrom(I32 val, Endianness mode) {
return serializeFrom(static_cast<U32>(val), mode);
}
#endif
#if FW_HAS_64_BIT == 1
SerializeStatus SerializeBufferBase::serializeFrom(U64 val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(val)) - 1 >= this->getBuffCapacity()) {
SerializeStatus LinearBufferBase::serializeFrom(U64 val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(val)) - 1 >= this->getCapacity()) {
return FW_SERIALIZE_NO_ROOM_LEFT;
}
FW_ASSERT(this->getBuffAddr());
@ -180,27 +182,27 @@ SerializeStatus SerializeBufferBase::serializeFrom(U64 val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::serializeFrom(I64 val, Endianness mode) {
SerializeStatus LinearBufferBase::serializeFrom(I64 val, Endianness mode) {
return serializeFrom(static_cast<U64>(val), mode);
}
#endif
SerializeStatus SerializeBufferBase::serializeFrom(F64 val, Endianness mode) {
SerializeStatus LinearBufferBase::serializeFrom(F64 val, Endianness mode) {
// floating point values need to be byte-swapped as well, so copy to U64 and use that routine
U64 u64Val;
(void)memcpy(&u64Val, &val, sizeof(val));
return this->serializeFrom(u64Val, mode);
}
SerializeStatus SerializeBufferBase::serializeFrom(F32 val, Endianness mode) {
SerializeStatus LinearBufferBase::serializeFrom(F32 val, Endianness mode) {
// floating point values need to be byte-swapped as well, so copy to U32 and use that routine
U32 u32Val;
(void)memcpy(&u32Val, &val, sizeof(val));
return this->serializeFrom(u32Val, mode);
}
SerializeStatus SerializeBufferBase::serializeFrom(bool val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(U8)) - 1 >= this->getBuffCapacity()) {
SerializeStatus LinearBufferBase::serializeFrom(bool val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(U8)) - 1 >= this->getCapacity()) {
return FW_SERIALIZE_NO_ROOM_LEFT;
}
@ -216,24 +218,22 @@ SerializeStatus SerializeBufferBase::serializeFrom(bool val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::serializeFrom(const void* val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(void*)) - 1 >= this->getBuffCapacity()) {
SerializeStatus LinearBufferBase::serializeFrom(const void* val, Endianness mode) {
if (this->m_serLoc + static_cast<Serializable::SizeType>(sizeof(void*)) - 1 >= this->getCapacity()) {
return FW_SERIALIZE_NO_ROOM_LEFT;
}
return this->serializeFrom(reinterpret_cast<PlatformPointerCastType>(val), mode);
}
SerializeStatus SerializeBufferBase::serializeFrom(const U8* buff,
Serializable::SizeType length,
Endianness endianMode) {
SerializeStatus LinearBufferBase::serializeFrom(const U8* buff, Serializable::SizeType length, Endianness endianMode) {
return this->serializeFrom(buff, static_cast<FwSizeType>(length), Serialization::INCLUDE_LENGTH, endianMode);
}
SerializeStatus SerializeBufferBase::serializeFrom(const U8* buff,
FwSizeType length,
Serialization::t lengthMode,
Endianness endianMode) { // First serialize length
SerializeStatus LinearBufferBase::serializeFrom(const U8* buff,
FwSizeType length,
Serialization::t lengthMode,
Endianness endianMode) { // First serialize length
SerializeStatus stat;
if (lengthMode == Serialization::INCLUDE_LENGTH) {
stat = this->serializeFrom(static_cast<FwSizeStoreType>(length), endianMode);
@ -243,7 +243,7 @@ SerializeStatus SerializeBufferBase::serializeFrom(const U8* buff,
}
// make sure we have enough space
if (this->m_serLoc + length > this->getBuffCapacity()) {
if (this->m_serLoc + length > this->getCapacity()) {
return FW_SERIALIZE_NO_ROOM_LEFT;
}
@ -255,14 +255,13 @@ SerializeStatus SerializeBufferBase::serializeFrom(const U8* buff,
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::serializeFrom(const Serializable& val, Endianness mode) {
SerializeStatus LinearBufferBase::serializeFrom(const Serializable& val, Endianness mode) {
return val.serializeTo(*this, mode);
}
SerializeStatus SerializeBufferBase::serializeFrom(const SerializeBufferBase& val, Endianness mode) {
Serializable::SizeType size = val.getBuffLength();
if (this->m_serLoc + size + static_cast<Serializable::SizeType>(sizeof(FwSizeStoreType)) >
this->getBuffCapacity()) {
SerializeStatus LinearBufferBase::serializeFrom(const LinearBufferBase& val, Endianness mode) {
Serializable::SizeType size = val.getSize();
if (this->m_serLoc + size + static_cast<Serializable::SizeType>(sizeof(FwSizeStoreType)) > this->getCapacity()) {
return FW_SERIALIZE_NO_ROOM_LEFT;
}
@ -282,7 +281,7 @@ SerializeStatus SerializeBufferBase::serializeFrom(const SerializeBufferBase& va
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::serializeSize(const FwSizeType size, Endianness mode) {
SerializeStatus LinearBufferBase::serializeSize(const FwSizeType size, Endianness mode) {
SerializeStatus status = FW_SERIALIZE_OK;
if ((size < std::numeric_limits<FwSizeStoreType>::min()) || (size > std::numeric_limits<FwSizeStoreType>::max())) {
status = FW_SERIALIZE_FORMAT_ERROR;
@ -295,11 +294,11 @@ SerializeStatus SerializeBufferBase::serializeSize(const FwSizeType size, Endian
// deserialization routines
SerializeStatus SerializeBufferBase::deserializeTo(U8& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(U8& val, Endianness mode) {
// check for room
if (this->getBuffLength() == this->m_deserLoc) {
if (this->getSize() == this->m_deserLoc) {
return FW_DESERIALIZE_BUFFER_EMPTY;
} else if (this->getBuffLength() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(val))) {
} else if (this->getSize() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(val))) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
// read from current location
@ -309,11 +308,11 @@ SerializeStatus SerializeBufferBase::deserializeTo(U8& val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::deserializeTo(I8& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(I8& val, Endianness mode) {
// check for room
if (this->getBuffLength() == this->m_deserLoc) {
if (this->getSize() == this->m_deserLoc) {
return FW_DESERIALIZE_BUFFER_EMPTY;
} else if (this->getBuffLength() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(val))) {
} else if (this->getSize() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(val))) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
// read from current location
@ -324,11 +323,11 @@ SerializeStatus SerializeBufferBase::deserializeTo(I8& val, Endianness mode) {
}
#if FW_HAS_16_BIT == 1
SerializeStatus SerializeBufferBase::deserializeTo(U16& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(U16& val, Endianness mode) {
// check for room
if (this->getBuffLength() == this->m_deserLoc) {
if (this->getSize() == this->m_deserLoc) {
return FW_DESERIALIZE_BUFFER_EMPTY;
} else if (this->getBuffLength() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(val))) {
} else if (this->getSize() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(val))) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
// read from current location
@ -352,7 +351,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(U16& val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::deserializeTo(I16& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(I16& val, Endianness mode) {
U16 unsignVal;
SerializeStatus res = deserializeTo(unsignVal, mode);
if (res == SerializeStatus::FW_SERIALIZE_OK) {
@ -362,11 +361,11 @@ SerializeStatus SerializeBufferBase::deserializeTo(I16& val, Endianness mode) {
}
#endif
#if FW_HAS_32_BIT == 1
SerializeStatus SerializeBufferBase::deserializeTo(U32& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(U32& val, Endianness mode) {
// check for room
if (this->getBuffLength() == this->m_deserLoc) {
if (this->getSize() == this->m_deserLoc) {
return FW_DESERIALIZE_BUFFER_EMPTY;
} else if (this->getBuffLength() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(val))) {
} else if (this->getSize() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(val))) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
// read from current location
@ -394,7 +393,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(U32& val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::deserializeTo(I32& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(I32& val, Endianness mode) {
U32 unsignVal;
SerializeStatus res = deserializeTo(unsignVal, mode);
if (res == SerializeStatus::FW_SERIALIZE_OK) {
@ -406,11 +405,11 @@ SerializeStatus SerializeBufferBase::deserializeTo(I32& val, Endianness mode) {
#if FW_HAS_64_BIT == 1
SerializeStatus SerializeBufferBase::deserializeTo(U64& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(U64& val, Endianness mode) {
// check for room
if (this->getBuffLength() == this->m_deserLoc) {
if (this->getSize() == this->m_deserLoc) {
return FW_DESERIALIZE_BUFFER_EMPTY;
} else if (this->getBuffLength() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(val))) {
} else if (this->getSize() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(val))) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
// read from current location
@ -446,7 +445,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(U64& val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::deserializeTo(I64& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(I64& val, Endianness mode) {
U64 unsignVal;
SerializeStatus res = deserializeTo(unsignVal, mode);
if (res == SerializeStatus::FW_SERIALIZE_OK) {
@ -456,7 +455,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(I64& val, Endianness mode) {
}
#endif
SerializeStatus SerializeBufferBase::deserializeTo(F64& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(F64& val, Endianness mode) {
// deserialize as 64-bit int to handle endianness
U64 tempVal;
SerializeStatus stat = this->deserializeTo(tempVal, mode);
@ -469,11 +468,11 @@ SerializeStatus SerializeBufferBase::deserializeTo(F64& val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::deserializeTo(bool& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(bool& val, Endianness mode) {
// check for room
if (this->getBuffLength() == this->m_deserLoc) {
if (this->getSize() == this->m_deserLoc) {
return FW_DESERIALIZE_BUFFER_EMPTY;
} else if (this->getBuffLength() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(U8))) {
} else if (this->getSize() - this->m_deserLoc < static_cast<Serializable::SizeType>(sizeof(U8))) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
// read from current location
@ -490,7 +489,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(bool& val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::deserializeTo(void*& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(void*& val, Endianness mode) {
// Deserialize as pointer cast, then convert to void*
PlatformPointerCastType pointerCastVal = 0;
const SerializeStatus stat = this->deserializeTo(pointerCastVal, mode);
@ -500,7 +499,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(void*& val, Endianness mode)
return stat;
}
SerializeStatus SerializeBufferBase::deserializeTo(F32& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(F32& val, Endianness mode) {
// deserialize as 64-bit int to handle endianness
U32 tempVal;
SerializeStatus stat = this->deserializeTo(tempVal, mode);
@ -512,17 +511,17 @@ SerializeStatus SerializeBufferBase::deserializeTo(F32& val, Endianness mode) {
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::deserializeTo(U8* buff, Serializable::SizeType& length, Endianness endianMode) {
SerializeStatus LinearBufferBase::deserializeTo(U8* buff, Serializable::SizeType& length, Endianness endianMode) {
FwSizeType length_in_out = static_cast<FwSizeType>(length);
SerializeStatus status = this->deserializeTo(buff, length_in_out, Serialization::INCLUDE_LENGTH, endianMode);
length = static_cast<Serializable::SizeType>(length_in_out);
return status;
}
SerializeStatus SerializeBufferBase::deserializeTo(U8* buff,
Serializable::SizeType& length,
Serialization::t lengthMode,
Endianness endianMode) {
SerializeStatus LinearBufferBase::deserializeTo(U8* buff,
Serializable::SizeType& length,
Serialization::t lengthMode,
Endianness endianMode) {
FW_ASSERT(this->getBuffAddr());
if (lengthMode == Serialization::INCLUDE_LENGTH) {
@ -535,7 +534,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(U8* buff,
}
// make sure it fits
if ((storedLength > this->getBuffLeft()) or (storedLength > length)) {
if ((storedLength > this->getDeserializeSizeLeft()) or (storedLength > length)) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
@ -545,7 +544,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(U8* buff,
} else {
// make sure enough is left
if (length > this->getBuffLeft()) {
if (length > this->getDeserializeSizeLeft()) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
@ -556,11 +555,11 @@ SerializeStatus SerializeBufferBase::deserializeTo(U8* buff,
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::deserializeTo(Serializable& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(Serializable& val, Endianness mode) {
return val.deserializeFrom(*this, mode);
}
SerializeStatus SerializeBufferBase::deserializeTo(SerializeBufferBase& val, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeTo(LinearBufferBase& val, Endianness mode) {
FW_ASSERT(val.getBuffAddr());
SerializeStatus stat = FW_SERIALIZE_OK;
@ -574,7 +573,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(SerializeBufferBase& val, End
// make sure destination has enough room
if ((storedLength > val.getBuffCapacity()) or (storedLength > this->getBuffLeft())) {
if ((storedLength > val.getCapacity()) or (storedLength > this->getDeserializeSizeLeft())) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
@ -592,7 +591,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(SerializeBufferBase& val, End
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::deserializeSize(FwSizeType& size, Endianness mode) {
SerializeStatus LinearBufferBase::deserializeSize(FwSizeType& size, Endianness mode) {
FwSizeStoreType storedSize = 0;
Fw::SerializeStatus status = this->deserializeTo(storedSize, mode);
if (status == FW_SERIALIZE_OK) {
@ -601,21 +600,21 @@ SerializeStatus SerializeBufferBase::deserializeSize(FwSizeType& size, Endiannes
return status;
}
void SerializeBufferBase::resetSer() {
void LinearBufferBase::resetSer() {
this->m_deserLoc = 0;
this->m_serLoc = 0;
}
void SerializeBufferBase::resetDeser() {
void LinearBufferBase::resetDeser() {
this->m_deserLoc = 0;
}
SerializeStatus SerializeBufferBase::serializeSkip(FwSizeType numBytesToSkip) {
SerializeStatus LinearBufferBase::serializeSkip(FwSizeType numBytesToSkip) {
Fw::SerializeStatus status = FW_SERIALIZE_OK;
// compute new deser loc
const FwSizeType newSerLoc = this->m_serLoc + numBytesToSkip;
// check for room
if (newSerLoc <= this->getBuffCapacity()) {
if (newSerLoc <= this->getCapacity()) {
// update deser loc
this->m_serLoc = static_cast<Serializable::SizeType>(newSerLoc);
} else {
@ -624,11 +623,11 @@ SerializeStatus SerializeBufferBase::serializeSkip(FwSizeType numBytesToSkip) {
return status;
}
SerializeStatus SerializeBufferBase::deserializeSkip(FwSizeType numBytesToSkip) {
SerializeStatus LinearBufferBase::deserializeSkip(FwSizeType numBytesToSkip) {
// check for room
if (this->getBuffLength() == this->m_deserLoc) {
if (this->getSize() == this->m_deserLoc) {
return FW_DESERIALIZE_BUFFER_EMPTY;
} else if (this->getBuffLength() - this->m_deserLoc < numBytesToSkip) {
} else if (this->getSize() - this->m_deserLoc < numBytesToSkip) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
// update location in buffer to skip the value
@ -636,25 +635,25 @@ SerializeStatus SerializeBufferBase::deserializeSkip(FwSizeType numBytesToSkip)
return FW_SERIALIZE_OK;
}
SerializeStatus SerializeBufferBase::moveSerToOffset(FwSizeType offset) {
SerializeStatus LinearBufferBase::moveSerToOffset(FwSizeType offset) {
// Reset serialization
this->resetSer();
// Advance to offset
return this->serializeSkip(offset);
}
SerializeStatus SerializeBufferBase::moveDeserToOffset(FwSizeType offset) {
SerializeStatus LinearBufferBase::moveDeserToOffset(FwSizeType offset) {
// Reset deserialization
this->resetDeser();
// Advance to offset
return this->deserializeSkip(offset);
}
Serializable::SizeType SerializeBufferBase::getBuffLength() const {
Serializable::SizeType LinearBufferBase::getSize() const {
return this->m_serLoc;
}
SerializeStatus SerializeBufferBase::setBuff(const U8* src, Serializable::SizeType length) {
if (this->getBuffCapacity() < length) {
SerializeStatus LinearBufferBase::setBuff(const U8* src, Serializable::SizeType length) {
if (this->getCapacity() < length) {
return FW_SERIALIZE_NO_ROOM_LEFT;
} else {
FW_ASSERT(src);
@ -666,8 +665,8 @@ SerializeStatus SerializeBufferBase::setBuff(const U8* src, Serializable::SizeTy
}
}
SerializeStatus SerializeBufferBase::setBuffLen(Serializable::SizeType length) {
if (this->getBuffCapacity() < length) {
SerializeStatus LinearBufferBase::setBuffLen(Serializable::SizeType length) {
if (this->getCapacity() < length) {
return FW_SERIALIZE_NO_ROOM_LEFT;
} else {
this->m_serLoc = length;
@ -676,17 +675,27 @@ SerializeStatus SerializeBufferBase::setBuffLen(Serializable::SizeType length) {
}
}
Serializable::SizeType SerializeBufferBase::getBuffLeft() const {
Serializable::SizeType LinearBufferBase::getDeserializeSizeLeft() const {
FW_ASSERT(this->m_serLoc >= this->m_deserLoc, static_cast<FwAssertArgType>(this->m_serLoc),
static_cast<FwAssertArgType>(this->m_deserLoc));
return this->m_serLoc - this->m_deserLoc;
}
SerializeStatus SerializeBufferBase::copyRaw(SerializeBufferBase& dest, Serializable::SizeType size) {
Serializable::SizeType LinearBufferBase::getSerializeSizeLeft() const {
FW_ASSERT(static_cast<FwAssertArgType>(this->m_serLoc));
return this->getCapacity() - this->m_serLoc;
}
SerializeStatus LinearBufferBase::copyRaw(SerialBufferBase& dest, Serializable::SizeType size) {
// make sure there is sufficient size in destination
if (dest.getBuffCapacity() < size) {
if (dest.getCapacity() < size) {
return FW_SERIALIZE_NO_ROOM_LEFT;
}
// make sure there is sufficient buffer in source
if (this->getDeserializeSizeLeft() < size) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
// otherwise, set destination buffer to data from deserialization pointer plus size
SerializeStatus stat = dest.setBuff(&this->getBuffAddr()[this->m_deserLoc], size);
if (stat == FW_SERIALIZE_OK) {
@ -695,13 +704,13 @@ SerializeStatus SerializeBufferBase::copyRaw(SerializeBufferBase& dest, Serializ
return stat;
}
SerializeStatus SerializeBufferBase::copyRawOffset(SerializeBufferBase& dest, Serializable::SizeType size) {
SerializeStatus LinearBufferBase::copyRawOffset(SerialBufferBase& dest, Serializable::SizeType size) {
// make sure there is sufficient size in destination
if (dest.getBuffCapacity() < size + dest.getBuffLength()) {
if (dest.getCapacity() < size + dest.getSize()) {
return FW_SERIALIZE_NO_ROOM_LEFT;
}
// make sure there is sufficient buffer in source
if (this->getBuffLeft() < size) {
if (this->getDeserializeSizeLeft() < size) {
return FW_DESERIALIZE_SIZE_MISMATCH;
}
@ -715,18 +724,18 @@ SerializeStatus SerializeBufferBase::copyRawOffset(SerializeBufferBase& dest, Se
// return address of buffer not yet deserialized. This is used
// to copy the remainder of a buffer.
const U8* SerializeBufferBase::getBuffAddrLeft() const {
const U8* LinearBufferBase::getBuffAddrLeft() const {
return &this->getBuffAddr()[this->m_deserLoc];
}
//!< gets address of end of serialization. Used to manually place data at the end
U8* SerializeBufferBase::getBuffAddrSer() {
U8* LinearBufferBase::getBuffAddrSer() {
return &this->getBuffAddr()[this->m_serLoc];
}
#ifdef BUILD_UT
bool SerializeBufferBase::operator==(const SerializeBufferBase& other) const {
if (this->getBuffLength() != other.getBuffLength()) {
bool LinearBufferBase::operator==(const SerializeBufferBase& other) const {
if (this->getSize() != other.getSize()) {
return false;
}
@ -736,7 +745,7 @@ bool SerializeBufferBase::operator==(const SerializeBufferBase& other) const {
FW_ASSERT(us);
FW_ASSERT(them);
for (Serializable::SizeType byte = 0; byte < this->getBuffLength(); byte++) {
for (Serializable::SizeType byte = 0; byte < this->getSize(); byte++) {
if (us[byte] != them[byte]) {
return false;
}
@ -745,12 +754,12 @@ bool SerializeBufferBase::operator==(const SerializeBufferBase& other) const {
return true;
}
std::ostream& operator<<(std::ostream& os, const SerializeBufferBase& buff) {
std::ostream& operator<<(std::ostream& os, const LinearBufferBase& buff) {
const U8* us = buff.getBuffAddr();
FW_ASSERT(us);
for (Serializable::SizeType byte = 0; byte < buff.getBuffLength(); byte++) {
for (Serializable::SizeType byte = 0; byte < buff.getSize(); byte++) {
os << "[" << std::setw(2) << std::hex << std::setfill('0') << us[byte] << "]" << std::dec;
}
@ -780,7 +789,7 @@ void ExternalSerializeBuffer::clear() {
this->m_buffSize = 0;
}
Serializable::SizeType ExternalSerializeBuffer::getBuffCapacity() const {
Serializable::SizeType ExternalSerializeBuffer::getCapacity() const {
return this->m_buffSize;
}
@ -796,130 +805,142 @@ const U8* ExternalSerializeBuffer::getBuffAddr() const {
// Deprecated method implementations for backward compatibility
// ----------------------------------------------------------------------
SerializeStatus SerializeBufferBase::serialize(U8 val) {
Serializable::SizeType LinearBufferBase::getBuffLength() const {
return this->getSize();
}
Serializable::SizeType LinearBufferBase::getBuffLeft() {
return this->getDeserializeSizeLeft();
}
SerializeStatus LinearBufferBase::serialize(U8 val) {
return this->serializeFrom(val);
}
SerializeStatus SerializeBufferBase::serialize(I8 val) {
SerializeStatus LinearBufferBase::serialize(I8 val) {
return this->serializeFrom(val);
}
#if FW_HAS_16_BIT == 1
SerializeStatus SerializeBufferBase::serialize(U16 val) {
SerializeStatus LinearBufferBase::serialize(U16 val) {
return this->serializeFrom(val);
}
SerializeStatus SerializeBufferBase::serialize(I16 val) {
SerializeStatus LinearBufferBase::serialize(I16 val) {
return this->serializeFrom(val);
}
#endif
#if FW_HAS_32_BIT == 1
SerializeStatus SerializeBufferBase::serialize(U32 val) {
SerializeStatus LinearBufferBase::serialize(U32 val) {
return this->serializeFrom(val);
}
SerializeStatus SerializeBufferBase::serialize(I32 val) {
SerializeStatus LinearBufferBase::serialize(I32 val) {
return this->serializeFrom(val);
}
#endif
#if FW_HAS_64_BIT == 1
SerializeStatus SerializeBufferBase::serialize(U64 val) {
SerializeStatus LinearBufferBase::serialize(U64 val) {
return this->serializeFrom(val);
}
SerializeStatus SerializeBufferBase::serialize(I64 val) {
SerializeStatus LinearBufferBase::serialize(I64 val) {
return this->serializeFrom(val);
}
#endif
SerializeStatus SerializeBufferBase::serialize(F32 val) {
SerializeStatus LinearBufferBase::serialize(F32 val) {
return this->serializeFrom(val);
}
SerializeStatus SerializeBufferBase::serialize(F64 val) {
SerializeStatus LinearBufferBase::serialize(F64 val) {
return this->serializeFrom(val);
}
SerializeStatus SerializeBufferBase::serialize(bool val) {
SerializeStatus LinearBufferBase::serialize(bool val) {
return this->serializeFrom(val);
}
SerializeStatus SerializeBufferBase::serialize(const void* val) {
SerializeStatus LinearBufferBase::serialize(const void* val) {
return this->serializeFrom(val);
}
// Deprecated method for backward compatibility
SerializeStatus SerializeBufferBase::serialize(const U8* buff, FwSizeType length, bool noLength) {
SerializeStatus LinearBufferBase::serialize(const U8* buff, FwSizeType length, bool noLength) {
const Serialization::t mode = noLength ? Serialization::OMIT_LENGTH : Serialization::INCLUDE_LENGTH;
return this->serializeFrom(buff, length, mode);
}
SerializeStatus SerializeBufferBase::serialize(const U8* buff, FwSizeType length) {
SerializeStatus LinearBufferBase::serialize(const U8* buff, FwSizeType length) {
return this->serializeFrom(buff, length);
}
SerializeStatus SerializeBufferBase::serialize(const U8* buff, FwSizeType length, Serialization::t mode) {
SerializeStatus LinearBufferBase::serialize(const U8* buff, FwSizeType length, Serialization::t mode) {
return this->serializeFrom(buff, length, mode);
}
SerializeStatus SerializeBufferBase::serialize(const Serializable& val) {
SerializeStatus LinearBufferBase::serialize(const Serializable& val) {
return this->serializeFrom(val);
}
SerializeStatus SerializeBufferBase::serialize(const SerializeBufferBase& val) {
SerializeStatus LinearBufferBase::serialize(const LinearBufferBase& val) {
return this->serializeFrom(val);
}
SerializeStatus SerializeBufferBase::deserialize(U8& val) {
SerializeStatus LinearBufferBase::deserialize(U8& val) {
return this->deserializeTo(val);
}
SerializeStatus SerializeBufferBase::deserialize(I8& val) {
SerializeStatus LinearBufferBase::deserialize(I8& val) {
return this->deserializeTo(val);
}
#if FW_HAS_16_BIT == 1
SerializeStatus SerializeBufferBase::deserialize(U16& val) {
SerializeStatus LinearBufferBase::deserialize(U16& val) {
return this->deserializeTo(val);
}
SerializeStatus SerializeBufferBase::deserialize(I16& val) {
SerializeStatus LinearBufferBase::deserialize(I16& val) {
return this->deserializeTo(val);
}
#endif
#if FW_HAS_32_BIT == 1
SerializeStatus SerializeBufferBase::deserialize(U32& val) {
SerializeStatus LinearBufferBase::deserialize(U32& val) {
return this->deserializeTo(val);
}
SerializeStatus SerializeBufferBase::deserialize(I32& val) {
SerializeStatus LinearBufferBase::deserialize(I32& val) {
return this->deserializeTo(val);
}
#endif
#if FW_HAS_64_BIT == 1
SerializeStatus SerializeBufferBase::deserialize(U64& val) {
SerializeStatus LinearBufferBase::deserialize(U64& val) {
return this->deserializeTo(val);
}
SerializeStatus SerializeBufferBase::deserialize(I64& val) {
SerializeStatus LinearBufferBase::deserialize(I64& val) {
return this->deserializeTo(val);
}
#endif
SerializeStatus SerializeBufferBase::deserialize(F32& val) {
SerializeStatus LinearBufferBase::deserialize(F32& val) {
return this->deserializeTo(val);
}
SerializeStatus SerializeBufferBase::deserialize(F64& val) {
SerializeStatus LinearBufferBase::deserialize(F64& val) {
return this->deserializeTo(val);
}
SerializeStatus SerializeBufferBase::deserialize(bool& val) {
SerializeStatus LinearBufferBase::deserialize(bool& val) {
return this->deserializeTo(val);
}
SerializeStatus SerializeBufferBase::deserialize(void*& val) {
SerializeStatus LinearBufferBase::deserialize(void*& val) {
return this->deserializeTo(val);
}
// Deprecated method for backward compatibility
SerializeStatus SerializeBufferBase::deserialize(U8* buff, FwSizeType& length, bool noLength) {
SerializeStatus LinearBufferBase::deserialize(U8* buff, FwSizeType& length, bool noLength) {
const Serialization::t mode = noLength ? Serialization::OMIT_LENGTH : Serialization::INCLUDE_LENGTH;
return this->deserializeTo(buff, length, mode);
}
SerializeStatus SerializeBufferBase::deserialize(U8* buff, FwSizeType& length) {
SerializeStatus LinearBufferBase::deserialize(U8* buff, FwSizeType& length) {
return this->deserializeTo(buff, length, Serialization::INCLUDE_LENGTH);
}
SerializeStatus SerializeBufferBase::deserialize(U8* buff, FwSizeType& length, Serialization::t mode) {
SerializeStatus LinearBufferBase::deserialize(U8* buff, FwSizeType& length, Serialization::t mode) {
return this->deserializeTo(buff, length, mode);
}
SerializeStatus SerializeBufferBase::deserialize(Serializable& val) {
SerializeStatus LinearBufferBase::deserialize(Serializable& val) {
return this->deserializeTo(val);
}
SerializeStatus SerializeBufferBase::deserialize(SerializeBufferBase& val) {
SerializeStatus LinearBufferBase::deserialize(LinearBufferBase& val) {
return this->deserializeTo(val);
}
Serializable::SizeType ExternalSerializeBuffer::getBuffCapacity() const {
return this->getCapacity();
}
} // namespace Fw

1544
Fw/Types/Serializable.hpp
View File

File diff suppressed because it is too large Load Diff

6
Fw/Types/StringBase.cpp
View File

@ -139,17 +139,17 @@ StringBase::SizeType StringBase::serializedTruncatedSize(FwSizeType maxLength) c
return static_cast<SizeType>(sizeof(FwSizeStoreType)) + static_cast<SizeType>(FW_MIN(this->length(), maxLength));
}
SerializeStatus StringBase::serializeTo(SerializeBufferBase& buffer, Fw::Endianness mode) const {
SerializeStatus StringBase::serializeTo(SerialBufferBase& buffer, Fw::Endianness mode) const {
return buffer.serializeFrom(reinterpret_cast<const U8*>(this->toChar()), this->length());
}
SerializeStatus StringBase::serializeTo(SerializeBufferBase& buffer, SizeType maxLength, Fw::Endianness mode) const {
SerializeStatus StringBase::serializeTo(SerialBufferBase& buffer, SizeType maxLength, Fw::Endianness mode) const {
const FwSizeType len = FW_MIN(maxLength, this->length());
// Serialize length and then bytes
return buffer.serializeFrom(reinterpret_cast<const U8*>(this->toChar()), len, Serialization::INCLUDE_LENGTH);
}
SerializeStatus StringBase::deserializeFrom(SerializeBufferBase& buffer, Fw::Endianness mode) {
SerializeStatus StringBase::deserializeFrom(SerialBufferBase& buffer, Fw::Endianness mode) {
// Get the max size of the deserialized string
const SizeType maxSize = this->maxLength();
// Initial estimate of actual size is max size

10
Fw/Types/StringBase.hpp
View File

@ -66,18 +66,18 @@ class StringBase : public Serializable {
FormatStatus format(const CHAR* formatString, ...); //!< write formatted string to buffer
FormatStatus vformat(const CHAR* formatString, va_list args); //!< write formatted string to buffer using va_list
SerializeStatus serializeTo(SerializeBufferBase& buffer, Endianness mode = Endianness::BIG) const override;
virtual SerializeStatus serializeTo(SerializeBufferBase& buffer,
SerializeStatus serializeTo(SerialBufferBase& buffer, Endianness mode = Endianness::BIG) const override;
virtual SerializeStatus serializeTo(SerialBufferBase& buffer,
SizeType maxLen,
Endianness mode = Endianness::BIG) const;
SerializeStatus deserializeFrom(SerializeBufferBase& buffer, Endianness mode = Endianness::BIG) override;
SerializeStatus deserializeFrom(SerialBufferBase& buffer, Endianness mode = Endianness::BIG) override;
DEPRECATED(SerializeStatus serialize(SerializeBufferBase& buffer) const,
DEPRECATED(SerializeStatus serialize(SerialBufferBase& buffer) const,
"Use serializeTo(SerializeBufferBase& buffer) instead") {
return this->serializeTo(buffer);
}
DEPRECATED(SerializeStatus serialize(SerializeBufferBase& buffer, SizeType maxLen) const,
DEPRECATED(SerializeStatus serialize(SerialBufferBase& buffer, SizeType maxLen) const,
"Use serializeTo(SerializeBufferBase& buffer, SizeType maxLen) instead") {
return this->serializeTo(buffer, maxLen);
}

16
Fw/Types/test/ut/ExternalSerializeBufferTest.cpp
View File

@ -12,37 +12,37 @@ constexpr SizeType BUFFER_SIZE = 10;
U8 buffer[BUFFER_SIZE];
void serializeOK(Fw::ExternalSerializeBuffer& esb) {
const SizeType buffCapacity = esb.getBuffCapacity();
ASSERT_EQ(esb.getBuffLength(), 0);
const SizeType buffCapacity = esb.getCapacity();
ASSERT_EQ(esb.getSize(), 0);
for (SizeType i = 0; i < buffCapacity; i++) {
const U8 value = static_cast<U8>(i);
const Fw::SerializeStatus status = esb.serializeFrom(value);
ASSERT_EQ(status, Fw::FW_SERIALIZE_OK);
}
ASSERT_EQ(esb.getBuffLength(), buffCapacity);
ASSERT_EQ(esb.getSize(), buffCapacity);
}
void serializeFail(Fw::ExternalSerializeBuffer& esb) {
ASSERT_EQ(esb.getBuffLength(), esb.getBuffCapacity());
ASSERT_EQ(esb.getSize(), esb.getCapacity());
const Fw::SerializeStatus status = esb.serializeFrom(static_cast<U8>(0));
ASSERT_EQ(status, Fw::FW_SERIALIZE_NO_ROOM_LEFT);
}
void deserializeOK(Fw::ExternalSerializeBuffer& esb) {
const SizeType buffCapacity = esb.getBuffCapacity();
ASSERT_EQ(esb.getBuffLeft(), buffCapacity);
const SizeType buffCapacity = esb.getCapacity();
ASSERT_EQ(esb.getDeserializeSizeLeft(), buffCapacity);
for (SizeType i = 0; i < buffCapacity; i++) {
U8 value = 0;
const Fw::SerializeStatus status = esb.deserializeTo(value);
ASSERT_EQ(status, Fw::FW_SERIALIZE_OK);
ASSERT_EQ(value, static_cast<U8>(i));
}
ASSERT_EQ(esb.getBuffLeft(), 0);
ASSERT_EQ(esb.getDeserializeSizeLeft(), 0);
}
void deserializeFail(Fw::ExternalSerializeBuffer& esb) {
U8 value = 0;
ASSERT_EQ(esb.getBuffLeft(), 0);
ASSERT_EQ(esb.getDeserializeSizeLeft(), 0);
const Fw::SerializeStatus status = esb.deserializeTo(value);
ASSERT_EQ(status, Fw::FW_DESERIALIZE_BUFFER_EMPTY);
}

6
Fw/Types/test/ut/TypesTest.cpp
View File

@ -30,7 +30,7 @@
class SerializeTestBuffer : public Fw::SerializeBufferBase {
public:
FwSizeType getBuffCapacity() const { // !< returns capacity, not current size, of buffer
FwSizeType getCapacity() const { // !< returns capacity, not current size, of buffer
return sizeof(m_testBuff);
}
@ -887,7 +887,7 @@ struct TestStruct {
class MySerializable : public Fw::Serializable {
public:
Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& buffer,
Fw::SerializeStatus serializeTo(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override {
buffer.serializeFrom(m_testStruct.m_u32, mode);
buffer.serializeFrom(m_testStruct.m_u16, mode);
@ -897,7 +897,7 @@ class MySerializable : public Fw::Serializable {
return Fw::FW_SERIALIZE_OK;
}
Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer,
Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) override {
buffer.serializeFrom(m_testStruct.m_buff, sizeof(m_testStruct.m_buff));
buffer.serializeFrom(m_testStruct.m_f32, mode);

4
Os/Posix/RawTime.cpp
View File

@ -44,7 +44,7 @@ PosixRawTime::Status PosixRawTime::getTimeInterval(const Os::RawTime& other, Fw:
return Status::OP_OK;
}
Fw::SerializeStatus PosixRawTime::serializeTo(Fw::SerializeBufferBase& buffer, Fw::Endianness mode) const {
Fw::SerializeStatus PosixRawTime::serializeTo(Fw::SerialBufferBase& buffer, Fw::Endianness mode) const {
static_assert(PosixRawTime::SERIALIZED_SIZE >= 2 * sizeof(U32),
"PosixRawTime implementation requires at least 2*sizeof(U32) serialization size");
Fw::SerializeStatus status = buffer.serializeFrom(static_cast<U32>(this->m_handle.m_timespec.tv_sec), mode);
@ -54,7 +54,7 @@ Fw::SerializeStatus PosixRawTime::serializeTo(Fw::SerializeBufferBase& buffer, F
return buffer.serializeFrom(static_cast<U32>(this->m_handle.m_timespec.tv_nsec), mode);
}
Fw::SerializeStatus PosixRawTime::deserializeFrom(Fw::SerializeBufferBase& buffer, Fw::Endianness mode) {
Fw::SerializeStatus PosixRawTime::deserializeFrom(Fw::SerialBufferBase& buffer, Fw::Endianness mode) {
static_assert(PosixRawTime::SERIALIZED_SIZE >= 2 * sizeof(U32),
"PosixRawTime implementation requires at least 2*sizeof(U32) serialization size");
U32 sec = 0;

4
Os/Posix/RawTime.hpp
View File

@ -65,7 +65,7 @@ class PosixRawTime : public RawTimeInterface {
//!
//! \param buffer The buffer to serialize the contents into.
//! \return Fw::SerializeStatus indicating the result of the serialization.
Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& buffer,
Fw::SerializeStatus serializeTo(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override;
//! \brief Deserialize the contents of the RawTimeInterface object from a buffer.
@ -80,7 +80,7 @@ class PosixRawTime : public RawTimeInterface {
//!
//! \param buffer The buffer to deserialize the contents from.
//! \return Fw::SerializeStatus indicating the result of the deserialization.
Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer,
Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) override;
private:

8
Os/Queue.cpp
View File

@ -93,19 +93,19 @@ QueueHandle* Queue::getHandle() {
return this->m_delegate.getHandle();
}
QueueInterface::Status Queue::send(const Fw::SerializeBufferBase& message,
QueueInterface::Status Queue::send(const Fw::LinearBufferBase& message,
FwQueuePriorityType priority,
QueueInterface::BlockingType blockType) {
return this->send(message.getBuffAddr(), message.getBuffLength(), priority, blockType);
return this->send(message.getBuffAddr(), message.getSize(), priority, blockType);
}
QueueInterface::Status Queue::receive(Fw::SerializeBufferBase& destination,
QueueInterface::Status Queue::receive(Fw::LinearBufferBase& destination,
QueueInterface::BlockingType blockType,
FwQueuePriorityType& priority) {
FwSizeType actualSize = 0;
destination.resetSer(); // Reset the buffer
QueueInterface::Status status =
this->receive(destination.getBuffAddrSer(), destination.getBuffCapacity(), blockType, actualSize, priority);
this->receive(destination.getBuffAddrSer(), destination.getCapacity(), blockType, actualSize, priority);
if (status == QueueInterface::Status::OP_OK) {
Fw::SerializeStatus serializeStatus =
destination.setBuffLen(static_cast<Fw::Serializable::SizeType>(actualSize));

4
Os/Queue.hpp
View File

@ -248,7 +248,7 @@ class Queue final : public QueueInterface {
//! \param priority: priority of the message
//! \param blockType: BLOCKING to block for space or NONBLOCKING to return error when queue is full
//! \return status of the send
Status send(const Fw::SerializeBufferBase& message, FwQueuePriorityType priority, BlockingType blockType);
Status send(const Fw::LinearBufferBase& message, FwQueuePriorityType priority, BlockingType blockType);
//! \brief receive a message from a queue
//!
@ -261,7 +261,7 @@ class Queue final : public QueueInterface {
//! \param priority: (output) priority of the message
//! \param blockType: BLOCKING to block for space or NONBLOCKING to return error when queue is full
//! \return status of the send
Status receive(Fw::SerializeBufferBase& destination, BlockingType blockType, FwQueuePriorityType& priority);
Status receive(Fw::LinearBufferBase& destination, BlockingType blockType, FwQueuePriorityType& priority);
//! \brief get the queue's depth in messages
FwSizeType getDepth() const;

4
Os/RawTime.cpp
View File

@ -43,12 +43,12 @@ RawTime::Status RawTime::getTimeInterval(const Os::RawTime& other, Fw::TimeInter
return this->m_delegate.getTimeInterval(other, result);
}
Fw::SerializeStatus RawTime::serializeTo(Fw::SerializeBufferBase& buffer, Fw::Endianness mode) const {
Fw::SerializeStatus RawTime::serializeTo(Fw::SerialBufferBase& buffer, Fw::Endianness mode) const {
FW_ASSERT(&this->m_delegate == reinterpret_cast<const RawTimeInterface*>(&this->m_handle_storage[0]));
return this->m_delegate.serializeTo(buffer, mode);
}
Fw::SerializeStatus RawTime::deserializeFrom(Fw::SerializeBufferBase& buffer, Fw::Endianness mode) {
Fw::SerializeStatus RawTime::deserializeFrom(Fw::SerialBufferBase& buffer, Fw::Endianness mode) {
FW_ASSERT(&this->m_delegate == reinterpret_cast<const RawTimeInterface*>(&this->m_handle_storage[0]));
return this->m_delegate.deserializeFrom(buffer, mode);
}

8
Os/RawTime.hpp
View File

@ -77,7 +77,7 @@ class RawTimeInterface : public Fw::Serializable {
//!
//! \param buffer The buffer to serialize the contents into.
//! \return Fw::SerializeStatus indicating the result of the serialization.
virtual Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& buffer,
virtual Fw::SerializeStatus serializeTo(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const = 0;
//! \brief Deserialize the contents of the RawTimeInterface object from a buffer.
@ -92,7 +92,7 @@ class RawTimeInterface : public Fw::Serializable {
//!
//! \param buffer The buffer to deserialize the contents from.
//! \return Fw::SerializeStatus indicating the result of the deserialization.
virtual Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer,
virtual Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) = 0;
};
@ -145,7 +145,7 @@ class RawTime final : public RawTimeInterface {
//!
//! \param buffer The buffer to serialize the contents into.
//! \return Fw::SerializeStatus indicating the result of the serialization.
Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& buffer,
Fw::SerializeStatus serializeTo(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override;
//! \brief Deserialize the contents of the RawTimeInterface object from a buffer.
@ -160,7 +160,7 @@ class RawTime final : public RawTimeInterface {
//!
//! \param buffer The buffer to deserialize the contents from.
//! \return Fw::SerializeStatus indicating the result of the deserialization.
Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer,
Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) override;
// ------------------------------------------------------------

4
Os/Stub/RawTime.cpp
View File

@ -21,11 +21,11 @@ StubRawTime::Status StubRawTime::getTimeInterval(const Os::RawTime& other, Fw::T
return Status::OP_OK;
}
Fw::SerializeStatus StubRawTime::serializeTo(Fw::SerializeBufferBase& buffer, Fw::Endianness mode) const {
Fw::SerializeStatus StubRawTime::serializeTo(Fw::SerialBufferBase& buffer, Fw::Endianness mode) const {
return Fw::FW_SERIALIZE_OK;
}
Fw::SerializeStatus StubRawTime::deserializeFrom(Fw::SerializeBufferBase& buffer, Fw::Endianness mode) {
Fw::SerializeStatus StubRawTime::deserializeFrom(Fw::SerialBufferBase& buffer, Fw::Endianness mode) {
return Fw::FW_SERIALIZE_OK;
}

4
Os/Stub/RawTime.hpp
View File

@ -64,7 +64,7 @@ class StubRawTime : public RawTimeInterface {
//!
//! \param buffer The buffer to serialize the contents into.
//! \return Fw::SerializeStatus indicating the result of the serialization.
Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& buffer,
Fw::SerializeStatus serializeTo(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override;
//! \brief Deserialize the contents of the RawTimeInterface object from a buffer.
@ -79,7 +79,7 @@ class StubRawTime : public RawTimeInterface {
//!
//! \param buffer The buffer to deserialize the contents from.
//! \return Fw::SerializeStatus indicating the result of the deserialization.
Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer,
Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) override;
private:

4
Os/Stub/test/RawTime.cpp
View File

@ -38,12 +38,12 @@ TestRawTime::Status TestRawTime::getTimeInterval(const Os::RawTime& other, Fw::T
return Status::OP_OK;
}
Fw::SerializeStatus TestRawTime::serializeTo(Fw::SerializeBufferBase& buffer, Fw::Endianness mode) const {
Fw::SerializeStatus TestRawTime::serializeTo(Fw::SerialBufferBase& buffer, Fw::Endianness mode) const {
StaticData::data.lastCalled = StaticData::LastFn::SERIALIZE_FN;
return Fw::FW_SERIALIZE_OK;
}
Fw::SerializeStatus TestRawTime::deserializeFrom(Fw::SerializeBufferBase& buffer, Fw::Endianness mode) {
Fw::SerializeStatus TestRawTime::deserializeFrom(Fw::SerialBufferBase& buffer, Fw::Endianness mode) {
StaticData::data.lastCalled = StaticData::LastFn::DESERIALIZE_FN;
return Fw::FW_SERIALIZE_OK;
}

4
Os/Stub/test/RawTime.hpp
View File

@ -67,9 +67,9 @@ class TestRawTime : public RawTimeInterface {
// ------------------------------------------------------------
Status now() override;
Status getTimeInterval(const Os::RawTime& other, Fw::TimeInterval& interval) const override;
Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& buffer,
Fw::SerializeStatus serializeTo(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) const override;
Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer,
Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase& buffer,
Fw::Endianness mode = Fw::Endianness::BIG) override;
private:

8
Os/ValidateFileCommon.cpp
View File

@ -71,12 +71,12 @@ File::Status readHash(const char* hashFileName, Utils::HashBuffer& hashBuffer) {
// Read hash from checksum file:
unsigned char savedHash[HASH_DIGEST_LENGTH];
FwSizeType size = static_cast<FwSizeType>(hashBuffer.getBuffCapacity());
FwSizeType size = static_cast<FwSizeType>(hashBuffer.getCapacity());
status = hashFile.read(savedHash, size);
if (File::OP_OK != status) {
return status;
}
if (static_cast<FwSizeType>(size) != hashBuffer.getBuffCapacity()) {
if (static_cast<FwSizeType>(size) != hashBuffer.getCapacity()) {
return File::BAD_SIZE;
}
hashFile.close();
@ -98,12 +98,12 @@ File::Status writeHash(const char* hashFileName, Utils::HashBuffer hashBuffer) {
}
// Write out the hash
FwSizeType size = static_cast<FwSizeType>(hashBuffer.getBuffLength());
FwSizeType size = static_cast<FwSizeType>(hashBuffer.getSize());
status = hashFile.write(hashBuffer.getBuffAddr(), size, Os::File::WaitType::NO_WAIT);
if (File::OP_OK != status) {
return status;
}
if (static_cast<FwSizeType>(size) != hashBuffer.getBuffLength()) {
if (static_cast<FwSizeType>(size) != hashBuffer.getSize()) {
return File::BAD_SIZE;
}
hashFile.close();

2
Os/test/ut/OsValidateFileTest.cpp
View File

@ -59,7 +59,7 @@ void testValidateFile(const char* fileName) {
return;
}
Utils::HashBuffer buf;
EXPECT_TRUE(static_cast<FwSizeType>(fileSize) == buf.getBuffCapacity());
EXPECT_TRUE(static_cast<FwSizeType>(fileSize) == buf.getCapacity());
// Validate file:
printf("Validating file %s against hash file %s\n", fileName, hashFileName);

2
Svc/BufferLogger/BufferLogger.cpp
View File

@ -50,7 +50,7 @@ void BufferLogger ::bufferSendIn_handler(const FwIndexType portNum, Fw::Buffer&
void BufferLogger ::comIn_handler(FwIndexType portNum, Fw::ComBuffer& data, U32 context) {
if (m_state == LogState::LOGGING_ON) {
const U8* const addr = data.getBuffAddr();
const FwSizeType size = data.getBuffLength();
const FwSizeType size = data.getSize();
m_file.logBuffer(addr, size);
}
}

2
Svc/Ccsds/TmFramer/TmFramer.cpp
View File

@ -108,7 +108,7 @@ void TmFramer ::dataReturnIn_handler(FwIndexType portNum,
void TmFramer ::fill_with_idle_packet(Fw::SerializeBufferBase& serializer) {
constexpr U16 endIndex = ComCfg::TmFrameFixedSize - TMTrailer::SERIALIZED_SIZE;
constexpr U16 idleApid = static_cast<U16>(ComCfg::Apid::SPP_IDLE_PACKET);
const U16 startIndex = static_cast<U16>(serializer.getBuffLength());
const U16 startIndex = static_cast<U16>(serializer.getSize());
const U16 idlePacketSize = static_cast<U16>(endIndex - startIndex);
// Length token is defined as the number of bytes of payload data minus 1
const U16 lengthToken = static_cast<U16>(idlePacketSize - SpacePacketHeader::SERIALIZED_SIZE - 1);

14
Svc/CmdSequencer/FPrimeSequence.cpp
View File

@ -58,7 +58,7 @@ bool CmdSequencerComponentImpl::FPrimeSequence ::loadFile(const Fw::StringBase&
}
bool CmdSequencerComponentImpl::FPrimeSequence ::hasMoreRecords() const {
return this->m_buffer.getBuffLeft() > 0;
return this->m_buffer.getDeserializeSizeLeft() > 0;
}
void CmdSequencerComponentImpl::FPrimeSequence ::nextRecord(Record& record) {
@ -102,7 +102,7 @@ bool CmdSequencerComponentImpl::FPrimeSequence ::readOpenFile() {
status = this->deserializeHeader() and this->readRecordsAndCRC() and this->extractCRC();
}
if (status) {
const FwSizeType buffLen = this->m_buffer.getBuffLength();
const FwSizeType buffLen = this->m_buffer.getSize();
this->m_crc.update(buffAddr, buffLen);
this->m_crc.finalize();
}
@ -116,7 +116,7 @@ bool CmdSequencerComponentImpl::FPrimeSequence ::readHeader() {
FwSizeType readLen = Sequence::Header::SERIALIZED_SIZE;
const FwSizeType capacity = buffer.getBuffCapacity();
const FwSizeType capacity = buffer.getCapacity();
FW_ASSERT(capacity >= readLen, static_cast<FwAssertArgType>(capacity), static_cast<FwAssertArgType>(readLen));
Os::File::Status fileStatus = file.read(buffer.getBuffAddr(), readLen);
@ -148,7 +148,7 @@ bool CmdSequencerComponentImpl::FPrimeSequence ::deserializeHeader() {
this->m_events.fileInvalid(CmdSequencer_FileReadStage::DESER_SIZE, serializeStatus);
return false;
}
if (header.m_fileSize > buffer.getBuffCapacity()) {
if (header.m_fileSize > buffer.getCapacity()) {
this->m_events.fileSizeError(header.m_fileSize);
return false;
}
@ -203,7 +203,7 @@ bool CmdSequencerComponentImpl::FPrimeSequence ::extractCRC() {
U32& crc = this->m_crc.m_stored;
// Compute the data size
const FwSizeType buffSize = buffer.getBuffLength();
const FwSizeType buffSize = buffer.getSize();
const FwSizeType crcSize = sizeof(crc);
U8* const buffAddr = buffer.getBuffAddr();
if (buffSize < crcSize) {
@ -280,7 +280,7 @@ Fw::SerializeStatus CmdSequencerComponentImpl::FPrimeSequence ::deserializeTimeT
Fw::SerializeStatus CmdSequencerComponentImpl::FPrimeSequence ::deserializeRecordSize(U32& recordSize) {
Fw::SerializeBufferBase& buffer = this->m_buffer;
Fw::SerializeStatus status = buffer.deserializeTo(recordSize);
if (status == Fw::FW_SERIALIZE_OK and recordSize > buffer.getBuffLeft()) {
if (status == Fw::FW_SERIALIZE_OK and recordSize > buffer.getDeserializeSizeLeft()) {
// Not enough data left
status = Fw::FW_DESERIALIZE_SIZE_MISMATCH;
}
@ -322,7 +322,7 @@ bool CmdSequencerComponentImpl::FPrimeSequence ::validateRecords() {
}
}
// Check there is no data left
const FwSizeType buffLeftSize = buffer.getBuffLeft();
const FwSizeType buffLeftSize = buffer.getDeserializeSizeLeft();
if (buffLeftSize > 0) {
this->m_events.recordMismatch(numRecords, static_cast<U32>(buffLeftSize));
return false;

12
Svc/CmdSequencer/formats/AMPCSSequence.cpp
View File

@ -108,7 +108,7 @@ bool AMPCSSequence ::validateRecords() {
Sequence::Record record;
// Deserialize all records and count the records
const U32 loopBound = static_cast<U32>(buffer.getBuffLeft());
const U32 loopBound = static_cast<U32>(buffer.getDeserializeSizeLeft());
U32 numRecords = 0;
for (; numRecords < loopBound; ++numRecords) {
if (not this->hasMoreRecords()) {
@ -129,7 +129,7 @@ bool AMPCSSequence ::validateRecords() {
}
bool AMPCSSequence ::hasMoreRecords() const {
return this->m_buffer.getBuffLeft() > 0;
return this->m_buffer.getDeserializeSizeLeft() > 0;
}
void AMPCSSequence ::nextRecord(Sequence::Record& record) {
@ -186,7 +186,7 @@ bool AMPCSSequence ::readOpenSequenceFile() {
}
if (status) {
U8* const buffAddr = this->m_buffer.getBuffAddr();
const FwSizeType buffLen = this->m_buffer.getBuffLength();
const FwSizeType buffLen = this->m_buffer.getSize();
FW_ASSERT(buffLen == this->m_header.m_fileSize, static_cast<FwAssertArgType>(buffLen),
static_cast<FwAssertArgType>(this->m_header.m_fileSize));
this->m_crc.update(buffAddr, buffLen);
@ -223,7 +223,7 @@ bool AMPCSSequence ::readRecords() {
U8* const addr = buffer.getBuffAddr();
// Check file size
if (size > this->m_buffer.getBuffCapacity()) {
if (size > this->m_buffer.getCapacity()) {
this->m_events.fileSizeError(static_cast<U32>(size));
return false;
}
@ -298,7 +298,7 @@ Fw::SerializeStatus AMPCSSequence ::deserializeTime(Fw::Time& timeTag) {
Fw::SerializeStatus AMPCSSequence ::deserializeCmdLength(Record::CmdLength::t& cmdLength) {
Fw::SerializeBufferBase& buffer = this->m_buffer;
Fw::SerializeStatus status = buffer.deserializeTo(cmdLength);
if (status == Fw::FW_SERIALIZE_OK and cmdLength > buffer.getBuffLeft()) {
if (status == Fw::FW_SERIALIZE_OK and cmdLength > buffer.getDeserializeSizeLeft()) {
// Not enough data left
status = Fw::FW_DESERIALIZE_SIZE_MISMATCH;
}
@ -328,7 +328,7 @@ Fw::SerializeStatus AMPCSSequence ::translateCommand(Fw::ComBuffer& comBuffer, c
sizeOfZeros += static_cast<U32>(sizeof(zeros));
}
// Set the buffer length
const U32 fixedBuffLen = static_cast<U32>(comBuffer.getBuffLength());
const U32 fixedBuffLen = static_cast<U32>(comBuffer.getSize());
FW_ASSERT(fixedBuffLen == sizeof(cmdDescriptor) + sizeOfZeros, static_cast<FwAssertArgType>(fixedBuffLen));
const U32 totalBuffLen = fixedBuffLen + cmdLength;
status = comBuffer.setBuffLen(totalBuffLen);

2
Svc/CmdSequencer/test/ut/SequenceFiles/AMPCS/CRCs.cpp
View File

@ -61,7 +61,7 @@ void createFile(Fw::SerializeBufferBase& buffer, const char* const fileName) {
void computeCRC(Fw::SerializeBufferBase& buffer, CRC& crc) {
crc.init();
const U8* const addr = buffer.getBuffAddr();
const U32 size = buffer.getBuffLength();
const U32 size = buffer.getSize();
crc.update(addr, size);
crc.finalize();
}

2
Svc/CmdSequencer/test/ut/SequenceFiles/AMPCS/Records.cpp
View File

@ -24,7 +24,7 @@ void serialize(const AMPCSSequence::Record::TimeFlag::t timeFlag,
const Fw::SerializeBufferBase& cmdField,
Fw::SerializeBufferBase& dest) {
const AMPCSSequence::Record::TimeFlag::Serial::t serialTimeFlag = timeFlag;
const AMPCSSequence::Record::CmdLength::t cmdLength = cmdField.getBuffLength();
const AMPCSSequence::Record::CmdLength::t cmdLength = cmdField.getSize();
const U8* const addr = cmdField.getBuffAddr();
ASSERT_EQ(Fw::FW_SERIALIZE_OK, dest.serializeFrom(serialTimeFlag));
ASSERT_EQ(Fw::FW_SERIALIZE_OK, dest.serializeFrom(time));

2
Svc/CmdSequencer/test/ut/SequenceFiles/BadCRCFile.cpp
View File

@ -33,7 +33,7 @@ void BadCRCFile ::serializeFPrime(Fw::SerializeBufferBase& buffer) {
ASSERT_EQ(Fw::FW_SERIALIZE_OK, buffer.serializeFrom(recordData));
// CRC
const U8* const addr = buffer.getBuffAddr();
const U32 size = buffer.getBuffLength();
const U32 size = buffer.getSize();
this->crc.init();
this->crc.update(addr, size);
this->crc.finalize();

8
Svc/CmdSequencer/test/ut/SequenceFiles/Buffers.cpp
View File

@ -19,10 +19,14 @@ namespace SequenceFiles {
namespace Buffers {
FwSizeType FileBuffer ::getBuffCapacity() const {
FwSizeType FileBuffer ::getCapacity() const {
return sizeof(m_buff);
}
FwSizeType FileBuffer ::getBuffCapacity() const {
return this->getCapacity();
}
U8* FileBuffer ::getBuffAddr() {
return m_buff;
}
@ -34,7 +38,7 @@ const U8* FileBuffer ::getBuffAddr() const {
void write(const Fw::SerializeBufferBase& buffer, const char* fileName) {
Os::File file;
ASSERT_EQ(file.open(fileName, Os::File::OPEN_WRITE), Os::File::OP_OK);
FwSizeType size = buffer.getBuffLength();
FwSizeType size = buffer.getSize();
const U32 expectedSize = size;
const U8* const buffAddr = buffer.getBuffAddr();
ASSERT_EQ(file.write(buffAddr, size, Os::File::WaitType::WAIT), Os::File::OP_OK);

3
Svc/CmdSequencer/test/ut/SequenceFiles/Buffers.hpp
View File

@ -26,7 +26,8 @@ class FileBuffer : public Fw::SerializeBufferBase {
enum Constants { CAPACITY = 4096 };
public:
FwSizeType getBuffCapacity() const;
DEPRECATED(FwSizeType getBuffCapacity() const, "Use getCapacity() instead");
FwSizeType getCapacity() const;
U8* getBuffAddr();

2
Svc/CmdSequencer/test/ut/SequenceFiles/FPrime/CRCs.cpp
View File

@ -22,7 +22,7 @@ namespace CRCs {
void serialize(Fw::SerializeBufferBase& destBuffer) {
CmdSequencerComponentImpl::FPrimeSequence::CRC crc;
crc.init();
crc.update(destBuffer.getBuffAddr(), destBuffer.getBuffLength());
crc.update(destBuffer.getBuffAddr(), destBuffer.getSize());
crc.finalize();
ASSERT_EQ(destBuffer.serializeFrom(crc.m_computed), Fw::FW_SERIALIZE_OK);
}

2
Svc/CmdSequencer/test/ut/SequenceFiles/FPrime/Records.cpp
View File

@ -27,7 +27,7 @@ void serialize(Records::Descriptor desc,
ASSERT_EQ(Fw::FW_SERIALIZE_OK, destBuffer.serializeFrom(descU8));
if (desc != CmdSequencerComponentImpl::Sequence::Record::END_OF_SEQUENCE) {
const U8* const buffAddr = opcodeAndArgument.getBuffAddr();
const U32 size = opcodeAndArgument.getBuffLength();
const U32 size = opcodeAndArgument.getSize();
const U32 recSize = sizeof(FwPacketDescriptorType) + size;
const FwPacketDescriptorType cmdDescriptor = Fw::ComPacketType::FW_PACKET_COMMAND;
const U32 seconds = time.getSeconds();

2
Svc/CmdSequencer/test/ut/SequenceFiles/TooLargeFile.cpp
View File

@ -45,7 +45,7 @@ void TooLargeFile ::serializeAMPCS(Fw::SerializeBufferBase& buffer) {
Fw::SerialBuffer cmdField(cmdFieldBuffer, sizeof(cmdFieldBuffer));
cmdField.setBuffLen(cmdFieldSize);
AMPCS::Records::serialize(timeFlag, time, cmdField, buffer);
ASSERT_EQ(sizeof(AMPCSSequence::SequenceHeader::t) + dataSize, buffer.getBuffLength());
ASSERT_EQ(sizeof(AMPCSSequence::SequenceHeader::t) + dataSize, buffer.getSize());
// CRC
AMPCS::CRCs::createFile(buffer, this->getName().toChar());
}

2
Svc/CmdSplitter/test/ut/CmdSplitterTester.cpp
View File

@ -36,7 +36,7 @@ Fw::ComBuffer CmdSplitterTester ::build_command_around_opcode(FwOpcodeType opcod
Fw::CmdArgBuffer args;
U32 random_size = STest::Pick::lowerUpper(0, static_cast<U32>(args.getBuffCapacity()));
U32 random_size = STest::Pick::lowerUpper(0, static_cast<U32>(args.getCapacity()));
args.resetSer();
for (FwSizeType i = 0; i < random_size; i++) {
args.serializeFrom(static_cast<U8>(STest::Pick::any()));

8
Svc/ComAggregator/ComAggregator.cpp
View File

@ -76,9 +76,9 @@ void ComAggregator ::Svc_AggregationMachine_action_doFill(SmId smId,
void ComAggregator ::Svc_AggregationMachine_action_doSend(SmId smId, Svc_AggregationMachine::Signal signal) {
// Send only when the buffer will be valid
if (this->m_frameSerializer.getBuffLength() > 0) {
if (this->m_frameSerializer.getSize() > 0) {
this->m_bufferState = Fw::Buffer::OwnershipState::NOT_OWNED;
this->m_frameBuffer.setSize(this->m_frameSerializer.getBuffLength());
this->m_frameBuffer.setSize(this->m_frameSerializer.getSize());
this->dataOut_out(0, this->m_frameBuffer, this->m_lastContext);
}
}
@ -103,12 +103,12 @@ bool ComAggregator ::Svc_AggregationMachine_guard_isFull(SmId smId,
Svc_AggregationMachine::Signal signal,
const Svc::ComDataContextPair& value) const {
FW_ASSERT(value.get_data().getSize() <= ComCfg::AggregationSize);
const FwSizeType remaining = this->m_frameSerializer.getBuffCapacity() - this->m_frameSerializer.getBuffLength();
const FwSizeType remaining = this->m_frameSerializer.getCapacity() - this->m_frameSerializer.getSize();
return (remaining <= value.get_data().getSize());
}
bool ComAggregator ::Svc_AggregationMachine_guard_isNotEmpty(SmId smId, Svc_AggregationMachine::Signal signal) const {
return this->m_frameSerializer.getBuffLength() > 0;
return this->m_frameSerializer.getSize() > 0;
}
bool ComAggregator ::Svc_AggregationMachine_guard_isGood(SmId smId,

12
Svc/ComAggregator/test/ut/ComAggregatorTester.cpp
View File

@ -53,7 +53,7 @@ void ComAggregatorTester ::validate_aggregation(const Fw::Buffer& buffer) {
}
void ComAggregatorTester ::validate_buffer_aggregated(const Fw::Buffer& buffer, const ComCfg::FrameContext& context) {
FwSizeType start = this->component.m_frameSerializer.getBuffLength() - buffer.getSize();
FwSizeType start = this->component.m_frameSerializer.getSize() - buffer.getSize();
for (FwSizeType i = 0; i < buffer.getSize(); i++) {
ASSERT_EQ(buffer.getData()[i], this->component.m_frameBuffer.getData()[start + i]);
}
@ -64,7 +64,7 @@ void ComAggregatorTester ::validate_buffer_aggregated(const Fw::Buffer& buffer,
void ComAggregatorTester ::test_initial() {
// Initial state should have empty buffer
ASSERT_EQ(this->component.m_frameSerializer.getBuffLength(), 0);
ASSERT_EQ(this->component.m_frameSerializer.getSize(), 0);
ASSERT_EQ(this->component.m_bufferState, Fw::Buffer::OwnershipState::OWNED);
this->component.preamble();
ASSERT_from_comStatusOut(0, Fw::Success::SUCCESS);
@ -77,7 +77,7 @@ void ComAggregatorTester ::test_initial() {
//! Tests fill operation
Fw::Buffer ComAggregatorTester ::test_fill(bool expect_hold) {
// Precondition: initial has run
const FwSizeType ORIGINAL_LENGTH = this->component.m_frameSerializer.getBuffLength();
const FwSizeType ORIGINAL_LENGTH = this->component.m_frameSerializer.getSize();
if (ORIGINAL_LENGTH == ComCfg::AggregationSize) {
// Nothing to fill
return Fw::Buffer();
@ -90,9 +90,9 @@ Fw::Buffer ComAggregatorTester ::test_fill(bool expect_hold) {
EXPECT_EQ(this->dispatchOne(this->component),
Svc::ComAggregatorComponentBase::MsgDispatchStatus::MSG_DISPATCH_OK); // Dispatch the state machine
if (expect_hold) {
EXPECT_EQ(ORIGINAL_LENGTH, this->component.m_frameSerializer.getBuffLength());
EXPECT_EQ(ORIGINAL_LENGTH, this->component.m_frameSerializer.getSize());
} else {
EXPECT_EQ(ORIGINAL_LENGTH + BUFFER_LENGTH, this->component.m_frameSerializer.getBuffLength());
EXPECT_EQ(ORIGINAL_LENGTH + BUFFER_LENGTH, this->component.m_frameSerializer.getSize());
this->validate_buffer_aggregated(buffer, context);
}
this->clearHistory();
@ -110,7 +110,7 @@ void ComAggregatorTester ::test_fill_multi() {
void ComAggregatorTester ::test_full() {
// Precondition: fill has run
// Chose a buffer that will be too large to fit but still will fit after being aggregated
const FwSizeType ORIGINAL_LENGTH = this->component.m_frameSerializer.getBuffLength();
const FwSizeType ORIGINAL_LENGTH = this->component.m_frameSerializer.getSize();
const U32 BUFFER_LENGTH = STest::Pick::lowerUpper(static_cast<U32>(ComCfg::AggregationSize - ORIGINAL_LENGTH + 1),
static_cast<U32>(ComCfg::AggregationSize));
Fw::Buffer buffer = fill_buffer(BUFFER_LENGTH);

6
Svc/ComLogger/ComLogger.cpp
View File

@ -87,7 +87,7 @@ void ComLogger ::comIn_handler(FwIndexType portNum, Fw::ComBuffer& data, U32 con
FW_ASSERT(portNum == 0);
// Get length of buffer:
FwSizeType sizeNative = data.getBuffLength();
FwSizeType sizeNative = data.getSize();
// ComLogger only writes 16-bit sizes to save space
// on disk:
FW_ASSERT(sizeNative < 65536, static_cast<FwAssertArgType>(sizeNative));
@ -182,8 +182,8 @@ void ComLogger ::writeComBufferToFile(Fw::ComBuffer& data, U16 size) {
U8 buffer[sizeof(size)];
Fw::SerialBuffer serialLength(&buffer[0], sizeof(size));
serialLength.serializeFrom(size);
if (this->writeToFile(serialLength.getBuffAddr(), static_cast<U16>(serialLength.getBuffLength()))) {
this->m_byteCount += static_cast<U32>(serialLength.getBuffLength());
if (this->writeToFile(serialLength.getBuffAddr(), static_cast<U16>(serialLength.getSize()))) {
this->m_byteCount += static_cast<U32>(serialLength.getSize());
} else {
return;
}

Some files were not shown because too many files have changed in this diff Show More