fpp/compiler/tools/fpp-to-cpp/test/struct/PrimitiveSerializableAc.ref.cpp

// ======================================================================
// \title  PrimitiveSerializableAc.cpp
// \author Generated by fpp-to-cpp
// \brief  cpp file for Primitive struct
// ======================================================================

#include "cstdio"
#include "cstring"

#include "Fw/Types/Assert.hpp"
#include "Fw/Types/StringUtils.hpp"
#include "PrimitiveSerializableAc.hpp"

// ----------------------------------------------------------------------
// StringSize80 class
// ----------------------------------------------------------------------

Primitive::StringSize80 ::
  StringSize80() :
    StringBase()
{
  this->m_buf[0] = 0;
}

Primitive::StringSize80 ::
  StringSize80(const char* src) :
    StringBase()
{
  Fw::StringUtils::string_copy(this->m_buf, src, sizeof(this->m_buf));
}

Primitive::StringSize80 ::
  StringSize80(const Fw::StringBase& src) :
    StringBase()
{
  Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}

Primitive::StringSize80 ::
  StringSize80(const StringSize80& src) :
    StringBase()
{
  Fw::StringUtils::string_copy(this->m_buf, src.toChar(), sizeof(this->m_buf));
}

Primitive::StringSize80 ::
  ~StringSize80()
{

}

Primitive::StringSize80& Primitive::StringSize80 ::
  operator=(const StringSize80& other)
{
  if (this == &other) {
    return *this;
  }

  Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
  return *this;
}

Primitive::StringSize80& Primitive::StringSize80 ::
  operator=(const Fw::StringBase& other)
{
  if (this == &other) {
    return *this;
  }

  Fw::StringUtils::string_copy(this->m_buf, other.toChar(), sizeof(this->m_buf));
  return *this;
}

Primitive::StringSize80& Primitive::StringSize80 ::
  operator=(const char* other)
{
  Fw::StringUtils::string_copy(this->m_buf, other, sizeof(this->m_buf));
  return *this;
}

const char* Primitive::StringSize80 ::
  toChar() const
{
  return this->m_buf;
}

NATIVE_UINT_TYPE Primitive::StringSize80 ::
  getCapacity() const
{
  return sizeof(this->m_buf);
}

// ----------------------------------------------------------------------
// Constructors
// ----------------------------------------------------------------------

Primitive ::
  Primitive() :
    Serializable(),
    m_var_F64(0.0),
    m_var_I16(0),
    m_var_I32(0),
    m_var_I64(0),
    m_var_I8(0),
    m_var_U16(0),
    m_var_U32(0),
    m_var_U64(0),
    m_var_U8(0),
    m_var_bool(false),
    m_var_string("")
{
  for (NATIVE_UINT_TYPE i = 0; i < 3; i++) {
    this->m_var_F32[i] = 0.0f;
  }
}

Primitive ::
  Primitive(
      const Type_of_var_F32& var_F32,
      F64 var_F64,
      I16 var_I16,
      I32 var_I32,
      I64 var_I64,
      I8 var_I8,
      U16 var_U16,
      U32 var_U32,
      U64 var_U64,
      U8 var_U8,
      bool var_bool,
      const StringSize80& var_string
  ) :
    Serializable(),
    m_var_F64(var_F64),
    m_var_I16(var_I16),
    m_var_I32(var_I32),
    m_var_I64(var_I64),
    m_var_I8(var_I8),
    m_var_U16(var_U16),
    m_var_U32(var_U32),
    m_var_U64(var_U64),
    m_var_U8(var_U8),
    m_var_bool(var_bool),
    m_var_string(var_string)
{
  for (NATIVE_UINT_TYPE i = 0; i < 3; i++) {
    this->m_var_F32[i] = var_F32[i];
  }
}

Primitive ::
  Primitive(const Primitive& obj) :
    Serializable(),
    m_var_F64(obj.m_var_F64),
    m_var_I16(obj.m_var_I16),
    m_var_I32(obj.m_var_I32),
    m_var_I64(obj.m_var_I64),
    m_var_I8(obj.m_var_I8),
    m_var_U16(obj.m_var_U16),
    m_var_U32(obj.m_var_U32),
    m_var_U64(obj.m_var_U64),
    m_var_U8(obj.m_var_U8),
    m_var_bool(obj.m_var_bool),
    m_var_string(obj.m_var_string)
{
  for (NATIVE_UINT_TYPE i = 0; i < 3; i++) {
    this->m_var_F32[i] = obj.m_var_F32[i];
  }
}

Primitive ::
  Primitive(
      F32 var_F32,
      F64 var_F64,
      I16 var_I16,
      I32 var_I32,
      I64 var_I64,
      I8 var_I8,
      U16 var_U16,
      U32 var_U32,
      U64 var_U64,
      U8 var_U8,
      bool var_bool,
      const StringSize80& var_string
  ) :
    Serializable(),
    m_var_F64(var_F64),
    m_var_I16(var_I16),
    m_var_I32(var_I32),
    m_var_I64(var_I64),
    m_var_I8(var_I8),
    m_var_U16(var_U16),
    m_var_U32(var_U32),
    m_var_U64(var_U64),
    m_var_U8(var_U8),
    m_var_bool(var_bool),
    m_var_string(var_string)
{
  for (NATIVE_UINT_TYPE i = 0; i < 3; i++) {
    this->m_var_F32[i] = var_F32;
  }
}

// ----------------------------------------------------------------------
// Operators
// ----------------------------------------------------------------------

Primitive& Primitive ::
  operator=(const Primitive& obj)
{
  if (this == &obj) {
    return *this;
  }

  set(obj.m_var_F32, obj.m_var_F64, obj.m_var_I16, obj.m_var_I32, obj.m_var_I64, obj.m_var_I8, obj.m_var_U16, obj.m_var_U32, obj.m_var_U64, obj.m_var_U8, obj.m_var_bool, obj.m_var_string);
  return *this;
}

bool Primitive ::
  operator==(const Primitive& obj) const
{
  // Compare non-array members
  if (!(
    (this->m_var_F64 == obj.m_var_F64) &&
    (this->m_var_I16 == obj.m_var_I16) &&
    (this->m_var_I32 == obj.m_var_I32) &&
    (this->m_var_I64 == obj.m_var_I64) &&
    (this->m_var_I8 == obj.m_var_I8) &&
    (this->m_var_U16 == obj.m_var_U16) &&
    (this->m_var_U32 == obj.m_var_U32) &&
    (this->m_var_U64 == obj.m_var_U64) &&
    (this->m_var_U8 == obj.m_var_U8) &&
    (this->m_var_bool == obj.m_var_bool) &&
    (this->m_var_string == obj.m_var_string)
  )) {
    return false;
  }

  // Compare array members
  if (!(this->m_var_F32 == obj.m_var_F32)) {
    for (NATIVE_UINT_TYPE i = 0; i < 3; i++) {
      if (!(this->m_var_F32[i] == obj.m_var_F32[i])) {
        return false;
      }
    }
  }

  return true;
}

bool Primitive ::
  operator!=(const Primitive& obj) const
{
  return !(*this == obj);
}

#ifdef BUILD_UT

std::ostream& operator<<(std::ostream& os, const Primitive& obj) {
  Fw::String s;
  obj.toString(s);
  os << s.toChar();
  return os;
}

#endif

// ----------------------------------------------------------------------
// Member functions
// ----------------------------------------------------------------------

Fw::SerializeStatus Primitive ::
  serialize(Fw::SerializeBufferBase& buffer) const
{
  Fw::SerializeStatus status;

  for (NATIVE_UINT_TYPE i = 0; i < 3; i++) {
    status = buffer.serialize(this->m_var_F32[i]);
    if (status != Fw::FW_SERIALIZE_OK) {
      return status;
    }
  }
  status = buffer.serialize(this->m_var_F64);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.serialize(this->m_var_I16);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.serialize(this->m_var_I32);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.serialize(this->m_var_I64);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.serialize(this->m_var_I8);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.serialize(this->m_var_U16);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.serialize(this->m_var_U32);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.serialize(this->m_var_U64);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.serialize(this->m_var_U8);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.serialize(this->m_var_bool);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.serialize(this->m_var_string);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }

  return status;
}

Fw::SerializeStatus Primitive ::
  deserialize(Fw::SerializeBufferBase& buffer)
{
  Fw::SerializeStatus status;

  for (NATIVE_UINT_TYPE i = 0; i < 3; i++) {
    status = buffer.deserialize(this->m_var_F32[i]);
    if (status != Fw::FW_SERIALIZE_OK) {
      return status;
    }
  }
  status = buffer.deserialize(this->m_var_F64);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.deserialize(this->m_var_I16);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.deserialize(this->m_var_I32);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.deserialize(this->m_var_I64);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.deserialize(this->m_var_I8);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.deserialize(this->m_var_U16);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.deserialize(this->m_var_U32);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.deserialize(this->m_var_U64);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.deserialize(this->m_var_U8);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.deserialize(this->m_var_bool);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }
  status = buffer.deserialize(this->m_var_string);
  if (status != Fw::FW_SERIALIZE_OK) {
    return status;
  }

  return status;
}

#if FW_SERIALIZABLE_TO_STRING

void Primitive ::
  toString(Fw::StringBase& sb) const
{
  static const char* formatString =
    "( "
    "m_var_F32 = [ %f, "
    "%f, "
    "%f ], "
    "m_var_F64 = %f, "
    "m_var_I16 = %" PRIi16 ", "
    "m_var_I32 = %" PRIi32 ", "
    "m_var_I64 = %" PRIi64 ", "
    "m_var_I8 = %" PRIi8 ", "
    "m_var_U16 = %" PRIu16 ", "
    "m_var_U32 = %" PRIu32 ", "
    "m_var_U64 = %" PRIu64 ", "
    "m_var_U8 = %" PRIu8 ", "
    "m_var_bool = %d, "
    "m_var_string = %s"
    " )";

  char outputString[FW_SERIALIZABLE_TO_STRING_BUFFER_SIZE];
  (void) snprintf(
    outputString,
    FW_SERIALIZABLE_TO_STRING_BUFFER_SIZE,
    formatString,
    this->m_var_F32[0],
    this->m_var_F32[1],
    this->m_var_F32[2],
    this->m_var_F64,
    this->m_var_I16,
    this->m_var_I32,
    this->m_var_I64,
    this->m_var_I8,
    this->m_var_U16,
    this->m_var_U32,
    this->m_var_U64,
    this->m_var_U8,
    this->m_var_bool,
    this->m_var_string.toChar()
  );

  outputString[FW_SERIALIZABLE_TO_STRING_BUFFER_SIZE-1] = 0; // NULL terminate
  sb = outputString;
}

#endif

// ----------------------------------------------------------------------
// Setter functions
// ----------------------------------------------------------------------

void Primitive ::
  set(
      const Type_of_var_F32& var_F32,
      F64 var_F64,
      I16 var_I16,
      I32 var_I32,
      I64 var_I64,
      I8 var_I8,
      U16 var_U16,
      U32 var_U32,
      U64 var_U64,
      U8 var_U8,
      bool var_bool,
      const StringSize80& var_string
  )
{
  this->m_var_F64 = var_F64;
  this->m_var_I16 = var_I16;
  this->m_var_I32 = var_I32;
  this->m_var_I64 = var_I64;
  this->m_var_I8 = var_I8;
  this->m_var_U16 = var_U16;
  this->m_var_U32 = var_U32;
  this->m_var_U64 = var_U64;
  this->m_var_U8 = var_U8;
  this->m_var_bool = var_bool;
  this->m_var_string = var_string;

  for (NATIVE_UINT_TYPE i = 0; i < 3; i++) {
    this->m_var_F32[i] = var_F32[i];
  }
}

void Primitive ::
  setvar_F32(const Type_of_var_F32& var_F32)
{
  for (NATIVE_UINT_TYPE i = 0; i < 3; i++) {
    this->m_var_F32[i] = var_F32[i];
  }
}

void Primitive ::
  setvar_F64(F64 var_F64)
{
  this->m_var_F64 = var_F64;
}

void Primitive ::
  setvar_I16(I16 var_I16)
{
  this->m_var_I16 = var_I16;
}

void Primitive ::
  setvar_I32(I32 var_I32)
{
  this->m_var_I32 = var_I32;
}

void Primitive ::
  setvar_I64(I64 var_I64)
{
  this->m_var_I64 = var_I64;
}

void Primitive ::
  setvar_I8(I8 var_I8)
{
  this->m_var_I8 = var_I8;
}

void Primitive ::
  setvar_U16(U16 var_U16)
{
  this->m_var_U16 = var_U16;
}

void Primitive ::
  setvar_U32(U32 var_U32)
{
  this->m_var_U32 = var_U32;
}

void Primitive ::
  setvar_U64(U64 var_U64)
{
  this->m_var_U64 = var_U64;
}

void Primitive ::
  setvar_U8(U8 var_U8)
{
  this->m_var_U8 = var_U8;
}

void Primitive ::
  setvar_bool(bool var_bool)
{
  this->m_var_bool = var_bool;
}

void Primitive ::
  setvar_string(const StringSize80& var_string)
{
  this->m_var_string = var_string;
}