fpp/compiler/tools/fpp-to-cpp/test/array/Enum2ArrayAc.ref.cpp

// ======================================================================
// \title  Enum2ArrayAc.cpp
// \author Generated by fpp-to-cpp
// \brief  cpp file for Enum2 array
// ======================================================================

#include "Enum2ArrayAc.hpp"
#include "Fw/Types/Assert.hpp"

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

Enum2 ::
  Enum2() :
    Serializable()
{
  *this = Enum2(E2::C, E2::C, E2::C, E2::C, E2::C);
}

Enum2 ::
  Enum2(const ElementType (&a)[SIZE]) :
    Serializable()
{
  for (FwSizeType index = 0; index < SIZE; index++) {
    this->elements[index] = a[index];
  }
}

Enum2 ::
  Enum2(const ElementType& e) :
    Serializable()
{
  for (FwSizeType index = 0; index < SIZE; index++) {
    this->elements[index] = e;
  }
}

Enum2 ::
  Enum2(
      const ElementType& e1,
      const ElementType& e2,
      const ElementType& e3,
      const ElementType& e4,
      const ElementType& e5
  ) :
    Serializable()
{
  this->elements[0] = e1;
  this->elements[1] = e2;
  this->elements[2] = e3;
  this->elements[3] = e4;
  this->elements[4] = e5;
}

Enum2 ::
  Enum2(const Enum2& obj) :
    Serializable()
{
  for (FwSizeType index = 0; index < SIZE; index++) {
    this->elements[index] = obj.elements[index];
  }
}

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

Enum2::ElementType& Enum2 ::
  operator[](const FwSizeType i)
{
  FW_ASSERT(i < SIZE, static_cast<FwAssertArgType>(i), static_cast<FwAssertArgType>(SIZE));
  return this->elements[i];
}

const Enum2::ElementType& Enum2 ::
  operator[](const FwSizeType i) const
{
  FW_ASSERT(i < SIZE, static_cast<FwAssertArgType>(i), static_cast<FwAssertArgType>(SIZE));
  return this->elements[i];
}

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

  for (FwSizeType index = 0; index < SIZE; index++) {
    this->elements[index] = obj.elements[index];
  }
  return *this;
}

Enum2& Enum2 ::
  operator=(const ElementType (&a)[SIZE])
{
  for (FwSizeType index = 0; index < SIZE; index++) {
    this->elements[index] = a[index];
  }
  return *this;
}

Enum2& Enum2 ::
  operator=(const std::initializer_list<ElementType>& il)
{
  // Since we are required to use C++11, this has to be a runtime check
  // In C++14, it can be a static check
  FW_ASSERT(il.size() == SIZE, static_cast<FwAssertArgType>(il.size()), static_cast<FwAssertArgType>(SIZE));
  FwSizeType i = 0;
  for (const auto& e : il) {
    FW_ASSERT(i < SIZE);
    this->elements[i] = e;
    i++;
  }
  return *this;
}

Enum2& Enum2 ::
  operator=(const ElementType& e)
{
  for (FwSizeType index = 0; index < SIZE; index++) {
    this->elements[index] = e;
  }
  return *this;
}

bool Enum2 ::
  operator==(const Enum2& obj) const
{
  for (FwSizeType index = 0; index < SIZE; index++) {
    if (!((*this)[index] == obj[index])) {
      return false;
    }
  }
  return true;
}

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

#ifdef BUILD_UT

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

#endif

// ----------------------------------------------------------------------
// Public member functions
// ----------------------------------------------------------------------

Fw::SerializeStatus Enum2 ::
  serializeTo(Fw::SerializeBufferBase& buffer) const
{
  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
  for (FwSizeType index = 0; index < SIZE; index++) {
    status = buffer.serializeFrom((*this)[index]);
    if (status != Fw::FW_SERIALIZE_OK) {
      return status;
    }
  }
  return status;
}

Fw::SerializeStatus Enum2 ::
  deserializeFrom(Fw::SerializeBufferBase& buffer)
{
  Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
  for (FwSizeType index = 0; index < SIZE; index++) {
    status = buffer.deserializeTo((*this)[index]);
    if (status != Fw::FW_SERIALIZE_OK) {
      return status;
    }
  }
  return status;
}

FwSizeType Enum2 ::
  serializedSize() const
{
  return SERIALIZED_SIZE;
}

#if FW_SERIALIZABLE_TO_STRING

void Enum2 ::
  toString(Fw::StringBase& sb) const
{
  // Clear the output string
  sb = "";

  // Array prefix
  if (sb.length() + 2 <= sb.maxLength()) {
    sb += "[ ";
  } else {
    return;
  }

  for (FwSizeType index = 0; index < SIZE; index++) {
    Fw::String tmp;
    this->elements[index].toString(tmp);

    FwSizeType size = tmp.length() + (index > 0 ? 2 : 0);
    if ((size + sb.length()) <= sb.maxLength()) {
      if (index > 0) {
        sb += ", ";
      }
      sb += tmp;
    } else {
      break;
    }
  }

  // Array suffix
  if (sb.length() + 2 <= sb.maxLength()) {
    sb += " ]";
  }
}

#endif