F´ Flight Software - C/C++ Documentation
A framework for building embedded system applications to NASA flight quality standards.
ChannelParamsSerializableAc.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title ChannelParamsSerializableAc.cpp
3 // \author Generated by fpp-to-cpp
4 // \brief cpp file for ChannelParams struct
5 // ======================================================================
6 
7 #include "Fw/Types/Assert.hpp"
8 #include "Svc/Ccsds/CfdpManager/Types/ChannelParamsSerializableAc.hpp"
9 
10 namespace Svc {
11 
12  namespace Ccsds {
13 
14  namespace Cfdp {
15 
16  // ----------------------------------------------------------------------
17  // Constructors
18  // ----------------------------------------------------------------------
19 
20  ChannelParams ::
21  ChannelParams() :
22  Serializable(),
23  m_ack_limit(),
24  m_nack_limit(),
25  m_ack_timer(),
26  m_inactivity_timer(),
27  m_dequeue_enabled(),
28  m_move_dir(m___fprime_ac_move_dir_buffer, sizeof m___fprime_ac_move_dir_buffer, Fw::String("")),
29  m_max_outgoing_pdus_per_cycle(),
30  m_tmp_dir(m___fprime_ac_tmp_dir_buffer, sizeof m___fprime_ac_tmp_dir_buffer, Fw::String("")),
31  m_fail_dir(m___fprime_ac_fail_dir_buffer, sizeof m___fprime_ac_fail_dir_buffer, Fw::String("")),
32  m_rx_dir(m___fprime_ac_rx_dir_buffer, sizeof m___fprime_ac_rx_dir_buffer, Fw::String(""))
33  {
34 
35  }
36 
37  ChannelParams ::
38  ChannelParams(
39  U8 ack_limit,
40  U8 nack_limit,
41  U32 ack_timer,
42  U32 inactivity_timer,
43  Fw::Enabled::T dequeue_enabled,
44  const Fw::StringBase& move_dir,
45  U32 max_outgoing_pdus_per_cycle,
46  const Fw::StringBase& tmp_dir,
47  const Fw::StringBase& fail_dir,
48  const Fw::StringBase& rx_dir
49  ) :
50  Serializable(),
51  m_ack_limit(ack_limit),
52  m_nack_limit(nack_limit),
53  m_ack_timer(ack_timer),
54  m_inactivity_timer(inactivity_timer),
55  m_dequeue_enabled(dequeue_enabled),
56  m_move_dir(m___fprime_ac_move_dir_buffer, sizeof m___fprime_ac_move_dir_buffer, move_dir),
57  m_max_outgoing_pdus_per_cycle(max_outgoing_pdus_per_cycle),
58  m_tmp_dir(m___fprime_ac_tmp_dir_buffer, sizeof m___fprime_ac_tmp_dir_buffer, tmp_dir),
59  m_fail_dir(m___fprime_ac_fail_dir_buffer, sizeof m___fprime_ac_fail_dir_buffer, fail_dir),
60  m_rx_dir(m___fprime_ac_rx_dir_buffer, sizeof m___fprime_ac_rx_dir_buffer, rx_dir)
61  {
62 
63  }
64 
65  ChannelParams ::
66  ChannelParams(const ChannelParams& obj) :
67  Serializable(),
68  m_ack_limit(obj.m_ack_limit),
69  m_nack_limit(obj.m_nack_limit),
70  m_ack_timer(obj.m_ack_timer),
71  m_inactivity_timer(obj.m_inactivity_timer),
72  m_dequeue_enabled(obj.m_dequeue_enabled),
73  m_move_dir(m___fprime_ac_move_dir_buffer, sizeof m___fprime_ac_move_dir_buffer, obj.m_move_dir),
74  m_max_outgoing_pdus_per_cycle(obj.m_max_outgoing_pdus_per_cycle),
75  m_tmp_dir(m___fprime_ac_tmp_dir_buffer, sizeof m___fprime_ac_tmp_dir_buffer, obj.m_tmp_dir),
76  m_fail_dir(m___fprime_ac_fail_dir_buffer, sizeof m___fprime_ac_fail_dir_buffer, obj.m_fail_dir),
77  m_rx_dir(m___fprime_ac_rx_dir_buffer, sizeof m___fprime_ac_rx_dir_buffer, obj.m_rx_dir)
78  {
79 
80  }
81 
82  // ----------------------------------------------------------------------
83  // Operators
84  // ----------------------------------------------------------------------
85 
86  ChannelParams& ChannelParams ::
87  operator=(const ChannelParams& obj)
88  {
89  if (this == &obj) {
90  return *this;
91  }
92 
93  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, obj.m_rx_dir);
94  return *this;
95  }
96 
97  bool ChannelParams ::
98  operator==(const ChannelParams& obj) const
99  {
100  if (this == &obj) { return true; }
101  return (
102  (this->m_ack_limit == obj.m_ack_limit) &&
103  (this->m_nack_limit == obj.m_nack_limit) &&
104  (this->m_ack_timer == obj.m_ack_timer) &&
105  (this->m_inactivity_timer == obj.m_inactivity_timer) &&
106  (this->m_dequeue_enabled == obj.m_dequeue_enabled) &&
107  (this->m_move_dir == obj.m_move_dir) &&
108  (this->m_max_outgoing_pdus_per_cycle == obj.m_max_outgoing_pdus_per_cycle) &&
109  (this->m_tmp_dir == obj.m_tmp_dir) &&
110  (this->m_fail_dir == obj.m_fail_dir) &&
111  (this->m_rx_dir == obj.m_rx_dir)
112  );
113  }
114 
115  bool ChannelParams ::
116  operator!=(const ChannelParams& obj) const
117  {
118  return !(*this == obj);
119  }
120 
121 #ifdef BUILD_UT
122 
123  std::ostream& operator<<(std::ostream& os, const ChannelParams& obj) {
124  Fw::String s;
125  obj.toString(s);
126  os << s.toChar();
127  return os;
128  }
129 
130 #endif
131 
132  // ----------------------------------------------------------------------
133  // Member functions
134  // ----------------------------------------------------------------------
135 
136  Fw::SerializeStatus ChannelParams ::
137  serializeTo(
138  Fw::SerialBufferBase& buffer,
139  Fw::Endianness mode
140  ) const
141  {
142  Fw::SerializeStatus status;
143 
144  status = buffer.serializeFrom(this->m_ack_limit, mode);
145  if (status != Fw::FW_SERIALIZE_OK) {
146  return status;
147  }
148  status = buffer.serializeFrom(this->m_nack_limit, mode);
149  if (status != Fw::FW_SERIALIZE_OK) {
150  return status;
151  }
152  status = buffer.serializeFrom(this->m_ack_timer, mode);
153  if (status != Fw::FW_SERIALIZE_OK) {
154  return status;
155  }
156  status = buffer.serializeFrom(this->m_inactivity_timer, mode);
157  if (status != Fw::FW_SERIALIZE_OK) {
158  return status;
159  }
160  status = buffer.serializeFrom(this->m_dequeue_enabled, mode);
161  if (status != Fw::FW_SERIALIZE_OK) {
162  return status;
163  }
164  status = buffer.serializeFrom(this->m_move_dir, mode);
165  if (status != Fw::FW_SERIALIZE_OK) {
166  return status;
167  }
168  status = buffer.serializeFrom(this->m_max_outgoing_pdus_per_cycle, mode);
169  if (status != Fw::FW_SERIALIZE_OK) {
170  return status;
171  }
172  status = buffer.serializeFrom(this->m_tmp_dir, mode);
173  if (status != Fw::FW_SERIALIZE_OK) {
174  return status;
175  }
176  status = buffer.serializeFrom(this->m_fail_dir, mode);
177  if (status != Fw::FW_SERIALIZE_OK) {
178  return status;
179  }
180  status = buffer.serializeFrom(this->m_rx_dir, mode);
181  if (status != Fw::FW_SERIALIZE_OK) {
182  return status;
183  }
184 
185  return status;
186  }
187 
188  Fw::SerializeStatus ChannelParams ::
189  deserializeFrom(
190  Fw::SerialBufferBase& buffer,
191  Fw::Endianness mode
192  )
193  {
194  Fw::SerializeStatus status;
195 
196  status = buffer.deserializeTo(this->m_ack_limit, mode);
197  if (status != Fw::FW_SERIALIZE_OK) {
198  return status;
199  }
200  status = buffer.deserializeTo(this->m_nack_limit, mode);
201  if (status != Fw::FW_SERIALIZE_OK) {
202  return status;
203  }
204  status = buffer.deserializeTo(this->m_ack_timer, mode);
205  if (status != Fw::FW_SERIALIZE_OK) {
206  return status;
207  }
208  status = buffer.deserializeTo(this->m_inactivity_timer, mode);
209  if (status != Fw::FW_SERIALIZE_OK) {
210  return status;
211  }
212  status = buffer.deserializeTo(this->m_dequeue_enabled, mode);
213  if (status != Fw::FW_SERIALIZE_OK) {
214  return status;
215  }
216  status = buffer.deserializeTo(this->m_move_dir, mode);
217  if (status != Fw::FW_SERIALIZE_OK) {
218  return status;
219  }
220  status = buffer.deserializeTo(this->m_max_outgoing_pdus_per_cycle, mode);
221  if (status != Fw::FW_SERIALIZE_OK) {
222  return status;
223  }
224  status = buffer.deserializeTo(this->m_tmp_dir, mode);
225  if (status != Fw::FW_SERIALIZE_OK) {
226  return status;
227  }
228  status = buffer.deserializeTo(this->m_fail_dir, mode);
229  if (status != Fw::FW_SERIALIZE_OK) {
230  return status;
231  }
232  status = buffer.deserializeTo(this->m_rx_dir, mode);
233  if (status != Fw::FW_SERIALIZE_OK) {
234  return status;
235  }
236 
237  return status;
238  }
239 
240  FwSizeType ChannelParams ::
241  serializedSize() const
242  {
243  FwSizeType size = 0;
244  size += sizeof(U8);
245  size += sizeof(U8);
246  size += sizeof(U32);
247  size += sizeof(U32);
248  size += Fw::Enabled::SERIALIZED_SIZE;
249  size += this->m_move_dir.serializedSize();
250  size += sizeof(U32);
251  size += this->m_tmp_dir.serializedSize();
252  size += this->m_fail_dir.serializedSize();
253  size += this->m_rx_dir.serializedSize();
254  return size;
255  }
256 
257 #if FW_SERIALIZABLE_TO_STRING
258 
259  void ChannelParams ::
260  toString(Fw::StringBase& sb) const
261  {
262  Fw::String tmp;
263  sb = "( ";
264 
265  // Format ack_limit
266  sb += "ack_limit = ";
267  tmp.format("%" PRIu8 "", this->m_ack_limit);
268  sb += tmp;
269  sb += ", ";
270 
271  // Format nack_limit
272  sb += "nack_limit = ";
273  tmp.format("%" PRIu8 "", this->m_nack_limit);
274  sb += tmp;
275  sb += ", ";
276 
277  // Format ack_timer
278  sb += "ack_timer = ";
279  tmp.format("%" PRIu32 "", this->m_ack_timer);
280  sb += tmp;
281  sb += ", ";
282 
283  // Format inactivity_timer
284  sb += "inactivity_timer = ";
285  tmp.format("%" PRIu32 "", this->m_inactivity_timer);
286  sb += tmp;
287  sb += ", ";
288 
289  // Format dequeue_enabled
290  sb += "dequeue_enabled = ";
291  this->m_dequeue_enabled.toString(tmp);
292  sb += tmp;
293  sb += ", ";
294 
295  // Format move_dir
296  sb += "move_dir = ";
297  sb += this->m_move_dir;
298  sb += ", ";
299 
300  // Format max_outgoing_pdus_per_cycle
301  sb += "max_outgoing_pdus_per_cycle = ";
302  tmp.format("%" PRIu32 "", this->m_max_outgoing_pdus_per_cycle);
303  sb += tmp;
304  sb += ", ";
305 
306  // Format tmp_dir
307  sb += "tmp_dir = ";
308  sb += this->m_tmp_dir;
309  sb += ", ";
310 
311  // Format fail_dir
312  sb += "fail_dir = ";
313  sb += this->m_fail_dir;
314  sb += ", ";
315 
316  // Format rx_dir
317  sb += "rx_dir = ";
318  sb += this->m_rx_dir;
319  sb += " )";
320  }
321 
322 #endif
323 
324  // ----------------------------------------------------------------------
325  // Setter functions
326  // ----------------------------------------------------------------------
327 
328  void ChannelParams ::
329  set(
330  U8 ack_limit,
331  U8 nack_limit,
332  U32 ack_timer,
333  U32 inactivity_timer,
334  Fw::Enabled::T dequeue_enabled,
335  const Fw::StringBase& move_dir,
336  U32 max_outgoing_pdus_per_cycle,
337  const Fw::StringBase& tmp_dir,
338  const Fw::StringBase& fail_dir,
339  const Fw::StringBase& rx_dir
340  )
341  {
342  this->m_ack_limit = ack_limit;
343  this->m_nack_limit = nack_limit;
344  this->m_ack_timer = ack_timer;
345  this->m_inactivity_timer = inactivity_timer;
346  this->m_dequeue_enabled = dequeue_enabled;
347  this->m_move_dir = move_dir;
348  this->m_max_outgoing_pdus_per_cycle = max_outgoing_pdus_per_cycle;
349  this->m_tmp_dir = tmp_dir;
350  this->m_fail_dir = fail_dir;
351  this->m_rx_dir = rx_dir;
352  }
353 
354  void ChannelParams ::
355  set_ack_limit(U8 ack_limit)
356  {
357  this->m_ack_limit = ack_limit;
358  }
359 
360  void ChannelParams ::
361  set_nack_limit(U8 nack_limit)
362  {
363  this->m_nack_limit = nack_limit;
364  }
365 
366  void ChannelParams ::
367  set_ack_timer(U32 ack_timer)
368  {
369  this->m_ack_timer = ack_timer;
370  }
371 
372  void ChannelParams ::
373  set_inactivity_timer(U32 inactivity_timer)
374  {
375  this->m_inactivity_timer = inactivity_timer;
376  }
377 
378  void ChannelParams ::
379  set_dequeue_enabled(Fw::Enabled::T dequeue_enabled)
380  {
381  this->m_dequeue_enabled = dequeue_enabled;
382  }
383 
384  void ChannelParams ::
385  set_move_dir(const Fw::StringBase& move_dir)
386  {
387  this->m_move_dir = move_dir;
388  }
389 
390  void ChannelParams ::
391  set_max_outgoing_pdus_per_cycle(U32 max_outgoing_pdus_per_cycle)
392  {
393  this->m_max_outgoing_pdus_per_cycle = max_outgoing_pdus_per_cycle;
394  }
395 
396  void ChannelParams ::
397  set_tmp_dir(const Fw::StringBase& tmp_dir)
398  {
399  this->m_tmp_dir = tmp_dir;
400  }
401 
402  void ChannelParams ::
403  set_fail_dir(const Fw::StringBase& fail_dir)
404  {
405  this->m_fail_dir = fail_dir;
406  }
407 
408  void ChannelParams ::
409  set_rx_dir(const Fw::StringBase& rx_dir)
410  {
411  this->m_rx_dir = rx_dir;
412  }
413 
414  }
415 
416  }
417 
418 }
Fw::FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.
Definition: Serializable.hpp:15
Svc::Ccsds::Cfdp::ChannelParams::set_ack_timer
void set_ack_timer(U32 ack_timer)
Set member ack_timer.
Definition: ChannelParamsSerializableAc.cpp:367
Svc::Ccsds::Cfdp::ChannelParams::operator!=
bool operator!=(const ChannelParams &obj) const
Inequality operator.
Definition: ChannelParamsSerializableAc.cpp:116
FwSizeType
PlatformSizeType FwSizeType
Definition: FwSizeTypeAliasAc.h:15
Svc::Ccsds::Cfdp::ChannelParams::set_rx_dir
void set_rx_dir(const Fw::StringBase &rx_dir)
Set member rx_dir.
Definition: ChannelParamsSerializableAc.cpp:409
Fw::String
StringTemplate< FW_FIXED_LENGTH_STRING_SIZE > String
Definition: String.hpp:14
Svc::Ccsds::Cfdp::ChannelParams::set_ack_limit
void set_ack_limit(U8 ack_limit)
Set member ack_limit.
Definition: ChannelParamsSerializableAc.cpp:355
Svc::Ccsds::Cfdp::ChannelParams::set_inactivity_timer
void set_inactivity_timer(U32 inactivity_timer)
Set member inactivity_timer.
Definition: ChannelParamsSerializableAc.cpp:373
Fw::Enabled::SERIALIZED_SIZE
The size of the serial representation.
Definition: EnabledEnumAc.hpp:50
Svc::Ccsds::Cfdp::ChannelParams::set_tmp_dir
void set_tmp_dir(const Fw::StringBase &tmp_dir)
Set member tmp_dir.
Definition: ChannelParamsSerializableAc.cpp:397
Svc::Ccsds::Cfdp::ChannelParams::serializedSize
FwSizeType serializedSize() const
Get the dynamic serialized size of the struct.
Definition: ChannelParamsSerializableAc.cpp:241
Svc::Ccsds::Cfdp::ChannelParams::set_nack_limit
void set_nack_limit(U8 nack_limit)
Set member nack_limit.
Definition: ChannelParamsSerializableAc.cpp:361
Svc::Ccsds::Cfdp::ChannelParams::operator=
ChannelParams & operator=(const ChannelParams &obj)
Copy assignment operator.
Definition: ChannelParamsSerializableAc.cpp:87
Svc::Ccsds::Cfdp::ChannelParams::set
void 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, const Fw::StringBase &rx_dir)
Set all members.
Definition: ChannelParamsSerializableAc.cpp:329
Fw::SerialBufferBase::serializeFrom
virtual SerializeStatus serializeFrom(U8 val, Endianness mode=Endianness::BIG)=0
Serialize an 8-bit unsigned integer value.
Svc::Ccsds::Cfdp::ChannelParams::ChannelParams
ChannelParams()
Constructor (default value)
Definition: ChannelParamsSerializableAc.cpp:21
Svc::Ccsds::Cfdp::ChannelParams::serializeTo
Fw::SerializeStatus serializeTo(Fw::SerialBufferBase &buffer, Fw::Endianness mode=Fw::Endianness::BIG) const
Serialization.
Definition: ChannelParamsSerializableAc.cpp:137
Fw::SerializeStatus
SerializeStatus
forward declaration for string
Definition: Serializable.hpp:14
Fw::ConstStringBase::serializedSize
SizeType serializedSize() const
Definition: ConstStringBase.cpp:45
Svc::Ccsds::Cfdp::ChannelParams::set_move_dir
void set_move_dir(const Fw::StringBase &move_dir)
Set member move_dir.
Definition: ChannelParamsSerializableAc.cpp:385
Fw::SerialBufferBase::deserializeTo
virtual SerializeStatus deserializeTo(U8 &val, Endianness mode=Endianness::BIG)=0
Deserialize an 8-bit unsigned integer value.
Assert.hpp
Svc::Ccsds::Cfdp::ChannelParams::set_fail_dir
void set_fail_dir(const Fw::StringBase &fail_dir)
Set member fail_dir.
Definition: ChannelParamsSerializableAc.cpp:403
Svc::Ccsds::Cfdp::ChannelParams::set_dequeue_enabled
void set_dequeue_enabled(Fw::Enabled::T dequeue_enabled)
Set member dequeue_enabled.
Definition: ChannelParamsSerializableAc.cpp:379
Fw::StringTemplate::toChar
const char * toChar() const
Convert to a C-style char*.
Definition: StringTemplate.hpp:49
Fw::StringBase::format
FormatStatus format(const CHAR *formatString,...)
write formatted string to buffer
Definition: StringBase.cpp:58
U8
uint8_t U8
8-bit unsigned integer
Definition: BasicTypes.h:54
Svc::Ccsds::Cfdp::ChannelParams
Structure for the configured array of CFDP channels.
Definition: ChannelParamsSerializableAc.hpp:24
ChannelParamsSerializableAc.hpp
Svc::Ccsds::Cfdp::ChannelParams::operator==
bool operator==(const ChannelParams &obj) const
Equality operator.
Definition: ChannelParamsSerializableAc.cpp:98
Svc
RateGroupDivider component implementation.
Definition: ActiveRateGroupCfg.hpp:18
Svc::Ccsds::Cfdp::ChannelParams::deserializeFrom
Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase &buffer, Fw::Endianness mode=Fw::Endianness::BIG)
Deserialization.
Definition: ChannelParamsSerializableAc.cpp:189
Fw
Implementation of malloc based allocator.
Definition: MemoryAllocation.hpp:14
Fw::Endianness
Endianness
Definition: Serializable.hpp:37
Fw::Enabled::T
T
The raw enum type.
Definition: EnabledEnumAc.hpp:32
Svc::Ccsds::Cfdp::ChannelParams::set_max_outgoing_pdus_per_cycle
void set_max_outgoing_pdus_per_cycle(U32 max_outgoing_pdus_per_cycle)
Set member max_outgoing_pdus_per_cycle.
Definition: ChannelParamsSerializableAc.cpp:391