F´ Flight Software - C/C++ Documentation  NASA-v1.5.0
A framework for building embedded system applications to NASA flight quality standards.
BufferManagerComponentAc.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title BufferManagerComponentAc.cpp
3 // \author Auto-generated
4 // \brief cpp file for BufferManager component base class
5 //
6 // \copyright
7 // Copyright 2009-2015, by the California Institute of Technology.
8 // ALL RIGHTS RESERVED. United States Government Sponsorship
9 // acknowledged.
10 //
11 // ======================================================================
12 
13 #include <stdio.h>
14 #include <FpConfig.hpp>
16 #include <Fw/Types/Assert.hpp>
17 #if FW_ENABLE_TEXT_LOGGING
19 #endif
20 
21 
22 namespace Svc {
23 
24  // ----------------------------------------------------------------------
25  // Getters for numbers of input ports
26  // ----------------------------------------------------------------------
27 
30  {
31  FW_ASSERT(portNum < this->getNum_bufferSendIn_InputPorts(),static_cast<AssertArg>(portNum));
32  return &this->m_bufferSendIn_InputPort[portNum];
33  }
34 
37  {
38  FW_ASSERT(portNum < this->getNum_bufferGetCallee_InputPorts(),static_cast<AssertArg>(portNum));
39  return &this->m_bufferGetCallee_InputPort[portNum];
40  }
41 
42  // ----------------------------------------------------------------------
43  // Typed connectors for output ports
44  // ----------------------------------------------------------------------
45 
48  NATIVE_INT_TYPE portNum,
49  Fw::InputTimePort* port
50  )
51  {
52  FW_ASSERT(portNum < this->getNum_timeCaller_OutputPorts(),static_cast<AssertArg>(portNum));
53  this->m_timeCaller_OutputPort[portNum].addCallPort(port);
54  }
55 
58  NATIVE_INT_TYPE portNum,
59  Fw::InputLogPort* port
60  )
61  {
62  FW_ASSERT(portNum < this->getNum_eventOut_OutputPorts(),static_cast<AssertArg>(portNum));
64  }
65 
66 #if FW_ENABLE_TEXT_LOGGING == 1
67  void BufferManagerComponentBase ::
68  set_textEventOut_OutputPort(
69  NATIVE_INT_TYPE portNum,
71  )
72  {
73  FW_ASSERT(portNum < this->getNum_textEventOut_OutputPorts(),static_cast<AssertArg>(portNum));
74  this->m_textEventOut_OutputPort[portNum].addCallPort(port);
75  }
76 #endif
77 
80  NATIVE_INT_TYPE portNum,
81  Fw::InputTlmPort* port
82  )
83  {
84  FW_ASSERT(portNum < this->getNum_tlmOut_OutputPorts(),static_cast<AssertArg>(portNum));
86  }
87 
88  // ----------------------------------------------------------------------
89  // Serialization connectors for output ports
90  // ----------------------------------------------------------------------
91 
92 #if FW_PORT_SERIALIZATION
93 
96  NATIVE_INT_TYPE portNum,
97  Fw::InputSerializePort *port
98  )
99  {
100  FW_ASSERT(portNum < this->getNum_timeCaller_OutputPorts(),static_cast<AssertArg>(portNum));
101  return this->m_timeCaller_OutputPort[portNum].registerSerialPort(port);
102  }
103 
106  NATIVE_INT_TYPE portNum,
107  Fw::InputSerializePort *port
108  )
109  {
110  FW_ASSERT(portNum < this->getNum_eventOut_OutputPorts(),static_cast<AssertArg>(portNum));
111  return this->m_eventOut_OutputPort[portNum].registerSerialPort(port);
112  }
113 
114 #if FW_ENABLE_TEXT_LOGGING == 1
115  void BufferManagerComponentBase ::
116  set_textEventOut_OutputPort(
117  NATIVE_INT_TYPE portNum,
118  Fw::InputSerializePort *port
119  )
120  {
121  FW_ASSERT(portNum < this->getNum_textEventOut_OutputPorts(),static_cast<AssertArg>(portNum));
122  return this->m_textEventOut_OutputPort[portNum].registerSerialPort(port);
123  }
124 #endif
125 
128  NATIVE_INT_TYPE portNum,
129  Fw::InputSerializePort *port
130  )
131  {
132  FW_ASSERT(portNum < this->getNum_tlmOut_OutputPorts(),static_cast<AssertArg>(portNum));
133  return this->m_tlmOut_OutputPort[portNum].registerSerialPort(port);
134  }
135 
136 #endif
137 
138  // ----------------------------------------------------------------------
139  // Component construction, initialization, and destruction
140  // ----------------------------------------------------------------------
141 
142  BufferManagerComponentBase ::
143 #if FW_OBJECT_NAMES == 1
144  BufferManagerComponentBase(const char* compName) :
145  Fw::PassiveComponentBase(compName)
146 #else
147  BufferManagerComponentBase() :
148  Fw::PassiveComponentBase()
149 #endif
150  {
151 
152 
153 
154 
155  }
156 
158  init(NATIVE_INT_TYPE instance)
159  {
160 
161  // Initialize base class
163 
164  // Connect input port bufferSendIn
165  for (
166  NATIVE_INT_TYPE port = 0;
167  port < this->getNum_bufferSendIn_InputPorts();
168  port++
169  ) {
170 
171  this->m_bufferSendIn_InputPort[port].init();
172  this->m_bufferSendIn_InputPort[port].addCallComp(
173  this,
174  m_p_bufferSendIn_in
175  );
176  this->m_bufferSendIn_InputPort[port].setPortNum(port);
177 
178 #if FW_OBJECT_NAMES == 1
179  char portName[120];
180  (void) snprintf(
181  portName,
182  sizeof(portName),
183  "%s_bufferSendIn_InputPort[%d]",
184  this->m_objName,
185  port
186  );
187  this->m_bufferSendIn_InputPort[port].setObjName(portName);
188 #endif
189 
190  }
191 
192  // Connect input port bufferGetCallee
193  for (
194  NATIVE_INT_TYPE port = 0;
195  port < this->getNum_bufferGetCallee_InputPorts();
196  port++
197  ) {
198 
199  this->m_bufferGetCallee_InputPort[port].init();
201  this,
203  );
204  this->m_bufferGetCallee_InputPort[port].setPortNum(port);
205 
206 #if FW_OBJECT_NAMES == 1
207  char portName[120];
208  (void) snprintf(
209  portName,
210  sizeof(portName),
211  "%s_bufferGetCallee_InputPort[%d]",
212  this->m_objName,
213  port
214  );
215  this->m_bufferGetCallee_InputPort[port].setObjName(portName);
216 #endif
217 
218  }
219 
220  // Initialize output port timeCaller
221  for (
222  NATIVE_INT_TYPE port = 0;
223  port < this->getNum_timeCaller_OutputPorts();
224  port++
225  ) {
226  this->m_timeCaller_OutputPort[port].init();
227 
228 #if FW_OBJECT_NAMES == 1
229  char portName[120];
230  (void) snprintf(
231  portName,
232  sizeof(portName),
233  "%s_timeCaller_OutputPort[%d]",
234  this->m_objName,
235  port
236  );
237  this->m_timeCaller_OutputPort[port].setObjName(portName);
238 #endif
239 
240  }
241 
242  // Initialize output port eventOut
243  for (
244  NATIVE_INT_TYPE port = 0;
245  port < this->getNum_eventOut_OutputPorts();
246  port++
247  ) {
248  this->m_eventOut_OutputPort[port].init();
249 
250 #if FW_OBJECT_NAMES == 1
251  char portName[120];
252  (void) snprintf(
253  portName,
254  sizeof(portName),
255  "%s_eventOut_OutputPort[%d]",
256  this->m_objName,
257  port
258  );
259  this->m_eventOut_OutputPort[port].setObjName(portName);
260 #endif
261 
262  }
263 
264  // Initialize output port textEventOut
265 #if FW_ENABLE_TEXT_LOGGING == 1
266  for (
267  NATIVE_INT_TYPE port = 0;
268  port < this->getNum_textEventOut_OutputPorts();
269  port++
270  ) {
271  this->m_textEventOut_OutputPort[port].init();
272 
273 #if FW_OBJECT_NAMES == 1
274  char portName[120];
275  (void) snprintf(
276  portName,
277  sizeof(portName),
278  "%s_textEventOut_OutputPort[%d]",
279  this->m_objName,
280  port
281  );
282  this->m_textEventOut_OutputPort[port].setObjName(portName);
283 #endif
284 
285  }
286 #endif
287 
288  // Initialize output port tlmOut
289  for (
290  NATIVE_INT_TYPE port = 0;
291  port < this->getNum_tlmOut_OutputPorts();
292  port++
293  ) {
294  this->m_tlmOut_OutputPort[port].init();
295 
296 #if FW_OBJECT_NAMES == 1
297  char portName[120];
298  (void) snprintf(
299  portName,
300  sizeof(portName),
301  "%s_tlmOut_OutputPort[%d]",
302  this->m_objName,
303  port
304  );
305  this->m_tlmOut_OutputPort[port].setObjName(portName);
306 #endif
307 
308  }
309 
310 
311  }
312 
315 
316  }
317 
318  // ----------------------------------------------------------------------
319  // Invocation functions for output ports
320  // ----------------------------------------------------------------------
321 
322  // ----------------------------------------------------------------------
323  // Getters for numbers of ports
324  // ----------------------------------------------------------------------
325 
326  NATIVE_INT_TYPE BufferManagerComponentBase ::
327  getNum_timeCaller_OutputPorts(void)
328  {
330  this->m_timeCaller_OutputPort
331  );
332  }
333 
336  {
339  );
340  }
341 
342 #if FW_ENABLE_TEXT_LOGGING == 1
343  NATIVE_INT_TYPE BufferManagerComponentBase ::
344  getNum_textEventOut_OutputPorts(void)
345  {
347  this->m_textEventOut_OutputPort
348  );
349  }
350 #endif
351 
352  NATIVE_INT_TYPE BufferManagerComponentBase ::
353  getNum_bufferSendIn_InputPorts(void)
354  {
356  this->m_bufferSendIn_InputPort
357  );
358  }
359 
362  {
365  );
366  }
367 
370  {
372  this->m_tlmOut_OutputPort
373  );
374  }
375 
376  // ----------------------------------------------------------------------
377  // Port connection status queries
378  // ----------------------------------------------------------------------
379 
380  bool BufferManagerComponentBase ::
381  isConnected_timeCaller_OutputPort(NATIVE_INT_TYPE portNum)
382  {
383  FW_ASSERT(
384  portNum < this->getNum_timeCaller_OutputPorts(),
385  static_cast<AssertArg>(portNum)
386  );
387  return this->m_timeCaller_OutputPort[portNum].isConnected();
388  }
389 
392  {
393  FW_ASSERT(
394  portNum < this->getNum_eventOut_OutputPorts(),
395  static_cast<AssertArg>(portNum)
396  );
397  return this->m_eventOut_OutputPort[portNum].isConnected();
398  }
399 
400 #if FW_ENABLE_TEXT_LOGGING == 1
401  bool BufferManagerComponentBase ::
402  isConnected_textEventOut_OutputPort(NATIVE_INT_TYPE portNum)
403  {
404  FW_ASSERT(
405  portNum < this->getNum_textEventOut_OutputPorts(),
406  static_cast<AssertArg>(portNum)
407  );
408  return this->m_textEventOut_OutputPort[portNum].isConnected();
409  }
410 #endif
411 
414  {
415  FW_ASSERT(
416  portNum < this->getNum_tlmOut_OutputPorts(),
417  static_cast<AssertArg>(portNum)
418  );
419  return this->m_tlmOut_OutputPort[portNum].isConnected();
420  }
421 
422  // ----------------------------------------------------------------------
423  // Telemetry write functions
424  // ----------------------------------------------------------------------
425 
426  void BufferManagerComponentBase ::
427  tlmWrite_BufferManager_NumAllocatedBuffers(U32 arg)
428  {
429 
430  if (this->m_tlmOut_OutputPort[0].isConnected()) {
431  Fw::Time _tlmTime;
432  if (this->m_timeCaller_OutputPort[0].isConnected()) {
433  this->m_timeCaller_OutputPort[0].invoke( _tlmTime);
434  }
435  Fw::TlmBuffer _tlmBuff;
436  Fw::SerializeStatus _stat = _tlmBuff.serialize(arg);
437  FW_ASSERT(
438  _stat == Fw::FW_SERIALIZE_OK,
439  static_cast<AssertArg>(_stat)
440  );
441 
442  FwChanIdType _id;
443 
444  _id = this->getIdBase() + CHANNELID_BUFFERMANAGER_NUMALLOCATEDBUFFERS;
445 
446  this->m_tlmOut_OutputPort[0].invoke(
447  _id,
448  _tlmTime,
449  _tlmBuff
450  );
451  }
452 
453  }
454 
457  {
458 
459  if (this->m_tlmOut_OutputPort[0].isConnected()) {
460  Fw::Time _tlmTime;
461  if (this->m_timeCaller_OutputPort[0].isConnected()) {
462  this->m_timeCaller_OutputPort[0].invoke( _tlmTime);
463  }
464  Fw::TlmBuffer _tlmBuff;
465  Fw::SerializeStatus _stat = _tlmBuff.serialize(arg);
466  FW_ASSERT(
467  _stat == Fw::FW_SERIALIZE_OK,
468  static_cast<AssertArg>(_stat)
469  );
470 
471  FwChanIdType _id;
472 
474 
475  this->m_tlmOut_OutputPort[0].invoke(
476  _id,
477  _tlmTime,
478  _tlmBuff
479  );
480  }
481 
482  }
483 
484  // ----------------------------------------------------------------------
485  // Time
486  // ----------------------------------------------------------------------
487 
488  Fw::Time BufferManagerComponentBase ::
489  getTime(void)
490  {
491  if (this->m_timeCaller_OutputPort[0].isConnected()) {
492  Fw::Time _time;
493  this->m_timeCaller_OutputPort[0].invoke(_time);
494  return _time;
495  } else {
496  return Fw::Time(TB_NONE,0,0);
497  }
498  }
499 
500  // ----------------------------------------------------------------------
501  // Event handling functions
502  // ----------------------------------------------------------------------
503 
504  void BufferManagerComponentBase ::
505  log_ACTIVITY_HI_ClearedErrorState(
506  void
507  )
508  {
509 
510 
511  // Get the time
512  Fw::Time _logTime;
513  if (this->m_timeCaller_OutputPort[0].isConnected()) {
514  this->m_timeCaller_OutputPort[0].invoke( _logTime);
515  }
516 
517  FwEventIdType _id = static_cast<FwEventIdType>(0);
518 
519  _id = this->getIdBase() + EVENTID_CLEAREDERRORSTATE;
520 
521  // Emit the event on the log port
522  if (this->m_eventOut_OutputPort[0].isConnected()) {
523 
524  Fw::LogBuffer _logBuff;
525 #if FW_AMPCS_COMPATIBLE
526  // for AMPCS, need to encode zero arguments
528  _zero_status = _logBuff.serialize(static_cast<U8>(0));
529  FW_ASSERT(
530  _zero_status == Fw::FW_SERIALIZE_OK,
531  static_cast<AssertArg>(_zero_status)
532  );
533 #endif
534 
535 
536  this->m_eventOut_OutputPort[0].invoke(
537  _id,
538  _logTime,Fw::LOG_ACTIVITY_HI,
539  _logBuff
540  );
541 
542  }
543 
544  // Emit the event on the text log port
545 #if FW_ENABLE_TEXT_LOGGING
546  if (this->m_textEventOut_OutputPort[0].isConnected()) {
547 
548 #if FW_OBJECT_NAMES == 1
549  const char* _formatString =
550  "(%s) %s: Cleared activity state";
551 #else
552  const char* _formatString =
553  "%s: Cleared activity state";
554 #endif
555 
556  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
557 
558  (void) snprintf(
559  _textBuffer,
561  _formatString,
562 #if FW_OBJECT_NAMES == 1
563  this->m_objName,
564 #endif
565  "ClearedErrorState "
566  );
567 
568  // Null terminate
569  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
570  Fw::TextLogString _logString = _textBuffer;
571  this->m_textEventOut_OutputPort[0].invoke(
572  _id,
573  _logTime,Fw::TEXT_LOG_ACTIVITY_HI,
574  _logString
575  );
576 
577  }
578 #endif
579 
580  }
581 
582 
585  void
586  )
587  {
588 
589 
590  // Get the time
591  Fw::Time _logTime;
592  if (this->m_timeCaller_OutputPort[0].isConnected()) {
593  this->m_timeCaller_OutputPort[0].invoke( _logTime);
594  }
595 
596  FwEventIdType _id = static_cast<FwEventIdType>(0);
597 
598  _id = this->getIdBase() + EVENTID_STORESIZEEXCEEDED;
599 
600  // Emit the event on the log port
601  if (this->m_eventOut_OutputPort[0].isConnected()) {
602 
603  Fw::LogBuffer _logBuff;
604 #if FW_AMPCS_COMPATIBLE
605  // for AMPCS, need to encode zero arguments
607  _zero_status = _logBuff.serialize(static_cast<U8>(0));
608  FW_ASSERT(
609  _zero_status == Fw::FW_SERIALIZE_OK,
610  static_cast<AssertArg>(_zero_status)
611  );
612 #endif
613 
614 
615  this->m_eventOut_OutputPort[0].invoke(
616  _id,
617  _logTime,Fw::LOG_WARNING_HI,
618  _logBuff
619  );
620 
621  }
622 
623  // Emit the event on the text log port
624 #if FW_ENABLE_TEXT_LOGGING
625  if (this->m_textEventOut_OutputPort[0].isConnected()) {
626 
627 #if FW_OBJECT_NAMES == 1
628  const char* _formatString =
629  "(%s) %s: Exceeded storage size";
630 #else
631  const char* _formatString =
632  "%s: Exceeded storage size";
633 #endif
634 
635  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
636 
637  (void) snprintf(
638  _textBuffer,
640  _formatString,
641 #if FW_OBJECT_NAMES == 1
642  this->m_objName,
643 #endif
644  "StoreSizeExceeded "
645  );
646 
647  // Null terminate
648  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
649  Fw::TextLogString _logString = _textBuffer;
650  this->m_textEventOut_OutputPort[0].invoke(
651  _id,
652  _logTime,Fw::TEXT_LOG_WARNING_HI,
653  _logString
654  );
655 
656  }
657 #endif
658 
659  }
660 
661 
664  void
665  )
666  {
667 
668 
669  // Get the time
670  Fw::Time _logTime;
671  if (this->m_timeCaller_OutputPort[0].isConnected()) {
672  this->m_timeCaller_OutputPort[0].invoke( _logTime);
673  }
674 
675  FwEventIdType _id = static_cast<FwEventIdType>(0);
676 
677  _id = this->getIdBase() + EVENTID_TOOMANYBUFFERS;
678 
679  // Emit the event on the log port
680  if (this->m_eventOut_OutputPort[0].isConnected()) {
681 
682  Fw::LogBuffer _logBuff;
683 #if FW_AMPCS_COMPATIBLE
684  // for AMPCS, need to encode zero arguments
686  _zero_status = _logBuff.serialize(static_cast<U8>(0));
687  FW_ASSERT(
688  _zero_status == Fw::FW_SERIALIZE_OK,
689  static_cast<AssertArg>(_zero_status)
690  );
691 #endif
692 
693 
694  this->m_eventOut_OutputPort[0].invoke(
695  _id,
696  _logTime,Fw::LOG_WARNING_HI,
697  _logBuff
698  );
699 
700  }
701 
702  // Emit the event on the text log port
703 #if FW_ENABLE_TEXT_LOGGING
704  if (this->m_textEventOut_OutputPort[0].isConnected()) {
705 
706 #if FW_OBJECT_NAMES == 1
707  const char* _formatString =
708  "(%s) %s: Too many active buffers";
709 #else
710  const char* _formatString =
711  "%s: Too many active buffers";
712 #endif
713 
714  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
715 
716  (void) snprintf(
717  _textBuffer,
719  _formatString,
720 #if FW_OBJECT_NAMES == 1
721  this->m_objName,
722 #endif
723  "TooManyBuffers "
724  );
725 
726  // Null terminate
727  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
728  Fw::TextLogString _logString = _textBuffer;
729  this->m_textEventOut_OutputPort[0].invoke(
730  _id,
731  _logTime,Fw::TEXT_LOG_WARNING_HI,
732  _logString
733  );
734 
735  }
736 #endif
737 
738  }
739 
740 
741  // ----------------------------------------------------------------------
742  // Mutex functions for guarded ports
743  // ----------------------------------------------------------------------
744 
745  void BufferManagerComponentBase ::
746  lock(void)
747  {
748  this->m_guardedPortMutex.lock();
749  }
750 
752  unLock(void)
753  {
754  this->m_guardedPortMutex.unLock();
755  }
756 
757  // ----------------------------------------------------------------------
758  // Calls for invocations received on typed input ports
759  // ----------------------------------------------------------------------
760 
761  void BufferManagerComponentBase ::
762  m_p_bufferSendIn_in(
763  Fw::PassiveComponentBase* callComp,
764  NATIVE_INT_TYPE portNum,
765  Fw::Buffer &fwBuffer
766  )
767  {
768  FW_ASSERT(callComp);
769  BufferManagerComponentBase* compPtr =
770  (BufferManagerComponentBase*) callComp;
771  compPtr->bufferSendIn_handlerBase(portNum, fwBuffer);
772  }
773 
776  Fw::PassiveComponentBase* callComp,
777  NATIVE_INT_TYPE portNum,
778  U32 size
779  )
780  {
781  FW_ASSERT(callComp);
782  BufferManagerComponentBase* compPtr =
783  (BufferManagerComponentBase*) callComp;
784  return compPtr->bufferGetCallee_handlerBase(portNum, size);
785  }
786 
787  // ----------------------------------------------------------------------
788  // Port handler base-class functions for typed input ports
789  // ----------------------------------------------------------------------
790 
791  void BufferManagerComponentBase ::
792  bufferSendIn_handlerBase(
793  NATIVE_INT_TYPE portNum,
794  Fw::Buffer &fwBuffer
795  )
796  {
797 
798  // Make sure port number is valid
799  FW_ASSERT(portNum < this->getNum_bufferSendIn_InputPorts(),static_cast<AssertArg>(portNum));
800 
801  // Lock guard mutex before calling
802  this->lock();
803 
804  // Down call to pure virtual handler method implemented in Impl class
805  this->bufferSendIn_handler(portNum, fwBuffer);
806 
807  // Unlock guard mutex
808  this->unLock();
809 
810  }
811 
814  NATIVE_INT_TYPE portNum,
815  U32 size
816  )
817  {
818 
819  // Make sure port number is valid
820  FW_ASSERT(portNum < this->getNum_bufferGetCallee_InputPorts(),static_cast<AssertArg>(portNum));
821  Fw::Buffer retVal;
822 
823  // Lock guard mutex before calling
824  this->lock();
825 
826  // Down call to pure virtual handler method implemented in Impl class
827  retVal = this->bufferGetCallee_handler(portNum, size);
828 
829  // Unlock guard mutex
830  this->unLock();
831 
832  return retVal;
833 
834  }
835 
836 } // end namespace Svc
Fw::TEXT_LOG_ACTIVITY_HI
@ TEXT_LOG_ACTIVITY_HI
Definition: LogTextPortAc.hpp:31
Fw::TextLogString
Definition: TextLogString.hpp:11
Fw::InputTimePort
Definition: TimePortAc.hpp:28
Svc::BufferManagerComponentBase::isConnected_eventOut_OutputPort
bool isConnected_eventOut_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BufferManagerComponentAc.cpp:391
Fw::InputTlmPort
Definition: TlmPortAc.hpp:29
Fw::PassiveComponentBase::getIdBase
U32 getIdBase(void) const
Definition: PassiveComponentBase.cpp:40
Svc::BufferManagerComponentBase::bufferGetCallee_handler
virtual Fw::Buffer bufferGetCallee_handler(NATIVE_INT_TYPE portNum, U32 size)=0
Handler for input port bufferGetCallee.
Fw::Time
Definition: Time.hpp:10
Svc::BufferManagerComponentBase::m_bufferGetCallee_InputPort
Fw::InputBufferGetPort m_bufferGetCallee_InputPort[NUM_BUFFERGETCALLEE_INPUT_PORTS]
Definition: BufferManagerComponentAc.hpp:445
Fw::SerializeStatus
SerializeStatus
forward declaration for string
Definition: Serializable.hpp:14
Fw::TlmBuffer
Definition: TlmBuffer.hpp:21
FwChanIdType
#define FwChanIdType
Type representation for a channel id.
Definition: FpConfig.hpp:66
Fw::PortBase::isConnected
bool isConnected(void)
Definition: PortBase.cpp:40
Fw::OutputLogPort::invoke
void invoke(FwEventIdType id, Fw::Time &timeTag, LogSeverity severity, LogBuffer &args)
Definition: LogPortAc.cpp:121
Fw::LOG_WARNING_HI
@ LOG_WARNING_HI
Definition: LogPortAc.hpp:28
FW_OBJECT_NAMES
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects)
Definition: FpConfig.hpp:91
Fw::SerializeBufferBase::serialize
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
Definition: Serializable.cpp:67
FW_NUM_ARRAY_ELEMENTS
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
Definition: BasicTypes.hpp:103
U8
uint8_t U8
8-bit unsigned integer
Definition: BasicTypes.hpp:76
Svc::BufferManagerComponentBase
Auto-generated base for BufferManager component.
Definition: BufferManagerComponentAc.hpp:44
Svc::BufferManagerComponentBase::isConnected_tlmOut_OutputPort
bool isConnected_tlmOut_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BufferManagerComponentAc.cpp:413
Fw::LogBuffer
Definition: LogBuffer.hpp:22
Fw::Buffer
Definition: BufferSerializableAc.hpp:24
Fw::TEXT_LOG_WARNING_HI
@ TEXT_LOG_WARNING_HI
Definition: LogTextPortAc.hpp:28
Svc::BufferManagerComponentBase::~BufferManagerComponentBase
virtual ~BufferManagerComponentBase(void)
Definition: BufferManagerComponentAc.cpp:314
Assert.hpp
Fw::FW_SERIALIZE_OK
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.
Definition: Serializable.hpp:15
Svc::BufferManagerComponentBase::CHANNELID_BUFFERMANAGER_ALLOCATEDSIZE
PROTECTED CHANNELID_BUFFERMANAGER_ALLOCATEDSIZE
Channel ID for BufferManager_AllocatedSize.
Definition: BufferManagerComponentAc.hpp:397
BufferManagerComponentAc.hpp
EightyCharString.hpp
Fw::PassiveComponentBase
Definition: PassiveComponentBase.hpp:10
Fw::OutputLogPort::init
void init(void)
Definition: LogPortAc.cpp:107
Fw::ObjBase::init
void init(void)
Object initializer.
Definition: ObjBase.cpp:26
Svc::BufferManagerComponentBase::m_p_bufferGetCallee_in
static Fw::Buffer m_p_bufferGetCallee_in(Fw::PassiveComponentBase *callComp, NATIVE_INT_TYPE portNum, U32 size)
Definition: BufferManagerComponentAc.cpp:775
Svc::BufferManagerComponentBase::get_bufferGetCallee_InputPort
Fw::InputBufferGetPort * get_bufferGetCallee_InputPort(NATIVE_INT_TYPE portNum)
Definition: BufferManagerComponentAc.cpp:36
Fw::OutputTlmPort::addCallPort
void addCallPort(InputTlmPort *callPort)
Definition: TlmPortAc.cpp:105
Svc::BufferManagerComponentBase::set_timeCaller_OutputPort
void set_timeCaller_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputTimePort *port)
Definition: BufferManagerComponentAc.cpp:47
Fw::InputBufferGetPort
Definition: BufferGetPortAc.hpp:28
Fw::OutputTlmPort::invoke
void invoke(FwChanIdType id, Fw::Time &timeTag, TlmBuffer &val)
Definition: TlmPortAc.cpp:115
Svc::BufferManagerComponentBase::unLock
virtual void unLock(void)
Definition: BufferManagerComponentAc.cpp:752
Svc::BufferManagerComponentBase::set_tlmOut_OutputPort
void set_tlmOut_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputTlmPort *port)
Definition: BufferManagerComponentAc.cpp:79
Fw::InputBufferSendPort
Definition: BufferSendPortAc.hpp:28
FW_ASSERT
#define FW_ASSERT(...)
Definition: Assert.hpp:9
Fw::LOG_ACTIVITY_HI
@ LOG_ACTIVITY_HI
Definition: LogPortAc.hpp:31
Svc::BufferManagerComponentBase::getNum_tlmOut_OutputPorts
NATIVE_INT_TYPE getNum_tlmOut_OutputPorts(void)
Definition: BufferManagerComponentAc.cpp:369
Svc::BufferManagerComponentBase::getNum_eventOut_OutputPorts
NATIVE_INT_TYPE getNum_eventOut_OutputPorts(void)
Definition: BufferManagerComponentAc.cpp:335
Fw::OutputTlmPort::init
void init(void)
Definition: TlmPortAc.cpp:101
Svc::BufferManagerComponentBase::get_bufferSendIn_InputPort
Fw::InputBufferSendPort * get_bufferSendIn_InputPort(NATIVE_INT_TYPE portNum)
Definition: BufferManagerComponentAc.cpp:29
Fw::InputBufferGetPort::init
void init(void)
initialization function
Definition: BufferGetPortAc.cpp:38
FpConfig.hpp
ISF configuration file.
Fw::InputPortBase::setPortNum
void setPortNum(NATIVE_INT_TYPE portNum)
Definition: InputPortBase.cpp:25
Svc::BufferManagerComponentBase::set_eventOut_OutputPort
void set_eventOut_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputLogPort *port)
Definition: BufferManagerComponentAc.cpp:57
Fw::OutputLogPort::addCallPort
void addCallPort(InputLogPort *callPort)
Definition: LogPortAc.cpp:111
Svc::BufferManagerComponentBase::bufferGetCallee_handlerBase
Fw::Buffer bufferGetCallee_handlerBase(NATIVE_INT_TYPE portNum, U32 size)
Definition: BufferManagerComponentAc.cpp:813
Svc::BufferManagerComponentBase::EVENTID_STORESIZEEXCEEDED
PROTECTED EVENTID_STORESIZEEXCEEDED
Definition: BufferManagerComponentAc.hpp:355
Fw::InputBufferGetPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
call to register a component
Definition: BufferGetPortAc.cpp:42
Svc
Definition: ActiveLoggerComponentAc.cpp:22
Svc::BufferManagerComponentBase::EVENTID_TOOMANYBUFFERS
PROTECTED EVENTID_TOOMANYBUFFERS
Definition: BufferManagerComponentAc.hpp:356
Svc::BufferManagerComponentBase::log_WARNING_HI_StoreSizeExceeded
void log_WARNING_HI_StoreSizeExceeded(void)
Definition: BufferManagerComponentAc.cpp:584
Svc::BufferManagerComponentBase::portNum
PRIVATE NATIVE_INT_TYPE portNum
Definition: BufferManagerComponentAc.hpp:481
Svc::BufferManagerComponentBase::log_WARNING_HI_TooManyBuffers
void log_WARNING_HI_TooManyBuffers(void)
Definition: BufferManagerComponentAc.cpp:663
Fw::InputLogPort
Definition: LogPortAc.hpp:40
Svc::BufferManagerComponentBase::m_eventOut_OutputPort
Fw::OutputLogPort m_eventOut_OutputPort[NUM_EVENTOUT_OUTPUT_PORTS]
Definition: BufferManagerComponentAc.hpp:459
Svc::BufferManagerComponentBase::getNum_bufferGetCallee_InputPorts
NATIVE_INT_TYPE getNum_bufferGetCallee_InputPorts(void)
Definition: BufferManagerComponentAc.cpp:361
Svc::BufferManagerComponentBase::tlmWrite_BufferManager_AllocatedSize
void tlmWrite_BufferManager_AllocatedSize(U32 arg)
Definition: BufferManagerComponentAc.cpp:456
FwEventIdType
#define FwEventIdType
Type representation for a event id.
Definition: FpConfig.hpp:70
Svc::BufferManagerComponentBase::fwBuffer
PROTECTED Fw::Buffer & fwBuffer
Definition: BufferManagerComponentAc.hpp:208
NATIVE_INT_TYPE
int NATIVE_INT_TYPE
native integer type declaration
Definition: BasicTypes.hpp:29
AssertArg
#define AssertArg
Definition: FpConfig.hpp:51
TB_NONE
@ TB_NONE
No time base has been established.
Definition: FpConfig.hpp:324
Svc::BufferManagerComponentBase::m_tlmOut_OutputPort
Fw::OutputTlmPort m_tlmOut_OutputPort[NUM_TLMOUT_OUTPUT_PORTS]
Definition: BufferManagerComponentAc.hpp:469
Fw
Definition: BufferGetPortAc.cpp:6
FW_LOG_TEXT_BUFFER_SIZE
#define FW_LOG_TEXT_BUFFER_SIZE
Max size of string for text log message.
Definition: FpConfig.hpp:291
Fw::InputLogTextPort
Definition: LogTextPortAc.hpp:40