ChannelParamsSerializableAc.cpp

Go to the documentation of this file.

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

#include "Fw/Types/Assert.hpp"
#include "Svc/Ccsds/CfdpManager/Types/ChannelParamsSerializableAc.hpp"

namespace Svc {

  namespace Ccsds {

    namespace Cfdp {

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

      ChannelParams ::
        ChannelParams() :
          Serializable(),
          m_ack_limit(),
          m_nack_limit(),
          m_ack_timer(),
          m_inactivity_timer(),
          m_dequeue_enabled(),
          m_move_dir(m___fprime_ac_move_dir_buffer, sizeof m___fprime_ac_move_dir_buffer, Fw::String("")),
          m_max_outgoing_pdus_per_cycle(),
          m_tmp_dir(m___fprime_ac_tmp_dir_buffer, sizeof m___fprime_ac_tmp_dir_buffer, Fw::String("")),
          m_fail_dir(m___fprime_ac_fail_dir_buffer, sizeof m___fprime_ac_fail_dir_buffer, Fw::String(""))
      {

      }

      ChannelParams ::
        ChannelParams(
            U8 ack_limit,
            U8 nack_limit,
            U32 ack_timer,
            U32 inactivity_timer,
            Fw::Enabled::T dequeue_enabled,
            const Fw::StringBase& move_dir,
            U32 max_outgoing_pdus_per_cycle,
            const Fw::StringBase& tmp_dir,
            const Fw::StringBase& fail_dir
        ) :
          Serializable(),
          m_ack_limit(ack_limit),
          m_nack_limit(nack_limit),
          m_ack_timer(ack_timer),
          m_inactivity_timer(inactivity_timer),
          m_dequeue_enabled(dequeue_enabled),
          m_move_dir(m___fprime_ac_move_dir_buffer, sizeof m___fprime_ac_move_dir_buffer, move_dir),
          m_max_outgoing_pdus_per_cycle(max_outgoing_pdus_per_cycle),
          m_tmp_dir(m___fprime_ac_tmp_dir_buffer, sizeof m___fprime_ac_tmp_dir_buffer, tmp_dir),
          m_fail_dir(m___fprime_ac_fail_dir_buffer, sizeof m___fprime_ac_fail_dir_buffer, fail_dir)
      {

      }

      ChannelParams ::
        ChannelParams(const ChannelParams& obj) :
          Serializable(),
          m_ack_limit(obj.m_ack_limit),
          m_nack_limit(obj.m_nack_limit),
          m_ack_timer(obj.m_ack_timer),
          m_inactivity_timer(obj.m_inactivity_timer),
          m_dequeue_enabled(obj.m_dequeue_enabled),
          m_move_dir(m___fprime_ac_move_dir_buffer, sizeof m___fprime_ac_move_dir_buffer, obj.m_move_dir),
          m_max_outgoing_pdus_per_cycle(obj.m_max_outgoing_pdus_per_cycle),
          m_tmp_dir(m___fprime_ac_tmp_dir_buffer, sizeof m___fprime_ac_tmp_dir_buffer, obj.m_tmp_dir),
          m_fail_dir(m___fprime_ac_fail_dir_buffer, sizeof m___fprime_ac_fail_dir_buffer, obj.m_fail_dir)
      {

      }

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

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

        set(obj.m_ack_limit, obj.m_nack_limit, obj.m_ack_timer, obj.m_inactivity_timer, obj.m_dequeue_enabled, obj.m_move_dir, obj.m_max_outgoing_pdus_per_cycle, obj.m_tmp_dir, obj.m_fail_dir);
        return *this;
      }

      bool ChannelParams ::
        operator==(const ChannelParams& obj) const
      {
        if (this == &obj) { return true; }
        return (
          (this->m_ack_limit == obj.m_ack_limit) &&
          (this->m_nack_limit == obj.m_nack_limit) &&
          (this->m_ack_timer == obj.m_ack_timer) &&
          (this->m_inactivity_timer == obj.m_inactivity_timer) &&
          (this->m_dequeue_enabled == obj.m_dequeue_enabled) &&
          (this->m_move_dir == obj.m_move_dir) &&
          (this->m_max_outgoing_pdus_per_cycle == obj.m_max_outgoing_pdus_per_cycle) &&
          (this->m_tmp_dir == obj.m_tmp_dir) &&
          (this->m_fail_dir == obj.m_fail_dir)
        );
      }

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

#ifdef BUILD_UT

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

#endif

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

      Fw::SerializeStatus ChannelParams ::
        serializeTo(
            Fw::SerialBufferBase& buffer,
            Fw::Endianness mode
        ) const
      {
        Fw::SerializeStatus status;

        status = buffer.serializeFrom(this->m_ack_limit, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.serializeFrom(this->m_nack_limit, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.serializeFrom(this->m_ack_timer, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.serializeFrom(this->m_inactivity_timer, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.serializeFrom(this->m_dequeue_enabled, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.serializeFrom(this->m_move_dir, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.serializeFrom(this->m_max_outgoing_pdus_per_cycle, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.serializeFrom(this->m_tmp_dir, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.serializeFrom(this->m_fail_dir, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }

        return status;
      }

      Fw::SerializeStatus ChannelParams ::
        deserializeFrom(
            Fw::SerialBufferBase& buffer,
            Fw::Endianness mode
        )
      {
        Fw::SerializeStatus status;

        status = buffer.deserializeTo(this->m_ack_limit, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.deserializeTo(this->m_nack_limit, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.deserializeTo(this->m_ack_timer, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.deserializeTo(this->m_inactivity_timer, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.deserializeTo(this->m_dequeue_enabled, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.deserializeTo(this->m_move_dir, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.deserializeTo(this->m_max_outgoing_pdus_per_cycle, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.deserializeTo(this->m_tmp_dir, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }
        status = buffer.deserializeTo(this->m_fail_dir, mode);
        if (status != Fw::FW_SERIALIZE_OK) {
          return status;
        }

        return status;
      }

      FwSizeType ChannelParams ::
        serializedSize() const
      {
        FwSizeType size = 0;
        size += sizeof(U8);
        size += sizeof(U8);
        size += sizeof(U32);
        size += sizeof(U32);
        size += Fw::Enabled::SERIALIZED_SIZE;
        size += this->m_move_dir.serializedSize();
        size += sizeof(U32);
        size += this->m_tmp_dir.serializedSize();
        size += this->m_fail_dir.serializedSize();
        return size;
      }

#if FW_SERIALIZABLE_TO_STRING

      void ChannelParams ::
        toString(Fw::StringBase& sb) const
      {
        Fw::String tmp;
        sb = "( ";

        // Format ack_limit
        sb += "ack_limit = ";
        tmp.format("%" PRIu8 "", this->m_ack_limit);
        sb += tmp;
        sb += ", ";

        // Format nack_limit
        sb += "nack_limit = ";
        tmp.format("%" PRIu8 "", this->m_nack_limit);
        sb += tmp;
        sb += ", ";

        // Format ack_timer
        sb += "ack_timer = ";
        tmp.format("%" PRIu32 "", this->m_ack_timer);
        sb += tmp;
        sb += ", ";

        // Format inactivity_timer
        sb += "inactivity_timer = ";
        tmp.format("%" PRIu32 "", this->m_inactivity_timer);
        sb += tmp;
        sb += ", ";

        // Format dequeue_enabled
        sb += "dequeue_enabled = ";
        this->m_dequeue_enabled.toString(tmp);
        sb += tmp;
        sb += ", ";

        // Format move_dir
        sb += "move_dir = ";
        sb += this->m_move_dir;
        sb += ", ";

        // Format max_outgoing_pdus_per_cycle
        sb += "max_outgoing_pdus_per_cycle = ";
        tmp.format("%" PRIu32 "", this->m_max_outgoing_pdus_per_cycle);
        sb += tmp;
        sb += ", ";

        // Format tmp_dir
        sb += "tmp_dir = ";
        sb += this->m_tmp_dir;
        sb += ", ";

        // Format fail_dir
        sb += "fail_dir = ";
        sb += this->m_fail_dir;
        sb += " )";
      }

#endif

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

      void ChannelParams ::
        set(
            U8 ack_limit,
            U8 nack_limit,
            U32 ack_timer,
            U32 inactivity_timer,
            Fw::Enabled::T dequeue_enabled,
            const Fw::StringBase& move_dir,
            U32 max_outgoing_pdus_per_cycle,
            const Fw::StringBase& tmp_dir,
            const Fw::StringBase& fail_dir
        )
      {
        this->m_ack_limit = ack_limit;
        this->m_nack_limit = nack_limit;
        this->m_ack_timer = ack_timer;
        this->m_inactivity_timer = inactivity_timer;
        this->m_dequeue_enabled = dequeue_enabled;
        this->m_move_dir = move_dir;
        this->m_max_outgoing_pdus_per_cycle = max_outgoing_pdus_per_cycle;
        this->m_tmp_dir = tmp_dir;
        this->m_fail_dir = fail_dir;
      }

      void ChannelParams ::
        set_ack_limit(U8 ack_limit)
      {
        this->m_ack_limit = ack_limit;
      }

      void ChannelParams ::
        set_nack_limit(U8 nack_limit)
      {
        this->m_nack_limit = nack_limit;
      }

      void ChannelParams ::
        set_ack_timer(U32 ack_timer)
      {
        this->m_ack_timer = ack_timer;
      }

      void ChannelParams ::
        set_inactivity_timer(U32 inactivity_timer)
      {
        this->m_inactivity_timer = inactivity_timer;
      }

      void ChannelParams ::
        set_dequeue_enabled(Fw::Enabled::T dequeue_enabled)
      {
        this->m_dequeue_enabled = dequeue_enabled;
      }

      void ChannelParams ::
        set_move_dir(const Fw::StringBase& move_dir)
      {
        this->m_move_dir = move_dir;
      }

      void ChannelParams ::
        set_max_outgoing_pdus_per_cycle(U32 max_outgoing_pdus_per_cycle)
      {
        this->m_max_outgoing_pdus_per_cycle = max_outgoing_pdus_per_cycle;
      }

      void ChannelParams ::
        set_tmp_dir(const Fw::StringBase& tmp_dir)
      {
        this->m_tmp_dir = tmp_dir;
      }

      void ChannelParams ::
        set_fail_dir(const Fw::StringBase& fail_dir)
      {
        this->m_fail_dir = fail_dir;
      }

    }

  }

}