PrimitiveArrayArrayAc.ref.cpp

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

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

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

PrimitiveArray ::
  PrimitiveArray() :
    Serializable(),
    elements()
{

}

PrimitiveArray ::
  PrimitiveArray(const ElementType (&a)[SIZE]) :
    Serializable()
{
  *this = a;
}

PrimitiveArray ::
  PrimitiveArray(const ElementType& e) :
    Serializable()
{
  *this = e;
}

PrimitiveArray ::
  PrimitiveArray(const std::initializer_list<ElementType>& il) :
    Serializable()
{
  *this = il;
}

PrimitiveArray ::
  PrimitiveArray(const PrimitiveArray& obj) :
    Serializable()
{
  *this = obj;
}

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

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

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

PrimitiveArray& PrimitiveArray ::
  operator=(const PrimitiveArray& obj)
{
  if (this != &obj) {
    for (FwSizeType index = 0; index < SIZE; index++) {
      this->elements[index] = obj.elements[index];
    }
  }
  return *this;
}

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

PrimitiveArray& PrimitiveArray ::
  operator=(const std::initializer_list<ElementType>& il)
{
  // Check that the initializer has the expected size
  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, static_cast<FwAssertArgType>(i), static_cast<FwAssertArgType>(SIZE));
    this->elements[i] = e;
    i++;
  }
  return *this;
}

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

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

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

#ifdef BUILD_UT

std::ostream& operator<<(std::ostream& os, const PrimitiveArray& obj) {
  os << "[";
  constexpr auto SIZE = PrimitiveArray::SIZE;
  for (FwSizeType index = 0; index < SIZE; index++) {
    if (index > 0) {
      os << ", ";
    }

    os << obj.elements[index];
                
  }
  os << "]";
  return os;
}

#endif

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

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

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

FwSizeType PrimitiveArray ::
  serializedSize() const
{
  FwSizeType size = 0;
  for (FwSizeType index = 0; index < SIZE; index++) {
    size += this->elements[index].serializedSize();
  }
  return size;
}

#if FW_SERIALIZABLE_TO_STRING

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

  // Array prefix
  sb += "[ ";

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

    if (index > 0) {
      sb += ", ";
    }
    sb += tmp;
  }

  // Array suffix
  sb += " ]";
}

#endif