nasa/fpp
1
0
Fork 0
mirror of https://github.com/nasa/fpp.git synced 2025-12-10 17:29:15 -06:00
Code Issues Packages Projects Releases 83 Wiki Activity

Add Little Endian Serialization Option

Browse Source
This commit is contained in:
Will MacCormack 2025-10-09 18:02:56 -05:00
parent 30543a69d6
commit b5e4c7b23f
129 changed files with 1052 additions and 504 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
compiler/lib/src/main/scala/codegen/CppWriter/ArrayCppWriter.scala
View File

@ -484,13 +484,19 @@ case class ArrayCppWriter (
CppDoc.Type("Fw::SerializeBufferBase&"),
"buffer",
Some("The serial buffer"),
),
CppDoc.Function.Param(
CppDoc.Type("Fw::Serialization::Endianness"),
"mode",
Some("Endianness of serialized buffer"),
Some("Fw::Serialization::BIG"),
)
),
CppDoc.Type("Fw::SerializeStatus"),
List.concat(
lines("Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;"),
indexIterator(
line("status = buffer.serializeFrom((*this)[index]);") ::
line("status = buffer.serializeFrom((*this)[index], mode);") ::
wrapInIf("status != Fw::FW_SERIALIZE_OK", lines("return status;")),
),
lines("return status;"),
@ -506,13 +512,19 @@ case class ArrayCppWriter (
CppDoc.Type("Fw::SerializeBufferBase&"),
"buffer",
Some("The serial buffer"),
),
CppDoc.Function.Param(
CppDoc.Type("Fw::Serialization::Endianness"),
"mode",
Some("Endianness of serialized buffer"),
Some("Fw::Serialization::BIG"),
)
),
CppDoc.Type("Fw::SerializeStatus"),
List.concat(
lines("Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;"),
indexIterator(
line("status = buffer.deserializeTo((*this)[index]);") ::
line("status = buffer.deserializeTo((*this)[index], mode);") ::
wrapInIf("status != Fw::FW_SERIALIZE_OK", lines("return status;")),
),
lines("return status;"),

17
compiler/lib/src/main/scala/codegen/CppWriter/EnumCppWriter.scala
View File

@ -316,12 +316,19 @@ case class EnumCppWriter(
CppDoc.Type("Fw::SerializeBufferBase&"),
"buffer",
Some("The serial buffer")
),
CppDoc.Function.Param(
CppDoc.Type("Fw::Serialization::Endianness"),
"mode",
Some("Endianness of serialized buffer"),
Some("Fw::Serialization::BIG"),
)
),
CppDoc.Type("Fw::SerializeStatus"),
lines(
s"""|const Fw::SerializeStatus status = buffer.serializeFrom(
| static_cast<SerialType>(this->e)
| static_cast<SerialType>(this->e),
| mode
|);
|return status;"""
),
@ -336,12 +343,18 @@ case class EnumCppWriter(
CppDoc.Type("Fw::SerializeBufferBase&"),
"buffer",
Some("The serial buffer")
),
CppDoc.Function.Param(
CppDoc.Type("Fw::Serialization::Endianness"),
"mode",
Some("Endianness of serialized buffer"),
Some("Fw::Serialization::BIG"),
)
),
CppDoc.Type("Fw::SerializeStatus"),
lines(
s"""|SerialType es;
|Fw::SerializeStatus status = buffer.deserializeTo(es);
|Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
|if (status == Fw::FW_SERIALIZE_OK) {
| this->e = static_cast<T>(es);
| if (!this->isValid()) {

16
compiler/lib/src/main/scala/codegen/CppWriter/StructCppWriter.scala
View File

@ -466,9 +466,9 @@ case class StructCppWriter(
lines("return status;")
)
def writeSerializeCall(n: String) =
line(s"status = buffer.serializeFrom(this->m_$n);") :: writeSerializeStatusCheck
line(s"status = buffer.serializeFrom(this->m_$n, mode);") :: writeSerializeStatusCheck
def writeDeserializeCall(n: String) =
line(s"status = buffer.deserializeTo(this->m_$n);") :: writeSerializeStatusCheck
line(s"status = buffer.deserializeTo(this->m_$n, mode);") :: writeSerializeStatusCheck
List(
List(
@ -487,6 +487,12 @@ case class StructCppWriter(
CppDoc.Type("Fw::SerializeBufferBase&"),
"buffer",
Some("The serial buffer")
),
CppDoc.Function.Param(
CppDoc.Type("Fw::Serialization::Endianness"),
"mode",
Some("Endianness of serialized buffer"),
Some("Fw::Serialization::BIG"),
)
),
CppDoc.Type("Fw::SerializeStatus"),
@ -511,6 +517,12 @@ case class StructCppWriter(
CppDoc.Type("Fw::SerializeBufferBase&"),
"buffer",
Some("The serial buffer")
),
CppDoc.Function.Param(
CppDoc.Type("Fw::Serialization::Endianness"),
"mode",
Some("Endianness of serialized buffer"),
Some("Fw::Serialization::BIG"),
)
),
CppDoc.Type("Fw::SerializeStatus"),

3
compiler/tools/fpp-to-cpp/test/.gitignore vendored
View File

@ -15,4 +15,5 @@ default-tests.sh
default-update-ref.sh
!*/include/*
!*.ref.h
!*.ref.h
fpp-*.json

14
compiler/tools/fpp-to-cpp/test/alias/AbsSerializableAc.ref.cpp vendored
View File

@ -78,11 +78,14 @@ std::ostream& operator<<(std::ostream& os, const Abs& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus Abs ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_A);
status = buffer.serializeFrom(this->m_A, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -91,11 +94,14 @@ Fw::SerializeStatus Abs ::
}
Fw::SerializeStatus Abs ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_A);
status = buffer.deserializeTo(this->m_A, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/alias/AbsSerializableAc.ref.hpp vendored
View File

@ -85,12 +85,14 @@ class Abs :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

26
compiler/tools/fpp-to-cpp/test/alias/BasicSerializableAc.ref.cpp vendored
View File

@ -98,23 +98,26 @@ std::ostream& operator<<(std::ostream& os, const Basic& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus Basic ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_A);
status = buffer.serializeFrom(this->m_A, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_B);
status = buffer.serializeFrom(this->m_B, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_C);
status = buffer.serializeFrom(this->m_C, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_D);
status = buffer.serializeFrom(this->m_D, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -123,23 +126,26 @@ Fw::SerializeStatus Basic ::
}
Fw::SerializeStatus Basic ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_A);
status = buffer.deserializeTo(this->m_A, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_B);
status = buffer.deserializeTo(this->m_B, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_C);
status = buffer.deserializeTo(this->m_C, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_D);
status = buffer.deserializeTo(this->m_D, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/alias/BasicSerializableAc.ref.hpp vendored
View File

@ -96,12 +96,14 @@ class Basic :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

26
compiler/tools/fpp-to-cpp/test/alias/NamespaceSerializableAc.ref.cpp vendored
View File

@ -98,23 +98,26 @@ std::ostream& operator<<(std::ostream& os, const Namespace& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus Namespace ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_A);
status = buffer.serializeFrom(this->m_A, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_B);
status = buffer.serializeFrom(this->m_B, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_C);
status = buffer.serializeFrom(this->m_C, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_D);
status = buffer.serializeFrom(this->m_D, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -123,23 +126,26 @@ Fw::SerializeStatus Namespace ::
}
Fw::SerializeStatus Namespace ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_A);
status = buffer.deserializeTo(this->m_A, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_B);
status = buffer.deserializeTo(this->m_B, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_C);
status = buffer.deserializeTo(this->m_C, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_D);
status = buffer.deserializeTo(this->m_D, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/alias/NamespaceSerializableAc.ref.hpp vendored
View File

@ -96,12 +96,14 @@ class Namespace :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

14
compiler/tools/fpp-to-cpp/test/array/AArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const A& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus A ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus A ::
}
Fw::SerializeStatus A ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/AArrayAc.ref.hpp vendored
View File

@ -136,12 +136,14 @@ class A :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/AbsTypeArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const AbsType& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus AbsType ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus AbsType ::
}
Fw::SerializeStatus AbsType ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/AbsTypeArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ class AbsType :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/AliasTypeArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const AliasType& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus AliasType ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus AliasType ::
}
Fw::SerializeStatus AliasType ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/AliasTypeArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ class AliasType :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/C_AArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const C_A& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus C_A ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus C_A ::
}
Fw::SerializeStatus C_A ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/C_AArrayAc.ref.hpp vendored
View File

@ -135,12 +135,14 @@ class C_A :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

15
compiler/tools/fpp-to-cpp/test/array/E1EnumAc.ref.cpp vendored
View File

@ -53,19 +53,26 @@ namespace M {
}
Fw::SerializeStatus E1 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
const Fw::SerializeStatus status = buffer.serializeFrom(
static_cast<SerialType>(this->e)
static_cast<SerialType>(this->e),
mode
);
return status;
}
Fw::SerializeStatus E1 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
SerialType es;
Fw::SerializeStatus status = buffer.deserializeTo(es);
Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
if (status == Fw::FW_SERIALIZE_OK) {
this->e = static_cast<T>(es);
if (!this->isValid()) {

6
compiler/tools/fpp-to-cpp/test/array/E1EnumAc.ref.hpp vendored
View File

@ -133,12 +133,14 @@ namespace M {
//! Serialize raw enum value to SerialType
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialize raw enum value from SerialType
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
#if FW_SERIALIZABLE_TO_STRING

15
compiler/tools/fpp-to-cpp/test/array/E2EnumAc.ref.cpp vendored
View File

@ -53,19 +53,26 @@ bool E2 ::
}
Fw::SerializeStatus E2 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
const Fw::SerializeStatus status = buffer.serializeFrom(
static_cast<SerialType>(this->e)
static_cast<SerialType>(this->e),
mode
);
return status;
}
Fw::SerializeStatus E2 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
SerialType es;
Fw::SerializeStatus status = buffer.deserializeTo(es);
Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
if (status == Fw::FW_SERIALIZE_OK) {
this->e = static_cast<T>(es);
if (!this->isValid()) {

6
compiler/tools/fpp-to-cpp/test/array/E2EnumAc.ref.hpp vendored
View File

@ -132,12 +132,14 @@ class E2 :
//! Serialize raw enum value to SerialType
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialize raw enum value from SerialType
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
#if FW_SERIALIZABLE_TO_STRING

14
compiler/tools/fpp-to-cpp/test/array/Enum1ArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const Enum1& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus Enum1 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus Enum1 ::
}
Fw::SerializeStatus Enum1 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/Enum1ArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ class Enum1 :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/Enum2ArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const Enum2& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus Enum2 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus Enum2 ::
}
Fw::SerializeStatus Enum2 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/Enum2ArrayAc.ref.hpp vendored
View File

@ -136,12 +136,14 @@ class Enum2 :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/HeaderPathArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const HeaderPath& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus HeaderPath ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus HeaderPath ::
}
Fw::SerializeStatus HeaderPath ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/HeaderPathArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ class HeaderPath :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/LargeSizeArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const LargeSize& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus LargeSize ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus LargeSize ::
}
Fw::SerializeStatus LargeSize ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/LargeSizeArrayAc.ref.hpp vendored
View File

@ -135,12 +135,14 @@ class LargeSize :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/PrimitiveArrayArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const PrimitiveArray& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus PrimitiveArray ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus PrimitiveArray ::
}
Fw::SerializeStatus PrimitiveArray ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/PrimitiveArrayArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ class PrimitiveArray :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/PrimitiveBoolArrayAc.ref.cpp vendored
View File

@ -143,11 +143,14 @@ namespace M {
// ----------------------------------------------------------------------
Fw::SerializeStatus PrimitiveBool ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -156,11 +159,14 @@ namespace M {
}
Fw::SerializeStatus PrimitiveBool ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/PrimitiveBoolArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ namespace M {
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/PrimitiveF32eArrayAc.ref.cpp vendored
View File

@ -143,11 +143,14 @@ namespace M {
// ----------------------------------------------------------------------
Fw::SerializeStatus PrimitiveF32e ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -156,11 +159,14 @@ namespace M {
}
Fw::SerializeStatus PrimitiveF32e ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/PrimitiveF32eArrayAc.ref.hpp vendored
View File

@ -138,12 +138,14 @@ namespace M {
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/PrimitiveF32fArrayAc.ref.cpp vendored
View File

@ -143,11 +143,14 @@ namespace M {
// ----------------------------------------------------------------------
Fw::SerializeStatus PrimitiveF32f ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -156,11 +159,14 @@ namespace M {
}
Fw::SerializeStatus PrimitiveF32f ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/PrimitiveF32fArrayAc.ref.hpp vendored
View File

@ -138,12 +138,14 @@ namespace M {
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/PrimitiveF64ArrayAc.ref.cpp vendored
View File

@ -143,11 +143,14 @@ namespace M {
// ----------------------------------------------------------------------
Fw::SerializeStatus PrimitiveF64 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -156,11 +159,14 @@ namespace M {
}
Fw::SerializeStatus PrimitiveF64 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/PrimitiveF64ArrayAc.ref.hpp vendored
View File

@ -138,12 +138,14 @@ namespace M {
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/PrimitiveI32ArrayAc.ref.cpp vendored
View File

@ -143,11 +143,14 @@ namespace M {
// ----------------------------------------------------------------------
Fw::SerializeStatus PrimitiveI32 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -156,11 +159,14 @@ namespace M {
}
Fw::SerializeStatus PrimitiveI32 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/PrimitiveI32ArrayAc.ref.hpp vendored
View File

@ -138,12 +138,14 @@ namespace M {
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/PrimitiveI64ArrayAc.ref.cpp vendored
View File

@ -143,11 +143,14 @@ namespace M {
// ----------------------------------------------------------------------
Fw::SerializeStatus PrimitiveI64 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -156,11 +159,14 @@ namespace M {
}
Fw::SerializeStatus PrimitiveI64 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/PrimitiveI64ArrayAc.ref.hpp vendored
View File

@ -138,12 +138,14 @@ namespace M {
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/PrimitiveU16ArrayAc.ref.cpp vendored
View File

@ -143,11 +143,14 @@ namespace M {
// ----------------------------------------------------------------------
Fw::SerializeStatus PrimitiveU16 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -156,11 +159,14 @@ namespace M {
}
Fw::SerializeStatus PrimitiveU16 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/PrimitiveU16ArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ namespace M {
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/PrimitiveU8ArrayAc.ref.cpp vendored
View File

@ -143,11 +143,14 @@ namespace M {
// ----------------------------------------------------------------------
Fw::SerializeStatus PrimitiveU8 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -156,11 +159,14 @@ namespace M {
}
Fw::SerializeStatus PrimitiveU8 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/PrimitiveU8ArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ namespace M {
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

58
compiler/tools/fpp-to-cpp/test/array/S1SerializableAc.ref.cpp vendored
View File

@ -140,55 +140,58 @@ namespace M {
// ----------------------------------------------------------------------
Fw::SerializeStatus S1 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_mF32);
status = buffer.serializeFrom(this->m_mF32, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mF64);
status = buffer.serializeFrom(this->m_mF64, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mI16);
status = buffer.serializeFrom(this->m_mI16, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mI32);
status = buffer.serializeFrom(this->m_mI32, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mI64);
status = buffer.serializeFrom(this->m_mI64, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mI8);
status = buffer.serializeFrom(this->m_mI8, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mU16);
status = buffer.serializeFrom(this->m_mU16, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mU32);
status = buffer.serializeFrom(this->m_mU32, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mU64);
status = buffer.serializeFrom(this->m_mU64, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mU8);
status = buffer.serializeFrom(this->m_mU8, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mBool);
status = buffer.serializeFrom(this->m_mBool, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mString);
status = buffer.serializeFrom(this->m_mString, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -197,55 +200,58 @@ namespace M {
}
Fw::SerializeStatus S1 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_mF32);
status = buffer.deserializeTo(this->m_mF32, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mF64);
status = buffer.deserializeTo(this->m_mF64, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mI16);
status = buffer.deserializeTo(this->m_mI16, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mI32);
status = buffer.deserializeTo(this->m_mI32, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mI64);
status = buffer.deserializeTo(this->m_mI64, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mI8);
status = buffer.deserializeTo(this->m_mI8, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mU16);
status = buffer.deserializeTo(this->m_mU16, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mU32);
status = buffer.deserializeTo(this->m_mU32, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mU64);
status = buffer.deserializeTo(this->m_mU64, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mU8);
status = buffer.deserializeTo(this->m_mU8, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mBool);
status = buffer.deserializeTo(this->m_mBool, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mString);
status = buffer.deserializeTo(this->m_mString, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/S1SerializableAc.ref.hpp vendored
View File

@ -110,12 +110,14 @@ namespace M {
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

14
compiler/tools/fpp-to-cpp/test/array/S2SerializableAc.ref.cpp vendored
View File

@ -78,11 +78,14 @@ std::ostream& operator<<(std::ostream& os, const S2& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus S2 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_s1);
status = buffer.serializeFrom(this->m_s1, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -91,11 +94,14 @@ Fw::SerializeStatus S2 ::
}
Fw::SerializeStatus S2 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_s1);
status = buffer.deserializeTo(this->m_s1, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/S2SerializableAc.ref.hpp vendored
View File

@ -85,12 +85,14 @@ class S2 :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

18
compiler/tools/fpp-to-cpp/test/array/S3SerializableAc.ref.cpp vendored
View File

@ -116,17 +116,20 @@ namespace S {
// ----------------------------------------------------------------------
Fw::SerializeStatus S3 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
for (FwSizeType i = 0; i < 3; i++) {
status = buffer.serializeFrom(this->m_mU32Array[i]);
status = buffer.serializeFrom(this->m_mU32Array[i], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
}
status = buffer.serializeFrom(this->m_mF64);
status = buffer.serializeFrom(this->m_mF64, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -135,17 +138,20 @@ namespace S {
}
Fw::SerializeStatus S3 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
for (FwSizeType i = 0; i < 3; i++) {
status = buffer.deserializeTo(this->m_mU32Array[i]);
status = buffer.deserializeTo(this->m_mU32Array[i], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
}
status = buffer.deserializeTo(this->m_mF64);
status = buffer.deserializeTo(this->m_mF64, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/S3SerializableAc.ref.hpp vendored
View File

@ -106,12 +106,14 @@ namespace S {
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

14
compiler/tools/fpp-to-cpp/test/array/SingleElementArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const SingleElement& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus SingleElement ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus SingleElement ::
}
Fw::SerializeStatus SingleElement ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/SingleElementArrayAc.ref.hpp vendored
View File

@ -136,12 +136,14 @@ class SingleElement :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/String1ArrayAc.ref.cpp vendored
View File

@ -148,11 +148,14 @@ std::ostream& operator<<(std::ostream& os, const String1& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus String1 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -161,11 +164,14 @@ Fw::SerializeStatus String1 ::
}
Fw::SerializeStatus String1 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/String1ArrayAc.ref.hpp vendored
View File

@ -140,12 +140,14 @@ class String1 :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/String2ArrayAc.ref.cpp vendored
View File

@ -148,11 +148,14 @@ std::ostream& operator<<(std::ostream& os, const String2& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus String2 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -161,11 +164,14 @@ Fw::SerializeStatus String2 ::
}
Fw::SerializeStatus String2 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/String2ArrayAc.ref.hpp vendored
View File

@ -140,12 +140,14 @@ class String2 :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/StringArrayArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const StringArray& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus StringArray ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus StringArray ::
}
Fw::SerializeStatus StringArray ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/StringArrayArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ class StringArray :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/Struct1ArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const Struct1& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus Struct1 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus Struct1 ::
}
Fw::SerializeStatus Struct1 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/Struct1ArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ class Struct1 :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/Struct2ArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const Struct2& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus Struct2 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus Struct2 ::
}
Fw::SerializeStatus Struct2 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/Struct2ArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ class Struct2 :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/array/Struct3ArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const Struct3& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus Struct3 ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus Struct3 ::
}
Fw::SerializeStatus Struct3 ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/array/Struct3ArrayAc.ref.hpp vendored
View File

@ -137,12 +137,14 @@ class Struct3 :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/component/base/AArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const A& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus A ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus A ::
}
Fw::SerializeStatus A ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/component/base/AArrayAc.ref.hpp vendored
View File

@ -136,12 +136,14 @@ class A :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

14
compiler/tools/fpp-to-cpp/test/component/base/ArrayAliasArrayArrayAc.ref.cpp vendored
View File

@ -141,11 +141,14 @@ std::ostream& operator<<(std::ostream& os, const ArrayAliasArray& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus ArrayAliasArray ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.serializeFrom((*this)[index]);
status = buffer.serializeFrom((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -154,11 +157,14 @@ Fw::SerializeStatus ArrayAliasArray ::
}
Fw::SerializeStatus ArrayAliasArray ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
for (FwSizeType index = 0; index < SIZE; index++) {
status = buffer.deserializeTo((*this)[index]);
status = buffer.deserializeTo((*this)[index], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/component/base/ArrayAliasArrayArrayAc.ref.hpp vendored
View File

@ -136,12 +136,14 @@ class ArrayAliasArray :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the array

15
compiler/tools/fpp-to-cpp/test/component/base/EEnumAc.ref.cpp vendored
View File

@ -50,19 +50,26 @@ bool E ::
}
Fw::SerializeStatus E ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
const Fw::SerializeStatus status = buffer.serializeFrom(
static_cast<SerialType>(this->e)
static_cast<SerialType>(this->e),
mode
);
return status;
}
Fw::SerializeStatus E ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
SerialType es;
Fw::SerializeStatus status = buffer.deserializeTo(es);
Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
if (status == Fw::FW_SERIALIZE_OK) {
this->e = static_cast<T>(es);
if (!this->isValid()) {

6
compiler/tools/fpp-to-cpp/test/component/base/EEnumAc.ref.hpp vendored
View File

@ -131,12 +131,14 @@ class E :
//! Serialize raw enum value to SerialType
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialize raw enum value from SerialType
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
#if FW_SERIALIZABLE_TO_STRING

18
compiler/tools/fpp-to-cpp/test/component/base/SSerializableAc.ref.cpp vendored
View File

@ -88,15 +88,18 @@ std::ostream& operator<<(std::ostream& os, const S& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus S ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_x);
status = buffer.serializeFrom(this->m_x, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_y);
status = buffer.serializeFrom(this->m_y, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -105,15 +108,18 @@ Fw::SerializeStatus S ::
}
Fw::SerializeStatus S ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_x);
status = buffer.deserializeTo(this->m_x, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_y);
status = buffer.deserializeTo(this->m_y, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/component/base/SSerializableAc.ref.hpp vendored
View File

@ -89,12 +89,14 @@ class S :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

30
compiler/tools/fpp-to-cpp/test/component/base/StructWithAliasSerializableAc.ref.cpp vendored
View File

@ -103,27 +103,30 @@ std::ostream& operator<<(std::ostream& os, const StructWithAlias& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus StructWithAlias ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_x);
status = buffer.serializeFrom(this->m_x, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_y);
status = buffer.serializeFrom(this->m_y, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_z);
status = buffer.serializeFrom(this->m_z, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_w);
status = buffer.serializeFrom(this->m_w, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_q);
status = buffer.serializeFrom(this->m_q, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -132,27 +135,30 @@ Fw::SerializeStatus StructWithAlias ::
}
Fw::SerializeStatus StructWithAlias ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_x);
status = buffer.deserializeTo(this->m_x, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_y);
status = buffer.deserializeTo(this->m_y, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_z);
status = buffer.deserializeTo(this->m_z, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_w);
status = buffer.deserializeTo(this->m_w, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_q);
status = buffer.deserializeTo(this->m_q, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/component/base/StructWithAliasSerializableAc.ref.hpp vendored
View File

@ -99,12 +99,14 @@ class StructWithAlias :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

15
compiler/tools/fpp-to-cpp/test/enum/AliasSerialTypeEnumAc.ref.cpp vendored
View File

@ -50,19 +50,26 @@ bool AliasSerialType ::
}
Fw::SerializeStatus AliasSerialType ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
const Fw::SerializeStatus status = buffer.serializeFrom(
static_cast<SerialType>(this->e)
static_cast<SerialType>(this->e),
mode
);
return status;
}
Fw::SerializeStatus AliasSerialType ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
SerialType es;
Fw::SerializeStatus status = buffer.deserializeTo(es);
Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
if (status == Fw::FW_SERIALIZE_OK) {
this->e = static_cast<T>(es);
if (!this->isValid()) {

6
compiler/tools/fpp-to-cpp/test/enum/AliasSerialTypeEnumAc.ref.hpp vendored
View File

@ -130,12 +130,14 @@ class AliasSerialType :
//! Serialize raw enum value to SerialType
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialize raw enum value from SerialType
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
#if FW_SERIALIZABLE_TO_STRING

15
compiler/tools/fpp-to-cpp/test/enum/C_EEnumAc.ref.cpp vendored
View File

@ -50,19 +50,26 @@ bool C_E ::
}
Fw::SerializeStatus C_E ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
const Fw::SerializeStatus status = buffer.serializeFrom(
static_cast<SerialType>(this->e)
static_cast<SerialType>(this->e),
mode
);
return status;
}
Fw::SerializeStatus C_E ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
SerialType es;
Fw::SerializeStatus status = buffer.deserializeTo(es);
Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
if (status == Fw::FW_SERIALIZE_OK) {
this->e = static_cast<T>(es);
if (!this->isValid()) {

6
compiler/tools/fpp-to-cpp/test/enum/C_EEnumAc.ref.hpp vendored
View File

@ -129,12 +129,14 @@ class C_E :
//! Serialize raw enum value to SerialType
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialize raw enum value from SerialType
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
#if FW_SERIALIZABLE_TO_STRING

15
compiler/tools/fpp-to-cpp/test/enum/DefaultEnumAc.ref.cpp vendored
View File

@ -52,19 +52,26 @@ namespace M {
}
Fw::SerializeStatus Default ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
const Fw::SerializeStatus status = buffer.serializeFrom(
static_cast<SerialType>(this->e)
static_cast<SerialType>(this->e),
mode
);
return status;
}
Fw::SerializeStatus Default ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
SerialType es;
Fw::SerializeStatus status = buffer.deserializeTo(es);
Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
if (status == Fw::FW_SERIALIZE_OK) {
this->e = static_cast<T>(es);
if (!this->isValid()) {

6
compiler/tools/fpp-to-cpp/test/enum/DefaultEnumAc.ref.hpp vendored
View File

@ -133,12 +133,14 @@ namespace M {
//! Serialize raw enum value to SerialType
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialize raw enum value from SerialType
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
#if FW_SERIALIZABLE_TO_STRING

15
compiler/tools/fpp-to-cpp/test/enum/EEnumAc.ref.cpp vendored
View File

@ -50,19 +50,26 @@ bool E ::
}
Fw::SerializeStatus E ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
const Fw::SerializeStatus status = buffer.serializeFrom(
static_cast<SerialType>(this->e)
static_cast<SerialType>(this->e),
mode
);
return status;
}
Fw::SerializeStatus E ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
SerialType es;
Fw::SerializeStatus status = buffer.deserializeTo(es);
Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
if (status == Fw::FW_SERIALIZE_OK) {
this->e = static_cast<T>(es);
if (!this->isValid()) {

6
compiler/tools/fpp-to-cpp/test/enum/EEnumAc.ref.hpp vendored
View File

@ -130,12 +130,14 @@ class E :
//! Serialize raw enum value to SerialType
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialize raw enum value from SerialType
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
#if FW_SERIALIZABLE_TO_STRING

15
compiler/tools/fpp-to-cpp/test/enum/ExplicitEnumAc.ref.cpp vendored
View File

@ -52,19 +52,26 @@ namespace M {
}
Fw::SerializeStatus Explicit ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
const Fw::SerializeStatus status = buffer.serializeFrom(
static_cast<SerialType>(this->e)
static_cast<SerialType>(this->e),
mode
);
return status;
}
Fw::SerializeStatus Explicit ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
SerialType es;
Fw::SerializeStatus status = buffer.deserializeTo(es);
Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
if (status == Fw::FW_SERIALIZE_OK) {
this->e = static_cast<T>(es);
if (!this->isValid()) {

6
compiler/tools/fpp-to-cpp/test/enum/ExplicitEnumAc.ref.hpp vendored
View File

@ -133,12 +133,14 @@ namespace M {
//! Serialize raw enum value to SerialType
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialize raw enum value from SerialType
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
#if FW_SERIALIZABLE_TO_STRING

15
compiler/tools/fpp-to-cpp/test/enum/ImplicitEnumAc.ref.cpp vendored
View File

@ -52,19 +52,26 @@ namespace M {
}
Fw::SerializeStatus Implicit ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
const Fw::SerializeStatus status = buffer.serializeFrom(
static_cast<SerialType>(this->e)
static_cast<SerialType>(this->e),
mode
);
return status;
}
Fw::SerializeStatus Implicit ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
SerialType es;
Fw::SerializeStatus status = buffer.deserializeTo(es);
Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
if (status == Fw::FW_SERIALIZE_OK) {
this->e = static_cast<T>(es);
if (!this->isValid()) {

6
compiler/tools/fpp-to-cpp/test/enum/ImplicitEnumAc.ref.hpp vendored
View File

@ -133,12 +133,14 @@ namespace M {
//! Serialize raw enum value to SerialType
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialize raw enum value from SerialType
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
#if FW_SERIALIZABLE_TO_STRING

15
compiler/tools/fpp-to-cpp/test/enum/SerializeTypeEnumAc.ref.cpp vendored
View File

@ -52,19 +52,26 @@ namespace M {
}
Fw::SerializeStatus SerializeType ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
const Fw::SerializeStatus status = buffer.serializeFrom(
static_cast<SerialType>(this->e)
static_cast<SerialType>(this->e),
mode
);
return status;
}
Fw::SerializeStatus SerializeType ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
SerialType es;
Fw::SerializeStatus status = buffer.deserializeTo(es);
Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
if (status == Fw::FW_SERIALIZE_OK) {
this->e = static_cast<T>(es);
if (!this->isValid()) {

6
compiler/tools/fpp-to-cpp/test/enum/SerializeTypeEnumAc.ref.hpp vendored
View File

@ -133,12 +133,14 @@ namespace M {
//! Serialize raw enum value to SerialType
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialize raw enum value from SerialType
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
#if FW_SERIALIZABLE_TO_STRING

14
compiler/tools/fpp-to-cpp/test/struct/AbsTypeSerializableAc.ref.cpp vendored
View File

@ -78,11 +78,14 @@ std::ostream& operator<<(std::ostream& os, const AbsType& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus AbsType ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_t);
status = buffer.serializeFrom(this->m_t, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -91,11 +94,14 @@ Fw::SerializeStatus AbsType ::
}
Fw::SerializeStatus AbsType ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_t);
status = buffer.deserializeTo(this->m_t, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/struct/AbsTypeSerializableAc.ref.hpp vendored
View File

@ -85,12 +85,14 @@ class AbsType :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

22
compiler/tools/fpp-to-cpp/test/struct/AliasTypeSerializableAc.ref.cpp vendored
View File

@ -135,20 +135,23 @@ std::ostream& operator<<(std::ostream& os, const AliasType& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus AliasType ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_x);
status = buffer.serializeFrom(this->m_x, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_y);
status = buffer.serializeFrom(this->m_y, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
for (FwSizeType i = 0; i < 10; i++) {
status = buffer.serializeFrom(this->m_z[i]);
status = buffer.serializeFrom(this->m_z[i], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -158,20 +161,23 @@ Fw::SerializeStatus AliasType ::
}
Fw::SerializeStatus AliasType ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_x);
status = buffer.deserializeTo(this->m_x, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_y);
status = buffer.deserializeTo(this->m_y, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
for (FwSizeType i = 0; i < 10; i++) {
status = buffer.deserializeTo(this->m_z[i]);
status = buffer.deserializeTo(this->m_z[i], mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/struct/AliasTypeSerializableAc.ref.hpp vendored
View File

@ -109,12 +109,14 @@ class AliasType :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

14
compiler/tools/fpp-to-cpp/test/struct/C_SSerializableAc.ref.cpp vendored
View File

@ -78,11 +78,14 @@ std::ostream& operator<<(std::ostream& os, const C_S& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus C_S ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_x);
status = buffer.serializeFrom(this->m_x, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -91,11 +94,14 @@ Fw::SerializeStatus C_S ::
}
Fw::SerializeStatus C_S ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_x);
status = buffer.deserializeTo(this->m_x, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/struct/C_SSerializableAc.ref.hpp vendored
View File

@ -84,12 +84,14 @@ class C_S :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

22
compiler/tools/fpp-to-cpp/test/struct/DefaultSerializableAc.ref.cpp vendored
View File

@ -93,19 +93,22 @@ std::ostream& operator<<(std::ostream& os, const Default& obj) {
// ----------------------------------------------------------------------
Fw::SerializeStatus Default ::
serializeTo(Fw::SerializeBufferBase& buffer) const
serializeTo(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
) const
{
Fw::SerializeStatus status;
status = buffer.serializeFrom(this->m_mU32);
status = buffer.serializeFrom(this->m_mU32, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mS1);
status = buffer.serializeFrom(this->m_mS1, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.serializeFrom(this->m_mF64);
status = buffer.serializeFrom(this->m_mF64, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
@ -114,19 +117,22 @@ Fw::SerializeStatus Default ::
}
Fw::SerializeStatus Default ::
deserializeFrom(Fw::SerializeBufferBase& buffer)
deserializeFrom(
Fw::SerializeBufferBase& buffer,
Fw::Serialization::Endianness mode
)
{
Fw::SerializeStatus status;
status = buffer.deserializeTo(this->m_mU32);
status = buffer.deserializeTo(this->m_mU32, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mS1);
status = buffer.deserializeTo(this->m_mS1, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}
status = buffer.deserializeTo(this->m_mF64);
status = buffer.deserializeTo(this->m_mF64, mode);
if (status != Fw::FW_SERIALIZE_OK) {
return status;
}

6
compiler/tools/fpp-to-cpp/test/struct/DefaultSerializableAc.ref.hpp vendored
View File

@ -90,12 +90,14 @@ class Default :
//! Serialization
Fw::SerializeStatus serializeTo(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
) const;
//! Deserialization
Fw::SerializeStatus deserializeFrom(
Fw::SerializeBufferBase& buffer //!< The serial buffer
Fw::SerializeBufferBase& buffer, //!< The serial buffer
Fw::Serialization::Endianness mode = Fw::Serialization::BIG //!< Endianness of serialized buffer
);
//! Get the dynamic serialized size of the struct

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