SequenceSerializableAc.cpp

Go to the documentation of this file.

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

#include "Fw/Types/Assert.hpp"
#include "Svc/FpySequencer/SequenceSerializableAc.hpp"

namespace Svc {

  namespace Fpy {

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

    Sequence ::
      Sequence() :
        Serializable(),
        m_header(0, 0, 0, 0, 0, 0, 0),
        m_footer(0)
    {
      for (FwSizeType i = 0; i < 16; i++) {
        this->m_args[i] = 0;
      }
      for (FwSizeType i = 0; i < 1024; i++) {
        this->m_statements[i] = Svc::Fpy::Statement(Svc::Fpy::StatementType::DIRECTIVE, 0, Fw::StatementArgBuffer());
      }
    }

    Sequence ::
      Sequence(
          const Svc::Fpy::Header& header,
          const Type_of_args& args,
          const Type_of_statements& statements,
          const Svc::Fpy::Footer& footer
      ) :
        Serializable(),
        m_header(header),
        m_footer(footer)
    {
      for (FwSizeType i = 0; i < 16; i++) {
        this->m_args[i] = args[i];
      }
      for (FwSizeType i = 0; i < 1024; i++) {
        this->m_statements[i] = statements[i];
      }
    }

    Sequence ::
      Sequence(const Sequence& obj) :
        Serializable(),
        m_header(obj.m_header),
        m_footer(obj.m_footer)
    {
      for (FwSizeType i = 0; i < 16; i++) {
        this->m_args[i] = obj.m_args[i];
      }
      for (FwSizeType i = 0; i < 1024; i++) {
        this->m_statements[i] = obj.m_statements[i];
      }
    }

    Sequence ::
      Sequence(
          const Svc::Fpy::Header& header,
          U8 args,
          const Svc::Fpy::Statement& statements,
          const Svc::Fpy::Footer& footer
      ) :
        Serializable(),
        m_header(header),
        m_footer(footer)
    {
      for (FwSizeType i = 0; i < 16; i++) {
        this->m_args[i] = args;
      }
      for (FwSizeType i = 0; i < 1024; i++) {
        this->m_statements[i] = statements;
      }
    }

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

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

      set(obj.m_header, obj.m_args, obj.m_statements, obj.m_footer);
      return *this;
    }

    bool Sequence ::
      operator==(const Sequence& obj) const
    {
      if (this == &obj) { return true; }

      // Compare non-array members
      if (!(
        (this->m_header == obj.m_header) &&
        (this->m_footer == obj.m_footer)
      )) {
        return false;
      }

      // Compare array members
      for (FwSizeType i = 0; i < 16; i++) {
        if (!(this->m_args[i] == obj.m_args[i])) {
          return false;
        }
      }
      for (FwSizeType i = 0; i < 1024; i++) {
        if (!(this->m_statements[i] == obj.m_statements[i])) {
          return false;
        }
      }

      return true;
    }

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

#ifdef BUILD_UT

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

#endif

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

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

      status = buffer.serialize(this->m_header);
      if (status != Fw::FW_SERIALIZE_OK) {
        return status;
      }
      for (FwSizeType i = 0; i < 16; i++) {
        status = buffer.serialize(this->m_args[i]);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
      }
      for (FwSizeType i = 0; i < 1024; i++) {
        status = buffer.serialize(this->m_statements[i]);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
      }
      status = buffer.serialize(this->m_footer);
      if (status != Fw::FW_SERIALIZE_OK) {
        return status;
      }

      return status;
    }

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

      status = buffer.deserialize(this->m_header);
      if (status != Fw::FW_SERIALIZE_OK) {
        return status;
      }
      for (FwSizeType i = 0; i < 16; i++) {
        status = buffer.deserialize(this->m_args[i]);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
      }
      for (FwSizeType i = 0; i < 1024; i++) {
        status = buffer.deserialize(this->m_statements[i]);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
      }
      status = buffer.deserialize(this->m_footer);
      if (status != Fw::FW_SERIALIZE_OK) {
        return status;
      }

      return status;
    }

#if FW_SERIALIZABLE_TO_STRING

    void Sequence ::
      toString(Fw::StringBase& sb) const
    {
      static const char* formatString =
        "( "
        "header = %s, "
        "args = [ %s ], "
        "statements = [ %s ], "
        "footer = %s"
        " )";

      // Declare strings to hold any serializable toString() arguments
      Fw::String headerStr;
      Fw::String argsStr;
      Fw::String statementsStr;
      Fw::String footerStr;

      // Call toString for arrays and serializable types
      this->m_header.toString(headerStr);
      for (FwSizeType i = 0; i < 16; i++) {
        Fw::String argsTmp;
        argsTmp.format("%" PRIu8 "", this->m_args[i]);

        FwSizeType size = argsTmp.length() + (i > 0 ? 2 : 0);
        if ((size + argsStr.length()) <= argsStr.maxLength()) {
          if (i > 0) {
            argsStr += ", ";
          }
          argsStr += argsTmp;
        } else {
          break;
        }
      }
      for (FwSizeType i = 0; i < 1024; i++) {
        Fw::String statementsTmp;
        this->m_statements[i].toString(statementsTmp);

        FwSizeType size = statementsTmp.length() + (i > 0 ? 2 : 0);
        if ((size + statementsStr.length()) <= statementsStr.maxLength()) {
          if (i > 0) {
            statementsStr += ", ";
          }
          statementsStr += statementsTmp;
        } else {
          break;
        }
      }
      this->m_footer.toString(footerStr);

      sb.format(
        formatString,
        headerStr.toChar(),
        argsStr.toChar(),
        statementsStr.toChar(),
        footerStr.toChar()
      );
    }

#endif

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

    void Sequence ::
      set(
          const Svc::Fpy::Header& header,
          const Type_of_args& args,
          const Type_of_statements& statements,
          const Svc::Fpy::Footer& footer
      )
    {
      this->m_header = header;
      this->m_footer = footer;

      for (FwSizeType i = 0; i < 16; i++) {
        this->m_args[i] = args[i];
      }
      for (FwSizeType i = 0; i < 1024; i++) {
        this->m_statements[i] = statements[i];
      }
    }

    void Sequence ::
      setheader(const Svc::Fpy::Header& header)
    {
      this->m_header = header;
    }

    void Sequence ::
      setargs(const Type_of_args& args)
    {
      for (FwSizeType i = 0; i < 16; i++) {
        this->m_args[i] = args[i];
      }
    }

    void Sequence ::
      setstatements(const Type_of_statements& statements)
    {
      for (FwSizeType i = 0; i < 1024; i++) {
        this->m_statements[i] = statements[i];
      }
    }

    void Sequence ::
      setfooter(const Svc::Fpy::Footer& footer)
    {
      this->m_footer = footer;
    }

  }

}