F´ Flight Software - C/C++ Documentation  devel
A framework for building embedded system applications to NASA flight quality standards.
DeframerComponentAc.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title DeframerComponentAc.cpp
3 // \author Generated by fpp-to-cpp
4 // \brief cpp file for Deframer component base class
5 // ======================================================================
6 
8 #include "Fw/Types/Assert.hpp"
10 #if FW_ENABLE_TEXT_LOGGING
11 #include "Fw/Types/String.hpp"
12 #endif
13 
14 namespace Svc {
15 
16  // ----------------------------------------------------------------------
17  // Component initialization
18  // ----------------------------------------------------------------------
19 
21  init(FwEnumStoreType instance)
22  {
23  // Initialize base class
25 
26  // Connect input port cmdResponseIn
27  for (
28  FwIndexType port = 0;
29  port < static_cast<FwIndexType>(this->getNum_cmdResponseIn_InputPorts());
30  port++
31  ) {
32  this->m_cmdResponseIn_InputPort[port].init();
33  this->m_cmdResponseIn_InputPort[port].addCallComp(
34  this,
35  m_p_cmdResponseIn_in
36  );
37  this->m_cmdResponseIn_InputPort[port].setPortNum(port);
38 
39 #if FW_OBJECT_NAMES == 1
40  Fw::ObjectName portName;
41  portName.format(
42  "%s_cmdResponseIn_InputPort[%" PRI_PlatformIntType "]",
43  this->m_objName.toChar(),
44  port
45  );
46  this->m_cmdResponseIn_InputPort[port].setObjName(portName.toChar());
47 #endif
48  }
49 
50  // Connect input port framedIn
51  for (
52  FwIndexType port = 0;
53  port < static_cast<FwIndexType>(this->getNum_framedIn_InputPorts());
54  port++
55  ) {
56  this->m_framedIn_InputPort[port].init();
57  this->m_framedIn_InputPort[port].addCallComp(
58  this,
59  m_p_framedIn_in
60  );
61  this->m_framedIn_InputPort[port].setPortNum(port);
62 
63 #if FW_OBJECT_NAMES == 1
64  Fw::ObjectName portName;
65  portName.format(
66  "%s_framedIn_InputPort[%" PRI_PlatformIntType "]",
67  this->m_objName.toChar(),
68  port
69  );
70  this->m_framedIn_InputPort[port].setObjName(portName.toChar());
71 #endif
72  }
73 
74  // Connect input port schedIn
75  for (
76  FwIndexType port = 0;
77  port < static_cast<FwIndexType>(this->getNum_schedIn_InputPorts());
78  port++
79  ) {
80  this->m_schedIn_InputPort[port].init();
81  this->m_schedIn_InputPort[port].addCallComp(
82  this,
83  m_p_schedIn_in
84  );
85  this->m_schedIn_InputPort[port].setPortNum(port);
86 
87 #if FW_OBJECT_NAMES == 1
88  Fw::ObjectName portName;
89  portName.format(
90  "%s_schedIn_InputPort[%" PRI_PlatformIntType "]",
91  this->m_objName.toChar(),
92  port
93  );
94  this->m_schedIn_InputPort[port].setObjName(portName.toChar());
95 #endif
96  }
97 
98  // Connect output port bufferAllocate
99  for (
100  FwIndexType port = 0;
101  port < static_cast<FwIndexType>(this->getNum_bufferAllocate_OutputPorts());
102  port++
103  ) {
104  this->m_bufferAllocate_OutputPort[port].init();
105 
106 #if FW_OBJECT_NAMES == 1
107  Fw::ObjectName portName;
108  portName.format(
109  "%s_bufferAllocate_OutputPort[%" PRI_PlatformIntType "]",
110  this->m_objName.toChar(),
111  port
112  );
113  this->m_bufferAllocate_OutputPort[port].setObjName(portName.toChar());
114 #endif
115  }
116 
117  // Connect output port bufferDeallocate
118  for (
119  FwIndexType port = 0;
120  port < static_cast<FwIndexType>(this->getNum_bufferDeallocate_OutputPorts());
121  port++
122  ) {
123  this->m_bufferDeallocate_OutputPort[port].init();
124 
125 #if FW_OBJECT_NAMES == 1
126  Fw::ObjectName portName;
127  portName.format(
128  "%s_bufferDeallocate_OutputPort[%" PRI_PlatformIntType "]",
129  this->m_objName.toChar(),
130  port
131  );
132  this->m_bufferDeallocate_OutputPort[port].setObjName(portName.toChar());
133 #endif
134  }
135 
136  // Connect output port bufferOut
137  for (
138  FwIndexType port = 0;
139  port < static_cast<FwIndexType>(this->getNum_bufferOut_OutputPorts());
140  port++
141  ) {
142  this->m_bufferOut_OutputPort[port].init();
143 
144 #if FW_OBJECT_NAMES == 1
145  Fw::ObjectName portName;
146  portName.format(
147  "%s_bufferOut_OutputPort[%" PRI_PlatformIntType "]",
148  this->m_objName.toChar(),
149  port
150  );
151  this->m_bufferOut_OutputPort[port].setObjName(portName.toChar());
152 #endif
153  }
154 
155  // Connect output port comOut
156  for (
157  FwIndexType port = 0;
158  port < static_cast<FwIndexType>(this->getNum_comOut_OutputPorts());
159  port++
160  ) {
161  this->m_comOut_OutputPort[port].init();
162 
163 #if FW_OBJECT_NAMES == 1
164  Fw::ObjectName portName;
165  portName.format(
166  "%s_comOut_OutputPort[%" PRI_PlatformIntType "]",
167  this->m_objName.toChar(),
168  port
169  );
170  this->m_comOut_OutputPort[port].setObjName(portName.toChar());
171 #endif
172  }
173 
174  // Connect output port framedDeallocate
175  for (
176  FwIndexType port = 0;
177  port < static_cast<FwIndexType>(this->getNum_framedDeallocate_OutputPorts());
178  port++
179  ) {
180  this->m_framedDeallocate_OutputPort[port].init();
181 
182 #if FW_OBJECT_NAMES == 1
183  Fw::ObjectName portName;
184  portName.format(
185  "%s_framedDeallocate_OutputPort[%" PRI_PlatformIntType "]",
186  this->m_objName.toChar(),
187  port
188  );
189  this->m_framedDeallocate_OutputPort[port].setObjName(portName.toChar());
190 #endif
191  }
192 
193  // Connect output port framedPoll
194  for (
195  FwIndexType port = 0;
196  port < static_cast<FwIndexType>(this->getNum_framedPoll_OutputPorts());
197  port++
198  ) {
199  this->m_framedPoll_OutputPort[port].init();
200 
201 #if FW_OBJECT_NAMES == 1
202  Fw::ObjectName portName;
203  portName.format(
204  "%s_framedPoll_OutputPort[%" PRI_PlatformIntType "]",
205  this->m_objName.toChar(),
206  port
207  );
208  this->m_framedPoll_OutputPort[port].setObjName(portName.toChar());
209 #endif
210  }
211  }
212 
213  // ----------------------------------------------------------------------
214  // Getters for typed input ports
215  // ----------------------------------------------------------------------
216 
219  {
220  FW_ASSERT(
221  portNum < this->getNum_cmdResponseIn_InputPorts(),
222  static_cast<FwAssertArgType>(portNum)
223  );
224 
225  return &this->m_cmdResponseIn_InputPort[portNum];
226  }
227 
230  {
231  FW_ASSERT(
232  portNum < this->getNum_framedIn_InputPorts(),
233  static_cast<FwAssertArgType>(portNum)
234  );
235 
236  return &this->m_framedIn_InputPort[portNum];
237  }
238 
241  {
242  FW_ASSERT(
243  portNum < this->getNum_schedIn_InputPorts(),
244  static_cast<FwAssertArgType>(portNum)
245  );
246 
247  return &this->m_schedIn_InputPort[portNum];
248  }
249 
250  // ----------------------------------------------------------------------
251  // Connect typed input ports to typed output ports
252  // ----------------------------------------------------------------------
253 
256  FwIndexType portNum,
258  )
259  {
260  FW_ASSERT(
261  portNum < this->getNum_bufferAllocate_OutputPorts(),
262  static_cast<FwAssertArgType>(portNum)
263  );
264 
265  this->m_bufferAllocate_OutputPort[portNum].addCallPort(port);
266  }
267 
270  FwIndexType portNum,
272  )
273  {
274  FW_ASSERT(
275  portNum < this->getNum_bufferDeallocate_OutputPorts(),
276  static_cast<FwAssertArgType>(portNum)
277  );
278 
279  this->m_bufferDeallocate_OutputPort[portNum].addCallPort(port);
280  }
281 
284  FwIndexType portNum,
286  )
287  {
288  FW_ASSERT(
289  portNum < this->getNum_bufferOut_OutputPorts(),
290  static_cast<FwAssertArgType>(portNum)
291  );
292 
293  this->m_bufferOut_OutputPort[portNum].addCallPort(port);
294  }
295 
298  FwIndexType portNum,
299  Fw::InputComPort* port
300  )
301  {
302  FW_ASSERT(
303  portNum < this->getNum_comOut_OutputPorts(),
304  static_cast<FwAssertArgType>(portNum)
305  );
306 
307  this->m_comOut_OutputPort[portNum].addCallPort(port);
308  }
309 
312  FwIndexType portNum,
314  )
315  {
316  FW_ASSERT(
317  portNum < this->getNum_framedDeallocate_OutputPorts(),
318  static_cast<FwAssertArgType>(portNum)
319  );
320 
321  this->m_framedDeallocate_OutputPort[portNum].addCallPort(port);
322  }
323 
326  FwIndexType portNum,
328  )
329  {
330  FW_ASSERT(
331  portNum < this->getNum_framedPoll_OutputPorts(),
332  static_cast<FwAssertArgType>(portNum)
333  );
334 
335  this->m_framedPoll_OutputPort[portNum].addCallPort(port);
336  }
337 
338 #if FW_PORT_SERIALIZATION
339 
340  // ----------------------------------------------------------------------
341  // Connect serial input ports to typed output ports
342  // ----------------------------------------------------------------------
343 
346  FwIndexType portNum,
347  Fw::InputSerializePort* port
348  )
349  {
350  FW_ASSERT(
351  portNum < this->getNum_bufferDeallocate_OutputPorts(),
352  static_cast<FwAssertArgType>(portNum)
353  );
354 
355  this->m_bufferDeallocate_OutputPort[portNum].registerSerialPort(port);
356  }
357 
360  FwIndexType portNum,
361  Fw::InputSerializePort* port
362  )
363  {
364  FW_ASSERT(
365  portNum < this->getNum_bufferOut_OutputPorts(),
366  static_cast<FwAssertArgType>(portNum)
367  );
368 
369  this->m_bufferOut_OutputPort[portNum].registerSerialPort(port);
370  }
371 
374  FwIndexType portNum,
375  Fw::InputSerializePort* port
376  )
377  {
378  FW_ASSERT(
379  portNum < this->getNum_comOut_OutputPorts(),
380  static_cast<FwAssertArgType>(portNum)
381  );
382 
383  this->m_comOut_OutputPort[portNum].registerSerialPort(port);
384  }
385 
388  FwIndexType portNum,
389  Fw::InputSerializePort* port
390  )
391  {
392  FW_ASSERT(
393  portNum < this->getNum_framedDeallocate_OutputPorts(),
394  static_cast<FwAssertArgType>(portNum)
395  );
396 
397  this->m_framedDeallocate_OutputPort[portNum].registerSerialPort(port);
398  }
399 
400 #endif
401 
402  // ----------------------------------------------------------------------
403  // Component construction and destruction
404  // ----------------------------------------------------------------------
405 
407  DeframerComponentBase(const char* compName) :
408  Fw::PassiveComponentBase(compName)
409  {
410 
411  }
412 
415  {
416 
417  }
418 
419  // ----------------------------------------------------------------------
420  // Getters for numbers of typed input ports
421  // ----------------------------------------------------------------------
422 
425  {
426  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_cmdResponseIn_InputPort));
427  }
428 
431  {
432  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_framedIn_InputPort));
433  }
434 
437  {
438  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_schedIn_InputPort));
439  }
440 
441  // ----------------------------------------------------------------------
442  // Getters for numbers of typed output ports
443  // ----------------------------------------------------------------------
444 
447  {
448  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_bufferAllocate_OutputPort));
449  }
450 
453  {
454  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_bufferDeallocate_OutputPort));
455  }
456 
459  {
460  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_bufferOut_OutputPort));
461  }
462 
465  {
466  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_comOut_OutputPort));
467  }
468 
471  {
472  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_framedDeallocate_OutputPort));
473  }
474 
477  {
478  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_framedPoll_OutputPort));
479  }
480 
481  // ----------------------------------------------------------------------
482  // Connection status queries for typed output ports
483  // ----------------------------------------------------------------------
484 
487  {
488  FW_ASSERT(
489  portNum < this->getNum_bufferAllocate_OutputPorts(),
490  static_cast<FwAssertArgType>(portNum)
491  );
492 
493  return this->m_bufferAllocate_OutputPort[portNum].isConnected();
494  }
495 
498  {
499  FW_ASSERT(
500  portNum < this->getNum_bufferDeallocate_OutputPorts(),
501  static_cast<FwAssertArgType>(portNum)
502  );
503 
504  return this->m_bufferDeallocate_OutputPort[portNum].isConnected();
505  }
506 
509  {
510  FW_ASSERT(
511  portNum < this->getNum_bufferOut_OutputPorts(),
512  static_cast<FwAssertArgType>(portNum)
513  );
514 
515  return this->m_bufferOut_OutputPort[portNum].isConnected();
516  }
517 
520  {
521  FW_ASSERT(
522  portNum < this->getNum_comOut_OutputPorts(),
523  static_cast<FwAssertArgType>(portNum)
524  );
525 
526  return this->m_comOut_OutputPort[portNum].isConnected();
527  }
528 
531  {
532  FW_ASSERT(
533  portNum < this->getNum_framedDeallocate_OutputPorts(),
534  static_cast<FwAssertArgType>(portNum)
535  );
536 
537  return this->m_framedDeallocate_OutputPort[portNum].isConnected();
538  }
539 
542  {
543  FW_ASSERT(
544  portNum < this->getNum_framedPoll_OutputPorts(),
545  static_cast<FwAssertArgType>(portNum)
546  );
547 
548  return this->m_framedPoll_OutputPort[portNum].isConnected();
549  }
550 
551  // ----------------------------------------------------------------------
552  // Port handler base-class functions for typed input ports
553  //
554  // Call these functions directly to bypass the corresponding ports
555  // ----------------------------------------------------------------------
556 
559  FwIndexType portNum,
560  FwOpcodeType opCode,
561  U32 cmdSeq,
562  const Fw::CmdResponse& response
563  )
564  {
565  // Make sure port number is valid
566  FW_ASSERT(
567  portNum < this->getNum_cmdResponseIn_InputPorts(),
568  static_cast<FwAssertArgType>(portNum)
569  );
570 
571  // Call handler function
572  this->cmdResponseIn_handler(
573  portNum,
574  opCode,
575  cmdSeq,
576  response
577  );
578  }
579 
582  FwIndexType portNum,
583  Fw::Buffer& recvBuffer,
584  const Drv::RecvStatus& recvStatus
585  )
586  {
587  // Make sure port number is valid
588  FW_ASSERT(
589  portNum < this->getNum_framedIn_InputPorts(),
590  static_cast<FwAssertArgType>(portNum)
591  );
592 
593  // Lock guard mutex before calling
594  this->lock();
595 
596  // Call handler function
597  this->framedIn_handler(
598  portNum,
599  recvBuffer,
600  recvStatus
601  );
602 
603  // Unlock guard mutex
604  this->unLock();
605  }
606 
609  FwIndexType portNum,
610  U32 context
611  )
612  {
613  // Make sure port number is valid
614  FW_ASSERT(
615  portNum < this->getNum_schedIn_InputPorts(),
616  static_cast<FwAssertArgType>(portNum)
617  );
618 
619  // Lock guard mutex before calling
620  this->lock();
621 
622  // Call handler function
623  this->schedIn_handler(
624  portNum,
625  context
626  );
627 
628  // Unlock guard mutex
629  this->unLock();
630  }
631 
632  // ----------------------------------------------------------------------
633  // Invocation functions for typed output ports
634  // ----------------------------------------------------------------------
635 
638  FwIndexType portNum,
639  U32 size
640  )
641  {
642  FW_ASSERT(
643  portNum < this->getNum_bufferAllocate_OutputPorts(),
644  static_cast<FwAssertArgType>(portNum)
645  );
646  return this->m_bufferAllocate_OutputPort[portNum].invoke(
647  size
648  );
649  }
650 
653  FwIndexType portNum,
654  Fw::Buffer& fwBuffer
655  )
656  {
657  FW_ASSERT(
658  portNum < this->getNum_bufferDeallocate_OutputPorts(),
659  static_cast<FwAssertArgType>(portNum)
660  );
661  this->m_bufferDeallocate_OutputPort[portNum].invoke(
662  fwBuffer
663  );
664  }
665 
668  FwIndexType portNum,
669  Fw::Buffer& fwBuffer
670  )
671  {
672  FW_ASSERT(
673  portNum < this->getNum_bufferOut_OutputPorts(),
674  static_cast<FwAssertArgType>(portNum)
675  );
676  this->m_bufferOut_OutputPort[portNum].invoke(
677  fwBuffer
678  );
679  }
680 
683  FwIndexType portNum,
684  Fw::ComBuffer& data,
685  U32 context
686  )
687  {
688  FW_ASSERT(
689  portNum < this->getNum_comOut_OutputPorts(),
690  static_cast<FwAssertArgType>(portNum)
691  );
692  this->m_comOut_OutputPort[portNum].invoke(
693  data,
694  context
695  );
696  }
697 
700  FwIndexType portNum,
701  Fw::Buffer& fwBuffer
702  )
703  {
704  FW_ASSERT(
705  portNum < this->getNum_framedDeallocate_OutputPorts(),
706  static_cast<FwAssertArgType>(portNum)
707  );
708  this->m_framedDeallocate_OutputPort[portNum].invoke(
709  fwBuffer
710  );
711  }
712 
715  FwIndexType portNum,
716  Fw::Buffer& pollBuffer
717  )
718  {
719  FW_ASSERT(
720  portNum < this->getNum_framedPoll_OutputPorts(),
721  static_cast<FwAssertArgType>(portNum)
722  );
723  return this->m_framedPoll_OutputPort[portNum].invoke(
724  pollBuffer
725  );
726  }
727 
728  // ----------------------------------------------------------------------
729  // Mutex operations for guarded ports
730  //
731  // You can override these operations to provide more sophisticated
732  // synchronization
733  // ----------------------------------------------------------------------
734 
736  lock()
737  {
738  this->m_guardedPortMutex.lock();
739  }
740 
742  unLock()
743  {
744  this->m_guardedPortMutex.unLock();
745  }
746 
747  // ----------------------------------------------------------------------
748  // Calls for messages received on typed input ports
749  // ----------------------------------------------------------------------
750 
751  void DeframerComponentBase ::
752  m_p_cmdResponseIn_in(
753  Fw::PassiveComponentBase* callComp,
754  FwIndexType portNum,
755  FwOpcodeType opCode,
756  U32 cmdSeq,
757  const Fw::CmdResponse& response
758  )
759  {
760  FW_ASSERT(callComp);
761  DeframerComponentBase* compPtr = static_cast<DeframerComponentBase*>(callComp);
762  compPtr->cmdResponseIn_handlerBase(
763  portNum,
764  opCode,
765  cmdSeq,
766  response
767  );
768  }
769 
770  void DeframerComponentBase ::
771  m_p_framedIn_in(
772  Fw::PassiveComponentBase* callComp,
773  FwIndexType portNum,
774  Fw::Buffer& recvBuffer,
775  const Drv::RecvStatus& recvStatus
776  )
777  {
778  FW_ASSERT(callComp);
779  DeframerComponentBase* compPtr = static_cast<DeframerComponentBase*>(callComp);
780  compPtr->framedIn_handlerBase(
781  portNum,
782  recvBuffer,
783  recvStatus
784  );
785  }
786 
787  void DeframerComponentBase ::
788  m_p_schedIn_in(
789  Fw::PassiveComponentBase* callComp,
790  FwIndexType portNum,
791  U32 context
792  )
793  {
794  FW_ASSERT(callComp);
795  DeframerComponentBase* compPtr = static_cast<DeframerComponentBase*>(callComp);
796  compPtr->schedIn_handlerBase(
797  portNum,
798  context
799  );
800  }
801 
802 }
#define FW_ASSERT(...)
Definition: Assert.hpp:14
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
Definition: BasicTypes.h:70
#define PRI_PlatformIntType
I32 FwEnumStoreType
Definition: FpConfig.h:64
PlatformAssertArgType FwAssertArgType
Definition: FpConfig.h:39
U32 FwOpcodeType
Definition: FpConfig.h:91
PlatformIndexType FwIndexType
Definition: FpConfig.h:25
Input ByteStreamPoll port.
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
Register a component.
void init()
Initialization function.
void init()
Initialization function.
Drv::PollStatus invoke(Fw::Buffer &pollBuffer)
Invoke a port interface.
void addCallPort(InputByteStreamPollPort *callPort)
Register an input port.
Status associated with the received data.
Enum representing a command response.
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
Register a component.
void init()
Initialization function.
void setPortNum(NATIVE_INT_TYPE portNum)
void init()
Object initializer.
Definition: ObjBase.cpp:27
const char * toChar() const
Definition: ObjectName.hpp:50
void init()
Initialization function.
void addCallPort(InputBufferGetPort *callPort)
Register an input port.
Fw::Buffer invoke(U32 size)
Invoke a port interface.
void addCallPort(InputBufferSendPort *callPort)
Register an input port.
void invoke(Fw::Buffer &fwBuffer)
Invoke a port interface.
void init()
Initialization function.
void addCallPort(InputComPort *callPort)
Register an input port.
Definition: ComPortAc.cpp:143
void init()
Initialization function.
Definition: ComPortAc.cpp:137
void invoke(Fw::ComBuffer &data, U32 context)
Invoke a port interface.
Definition: ComPortAc.cpp:156
bool isConnected()
Definition: PortBase.cpp:41
void format(const CHAR *formatString,...)
write formatted string to buffer
Definition: StringBase.cpp:56
void unLock()
unlock the mutex and assert success
Definition: Mutex.cpp:40
void lock()
lock the mutex and assert success
Definition: Mutex.cpp:34
Auto-generated base for Deframer component.
FwIndexType getNum_bufferDeallocate_OutputPorts() const
virtual void unLock()
Unlock the guarded mutex.
void set_bufferDeallocate_OutputPort(FwIndexType portNum, Fw::InputBufferSendPort *port)
Connect port to bufferDeallocate[portNum].
void bufferDeallocate_out(FwIndexType portNum, Fw::Buffer &fwBuffer)
Invoke output port bufferDeallocate.
FwIndexType getNum_framedIn_InputPorts() const
FwIndexType getNum_cmdResponseIn_InputPorts() const
void framedDeallocate_out(FwIndexType portNum, Fw::Buffer &fwBuffer)
Invoke output port framedDeallocate.
virtual void lock()
Lock the guarded mutex.
void set_framedDeallocate_OutputPort(FwIndexType portNum, Fw::InputBufferSendPort *port)
Connect port to framedDeallocate[portNum].
void set_framedPoll_OutputPort(FwIndexType portNum, Drv::InputByteStreamPollPort *port)
Connect port to framedPoll[portNum].
virtual void schedIn_handler(FwIndexType portNum, U32 context)=0
Handler for input port schedIn.
virtual ~DeframerComponentBase()
Destroy DeframerComponentBase object.
void bufferOut_out(FwIndexType portNum, Fw::Buffer &fwBuffer)
Invoke output port bufferOut.
Svc::InputSchedPort * get_schedIn_InputPort(FwIndexType portNum)
DeframerComponentBase(const char *compName="")
Construct DeframerComponentBase object.
FwIndexType getNum_bufferOut_OutputPorts() const
Fw::Buffer bufferAllocate_out(FwIndexType portNum, U32 size)
Invoke output port bufferAllocate.
FwIndexType getNum_comOut_OutputPorts() const
virtual void cmdResponseIn_handler(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)=0
Handler for input port cmdResponseIn.
Drv::PollStatus framedPoll_out(FwIndexType portNum, Fw::Buffer &pollBuffer)
Invoke output port framedPoll.
bool isConnected_bufferAllocate_OutputPort(FwIndexType portNum)
bool isConnected_bufferOut_OutputPort(FwIndexType portNum)
void comOut_out(FwIndexType portNum, Fw::ComBuffer &data, U32 context)
Invoke output port comOut.
virtual void framedIn_handler(FwIndexType portNum, Fw::Buffer &recvBuffer, const Drv::RecvStatus &recvStatus)=0
Handler for input port framedIn.
void schedIn_handlerBase(FwIndexType portNum, U32 context)
Handler base-class function for input port schedIn.
Fw::InputCmdResponsePort * get_cmdResponseIn_InputPort(FwIndexType portNum)
void cmdResponseIn_handlerBase(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)
Handler base-class function for input port cmdResponseIn.
void set_bufferOut_OutputPort(FwIndexType portNum, Fw::InputBufferSendPort *port)
Connect port to bufferOut[portNum].
FwIndexType getNum_framedDeallocate_OutputPorts() const
FwIndexType getNum_framedPoll_OutputPorts() const
bool isConnected_bufferDeallocate_OutputPort(FwIndexType portNum)
void set_comOut_OutputPort(FwIndexType portNum, Fw::InputComPort *port)
Connect port to comOut[portNum].
void framedIn_handlerBase(FwIndexType portNum, Fw::Buffer &recvBuffer, const Drv::RecvStatus &recvStatus)
Handler base-class function for input port framedIn.
void set_bufferAllocate_OutputPort(FwIndexType portNum, Fw::InputBufferGetPort *port)
Connect port to bufferAllocate[portNum].
bool isConnected_framedDeallocate_OutputPort(FwIndexType portNum)
FwIndexType getNum_schedIn_InputPorts() const
FwIndexType getNum_bufferAllocate_OutputPorts() const
bool isConnected_framedPoll_OutputPort(FwIndexType portNum)
bool isConnected_comOut_OutputPort(FwIndexType portNum)
Drv::InputByteStreamRecvPort * get_framedIn_InputPort(FwIndexType portNum)
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
Register a component.
Definition: SchedPortAc.cpp:62
void init()
Initialization function.
Definition: SchedPortAc.cpp:56