RINASim  October 2016
Documentation of framework for OMNeT++
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
ControlPDU_m.cc
Go to the documentation of this file.
1 //
2 // Generated file, do not edit! Created by nedtool 5.0 from DIF/EFCP/DTCP/ControlPDU.msg.
3 //
4 
5 // Disable warnings about unused variables, empty switch stmts, etc:
6 #ifdef _MSC_VER
7 # pragma warning(disable:4101)
8 # pragma warning(disable:4065)
9 #endif
10 
11 #include <iostream>
12 #include <sstream>
13 #include "ControlPDU_m.h"
14 
15 namespace omnetpp {
16 
17 // Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
18 // They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
19 
20 // Packing/unpacking an std::vector
21 template<typename T, typename A>
22 void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
23 {
24  int n = v.size();
25  doParsimPacking(buffer, n);
26  for (int i = 0; i < n; i++)
27  doParsimPacking(buffer, v[i]);
28 }
29 
30 template<typename T, typename A>
31 void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
32 {
33  int n;
34  doParsimUnpacking(buffer, n);
35  v.resize(n);
36  for (int i = 0; i < n; i++)
37  doParsimUnpacking(buffer, v[i]);
38 }
39 
40 // Packing/unpacking an std::list
41 template<typename T, typename A>
42 void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
43 {
44  doParsimPacking(buffer, (int)l.size());
45  for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
46  doParsimPacking(buffer, (T&)*it);
47 }
48 
49 template<typename T, typename A>
50 void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
51 {
52  int n;
53  doParsimUnpacking(buffer, n);
54  for (int i=0; i<n; i++) {
55  l.push_back(T());
56  doParsimUnpacking(buffer, l.back());
57  }
58 }
59 
60 // Packing/unpacking an std::set
61 template<typename T, typename Tr, typename A>
62 void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
63 {
64  doParsimPacking(buffer, (int)s.size());
65  for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
66  doParsimPacking(buffer, *it);
67 }
68 
69 template<typename T, typename Tr, typename A>
70 void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
71 {
72  int n;
73  doParsimUnpacking(buffer, n);
74  for (int i=0; i<n; i++) {
75  T x;
76  doParsimUnpacking(buffer, x);
77  s.insert(x);
78  }
79 }
80 
81 // Packing/unpacking an std::map
82 template<typename K, typename V, typename Tr, typename A>
83 void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
84 {
85  doParsimPacking(buffer, (int)m.size());
86  for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
87  doParsimPacking(buffer, it->first);
88  doParsimPacking(buffer, it->second);
89  }
90 }
91 
92 template<typename K, typename V, typename Tr, typename A>
93 void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
94 {
95  int n;
96  doParsimUnpacking(buffer, n);
97  for (int i=0; i<n; i++) {
98  K k; V v;
99  doParsimUnpacking(buffer, k);
100  doParsimUnpacking(buffer, v);
101  m[k] = v;
102  }
103 }
104 
105 // Default pack/unpack function for arrays
106 template<typename T>
107 void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
108 {
109  for (int i = 0; i < n; i++)
110  doParsimPacking(b, t[i]);
111 }
112 
113 template<typename T>
114 void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
115 {
116  for (int i = 0; i < n; i++)
117  doParsimUnpacking(b, t[i]);
118 }
119 
120 // Default rule to prevent compiler from choosing base class' doParsimPacking() function
121 template<typename T>
122 void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
123 {
124  throw omnetpp::cRuntimeError("Parsim error: no doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
125 }
126 
127 template<typename T>
128 void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
129 {
130  throw omnetpp::cRuntimeError("Parsim error: no doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
131 }
132 
133 } // namespace omnetpp
134 
135 
136 // forward
137 template<typename T, typename A>
138 std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
139 
140 // Template rule which fires if a struct or class doesn't have operator<<
141 template<typename T>
142 inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
143 
144 // operator<< for std::vector<T>
145 template<typename T, typename A>
146 inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
147 {
148  out.put('{');
149  for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
150  {
151  if (it != vec.begin()) {
152  out.put(','); out.put(' ');
153  }
154  out << *it;
155  }
156  out.put('}');
157 
158  char buf[32];
159  sprintf(buf, " (size=%u)", (unsigned int)vec.size());
160  out.write(buf, strlen(buf));
161  return out;
162 }
163 
165 
166 ControlPDU::ControlPDU(const char *name, int kind) : ::PDU(name,kind)
167 {
168  this->setType(-1);
169 }
170 
171 ControlPDU::ControlPDU(const ControlPDU& other) : ::PDU(other)
172 {
173  copy(other);
174 }
175 
177 {
178 }
179 
181 {
182  if (this==&other) return *this;
183  ::PDU::operator=(other);
184  copy(other);
185  return *this;
186 }
187 
188 void ControlPDU::copy(const ControlPDU& other)
189 {
190 }
191 
192 void ControlPDU::parsimPack(omnetpp::cCommBuffer *b) const
193 {
195 }
196 
197 void ControlPDU::parsimUnpack(omnetpp::cCommBuffer *b)
198 {
200 }
201 
202 class ControlPDUDescriptor : public omnetpp::cClassDescriptor
203 {
204  private:
205  mutable const char **propertynames;
206  public:
208  virtual ~ControlPDUDescriptor();
209 
210  virtual bool doesSupport(omnetpp::cObject *obj) const override;
211  virtual const char **getPropertyNames() const override;
212  virtual const char *getProperty(const char *propertyname) const override;
213  virtual int getFieldCount() const override;
214  virtual const char *getFieldName(int field) const override;
215  virtual int findField(const char *fieldName) const override;
216  virtual unsigned int getFieldTypeFlags(int field) const override;
217  virtual const char *getFieldTypeString(int field) const override;
218  virtual const char **getFieldPropertyNames(int field) const override;
219  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
220  virtual int getFieldArraySize(void *object, int field) const override;
221 
222  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
223  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
224 
225  virtual const char *getFieldStructName(int field) const override;
226  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
227 };
228 
230 
231 ControlPDUDescriptor::ControlPDUDescriptor() : omnetpp::cClassDescriptor("ControlPDU", "PDU")
232 {
233  propertynames = nullptr;
234 }
235 
237 {
238  delete[] propertynames;
239 }
240 
241 bool ControlPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
242 {
243  return dynamic_cast<ControlPDU *>(obj)!=nullptr;
244 }
245 
247 {
248  if (!propertynames) {
249  static const char *names[] = { nullptr };
250  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
251  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
252  propertynames = mergeLists(basenames, names);
253  }
254  return propertynames;
255 }
256 
257 const char *ControlPDUDescriptor::getProperty(const char *propertyname) const
258 {
259  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
260  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
261 }
262 
264 {
265  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
266  return basedesc ? 0+basedesc->getFieldCount() : 0;
267 }
268 
269 unsigned int ControlPDUDescriptor::getFieldTypeFlags(int field) const
270 {
271  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
272  if (basedesc) {
273  if (field < basedesc->getFieldCount())
274  return basedesc->getFieldTypeFlags(field);
275  field -= basedesc->getFieldCount();
276  }
277  return 0;
278 }
279 
280 const char *ControlPDUDescriptor::getFieldName(int field) const
281 {
282  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
283  if (basedesc) {
284  if (field < basedesc->getFieldCount())
285  return basedesc->getFieldName(field);
286  field -= basedesc->getFieldCount();
287  }
288  return nullptr;
289 }
290 
291 int ControlPDUDescriptor::findField(const char *fieldName) const
292 {
293  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
294  return basedesc ? basedesc->findField(fieldName) : -1;
295 }
296 
297 const char *ControlPDUDescriptor::getFieldTypeString(int field) const
298 {
299  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
300  if (basedesc) {
301  if (field < basedesc->getFieldCount())
302  return basedesc->getFieldTypeString(field);
303  field -= basedesc->getFieldCount();
304  }
305  return nullptr;
306 }
307 
308 const char **ControlPDUDescriptor::getFieldPropertyNames(int field) const
309 {
310  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
311  if (basedesc) {
312  if (field < basedesc->getFieldCount())
313  return basedesc->getFieldPropertyNames(field);
314  field -= basedesc->getFieldCount();
315  }
316  switch (field) {
317  default: return nullptr;
318  }
319 }
320 
321 const char *ControlPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
322 {
323  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
324  if (basedesc) {
325  if (field < basedesc->getFieldCount())
326  return basedesc->getFieldProperty(field, propertyname);
327  field -= basedesc->getFieldCount();
328  }
329  switch (field) {
330  default: return nullptr;
331  }
332 }
333 
334 int ControlPDUDescriptor::getFieldArraySize(void *object, int field) const
335 {
336  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
337  if (basedesc) {
338  if (field < basedesc->getFieldCount())
339  return basedesc->getFieldArraySize(object, field);
340  field -= basedesc->getFieldCount();
341  }
342  ControlPDU *pp = (ControlPDU *)object; (void)pp;
343  switch (field) {
344  default: return 0;
345  }
346 }
347 
348 std::string ControlPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
349 {
350  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
351  if (basedesc) {
352  if (field < basedesc->getFieldCount())
353  return basedesc->getFieldValueAsString(object,field,i);
354  field -= basedesc->getFieldCount();
355  }
356  ControlPDU *pp = (ControlPDU *)object; (void)pp;
357  switch (field) {
358  default: return "";
359  }
360 }
361 
362 bool ControlPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
363 {
364  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
365  if (basedesc) {
366  if (field < basedesc->getFieldCount())
367  return basedesc->setFieldValueAsString(object,field,i,value);
368  field -= basedesc->getFieldCount();
369  }
370  ControlPDU *pp = (ControlPDU *)object; (void)pp;
371  switch (field) {
372  default: return false;
373  }
374 }
375 
376 const char *ControlPDUDescriptor::getFieldStructName(int field) const
377 {
378  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
379  if (basedesc) {
380  if (field < basedesc->getFieldCount())
381  return basedesc->getFieldStructName(field);
382  field -= basedesc->getFieldCount();
383  }
384  return nullptr;
385 }
386 
387 void *ControlPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
388 {
389  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
390  if (basedesc) {
391  if (field < basedesc->getFieldCount())
392  return basedesc->getFieldStructValuePointer(object, field, i);
393  field -= basedesc->getFieldCount();
394  }
395  ControlPDU *pp = (ControlPDU *)object; (void)pp;
396  switch (field) {
397  default: return nullptr;
398  }
399 }
400 
402 
403 NAckPDU::NAckPDU(const char *name, int kind) : ::ControlPDU(name,kind)
404 {
405  this->ackNackSeqNum = 0;
406 }
407 
408 NAckPDU::NAckPDU(const NAckPDU& other) : ::ControlPDU(other)
409 {
410  copy(other);
411 }
412 
414 {
415 }
416 
418 {
419  if (this==&other) return *this;
420  ::ControlPDU::operator=(other);
421  copy(other);
422  return *this;
423 }
424 
425 void NAckPDU::copy(const NAckPDU& other)
426 {
427  this->ackNackSeqNum = other.ackNackSeqNum;
428 }
429 
430 void NAckPDU::parsimPack(omnetpp::cCommBuffer *b) const
431 {
434 }
435 
436 void NAckPDU::parsimUnpack(omnetpp::cCommBuffer *b)
437 {
440 }
441 
442 unsigned int NAckPDU::getAckNackSeqNum() const
443 {
444  return this->ackNackSeqNum;
445 }
446 
447 void NAckPDU::setAckNackSeqNum(unsigned int ackNackSeqNum)
448 {
449  this->ackNackSeqNum = ackNackSeqNum;
450 }
451 
452 class NAckPDUDescriptor : public omnetpp::cClassDescriptor
453 {
454  private:
455  mutable const char **propertynames;
456  public:
458  virtual ~NAckPDUDescriptor();
459 
460  virtual bool doesSupport(omnetpp::cObject *obj) const override;
461  virtual const char **getPropertyNames() const override;
462  virtual const char *getProperty(const char *propertyname) const override;
463  virtual int getFieldCount() const override;
464  virtual const char *getFieldName(int field) const override;
465  virtual int findField(const char *fieldName) const override;
466  virtual unsigned int getFieldTypeFlags(int field) const override;
467  virtual const char *getFieldTypeString(int field) const override;
468  virtual const char **getFieldPropertyNames(int field) const override;
469  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
470  virtual int getFieldArraySize(void *object, int field) const override;
471 
472  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
473  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
474 
475  virtual const char *getFieldStructName(int field) const override;
476  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
477 };
478 
480 
481 NAckPDUDescriptor::NAckPDUDescriptor() : omnetpp::cClassDescriptor("NAckPDU", "ControlPDU")
482 {
483  propertynames = nullptr;
484 }
485 
487 {
488  delete[] propertynames;
489 }
490 
491 bool NAckPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
492 {
493  return dynamic_cast<NAckPDU *>(obj)!=nullptr;
494 }
495 
497 {
498  if (!propertynames) {
499  static const char *names[] = { nullptr };
500  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
501  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
502  propertynames = mergeLists(basenames, names);
503  }
504  return propertynames;
505 }
506 
507 const char *NAckPDUDescriptor::getProperty(const char *propertyname) const
508 {
509  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
510  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
511 }
512 
514 {
515  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
516  return basedesc ? 1+basedesc->getFieldCount() : 1;
517 }
518 
519 unsigned int NAckPDUDescriptor::getFieldTypeFlags(int field) const
520 {
521  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
522  if (basedesc) {
523  if (field < basedesc->getFieldCount())
524  return basedesc->getFieldTypeFlags(field);
525  field -= basedesc->getFieldCount();
526  }
527  static unsigned int fieldTypeFlags[] = {
528  FD_ISEDITABLE,
529  };
530  return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
531 }
532 
533 const char *NAckPDUDescriptor::getFieldName(int field) const
534 {
535  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
536  if (basedesc) {
537  if (field < basedesc->getFieldCount())
538  return basedesc->getFieldName(field);
539  field -= basedesc->getFieldCount();
540  }
541  static const char *fieldNames[] = {
542  "ackNackSeqNum",
543  };
544  return (field>=0 && field<1) ? fieldNames[field] : nullptr;
545 }
546 
547 int NAckPDUDescriptor::findField(const char *fieldName) const
548 {
549  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
550  int base = basedesc ? basedesc->getFieldCount() : 0;
551  if (fieldName[0]=='a' && strcmp(fieldName, "ackNackSeqNum")==0) return base+0;
552  return basedesc ? basedesc->findField(fieldName) : -1;
553 }
554 
555 const char *NAckPDUDescriptor::getFieldTypeString(int field) const
556 {
557  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
558  if (basedesc) {
559  if (field < basedesc->getFieldCount())
560  return basedesc->getFieldTypeString(field);
561  field -= basedesc->getFieldCount();
562  }
563  static const char *fieldTypeStrings[] = {
564  "unsigned int",
565  };
566  return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
567 }
568 
569 const char **NAckPDUDescriptor::getFieldPropertyNames(int field) const
570 {
571  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
572  if (basedesc) {
573  if (field < basedesc->getFieldCount())
574  return basedesc->getFieldPropertyNames(field);
575  field -= basedesc->getFieldCount();
576  }
577  switch (field) {
578  default: return nullptr;
579  }
580 }
581 
582 const char *NAckPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
583 {
584  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
585  if (basedesc) {
586  if (field < basedesc->getFieldCount())
587  return basedesc->getFieldProperty(field, propertyname);
588  field -= basedesc->getFieldCount();
589  }
590  switch (field) {
591  default: return nullptr;
592  }
593 }
594 
595 int NAckPDUDescriptor::getFieldArraySize(void *object, int field) const
596 {
597  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
598  if (basedesc) {
599  if (field < basedesc->getFieldCount())
600  return basedesc->getFieldArraySize(object, field);
601  field -= basedesc->getFieldCount();
602  }
603  NAckPDU *pp = (NAckPDU *)object; (void)pp;
604  switch (field) {
605  default: return 0;
606  }
607 }
608 
609 std::string NAckPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
610 {
611  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
612  if (basedesc) {
613  if (field < basedesc->getFieldCount())
614  return basedesc->getFieldValueAsString(object,field,i);
615  field -= basedesc->getFieldCount();
616  }
617  NAckPDU *pp = (NAckPDU *)object; (void)pp;
618  switch (field) {
619  case 0: return ulong2string(pp->getAckNackSeqNum());
620  default: return "";
621  }
622 }
623 
624 bool NAckPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
625 {
626  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
627  if (basedesc) {
628  if (field < basedesc->getFieldCount())
629  return basedesc->setFieldValueAsString(object,field,i,value);
630  field -= basedesc->getFieldCount();
631  }
632  NAckPDU *pp = (NAckPDU *)object; (void)pp;
633  switch (field) {
634  case 0: pp->setAckNackSeqNum(string2ulong(value)); return true;
635  default: return false;
636  }
637 }
638 
639 const char *NAckPDUDescriptor::getFieldStructName(int field) const
640 {
641  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
642  if (basedesc) {
643  if (field < basedesc->getFieldCount())
644  return basedesc->getFieldStructName(field);
645  field -= basedesc->getFieldCount();
646  }
647  switch (field) {
648  default: return nullptr;
649  };
650 }
651 
652 void *NAckPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
653 {
654  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
655  if (basedesc) {
656  if (field < basedesc->getFieldCount())
657  return basedesc->getFieldStructValuePointer(object, field, i);
658  field -= basedesc->getFieldCount();
659  }
660  NAckPDU *pp = (NAckPDU *)object; (void)pp;
661  switch (field) {
662  default: return nullptr;
663  }
664 }
665 
667 
668 FlowControlPDU::FlowControlPDU(const char *name, int kind) : ::NAckPDU(name,kind)
669 {
670  this->rcvRightWinEdge = 0;
671  this->rcvRate = 0;
672  this->timeUnit = 0;
673  this->sndLeftWinEdge = 0;
674  this->sndRightWinEdge = 0;
675  this->sndRate = 0;
676 }
677 
679 {
680  copy(other);
681 }
682 
684 {
685 }
686 
688 {
689  if (this==&other) return *this;
690  ::NAckPDU::operator=(other);
691  copy(other);
692  return *this;
693 }
694 
696 {
697  this->rcvRightWinEdge = other.rcvRightWinEdge;
698  this->rcvRate = other.rcvRate;
699  this->timeUnit = other.timeUnit;
700  this->sndLeftWinEdge = other.sndLeftWinEdge;
701  this->sndRightWinEdge = other.sndRightWinEdge;
702  this->sndRate = other.sndRate;
703 }
704 
705 void FlowControlPDU::parsimPack(omnetpp::cCommBuffer *b) const
706 {
709  doParsimPacking(b,this->rcvRate);
710  doParsimPacking(b,this->timeUnit);
713  doParsimPacking(b,this->sndRate);
714 }
715 
716 void FlowControlPDU::parsimUnpack(omnetpp::cCommBuffer *b)
717 {
720  doParsimUnpacking(b,this->rcvRate);
721  doParsimUnpacking(b,this->timeUnit);
724  doParsimUnpacking(b,this->sndRate);
725 }
726 
728 {
729  return this->rcvRightWinEdge;
730 }
731 
732 void FlowControlPDU::setRcvRightWinEdge(unsigned int rcvRightWinEdge)
733 {
734  this->rcvRightWinEdge = rcvRightWinEdge;
735 }
736 
737 unsigned int FlowControlPDU::getRcvRate() const
738 {
739  return this->rcvRate;
740 }
741 
742 void FlowControlPDU::setRcvRate(unsigned int rcvRate)
743 {
744  this->rcvRate = rcvRate;
745 }
746 
747 unsigned long FlowControlPDU::getTimeUnit() const
748 {
749  return this->timeUnit;
750 }
751 
752 void FlowControlPDU::setTimeUnit(unsigned long timeUnit)
753 {
754  this->timeUnit = timeUnit;
755 }
756 
758 {
759  return this->sndLeftWinEdge;
760 }
761 
762 void FlowControlPDU::setSndLeftWinEdge(unsigned int sndLeftWinEdge)
763 {
764  this->sndLeftWinEdge = sndLeftWinEdge;
765 }
766 
768 {
769  return this->sndRightWinEdge;
770 }
771 
772 void FlowControlPDU::setSndRightWinEdge(unsigned int sndRightWinEdge)
773 {
774  this->sndRightWinEdge = sndRightWinEdge;
775 }
776 
777 unsigned int FlowControlPDU::getSndRate() const
778 {
779  return this->sndRate;
780 }
781 
782 void FlowControlPDU::setSndRate(unsigned int sndRate)
783 {
784  this->sndRate = sndRate;
785 }
786 
787 class FlowControlPDUDescriptor : public omnetpp::cClassDescriptor
788 {
789  private:
790  mutable const char **propertynames;
791  public:
793  virtual ~FlowControlPDUDescriptor();
794 
795  virtual bool doesSupport(omnetpp::cObject *obj) const override;
796  virtual const char **getPropertyNames() const override;
797  virtual const char *getProperty(const char *propertyname) const override;
798  virtual int getFieldCount() const override;
799  virtual const char *getFieldName(int field) const override;
800  virtual int findField(const char *fieldName) const override;
801  virtual unsigned int getFieldTypeFlags(int field) const override;
802  virtual const char *getFieldTypeString(int field) const override;
803  virtual const char **getFieldPropertyNames(int field) const override;
804  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
805  virtual int getFieldArraySize(void *object, int field) const override;
806 
807  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
808  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
809 
810  virtual const char *getFieldStructName(int field) const override;
811  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
812 };
813 
815 
816 FlowControlPDUDescriptor::FlowControlPDUDescriptor() : omnetpp::cClassDescriptor("FlowControlPDU", "NAckPDU")
817 {
818  propertynames = nullptr;
819 }
820 
822 {
823  delete[] propertynames;
824 }
825 
826 bool FlowControlPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
827 {
828  return dynamic_cast<FlowControlPDU *>(obj)!=nullptr;
829 }
830 
832 {
833  if (!propertynames) {
834  static const char *names[] = { nullptr };
835  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
836  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
837  propertynames = mergeLists(basenames, names);
838  }
839  return propertynames;
840 }
841 
842 const char *FlowControlPDUDescriptor::getProperty(const char *propertyname) const
843 {
844  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
845  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
846 }
847 
849 {
850  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
851  return basedesc ? 6+basedesc->getFieldCount() : 6;
852 }
853 
854 unsigned int FlowControlPDUDescriptor::getFieldTypeFlags(int field) const
855 {
856  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
857  if (basedesc) {
858  if (field < basedesc->getFieldCount())
859  return basedesc->getFieldTypeFlags(field);
860  field -= basedesc->getFieldCount();
861  }
862  static unsigned int fieldTypeFlags[] = {
863  FD_ISEDITABLE,
864  FD_ISEDITABLE,
865  FD_ISEDITABLE,
866  FD_ISEDITABLE,
867  FD_ISEDITABLE,
868  FD_ISEDITABLE,
869  };
870  return (field>=0 && field<6) ? fieldTypeFlags[field] : 0;
871 }
872 
873 const char *FlowControlPDUDescriptor::getFieldName(int field) const
874 {
875  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
876  if (basedesc) {
877  if (field < basedesc->getFieldCount())
878  return basedesc->getFieldName(field);
879  field -= basedesc->getFieldCount();
880  }
881  static const char *fieldNames[] = {
882  "rcvRightWinEdge",
883  "rcvRate",
884  "timeUnit",
885  "sndLeftWinEdge",
886  "sndRightWinEdge",
887  "sndRate",
888  };
889  return (field>=0 && field<6) ? fieldNames[field] : nullptr;
890 }
891 
892 int FlowControlPDUDescriptor::findField(const char *fieldName) const
893 {
894  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
895  int base = basedesc ? basedesc->getFieldCount() : 0;
896  if (fieldName[0]=='r' && strcmp(fieldName, "rcvRightWinEdge")==0) return base+0;
897  if (fieldName[0]=='r' && strcmp(fieldName, "rcvRate")==0) return base+1;
898  if (fieldName[0]=='t' && strcmp(fieldName, "timeUnit")==0) return base+2;
899  if (fieldName[0]=='s' && strcmp(fieldName, "sndLeftWinEdge")==0) return base+3;
900  if (fieldName[0]=='s' && strcmp(fieldName, "sndRightWinEdge")==0) return base+4;
901  if (fieldName[0]=='s' && strcmp(fieldName, "sndRate")==0) return base+5;
902  return basedesc ? basedesc->findField(fieldName) : -1;
903 }
904 
906 {
907  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
908  if (basedesc) {
909  if (field < basedesc->getFieldCount())
910  return basedesc->getFieldTypeString(field);
911  field -= basedesc->getFieldCount();
912  }
913  static const char *fieldTypeStrings[] = {
914  "unsigned int",
915  "unsigned int",
916  "unsigned long",
917  "unsigned int",
918  "unsigned int",
919  "unsigned int",
920  };
921  return (field>=0 && field<6) ? fieldTypeStrings[field] : nullptr;
922 }
923 
925 {
926  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
927  if (basedesc) {
928  if (field < basedesc->getFieldCount())
929  return basedesc->getFieldPropertyNames(field);
930  field -= basedesc->getFieldCount();
931  }
932  switch (field) {
933  default: return nullptr;
934  }
935 }
936 
937 const char *FlowControlPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
938 {
939  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
940  if (basedesc) {
941  if (field < basedesc->getFieldCount())
942  return basedesc->getFieldProperty(field, propertyname);
943  field -= basedesc->getFieldCount();
944  }
945  switch (field) {
946  default: return nullptr;
947  }
948 }
949 
950 int FlowControlPDUDescriptor::getFieldArraySize(void *object, int field) const
951 {
952  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
953  if (basedesc) {
954  if (field < basedesc->getFieldCount())
955  return basedesc->getFieldArraySize(object, field);
956  field -= basedesc->getFieldCount();
957  }
958  FlowControlPDU *pp = (FlowControlPDU *)object; (void)pp;
959  switch (field) {
960  default: return 0;
961  }
962 }
963 
964 std::string FlowControlPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
965 {
966  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
967  if (basedesc) {
968  if (field < basedesc->getFieldCount())
969  return basedesc->getFieldValueAsString(object,field,i);
970  field -= basedesc->getFieldCount();
971  }
972  FlowControlPDU *pp = (FlowControlPDU *)object; (void)pp;
973  switch (field) {
974  case 0: return ulong2string(pp->getRcvRightWinEdge());
975  case 1: return ulong2string(pp->getRcvRate());
976  case 2: return ulong2string(pp->getTimeUnit());
977  case 3: return ulong2string(pp->getSndLeftWinEdge());
978  case 4: return ulong2string(pp->getSndRightWinEdge());
979  case 5: return ulong2string(pp->getSndRate());
980  default: return "";
981  }
982 }
983 
984 bool FlowControlPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
985 {
986  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
987  if (basedesc) {
988  if (field < basedesc->getFieldCount())
989  return basedesc->setFieldValueAsString(object,field,i,value);
990  field -= basedesc->getFieldCount();
991  }
992  FlowControlPDU *pp = (FlowControlPDU *)object; (void)pp;
993  switch (field) {
994  case 0: pp->setRcvRightWinEdge(string2ulong(value)); return true;
995  case 1: pp->setRcvRate(string2ulong(value)); return true;
996  case 2: pp->setTimeUnit(string2ulong(value)); return true;
997  case 3: pp->setSndLeftWinEdge(string2ulong(value)); return true;
998  case 4: pp->setSndRightWinEdge(string2ulong(value)); return true;
999  case 5: pp->setSndRate(string2ulong(value)); return true;
1000  default: return false;
1001  }
1002 }
1003 
1005 {
1006  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1007  if (basedesc) {
1008  if (field < basedesc->getFieldCount())
1009  return basedesc->getFieldStructName(field);
1010  field -= basedesc->getFieldCount();
1011  }
1012  switch (field) {
1013  default: return nullptr;
1014  };
1015 }
1016 
1017 void *FlowControlPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
1018 {
1019  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1020  if (basedesc) {
1021  if (field < basedesc->getFieldCount())
1022  return basedesc->getFieldStructValuePointer(object, field, i);
1023  field -= basedesc->getFieldCount();
1024  }
1025  FlowControlPDU *pp = (FlowControlPDU *)object; (void)pp;
1026  switch (field) {
1027  default: return nullptr;
1028  }
1029 }
1030 
1032 
1033 AckOnlyPDU::AckOnlyPDU(const char *name, int kind) : ::NAckPDU(name,kind)
1034 {
1035  this->setType(ACK_ONLY_PDU);
1036 }
1037 
1039 {
1040  copy(other);
1041 }
1042 
1044 {
1045 }
1046 
1048 {
1049  if (this==&other) return *this;
1050  ::NAckPDU::operator=(other);
1051  copy(other);
1052  return *this;
1053 }
1054 
1055 void AckOnlyPDU::copy(const AckOnlyPDU& other)
1056 {
1057 }
1058 
1059 void AckOnlyPDU::parsimPack(omnetpp::cCommBuffer *b) const
1060 {
1062 }
1063 
1064 void AckOnlyPDU::parsimUnpack(omnetpp::cCommBuffer *b)
1065 {
1067 }
1068 
1069 class AckOnlyPDUDescriptor : public omnetpp::cClassDescriptor
1070 {
1071  private:
1072  mutable const char **propertynames;
1073  public:
1075  virtual ~AckOnlyPDUDescriptor();
1076 
1077  virtual bool doesSupport(omnetpp::cObject *obj) const override;
1078  virtual const char **getPropertyNames() const override;
1079  virtual const char *getProperty(const char *propertyname) const override;
1080  virtual int getFieldCount() const override;
1081  virtual const char *getFieldName(int field) const override;
1082  virtual int findField(const char *fieldName) const override;
1083  virtual unsigned int getFieldTypeFlags(int field) const override;
1084  virtual const char *getFieldTypeString(int field) const override;
1085  virtual const char **getFieldPropertyNames(int field) const override;
1086  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
1087  virtual int getFieldArraySize(void *object, int field) const override;
1088 
1089  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
1090  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
1091 
1092  virtual const char *getFieldStructName(int field) const override;
1093  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
1094 };
1095 
1097 
1098 AckOnlyPDUDescriptor::AckOnlyPDUDescriptor() : omnetpp::cClassDescriptor("AckOnlyPDU", "NAckPDU")
1099 {
1100  propertynames = nullptr;
1101 }
1102 
1104 {
1105  delete[] propertynames;
1106 }
1107 
1108 bool AckOnlyPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
1109 {
1110  return dynamic_cast<AckOnlyPDU *>(obj)!=nullptr;
1111 }
1112 
1114 {
1115  if (!propertynames) {
1116  static const char *names[] = { nullptr };
1117  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1118  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
1119  propertynames = mergeLists(basenames, names);
1120  }
1121  return propertynames;
1122 }
1123 
1124 const char *AckOnlyPDUDescriptor::getProperty(const char *propertyname) const
1125 {
1126  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1127  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
1128 }
1129 
1131 {
1132  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1133  return basedesc ? 0+basedesc->getFieldCount() : 0;
1134 }
1135 
1136 unsigned int AckOnlyPDUDescriptor::getFieldTypeFlags(int field) const
1137 {
1138  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1139  if (basedesc) {
1140  if (field < basedesc->getFieldCount())
1141  return basedesc->getFieldTypeFlags(field);
1142  field -= basedesc->getFieldCount();
1143  }
1144  return 0;
1145 }
1146 
1147 const char *AckOnlyPDUDescriptor::getFieldName(int field) const
1148 {
1149  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1150  if (basedesc) {
1151  if (field < basedesc->getFieldCount())
1152  return basedesc->getFieldName(field);
1153  field -= basedesc->getFieldCount();
1154  }
1155  return nullptr;
1156 }
1157 
1158 int AckOnlyPDUDescriptor::findField(const char *fieldName) const
1159 {
1160  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1161  return basedesc ? basedesc->findField(fieldName) : -1;
1162 }
1163 
1164 const char *AckOnlyPDUDescriptor::getFieldTypeString(int field) const
1165 {
1166  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1167  if (basedesc) {
1168  if (field < basedesc->getFieldCount())
1169  return basedesc->getFieldTypeString(field);
1170  field -= basedesc->getFieldCount();
1171  }
1172  return nullptr;
1173 }
1174 
1175 const char **AckOnlyPDUDescriptor::getFieldPropertyNames(int field) const
1176 {
1177  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1178  if (basedesc) {
1179  if (field < basedesc->getFieldCount())
1180  return basedesc->getFieldPropertyNames(field);
1181  field -= basedesc->getFieldCount();
1182  }
1183  switch (field) {
1184  default: return nullptr;
1185  }
1186 }
1187 
1188 const char *AckOnlyPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
1189 {
1190  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1191  if (basedesc) {
1192  if (field < basedesc->getFieldCount())
1193  return basedesc->getFieldProperty(field, propertyname);
1194  field -= basedesc->getFieldCount();
1195  }
1196  switch (field) {
1197  default: return nullptr;
1198  }
1199 }
1200 
1201 int AckOnlyPDUDescriptor::getFieldArraySize(void *object, int field) const
1202 {
1203  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1204  if (basedesc) {
1205  if (field < basedesc->getFieldCount())
1206  return basedesc->getFieldArraySize(object, field);
1207  field -= basedesc->getFieldCount();
1208  }
1209  AckOnlyPDU *pp = (AckOnlyPDU *)object; (void)pp;
1210  switch (field) {
1211  default: return 0;
1212  }
1213 }
1214 
1215 std::string AckOnlyPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
1216 {
1217  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1218  if (basedesc) {
1219  if (field < basedesc->getFieldCount())
1220  return basedesc->getFieldValueAsString(object,field,i);
1221  field -= basedesc->getFieldCount();
1222  }
1223  AckOnlyPDU *pp = (AckOnlyPDU *)object; (void)pp;
1224  switch (field) {
1225  default: return "";
1226  }
1227 }
1228 
1229 bool AckOnlyPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
1230 {
1231  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1232  if (basedesc) {
1233  if (field < basedesc->getFieldCount())
1234  return basedesc->setFieldValueAsString(object,field,i,value);
1235  field -= basedesc->getFieldCount();
1236  }
1237  AckOnlyPDU *pp = (AckOnlyPDU *)object; (void)pp;
1238  switch (field) {
1239  default: return false;
1240  }
1241 }
1242 
1243 const char *AckOnlyPDUDescriptor::getFieldStructName(int field) const
1244 {
1245  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1246  if (basedesc) {
1247  if (field < basedesc->getFieldCount())
1248  return basedesc->getFieldStructName(field);
1249  field -= basedesc->getFieldCount();
1250  }
1251  return nullptr;
1252 }
1253 
1254 void *AckOnlyPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
1255 {
1256  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1257  if (basedesc) {
1258  if (field < basedesc->getFieldCount())
1259  return basedesc->getFieldStructValuePointer(object, field, i);
1260  field -= basedesc->getFieldCount();
1261  }
1262  AckOnlyPDU *pp = (AckOnlyPDU *)object; (void)pp;
1263  switch (field) {
1264  default: return nullptr;
1265  }
1266 }
1267 
1269 
1270 NackOnlyPDU::NackOnlyPDU(const char *name, int kind) : ::NAckPDU(name,kind)
1271 {
1272  this->setType(NACK_ONLY_PDU);
1273 }
1274 
1276 {
1277  copy(other);
1278 }
1279 
1281 {
1282 }
1283 
1285 {
1286  if (this==&other) return *this;
1287  ::NAckPDU::operator=(other);
1288  copy(other);
1289  return *this;
1290 }
1291 
1292 void NackOnlyPDU::copy(const NackOnlyPDU& other)
1293 {
1294 }
1295 
1296 void NackOnlyPDU::parsimPack(omnetpp::cCommBuffer *b) const
1297 {
1299 }
1300 
1301 void NackOnlyPDU::parsimUnpack(omnetpp::cCommBuffer *b)
1302 {
1304 }
1305 
1306 class NackOnlyPDUDescriptor : public omnetpp::cClassDescriptor
1307 {
1308  private:
1309  mutable const char **propertynames;
1310  public:
1312  virtual ~NackOnlyPDUDescriptor();
1313 
1314  virtual bool doesSupport(omnetpp::cObject *obj) const override;
1315  virtual const char **getPropertyNames() const override;
1316  virtual const char *getProperty(const char *propertyname) const override;
1317  virtual int getFieldCount() const override;
1318  virtual const char *getFieldName(int field) const override;
1319  virtual int findField(const char *fieldName) const override;
1320  virtual unsigned int getFieldTypeFlags(int field) const override;
1321  virtual const char *getFieldTypeString(int field) const override;
1322  virtual const char **getFieldPropertyNames(int field) const override;
1323  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
1324  virtual int getFieldArraySize(void *object, int field) const override;
1325 
1326  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
1327  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
1328 
1329  virtual const char *getFieldStructName(int field) const override;
1330  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
1331 };
1332 
1334 
1335 NackOnlyPDUDescriptor::NackOnlyPDUDescriptor() : omnetpp::cClassDescriptor("NackOnlyPDU", "NAckPDU")
1336 {
1337  propertynames = nullptr;
1338 }
1339 
1341 {
1342  delete[] propertynames;
1343 }
1344 
1345 bool NackOnlyPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
1346 {
1347  return dynamic_cast<NackOnlyPDU *>(obj)!=nullptr;
1348 }
1349 
1351 {
1352  if (!propertynames) {
1353  static const char *names[] = { nullptr };
1354  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1355  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
1356  propertynames = mergeLists(basenames, names);
1357  }
1358  return propertynames;
1359 }
1360 
1361 const char *NackOnlyPDUDescriptor::getProperty(const char *propertyname) const
1362 {
1363  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1364  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
1365 }
1366 
1368 {
1369  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1370  return basedesc ? 0+basedesc->getFieldCount() : 0;
1371 }
1372 
1373 unsigned int NackOnlyPDUDescriptor::getFieldTypeFlags(int field) const
1374 {
1375  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1376  if (basedesc) {
1377  if (field < basedesc->getFieldCount())
1378  return basedesc->getFieldTypeFlags(field);
1379  field -= basedesc->getFieldCount();
1380  }
1381  return 0;
1382 }
1383 
1384 const char *NackOnlyPDUDescriptor::getFieldName(int field) const
1385 {
1386  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1387  if (basedesc) {
1388  if (field < basedesc->getFieldCount())
1389  return basedesc->getFieldName(field);
1390  field -= basedesc->getFieldCount();
1391  }
1392  return nullptr;
1393 }
1394 
1395 int NackOnlyPDUDescriptor::findField(const char *fieldName) const
1396 {
1397  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1398  return basedesc ? basedesc->findField(fieldName) : -1;
1399 }
1400 
1401 const char *NackOnlyPDUDescriptor::getFieldTypeString(int field) const
1402 {
1403  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1404  if (basedesc) {
1405  if (field < basedesc->getFieldCount())
1406  return basedesc->getFieldTypeString(field);
1407  field -= basedesc->getFieldCount();
1408  }
1409  return nullptr;
1410 }
1411 
1413 {
1414  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1415  if (basedesc) {
1416  if (field < basedesc->getFieldCount())
1417  return basedesc->getFieldPropertyNames(field);
1418  field -= basedesc->getFieldCount();
1419  }
1420  switch (field) {
1421  default: return nullptr;
1422  }
1423 }
1424 
1425 const char *NackOnlyPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
1426 {
1427  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1428  if (basedesc) {
1429  if (field < basedesc->getFieldCount())
1430  return basedesc->getFieldProperty(field, propertyname);
1431  field -= basedesc->getFieldCount();
1432  }
1433  switch (field) {
1434  default: return nullptr;
1435  }
1436 }
1437 
1438 int NackOnlyPDUDescriptor::getFieldArraySize(void *object, int field) const
1439 {
1440  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1441  if (basedesc) {
1442  if (field < basedesc->getFieldCount())
1443  return basedesc->getFieldArraySize(object, field);
1444  field -= basedesc->getFieldCount();
1445  }
1446  NackOnlyPDU *pp = (NackOnlyPDU *)object; (void)pp;
1447  switch (field) {
1448  default: return 0;
1449  }
1450 }
1451 
1452 std::string NackOnlyPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
1453 {
1454  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1455  if (basedesc) {
1456  if (field < basedesc->getFieldCount())
1457  return basedesc->getFieldValueAsString(object,field,i);
1458  field -= basedesc->getFieldCount();
1459  }
1460  NackOnlyPDU *pp = (NackOnlyPDU *)object; (void)pp;
1461  switch (field) {
1462  default: return "";
1463  }
1464 }
1465 
1466 bool NackOnlyPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
1467 {
1468  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1469  if (basedesc) {
1470  if (field < basedesc->getFieldCount())
1471  return basedesc->setFieldValueAsString(object,field,i,value);
1472  field -= basedesc->getFieldCount();
1473  }
1474  NackOnlyPDU *pp = (NackOnlyPDU *)object; (void)pp;
1475  switch (field) {
1476  default: return false;
1477  }
1478 }
1479 
1480 const char *NackOnlyPDUDescriptor::getFieldStructName(int field) const
1481 {
1482  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1483  if (basedesc) {
1484  if (field < basedesc->getFieldCount())
1485  return basedesc->getFieldStructName(field);
1486  field -= basedesc->getFieldCount();
1487  }
1488  return nullptr;
1489 }
1490 
1491 void *NackOnlyPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
1492 {
1493  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1494  if (basedesc) {
1495  if (field < basedesc->getFieldCount())
1496  return basedesc->getFieldStructValuePointer(object, field, i);
1497  field -= basedesc->getFieldCount();
1498  }
1499  NackOnlyPDU *pp = (NackOnlyPDU *)object; (void)pp;
1500  switch (field) {
1501  default: return nullptr;
1502  }
1503 }
1504 
1506 
1507 AckFlowPDU::AckFlowPDU(const char *name, int kind) : ::FlowControlPDU(name,kind)
1508 {
1509  this->setType(ACK_FLOW_PDU);
1510 }
1511 
1513 {
1514  copy(other);
1515 }
1516 
1518 {
1519 }
1520 
1522 {
1523  if (this==&other) return *this;
1524  ::FlowControlPDU::operator=(other);
1525  copy(other);
1526  return *this;
1527 }
1528 
1529 void AckFlowPDU::copy(const AckFlowPDU& other)
1530 {
1531 }
1532 
1533 void AckFlowPDU::parsimPack(omnetpp::cCommBuffer *b) const
1534 {
1536 }
1537 
1538 void AckFlowPDU::parsimUnpack(omnetpp::cCommBuffer *b)
1539 {
1541 }
1542 
1543 class AckFlowPDUDescriptor : public omnetpp::cClassDescriptor
1544 {
1545  private:
1546  mutable const char **propertynames;
1547  public:
1549  virtual ~AckFlowPDUDescriptor();
1550 
1551  virtual bool doesSupport(omnetpp::cObject *obj) const override;
1552  virtual const char **getPropertyNames() const override;
1553  virtual const char *getProperty(const char *propertyname) const override;
1554  virtual int getFieldCount() const override;
1555  virtual const char *getFieldName(int field) const override;
1556  virtual int findField(const char *fieldName) const override;
1557  virtual unsigned int getFieldTypeFlags(int field) const override;
1558  virtual const char *getFieldTypeString(int field) const override;
1559  virtual const char **getFieldPropertyNames(int field) const override;
1560  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
1561  virtual int getFieldArraySize(void *object, int field) const override;
1562 
1563  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
1564  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
1565 
1566  virtual const char *getFieldStructName(int field) const override;
1567  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
1568 };
1569 
1571 
1572 AckFlowPDUDescriptor::AckFlowPDUDescriptor() : omnetpp::cClassDescriptor("AckFlowPDU", "FlowControlPDU")
1573 {
1574  propertynames = nullptr;
1575 }
1576 
1578 {
1579  delete[] propertynames;
1580 }
1581 
1582 bool AckFlowPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
1583 {
1584  return dynamic_cast<AckFlowPDU *>(obj)!=nullptr;
1585 }
1586 
1588 {
1589  if (!propertynames) {
1590  static const char *names[] = { nullptr };
1591  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1592  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
1593  propertynames = mergeLists(basenames, names);
1594  }
1595  return propertynames;
1596 }
1597 
1598 const char *AckFlowPDUDescriptor::getProperty(const char *propertyname) const
1599 {
1600  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1601  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
1602 }
1603 
1605 {
1606  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1607  return basedesc ? 0+basedesc->getFieldCount() : 0;
1608 }
1609 
1610 unsigned int AckFlowPDUDescriptor::getFieldTypeFlags(int field) const
1611 {
1612  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1613  if (basedesc) {
1614  if (field < basedesc->getFieldCount())
1615  return basedesc->getFieldTypeFlags(field);
1616  field -= basedesc->getFieldCount();
1617  }
1618  return 0;
1619 }
1620 
1621 const char *AckFlowPDUDescriptor::getFieldName(int field) const
1622 {
1623  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1624  if (basedesc) {
1625  if (field < basedesc->getFieldCount())
1626  return basedesc->getFieldName(field);
1627  field -= basedesc->getFieldCount();
1628  }
1629  return nullptr;
1630 }
1631 
1632 int AckFlowPDUDescriptor::findField(const char *fieldName) const
1633 {
1634  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1635  return basedesc ? basedesc->findField(fieldName) : -1;
1636 }
1637 
1638 const char *AckFlowPDUDescriptor::getFieldTypeString(int field) const
1639 {
1640  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1641  if (basedesc) {
1642  if (field < basedesc->getFieldCount())
1643  return basedesc->getFieldTypeString(field);
1644  field -= basedesc->getFieldCount();
1645  }
1646  return nullptr;
1647 }
1648 
1649 const char **AckFlowPDUDescriptor::getFieldPropertyNames(int field) const
1650 {
1651  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1652  if (basedesc) {
1653  if (field < basedesc->getFieldCount())
1654  return basedesc->getFieldPropertyNames(field);
1655  field -= basedesc->getFieldCount();
1656  }
1657  switch (field) {
1658  default: return nullptr;
1659  }
1660 }
1661 
1662 const char *AckFlowPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
1663 {
1664  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1665  if (basedesc) {
1666  if (field < basedesc->getFieldCount())
1667  return basedesc->getFieldProperty(field, propertyname);
1668  field -= basedesc->getFieldCount();
1669  }
1670  switch (field) {
1671  default: return nullptr;
1672  }
1673 }
1674 
1675 int AckFlowPDUDescriptor::getFieldArraySize(void *object, int field) const
1676 {
1677  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1678  if (basedesc) {
1679  if (field < basedesc->getFieldCount())
1680  return basedesc->getFieldArraySize(object, field);
1681  field -= basedesc->getFieldCount();
1682  }
1683  AckFlowPDU *pp = (AckFlowPDU *)object; (void)pp;
1684  switch (field) {
1685  default: return 0;
1686  }
1687 }
1688 
1689 std::string AckFlowPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
1690 {
1691  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1692  if (basedesc) {
1693  if (field < basedesc->getFieldCount())
1694  return basedesc->getFieldValueAsString(object,field,i);
1695  field -= basedesc->getFieldCount();
1696  }
1697  AckFlowPDU *pp = (AckFlowPDU *)object; (void)pp;
1698  switch (field) {
1699  default: return "";
1700  }
1701 }
1702 
1703 bool AckFlowPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
1704 {
1705  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1706  if (basedesc) {
1707  if (field < basedesc->getFieldCount())
1708  return basedesc->setFieldValueAsString(object,field,i,value);
1709  field -= basedesc->getFieldCount();
1710  }
1711  AckFlowPDU *pp = (AckFlowPDU *)object; (void)pp;
1712  switch (field) {
1713  default: return false;
1714  }
1715 }
1716 
1717 const char *AckFlowPDUDescriptor::getFieldStructName(int field) const
1718 {
1719  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1720  if (basedesc) {
1721  if (field < basedesc->getFieldCount())
1722  return basedesc->getFieldStructName(field);
1723  field -= basedesc->getFieldCount();
1724  }
1725  return nullptr;
1726 }
1727 
1728 void *AckFlowPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
1729 {
1730  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1731  if (basedesc) {
1732  if (field < basedesc->getFieldCount())
1733  return basedesc->getFieldStructValuePointer(object, field, i);
1734  field -= basedesc->getFieldCount();
1735  }
1736  AckFlowPDU *pp = (AckFlowPDU *)object; (void)pp;
1737  switch (field) {
1738  default: return nullptr;
1739  }
1740 }
1741 
1743 
1744 NackFlowPDU::NackFlowPDU(const char *name, int kind) : ::FlowControlPDU(name,kind)
1745 {
1746  this->setType(NACK_FLOW_PDU);
1747 }
1748 
1750 {
1751  copy(other);
1752 }
1753 
1755 {
1756 }
1757 
1759 {
1760  if (this==&other) return *this;
1761  ::FlowControlPDU::operator=(other);
1762  copy(other);
1763  return *this;
1764 }
1765 
1766 void NackFlowPDU::copy(const NackFlowPDU& other)
1767 {
1768 }
1769 
1770 void NackFlowPDU::parsimPack(omnetpp::cCommBuffer *b) const
1771 {
1773 }
1774 
1775 void NackFlowPDU::parsimUnpack(omnetpp::cCommBuffer *b)
1776 {
1778 }
1779 
1780 class NackFlowPDUDescriptor : public omnetpp::cClassDescriptor
1781 {
1782  private:
1783  mutable const char **propertynames;
1784  public:
1786  virtual ~NackFlowPDUDescriptor();
1787 
1788  virtual bool doesSupport(omnetpp::cObject *obj) const override;
1789  virtual const char **getPropertyNames() const override;
1790  virtual const char *getProperty(const char *propertyname) const override;
1791  virtual int getFieldCount() const override;
1792  virtual const char *getFieldName(int field) const override;
1793  virtual int findField(const char *fieldName) const override;
1794  virtual unsigned int getFieldTypeFlags(int field) const override;
1795  virtual const char *getFieldTypeString(int field) const override;
1796  virtual const char **getFieldPropertyNames(int field) const override;
1797  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
1798  virtual int getFieldArraySize(void *object, int field) const override;
1799 
1800  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
1801  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
1802 
1803  virtual const char *getFieldStructName(int field) const override;
1804  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
1805 };
1806 
1808 
1809 NackFlowPDUDescriptor::NackFlowPDUDescriptor() : omnetpp::cClassDescriptor("NackFlowPDU", "FlowControlPDU")
1810 {
1811  propertynames = nullptr;
1812 }
1813 
1815 {
1816  delete[] propertynames;
1817 }
1818 
1819 bool NackFlowPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
1820 {
1821  return dynamic_cast<NackFlowPDU *>(obj)!=nullptr;
1822 }
1823 
1825 {
1826  if (!propertynames) {
1827  static const char *names[] = { nullptr };
1828  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1829  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
1830  propertynames = mergeLists(basenames, names);
1831  }
1832  return propertynames;
1833 }
1834 
1835 const char *NackFlowPDUDescriptor::getProperty(const char *propertyname) const
1836 {
1837  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1838  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
1839 }
1840 
1842 {
1843  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1844  return basedesc ? 0+basedesc->getFieldCount() : 0;
1845 }
1846 
1847 unsigned int NackFlowPDUDescriptor::getFieldTypeFlags(int field) const
1848 {
1849  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1850  if (basedesc) {
1851  if (field < basedesc->getFieldCount())
1852  return basedesc->getFieldTypeFlags(field);
1853  field -= basedesc->getFieldCount();
1854  }
1855  return 0;
1856 }
1857 
1858 const char *NackFlowPDUDescriptor::getFieldName(int field) const
1859 {
1860  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1861  if (basedesc) {
1862  if (field < basedesc->getFieldCount())
1863  return basedesc->getFieldName(field);
1864  field -= basedesc->getFieldCount();
1865  }
1866  return nullptr;
1867 }
1868 
1869 int NackFlowPDUDescriptor::findField(const char *fieldName) const
1870 {
1871  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1872  return basedesc ? basedesc->findField(fieldName) : -1;
1873 }
1874 
1875 const char *NackFlowPDUDescriptor::getFieldTypeString(int field) const
1876 {
1877  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1878  if (basedesc) {
1879  if (field < basedesc->getFieldCount())
1880  return basedesc->getFieldTypeString(field);
1881  field -= basedesc->getFieldCount();
1882  }
1883  return nullptr;
1884 }
1885 
1887 {
1888  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1889  if (basedesc) {
1890  if (field < basedesc->getFieldCount())
1891  return basedesc->getFieldPropertyNames(field);
1892  field -= basedesc->getFieldCount();
1893  }
1894  switch (field) {
1895  default: return nullptr;
1896  }
1897 }
1898 
1899 const char *NackFlowPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
1900 {
1901  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1902  if (basedesc) {
1903  if (field < basedesc->getFieldCount())
1904  return basedesc->getFieldProperty(field, propertyname);
1905  field -= basedesc->getFieldCount();
1906  }
1907  switch (field) {
1908  default: return nullptr;
1909  }
1910 }
1911 
1912 int NackFlowPDUDescriptor::getFieldArraySize(void *object, int field) const
1913 {
1914  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1915  if (basedesc) {
1916  if (field < basedesc->getFieldCount())
1917  return basedesc->getFieldArraySize(object, field);
1918  field -= basedesc->getFieldCount();
1919  }
1920  NackFlowPDU *pp = (NackFlowPDU *)object; (void)pp;
1921  switch (field) {
1922  default: return 0;
1923  }
1924 }
1925 
1926 std::string NackFlowPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
1927 {
1928  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1929  if (basedesc) {
1930  if (field < basedesc->getFieldCount())
1931  return basedesc->getFieldValueAsString(object,field,i);
1932  field -= basedesc->getFieldCount();
1933  }
1934  NackFlowPDU *pp = (NackFlowPDU *)object; (void)pp;
1935  switch (field) {
1936  default: return "";
1937  }
1938 }
1939 
1940 bool NackFlowPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
1941 {
1942  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1943  if (basedesc) {
1944  if (field < basedesc->getFieldCount())
1945  return basedesc->setFieldValueAsString(object,field,i,value);
1946  field -= basedesc->getFieldCount();
1947  }
1948  NackFlowPDU *pp = (NackFlowPDU *)object; (void)pp;
1949  switch (field) {
1950  default: return false;
1951  }
1952 }
1953 
1954 const char *NackFlowPDUDescriptor::getFieldStructName(int field) const
1955 {
1956  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1957  if (basedesc) {
1958  if (field < basedesc->getFieldCount())
1959  return basedesc->getFieldStructName(field);
1960  field -= basedesc->getFieldCount();
1961  }
1962  return nullptr;
1963 }
1964 
1965 void *NackFlowPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
1966 {
1967  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
1968  if (basedesc) {
1969  if (field < basedesc->getFieldCount())
1970  return basedesc->getFieldStructValuePointer(object, field, i);
1971  field -= basedesc->getFieldCount();
1972  }
1973  NackFlowPDU *pp = (NackFlowPDU *)object; (void)pp;
1974  switch (field) {
1975  default: return nullptr;
1976  }
1977 }
1978 
1980 
1981 FlowControlOnlyPDU::FlowControlOnlyPDU(const char *name, int kind) : ::FlowControlPDU(name,kind)
1982 {
1983  this->setType(FLOW_ONLY_PDU);
1984 }
1985 
1987 {
1988  copy(other);
1989 }
1990 
1992 {
1993 }
1994 
1996 {
1997  if (this==&other) return *this;
1998  ::FlowControlPDU::operator=(other);
1999  copy(other);
2000  return *this;
2001 }
2002 
2004 {
2005 }
2006 
2007 void FlowControlOnlyPDU::parsimPack(omnetpp::cCommBuffer *b) const
2008 {
2010 }
2011 
2012 void FlowControlOnlyPDU::parsimUnpack(omnetpp::cCommBuffer *b)
2013 {
2015 }
2016 
2017 class FlowControlOnlyPDUDescriptor : public omnetpp::cClassDescriptor
2018 {
2019  private:
2020  mutable const char **propertynames;
2021  public:
2024 
2025  virtual bool doesSupport(omnetpp::cObject *obj) const override;
2026  virtual const char **getPropertyNames() const override;
2027  virtual const char *getProperty(const char *propertyname) const override;
2028  virtual int getFieldCount() const override;
2029  virtual const char *getFieldName(int field) const override;
2030  virtual int findField(const char *fieldName) const override;
2031  virtual unsigned int getFieldTypeFlags(int field) const override;
2032  virtual const char *getFieldTypeString(int field) const override;
2033  virtual const char **getFieldPropertyNames(int field) const override;
2034  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
2035  virtual int getFieldArraySize(void *object, int field) const override;
2036 
2037  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
2038  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
2039 
2040  virtual const char *getFieldStructName(int field) const override;
2041  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
2042 };
2043 
2045 
2046 FlowControlOnlyPDUDescriptor::FlowControlOnlyPDUDescriptor() : omnetpp::cClassDescriptor("FlowControlOnlyPDU", "FlowControlPDU")
2047 {
2048  propertynames = nullptr;
2049 }
2050 
2052 {
2053  delete[] propertynames;
2054 }
2055 
2056 bool FlowControlOnlyPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
2057 {
2058  return dynamic_cast<FlowControlOnlyPDU *>(obj)!=nullptr;
2059 }
2060 
2062 {
2063  if (!propertynames) {
2064  static const char *names[] = { nullptr };
2065  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2066  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
2067  propertynames = mergeLists(basenames, names);
2068  }
2069  return propertynames;
2070 }
2071 
2072 const char *FlowControlOnlyPDUDescriptor::getProperty(const char *propertyname) const
2073 {
2074  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2075  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
2076 }
2077 
2079 {
2080  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2081  return basedesc ? 0+basedesc->getFieldCount() : 0;
2082 }
2083 
2085 {
2086  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2087  if (basedesc) {
2088  if (field < basedesc->getFieldCount())
2089  return basedesc->getFieldTypeFlags(field);
2090  field -= basedesc->getFieldCount();
2091  }
2092  return 0;
2093 }
2094 
2096 {
2097  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2098  if (basedesc) {
2099  if (field < basedesc->getFieldCount())
2100  return basedesc->getFieldName(field);
2101  field -= basedesc->getFieldCount();
2102  }
2103  return nullptr;
2104 }
2105 
2106 int FlowControlOnlyPDUDescriptor::findField(const char *fieldName) const
2107 {
2108  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2109  return basedesc ? basedesc->findField(fieldName) : -1;
2110 }
2111 
2113 {
2114  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2115  if (basedesc) {
2116  if (field < basedesc->getFieldCount())
2117  return basedesc->getFieldTypeString(field);
2118  field -= basedesc->getFieldCount();
2119  }
2120  return nullptr;
2121 }
2122 
2124 {
2125  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2126  if (basedesc) {
2127  if (field < basedesc->getFieldCount())
2128  return basedesc->getFieldPropertyNames(field);
2129  field -= basedesc->getFieldCount();
2130  }
2131  switch (field) {
2132  default: return nullptr;
2133  }
2134 }
2135 
2136 const char *FlowControlOnlyPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
2137 {
2138  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2139  if (basedesc) {
2140  if (field < basedesc->getFieldCount())
2141  return basedesc->getFieldProperty(field, propertyname);
2142  field -= basedesc->getFieldCount();
2143  }
2144  switch (field) {
2145  default: return nullptr;
2146  }
2147 }
2148 
2149 int FlowControlOnlyPDUDescriptor::getFieldArraySize(void *object, int field) const
2150 {
2151  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2152  if (basedesc) {
2153  if (field < basedesc->getFieldCount())
2154  return basedesc->getFieldArraySize(object, field);
2155  field -= basedesc->getFieldCount();
2156  }
2157  FlowControlOnlyPDU *pp = (FlowControlOnlyPDU *)object; (void)pp;
2158  switch (field) {
2159  default: return 0;
2160  }
2161 }
2162 
2163 std::string FlowControlOnlyPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
2164 {
2165  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2166  if (basedesc) {
2167  if (field < basedesc->getFieldCount())
2168  return basedesc->getFieldValueAsString(object,field,i);
2169  field -= basedesc->getFieldCount();
2170  }
2171  FlowControlOnlyPDU *pp = (FlowControlOnlyPDU *)object; (void)pp;
2172  switch (field) {
2173  default: return "";
2174  }
2175 }
2176 
2177 bool FlowControlOnlyPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
2178 {
2179  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2180  if (basedesc) {
2181  if (field < basedesc->getFieldCount())
2182  return basedesc->setFieldValueAsString(object,field,i,value);
2183  field -= basedesc->getFieldCount();
2184  }
2185  FlowControlOnlyPDU *pp = (FlowControlOnlyPDU *)object; (void)pp;
2186  switch (field) {
2187  default: return false;
2188  }
2189 }
2190 
2192 {
2193  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2194  if (basedesc) {
2195  if (field < basedesc->getFieldCount())
2196  return basedesc->getFieldStructName(field);
2197  field -= basedesc->getFieldCount();
2198  }
2199  return nullptr;
2200 }
2201 
2202 void *FlowControlOnlyPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
2203 {
2204  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2205  if (basedesc) {
2206  if (field < basedesc->getFieldCount())
2207  return basedesc->getFieldStructValuePointer(object, field, i);
2208  field -= basedesc->getFieldCount();
2209  }
2210  FlowControlOnlyPDU *pp = (FlowControlOnlyPDU *)object; (void)pp;
2211  switch (field) {
2212  default: return nullptr;
2213  }
2214 }
2215 
2217 
2218 SelectiveNAckFlow::SelectiveNAckFlow(const char *name, int kind) : ::FlowControlPDU(name,kind)
2219 {
2220  this->newLeftWinEdge = 0;
2221  this->nackListLen = 0;
2222  nackList_arraysize = 0;
2223  this->nackList = 0;
2224 }
2225 
2227 {
2228  nackList_arraysize = 0;
2229  this->nackList = 0;
2230  copy(other);
2231 }
2232 
2234 {
2235  delete [] this->nackList;
2236 }
2237 
2239 {
2240  if (this==&other) return *this;
2241  ::FlowControlPDU::operator=(other);
2242  copy(other);
2243  return *this;
2244 }
2245 
2247 {
2248  this->newLeftWinEdge = other.newLeftWinEdge;
2249  this->nackListLen = other.nackListLen;
2250  delete [] this->nackList;
2251  this->nackList = (other.nackList_arraysize==0) ? nullptr : new unsigned int[other.nackList_arraysize];
2253  for (unsigned int i=0; i<nackList_arraysize; i++)
2254  this->nackList[i] = other.nackList[i];
2255 }
2256 
2257 void SelectiveNAckFlow::parsimPack(omnetpp::cCommBuffer *b) const
2258 {
2261  doParsimPacking(b,this->nackListLen);
2262  b->pack(nackList_arraysize);
2264 }
2265 
2266 void SelectiveNAckFlow::parsimUnpack(omnetpp::cCommBuffer *b)
2267 {
2270  doParsimUnpacking(b,this->nackListLen);
2271  delete [] this->nackList;
2272  b->unpack(nackList_arraysize);
2273  if (nackList_arraysize==0) {
2274  this->nackList = 0;
2275  } else {
2276  this->nackList = new unsigned int[nackList_arraysize];
2278  }
2279 }
2280 
2282 {
2283  return this->newLeftWinEdge;
2284 }
2285 
2286 void SelectiveNAckFlow::setNewLeftWinEdge(unsigned int newLeftWinEdge)
2287 {
2288  this->newLeftWinEdge = newLeftWinEdge;
2289 }
2290 
2292 {
2293  return this->nackListLen;
2294 }
2295 
2296 void SelectiveNAckFlow::setNackListLen(unsigned int nackListLen)
2297 {
2298  this->nackListLen = nackListLen;
2299 }
2300 
2302 {
2303  unsigned int *nackList2 = (size==0) ? nullptr : new unsigned int[size];
2304  unsigned int sz = nackList_arraysize < size ? nackList_arraysize : size;
2305  for (unsigned int i=0; i<sz; i++)
2306  nackList2[i] = this->nackList[i];
2307  for (unsigned int i=sz; i<size; i++)
2308  nackList2[i] = 0;
2309  nackList_arraysize = size;
2310  delete [] this->nackList;
2311  this->nackList = nackList2;
2312 }
2313 
2315 {
2316  return nackList_arraysize;
2317 }
2318 
2319 unsigned int SelectiveNAckFlow::getNackList(unsigned int k) const
2320 {
2321  if (k>=nackList_arraysize) throw omnetpp::cRuntimeError("Array of size %d indexed by %d", nackList_arraysize, k);
2322  return this->nackList[k];
2323 }
2324 
2325 void SelectiveNAckFlow::setNackList(unsigned int k, unsigned int nackList)
2326 {
2327  if (k>=nackList_arraysize) throw omnetpp::cRuntimeError("Array of size %d indexed by %d", nackList_arraysize, k);
2328  this->nackList[k] = nackList;
2329 }
2330 
2331 class SelectiveNAckFlowDescriptor : public omnetpp::cClassDescriptor
2332 {
2333  private:
2334  mutable const char **propertynames;
2335  public:
2337  virtual ~SelectiveNAckFlowDescriptor();
2338 
2339  virtual bool doesSupport(omnetpp::cObject *obj) const override;
2340  virtual const char **getPropertyNames() const override;
2341  virtual const char *getProperty(const char *propertyname) const override;
2342  virtual int getFieldCount() const override;
2343  virtual const char *getFieldName(int field) const override;
2344  virtual int findField(const char *fieldName) const override;
2345  virtual unsigned int getFieldTypeFlags(int field) const override;
2346  virtual const char *getFieldTypeString(int field) const override;
2347  virtual const char **getFieldPropertyNames(int field) const override;
2348  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
2349  virtual int getFieldArraySize(void *object, int field) const override;
2350 
2351  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
2352  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
2353 
2354  virtual const char *getFieldStructName(int field) const override;
2355  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
2356 };
2357 
2359 
2360 SelectiveNAckFlowDescriptor::SelectiveNAckFlowDescriptor() : omnetpp::cClassDescriptor("SelectiveNAckFlow", "FlowControlPDU")
2361 {
2362  propertynames = nullptr;
2363 }
2364 
2366 {
2367  delete[] propertynames;
2368 }
2369 
2370 bool SelectiveNAckFlowDescriptor::doesSupport(omnetpp::cObject *obj) const
2371 {
2372  return dynamic_cast<SelectiveNAckFlow *>(obj)!=nullptr;
2373 }
2374 
2376 {
2377  if (!propertynames) {
2378  static const char *names[] = { nullptr };
2379  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2380  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
2381  propertynames = mergeLists(basenames, names);
2382  }
2383  return propertynames;
2384 }
2385 
2386 const char *SelectiveNAckFlowDescriptor::getProperty(const char *propertyname) const
2387 {
2388  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2389  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
2390 }
2391 
2393 {
2394  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2395  return basedesc ? 3+basedesc->getFieldCount() : 3;
2396 }
2397 
2399 {
2400  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2401  if (basedesc) {
2402  if (field < basedesc->getFieldCount())
2403  return basedesc->getFieldTypeFlags(field);
2404  field -= basedesc->getFieldCount();
2405  }
2406  static unsigned int fieldTypeFlags[] = {
2407  FD_ISEDITABLE,
2408  FD_ISEDITABLE,
2409  FD_ISARRAY | FD_ISEDITABLE,
2410  };
2411  return (field>=0 && field<3) ? fieldTypeFlags[field] : 0;
2412 }
2413 
2414 const char *SelectiveNAckFlowDescriptor::getFieldName(int field) const
2415 {
2416  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2417  if (basedesc) {
2418  if (field < basedesc->getFieldCount())
2419  return basedesc->getFieldName(field);
2420  field -= basedesc->getFieldCount();
2421  }
2422  static const char *fieldNames[] = {
2423  "newLeftWinEdge",
2424  "nackListLen",
2425  "nackList",
2426  };
2427  return (field>=0 && field<3) ? fieldNames[field] : nullptr;
2428 }
2429 
2430 int SelectiveNAckFlowDescriptor::findField(const char *fieldName) const
2431 {
2432  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2433  int base = basedesc ? basedesc->getFieldCount() : 0;
2434  if (fieldName[0]=='n' && strcmp(fieldName, "newLeftWinEdge")==0) return base+0;
2435  if (fieldName[0]=='n' && strcmp(fieldName, "nackListLen")==0) return base+1;
2436  if (fieldName[0]=='n' && strcmp(fieldName, "nackList")==0) return base+2;
2437  return basedesc ? basedesc->findField(fieldName) : -1;
2438 }
2439 
2441 {
2442  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2443  if (basedesc) {
2444  if (field < basedesc->getFieldCount())
2445  return basedesc->getFieldTypeString(field);
2446  field -= basedesc->getFieldCount();
2447  }
2448  static const char *fieldTypeStrings[] = {
2449  "unsigned int",
2450  "unsigned int",
2451  "unsigned int",
2452  };
2453  return (field>=0 && field<3) ? fieldTypeStrings[field] : nullptr;
2454 }
2455 
2457 {
2458  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2459  if (basedesc) {
2460  if (field < basedesc->getFieldCount())
2461  return basedesc->getFieldPropertyNames(field);
2462  field -= basedesc->getFieldCount();
2463  }
2464  switch (field) {
2465  default: return nullptr;
2466  }
2467 }
2468 
2469 const char *SelectiveNAckFlowDescriptor::getFieldProperty(int field, const char *propertyname) const
2470 {
2471  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2472  if (basedesc) {
2473  if (field < basedesc->getFieldCount())
2474  return basedesc->getFieldProperty(field, propertyname);
2475  field -= basedesc->getFieldCount();
2476  }
2477  switch (field) {
2478  default: return nullptr;
2479  }
2480 }
2481 
2482 int SelectiveNAckFlowDescriptor::getFieldArraySize(void *object, int field) const
2483 {
2484  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2485  if (basedesc) {
2486  if (field < basedesc->getFieldCount())
2487  return basedesc->getFieldArraySize(object, field);
2488  field -= basedesc->getFieldCount();
2489  }
2490  SelectiveNAckFlow *pp = (SelectiveNAckFlow *)object; (void)pp;
2491  switch (field) {
2492  case 2: return pp->getNackListArraySize();
2493  default: return 0;
2494  }
2495 }
2496 
2497 std::string SelectiveNAckFlowDescriptor::getFieldValueAsString(void *object, int field, int i) const
2498 {
2499  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2500  if (basedesc) {
2501  if (field < basedesc->getFieldCount())
2502  return basedesc->getFieldValueAsString(object,field,i);
2503  field -= basedesc->getFieldCount();
2504  }
2505  SelectiveNAckFlow *pp = (SelectiveNAckFlow *)object; (void)pp;
2506  switch (field) {
2507  case 0: return ulong2string(pp->getNewLeftWinEdge());
2508  case 1: return ulong2string(pp->getNackListLen());
2509  case 2: return ulong2string(pp->getNackList(i));
2510  default: return "";
2511  }
2512 }
2513 
2514 bool SelectiveNAckFlowDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
2515 {
2516  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2517  if (basedesc) {
2518  if (field < basedesc->getFieldCount())
2519  return basedesc->setFieldValueAsString(object,field,i,value);
2520  field -= basedesc->getFieldCount();
2521  }
2522  SelectiveNAckFlow *pp = (SelectiveNAckFlow *)object; (void)pp;
2523  switch (field) {
2524  case 0: pp->setNewLeftWinEdge(string2ulong(value)); return true;
2525  case 1: pp->setNackListLen(string2ulong(value)); return true;
2526  case 2: pp->setNackList(i,string2ulong(value)); return true;
2527  default: return false;
2528  }
2529 }
2530 
2532 {
2533  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2534  if (basedesc) {
2535  if (field < basedesc->getFieldCount())
2536  return basedesc->getFieldStructName(field);
2537  field -= basedesc->getFieldCount();
2538  }
2539  switch (field) {
2540  default: return nullptr;
2541  };
2542 }
2543 
2544 void *SelectiveNAckFlowDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
2545 {
2546  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2547  if (basedesc) {
2548  if (field < basedesc->getFieldCount())
2549  return basedesc->getFieldStructValuePointer(object, field, i);
2550  field -= basedesc->getFieldCount();
2551  }
2552  SelectiveNAckFlow *pp = (SelectiveNAckFlow *)object; (void)pp;
2553  switch (field) {
2554  default: return nullptr;
2555  }
2556 }
2557 
2559 
2560 SelectiveAckFlowPDU::SelectiveAckFlowPDU(const char *name, int kind) : ::SelectiveNAckFlow(name,kind)
2561 {
2563 }
2564 
2566 {
2567  copy(other);
2568 }
2569 
2571 {
2572 }
2573 
2575 {
2576  if (this==&other) return *this;
2577  ::SelectiveNAckFlow::operator=(other);
2578  copy(other);
2579  return *this;
2580 }
2581 
2583 {
2584 }
2585 
2586 void SelectiveAckFlowPDU::parsimPack(omnetpp::cCommBuffer *b) const
2587 {
2589 }
2590 
2591 void SelectiveAckFlowPDU::parsimUnpack(omnetpp::cCommBuffer *b)
2592 {
2594 }
2595 
2596 class SelectiveAckFlowPDUDescriptor : public omnetpp::cClassDescriptor
2597 {
2598  private:
2599  mutable const char **propertynames;
2600  public:
2603 
2604  virtual bool doesSupport(omnetpp::cObject *obj) const override;
2605  virtual const char **getPropertyNames() const override;
2606  virtual const char *getProperty(const char *propertyname) const override;
2607  virtual int getFieldCount() const override;
2608  virtual const char *getFieldName(int field) const override;
2609  virtual int findField(const char *fieldName) const override;
2610  virtual unsigned int getFieldTypeFlags(int field) const override;
2611  virtual const char *getFieldTypeString(int field) const override;
2612  virtual const char **getFieldPropertyNames(int field) const override;
2613  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
2614  virtual int getFieldArraySize(void *object, int field) const override;
2615 
2616  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
2617  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
2618 
2619  virtual const char *getFieldStructName(int field) const override;
2620  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
2621 };
2622 
2624 
2625 SelectiveAckFlowPDUDescriptor::SelectiveAckFlowPDUDescriptor() : omnetpp::cClassDescriptor("SelectiveAckFlowPDU", "SelectiveNAckFlow")
2626 {
2627  propertynames = nullptr;
2628 }
2629 
2631 {
2632  delete[] propertynames;
2633 }
2634 
2635 bool SelectiveAckFlowPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
2636 {
2637  return dynamic_cast<SelectiveAckFlowPDU *>(obj)!=nullptr;
2638 }
2639 
2641 {
2642  if (!propertynames) {
2643  static const char *names[] = { nullptr };
2644  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2645  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
2646  propertynames = mergeLists(basenames, names);
2647  }
2648  return propertynames;
2649 }
2650 
2651 const char *SelectiveAckFlowPDUDescriptor::getProperty(const char *propertyname) const
2652 {
2653  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2654  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
2655 }
2656 
2658 {
2659  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2660  return basedesc ? 0+basedesc->getFieldCount() : 0;
2661 }
2662 
2664 {
2665  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2666  if (basedesc) {
2667  if (field < basedesc->getFieldCount())
2668  return basedesc->getFieldTypeFlags(field);
2669  field -= basedesc->getFieldCount();
2670  }
2671  return 0;
2672 }
2673 
2675 {
2676  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2677  if (basedesc) {
2678  if (field < basedesc->getFieldCount())
2679  return basedesc->getFieldName(field);
2680  field -= basedesc->getFieldCount();
2681  }
2682  return nullptr;
2683 }
2684 
2685 int SelectiveAckFlowPDUDescriptor::findField(const char *fieldName) const
2686 {
2687  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2688  return basedesc ? basedesc->findField(fieldName) : -1;
2689 }
2690 
2692 {
2693  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2694  if (basedesc) {
2695  if (field < basedesc->getFieldCount())
2696  return basedesc->getFieldTypeString(field);
2697  field -= basedesc->getFieldCount();
2698  }
2699  return nullptr;
2700 }
2701 
2703 {
2704  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2705  if (basedesc) {
2706  if (field < basedesc->getFieldCount())
2707  return basedesc->getFieldPropertyNames(field);
2708  field -= basedesc->getFieldCount();
2709  }
2710  switch (field) {
2711  default: return nullptr;
2712  }
2713 }
2714 
2715 const char *SelectiveAckFlowPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
2716 {
2717  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2718  if (basedesc) {
2719  if (field < basedesc->getFieldCount())
2720  return basedesc->getFieldProperty(field, propertyname);
2721  field -= basedesc->getFieldCount();
2722  }
2723  switch (field) {
2724  default: return nullptr;
2725  }
2726 }
2727 
2728 int SelectiveAckFlowPDUDescriptor::getFieldArraySize(void *object, int field) const
2729 {
2730  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2731  if (basedesc) {
2732  if (field < basedesc->getFieldCount())
2733  return basedesc->getFieldArraySize(object, field);
2734  field -= basedesc->getFieldCount();
2735  }
2736  SelectiveAckFlowPDU *pp = (SelectiveAckFlowPDU *)object; (void)pp;
2737  switch (field) {
2738  default: return 0;
2739  }
2740 }
2741 
2742 std::string SelectiveAckFlowPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
2743 {
2744  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2745  if (basedesc) {
2746  if (field < basedesc->getFieldCount())
2747  return basedesc->getFieldValueAsString(object,field,i);
2748  field -= basedesc->getFieldCount();
2749  }
2750  SelectiveAckFlowPDU *pp = (SelectiveAckFlowPDU *)object; (void)pp;
2751  switch (field) {
2752  default: return "";
2753  }
2754 }
2755 
2756 bool SelectiveAckFlowPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
2757 {
2758  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2759  if (basedesc) {
2760  if (field < basedesc->getFieldCount())
2761  return basedesc->setFieldValueAsString(object,field,i,value);
2762  field -= basedesc->getFieldCount();
2763  }
2764  SelectiveAckFlowPDU *pp = (SelectiveAckFlowPDU *)object; (void)pp;
2765  switch (field) {
2766  default: return false;
2767  }
2768 }
2769 
2771 {
2772  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2773  if (basedesc) {
2774  if (field < basedesc->getFieldCount())
2775  return basedesc->getFieldStructName(field);
2776  field -= basedesc->getFieldCount();
2777  }
2778  return nullptr;
2779 }
2780 
2781 void *SelectiveAckFlowPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
2782 {
2783  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2784  if (basedesc) {
2785  if (field < basedesc->getFieldCount())
2786  return basedesc->getFieldStructValuePointer(object, field, i);
2787  field -= basedesc->getFieldCount();
2788  }
2789  SelectiveAckFlowPDU *pp = (SelectiveAckFlowPDU *)object; (void)pp;
2790  switch (field) {
2791  default: return nullptr;
2792  }
2793 }
2794 
2796 
2797 SelectiveNackFlowPDU::SelectiveNackFlowPDU(const char *name, int kind) : ::SelectiveNAckFlow(name,kind)
2798 {
2800 }
2801 
2803 {
2804  copy(other);
2805 }
2806 
2808 {
2809 }
2810 
2812 {
2813  if (this==&other) return *this;
2814  ::SelectiveNAckFlow::operator=(other);
2815  copy(other);
2816  return *this;
2817 }
2818 
2820 {
2821 }
2822 
2823 void SelectiveNackFlowPDU::parsimPack(omnetpp::cCommBuffer *b) const
2824 {
2826 }
2827 
2828 void SelectiveNackFlowPDU::parsimUnpack(omnetpp::cCommBuffer *b)
2829 {
2831 }
2832 
2833 class SelectiveNackFlowPDUDescriptor : public omnetpp::cClassDescriptor
2834 {
2835  private:
2836  mutable const char **propertynames;
2837  public:
2840 
2841  virtual bool doesSupport(omnetpp::cObject *obj) const override;
2842  virtual const char **getPropertyNames() const override;
2843  virtual const char *getProperty(const char *propertyname) const override;
2844  virtual int getFieldCount() const override;
2845  virtual const char *getFieldName(int field) const override;
2846  virtual int findField(const char *fieldName) const override;
2847  virtual unsigned int getFieldTypeFlags(int field) const override;
2848  virtual const char *getFieldTypeString(int field) const override;
2849  virtual const char **getFieldPropertyNames(int field) const override;
2850  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
2851  virtual int getFieldArraySize(void *object, int field) const override;
2852 
2853  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
2854  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
2855 
2856  virtual const char *getFieldStructName(int field) const override;
2857  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
2858 };
2859 
2861 
2862 SelectiveNackFlowPDUDescriptor::SelectiveNackFlowPDUDescriptor() : omnetpp::cClassDescriptor("SelectiveNackFlowPDU", "SelectiveNAckFlow")
2863 {
2864  propertynames = nullptr;
2865 }
2866 
2868 {
2869  delete[] propertynames;
2870 }
2871 
2872 bool SelectiveNackFlowPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
2873 {
2874  return dynamic_cast<SelectiveNackFlowPDU *>(obj)!=nullptr;
2875 }
2876 
2878 {
2879  if (!propertynames) {
2880  static const char *names[] = { nullptr };
2881  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2882  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
2883  propertynames = mergeLists(basenames, names);
2884  }
2885  return propertynames;
2886 }
2887 
2888 const char *SelectiveNackFlowPDUDescriptor::getProperty(const char *propertyname) const
2889 {
2890  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2891  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
2892 }
2893 
2895 {
2896  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2897  return basedesc ? 0+basedesc->getFieldCount() : 0;
2898 }
2899 
2901 {
2902  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2903  if (basedesc) {
2904  if (field < basedesc->getFieldCount())
2905  return basedesc->getFieldTypeFlags(field);
2906  field -= basedesc->getFieldCount();
2907  }
2908  return 0;
2909 }
2910 
2912 {
2913  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2914  if (basedesc) {
2915  if (field < basedesc->getFieldCount())
2916  return basedesc->getFieldName(field);
2917  field -= basedesc->getFieldCount();
2918  }
2919  return nullptr;
2920 }
2921 
2922 int SelectiveNackFlowPDUDescriptor::findField(const char *fieldName) const
2923 {
2924  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2925  return basedesc ? basedesc->findField(fieldName) : -1;
2926 }
2927 
2929 {
2930  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2931  if (basedesc) {
2932  if (field < basedesc->getFieldCount())
2933  return basedesc->getFieldTypeString(field);
2934  field -= basedesc->getFieldCount();
2935  }
2936  return nullptr;
2937 }
2938 
2940 {
2941  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2942  if (basedesc) {
2943  if (field < basedesc->getFieldCount())
2944  return basedesc->getFieldPropertyNames(field);
2945  field -= basedesc->getFieldCount();
2946  }
2947  switch (field) {
2948  default: return nullptr;
2949  }
2950 }
2951 
2952 const char *SelectiveNackFlowPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
2953 {
2954  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2955  if (basedesc) {
2956  if (field < basedesc->getFieldCount())
2957  return basedesc->getFieldProperty(field, propertyname);
2958  field -= basedesc->getFieldCount();
2959  }
2960  switch (field) {
2961  default: return nullptr;
2962  }
2963 }
2964 
2965 int SelectiveNackFlowPDUDescriptor::getFieldArraySize(void *object, int field) const
2966 {
2967  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2968  if (basedesc) {
2969  if (field < basedesc->getFieldCount())
2970  return basedesc->getFieldArraySize(object, field);
2971  field -= basedesc->getFieldCount();
2972  }
2973  SelectiveNackFlowPDU *pp = (SelectiveNackFlowPDU *)object; (void)pp;
2974  switch (field) {
2975  default: return 0;
2976  }
2977 }
2978 
2979 std::string SelectiveNackFlowPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
2980 {
2981  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2982  if (basedesc) {
2983  if (field < basedesc->getFieldCount())
2984  return basedesc->getFieldValueAsString(object,field,i);
2985  field -= basedesc->getFieldCount();
2986  }
2987  SelectiveNackFlowPDU *pp = (SelectiveNackFlowPDU *)object; (void)pp;
2988  switch (field) {
2989  default: return "";
2990  }
2991 }
2992 
2993 bool SelectiveNackFlowPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
2994 {
2995  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
2996  if (basedesc) {
2997  if (field < basedesc->getFieldCount())
2998  return basedesc->setFieldValueAsString(object,field,i,value);
2999  field -= basedesc->getFieldCount();
3000  }
3001  SelectiveNackFlowPDU *pp = (SelectiveNackFlowPDU *)object; (void)pp;
3002  switch (field) {
3003  default: return false;
3004  }
3005 }
3006 
3008 {
3009  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3010  if (basedesc) {
3011  if (field < basedesc->getFieldCount())
3012  return basedesc->getFieldStructName(field);
3013  field -= basedesc->getFieldCount();
3014  }
3015  return nullptr;
3016 }
3017 
3018 void *SelectiveNackFlowPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
3019 {
3020  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3021  if (basedesc) {
3022  if (field < basedesc->getFieldCount())
3023  return basedesc->getFieldStructValuePointer(object, field, i);
3024  field -= basedesc->getFieldCount();
3025  }
3026  SelectiveNackFlowPDU *pp = (SelectiveNackFlowPDU *)object; (void)pp;
3027  switch (field) {
3028  default: return nullptr;
3029  }
3030 }
3031 
3033 
3034 SelectiveAckPDU::SelectiveAckPDU(const char *name, int kind) : ::SelectiveNAckFlow(name,kind)
3035 {
3036  this->setType(SELECT_ACK_PDU);
3037 }
3038 
3040 {
3041  copy(other);
3042 }
3043 
3045 {
3046 }
3047 
3049 {
3050  if (this==&other) return *this;
3051  ::SelectiveNAckFlow::operator=(other);
3052  copy(other);
3053  return *this;
3054 }
3055 
3057 {
3058 }
3059 
3060 void SelectiveAckPDU::parsimPack(omnetpp::cCommBuffer *b) const
3061 {
3063 }
3064 
3065 void SelectiveAckPDU::parsimUnpack(omnetpp::cCommBuffer *b)
3066 {
3068 }
3069 
3070 class SelectiveAckPDUDescriptor : public omnetpp::cClassDescriptor
3071 {
3072  private:
3073  mutable const char **propertynames;
3074  public:
3076  virtual ~SelectiveAckPDUDescriptor();
3077 
3078  virtual bool doesSupport(omnetpp::cObject *obj) const override;
3079  virtual const char **getPropertyNames() const override;
3080  virtual const char *getProperty(const char *propertyname) const override;
3081  virtual int getFieldCount() const override;
3082  virtual const char *getFieldName(int field) const override;
3083  virtual int findField(const char *fieldName) const override;
3084  virtual unsigned int getFieldTypeFlags(int field) const override;
3085  virtual const char *getFieldTypeString(int field) const override;
3086  virtual const char **getFieldPropertyNames(int field) const override;
3087  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
3088  virtual int getFieldArraySize(void *object, int field) const override;
3089 
3090  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
3091  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
3092 
3093  virtual const char *getFieldStructName(int field) const override;
3094  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
3095 };
3096 
3098 
3099 SelectiveAckPDUDescriptor::SelectiveAckPDUDescriptor() : omnetpp::cClassDescriptor("SelectiveAckPDU", "SelectiveNAckFlow")
3100 {
3101  propertynames = nullptr;
3102 }
3103 
3105 {
3106  delete[] propertynames;
3107 }
3108 
3109 bool SelectiveAckPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
3110 {
3111  return dynamic_cast<SelectiveAckPDU *>(obj)!=nullptr;
3112 }
3113 
3115 {
3116  if (!propertynames) {
3117  static const char *names[] = { nullptr };
3118  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3119  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
3120  propertynames = mergeLists(basenames, names);
3121  }
3122  return propertynames;
3123 }
3124 
3125 const char *SelectiveAckPDUDescriptor::getProperty(const char *propertyname) const
3126 {
3127  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3128  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
3129 }
3130 
3132 {
3133  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3134  return basedesc ? 0+basedesc->getFieldCount() : 0;
3135 }
3136 
3138 {
3139  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3140  if (basedesc) {
3141  if (field < basedesc->getFieldCount())
3142  return basedesc->getFieldTypeFlags(field);
3143  field -= basedesc->getFieldCount();
3144  }
3145  return 0;
3146 }
3147 
3148 const char *SelectiveAckPDUDescriptor::getFieldName(int field) const
3149 {
3150  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3151  if (basedesc) {
3152  if (field < basedesc->getFieldCount())
3153  return basedesc->getFieldName(field);
3154  field -= basedesc->getFieldCount();
3155  }
3156  return nullptr;
3157 }
3158 
3159 int SelectiveAckPDUDescriptor::findField(const char *fieldName) const
3160 {
3161  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3162  return basedesc ? basedesc->findField(fieldName) : -1;
3163 }
3164 
3166 {
3167  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3168  if (basedesc) {
3169  if (field < basedesc->getFieldCount())
3170  return basedesc->getFieldTypeString(field);
3171  field -= basedesc->getFieldCount();
3172  }
3173  return nullptr;
3174 }
3175 
3177 {
3178  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3179  if (basedesc) {
3180  if (field < basedesc->getFieldCount())
3181  return basedesc->getFieldPropertyNames(field);
3182  field -= basedesc->getFieldCount();
3183  }
3184  switch (field) {
3185  default: return nullptr;
3186  }
3187 }
3188 
3189 const char *SelectiveAckPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
3190 {
3191  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3192  if (basedesc) {
3193  if (field < basedesc->getFieldCount())
3194  return basedesc->getFieldProperty(field, propertyname);
3195  field -= basedesc->getFieldCount();
3196  }
3197  switch (field) {
3198  default: return nullptr;
3199  }
3200 }
3201 
3202 int SelectiveAckPDUDescriptor::getFieldArraySize(void *object, int field) const
3203 {
3204  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3205  if (basedesc) {
3206  if (field < basedesc->getFieldCount())
3207  return basedesc->getFieldArraySize(object, field);
3208  field -= basedesc->getFieldCount();
3209  }
3210  SelectiveAckPDU *pp = (SelectiveAckPDU *)object; (void)pp;
3211  switch (field) {
3212  default: return 0;
3213  }
3214 }
3215 
3216 std::string SelectiveAckPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
3217 {
3218  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3219  if (basedesc) {
3220  if (field < basedesc->getFieldCount())
3221  return basedesc->getFieldValueAsString(object,field,i);
3222  field -= basedesc->getFieldCount();
3223  }
3224  SelectiveAckPDU *pp = (SelectiveAckPDU *)object; (void)pp;
3225  switch (field) {
3226  default: return "";
3227  }
3228 }
3229 
3230 bool SelectiveAckPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
3231 {
3232  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3233  if (basedesc) {
3234  if (field < basedesc->getFieldCount())
3235  return basedesc->setFieldValueAsString(object,field,i,value);
3236  field -= basedesc->getFieldCount();
3237  }
3238  SelectiveAckPDU *pp = (SelectiveAckPDU *)object; (void)pp;
3239  switch (field) {
3240  default: return false;
3241  }
3242 }
3243 
3245 {
3246  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3247  if (basedesc) {
3248  if (field < basedesc->getFieldCount())
3249  return basedesc->getFieldStructName(field);
3250  field -= basedesc->getFieldCount();
3251  }
3252  return nullptr;
3253 }
3254 
3255 void *SelectiveAckPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
3256 {
3257  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3258  if (basedesc) {
3259  if (field < basedesc->getFieldCount())
3260  return basedesc->getFieldStructValuePointer(object, field, i);
3261  field -= basedesc->getFieldCount();
3262  }
3263  SelectiveAckPDU *pp = (SelectiveAckPDU *)object; (void)pp;
3264  switch (field) {
3265  default: return nullptr;
3266  }
3267 }
3268 
3270 
3271 SelectiveNackPDU::SelectiveNackPDU(const char *name, int kind) : ::SelectiveNAckFlow(name,kind)
3272 {
3273  this->setType(SELECT_NACK_PDU);
3274 }
3275 
3277 {
3278  copy(other);
3279 }
3280 
3282 {
3283 }
3284 
3286 {
3287  if (this==&other) return *this;
3288  ::SelectiveNAckFlow::operator=(other);
3289  copy(other);
3290  return *this;
3291 }
3292 
3294 {
3295 }
3296 
3297 void SelectiveNackPDU::parsimPack(omnetpp::cCommBuffer *b) const
3298 {
3300 }
3301 
3302 void SelectiveNackPDU::parsimUnpack(omnetpp::cCommBuffer *b)
3303 {
3305 }
3306 
3307 class SelectiveNackPDUDescriptor : public omnetpp::cClassDescriptor
3308 {
3309  private:
3310  mutable const char **propertynames;
3311  public:
3313  virtual ~SelectiveNackPDUDescriptor();
3314 
3315  virtual bool doesSupport(omnetpp::cObject *obj) const override;
3316  virtual const char **getPropertyNames() const override;
3317  virtual const char *getProperty(const char *propertyname) const override;
3318  virtual int getFieldCount() const override;
3319  virtual const char *getFieldName(int field) const override;
3320  virtual int findField(const char *fieldName) const override;
3321  virtual unsigned int getFieldTypeFlags(int field) const override;
3322  virtual const char *getFieldTypeString(int field) const override;
3323  virtual const char **getFieldPropertyNames(int field) const override;
3324  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
3325  virtual int getFieldArraySize(void *object, int field) const override;
3326 
3327  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
3328  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
3329 
3330  virtual const char *getFieldStructName(int field) const override;
3331  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
3332 };
3333 
3335 
3336 SelectiveNackPDUDescriptor::SelectiveNackPDUDescriptor() : omnetpp::cClassDescriptor("SelectiveNackPDU", "SelectiveNAckFlow")
3337 {
3338  propertynames = nullptr;
3339 }
3340 
3342 {
3343  delete[] propertynames;
3344 }
3345 
3346 bool SelectiveNackPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
3347 {
3348  return dynamic_cast<SelectiveNackPDU *>(obj)!=nullptr;
3349 }
3350 
3352 {
3353  if (!propertynames) {
3354  static const char *names[] = { nullptr };
3355  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3356  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
3357  propertynames = mergeLists(basenames, names);
3358  }
3359  return propertynames;
3360 }
3361 
3362 const char *SelectiveNackPDUDescriptor::getProperty(const char *propertyname) const
3363 {
3364  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3365  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
3366 }
3367 
3369 {
3370  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3371  return basedesc ? 0+basedesc->getFieldCount() : 0;
3372 }
3373 
3375 {
3376  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3377  if (basedesc) {
3378  if (field < basedesc->getFieldCount())
3379  return basedesc->getFieldTypeFlags(field);
3380  field -= basedesc->getFieldCount();
3381  }
3382  return 0;
3383 }
3384 
3385 const char *SelectiveNackPDUDescriptor::getFieldName(int field) const
3386 {
3387  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3388  if (basedesc) {
3389  if (field < basedesc->getFieldCount())
3390  return basedesc->getFieldName(field);
3391  field -= basedesc->getFieldCount();
3392  }
3393  return nullptr;
3394 }
3395 
3396 int SelectiveNackPDUDescriptor::findField(const char *fieldName) const
3397 {
3398  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3399  return basedesc ? basedesc->findField(fieldName) : -1;
3400 }
3401 
3403 {
3404  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3405  if (basedesc) {
3406  if (field < basedesc->getFieldCount())
3407  return basedesc->getFieldTypeString(field);
3408  field -= basedesc->getFieldCount();
3409  }
3410  return nullptr;
3411 }
3412 
3414 {
3415  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3416  if (basedesc) {
3417  if (field < basedesc->getFieldCount())
3418  return basedesc->getFieldPropertyNames(field);
3419  field -= basedesc->getFieldCount();
3420  }
3421  switch (field) {
3422  default: return nullptr;
3423  }
3424 }
3425 
3426 const char *SelectiveNackPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
3427 {
3428  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3429  if (basedesc) {
3430  if (field < basedesc->getFieldCount())
3431  return basedesc->getFieldProperty(field, propertyname);
3432  field -= basedesc->getFieldCount();
3433  }
3434  switch (field) {
3435  default: return nullptr;
3436  }
3437 }
3438 
3439 int SelectiveNackPDUDescriptor::getFieldArraySize(void *object, int field) const
3440 {
3441  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3442  if (basedesc) {
3443  if (field < basedesc->getFieldCount())
3444  return basedesc->getFieldArraySize(object, field);
3445  field -= basedesc->getFieldCount();
3446  }
3447  SelectiveNackPDU *pp = (SelectiveNackPDU *)object; (void)pp;
3448  switch (field) {
3449  default: return 0;
3450  }
3451 }
3452 
3453 std::string SelectiveNackPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
3454 {
3455  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3456  if (basedesc) {
3457  if (field < basedesc->getFieldCount())
3458  return basedesc->getFieldValueAsString(object,field,i);
3459  field -= basedesc->getFieldCount();
3460  }
3461  SelectiveNackPDU *pp = (SelectiveNackPDU *)object; (void)pp;
3462  switch (field) {
3463  default: return "";
3464  }
3465 }
3466 
3467 bool SelectiveNackPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
3468 {
3469  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3470  if (basedesc) {
3471  if (field < basedesc->getFieldCount())
3472  return basedesc->setFieldValueAsString(object,field,i,value);
3473  field -= basedesc->getFieldCount();
3474  }
3475  SelectiveNackPDU *pp = (SelectiveNackPDU *)object; (void)pp;
3476  switch (field) {
3477  default: return false;
3478  }
3479 }
3480 
3482 {
3483  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3484  if (basedesc) {
3485  if (field < basedesc->getFieldCount())
3486  return basedesc->getFieldStructName(field);
3487  field -= basedesc->getFieldCount();
3488  }
3489  return nullptr;
3490 }
3491 
3492 void *SelectiveNackPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
3493 {
3494  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3495  if (basedesc) {
3496  if (field < basedesc->getFieldCount())
3497  return basedesc->getFieldStructValuePointer(object, field, i);
3498  field -= basedesc->getFieldCount();
3499  }
3500  SelectiveNackPDU *pp = (SelectiveNackPDU *)object; (void)pp;
3501  switch (field) {
3502  default: return nullptr;
3503  }
3504 }
3505 
3507 
3508 ControlAckPDU::ControlAckPDU(const char *name, int kind) : ::ControlPDU(name,kind)
3509 {
3510  this->setType(CONTROL_ACK_PDU);
3511 
3512  this->lastCtrlSeqNumRcv = 0;
3513  this->rcvLeftWinEdge = 0;
3514  this->rcvRightWinEdge = 0;
3515  this->sndLeftWinEdge = 0;
3516  this->sndRightWinEdge = 0;
3517  this->rcvRate = 0;
3518 }
3519 
3521 {
3522  copy(other);
3523 }
3524 
3526 {
3527 }
3528 
3530 {
3531  if (this==&other) return *this;
3532  ::ControlPDU::operator=(other);
3533  copy(other);
3534  return *this;
3535 }
3536 
3538 {
3539  this->lastCtrlSeqNumRcv = other.lastCtrlSeqNumRcv;
3540  this->rcvLeftWinEdge = other.rcvLeftWinEdge;
3541  this->rcvRightWinEdge = other.rcvRightWinEdge;
3542  this->sndLeftWinEdge = other.sndLeftWinEdge;
3543  this->sndRightWinEdge = other.sndRightWinEdge;
3544  this->rcvRate = other.rcvRate;
3545 }
3546 
3547 void ControlAckPDU::parsimPack(omnetpp::cCommBuffer *b) const
3548 {
3555  doParsimPacking(b,this->rcvRate);
3556 }
3557 
3558 void ControlAckPDU::parsimUnpack(omnetpp::cCommBuffer *b)
3559 {
3566  doParsimUnpacking(b,this->rcvRate);
3567 }
3568 
3570 {
3571  return this->lastCtrlSeqNumRcv;
3572 }
3573 
3574 void ControlAckPDU::setLastCtrlSeqNumRcv(unsigned int lastCtrlSeqNumRcv)
3575 {
3576  this->lastCtrlSeqNumRcv = lastCtrlSeqNumRcv;
3577 }
3578 
3580 {
3581  return this->rcvLeftWinEdge;
3582 }
3583 
3584 void ControlAckPDU::setRcvLeftWinEdge(unsigned int rcvLeftWinEdge)
3585 {
3586  this->rcvLeftWinEdge = rcvLeftWinEdge;
3587 }
3588 
3590 {
3591  return this->rcvRightWinEdge;
3592 }
3593 
3594 void ControlAckPDU::setRcvRightWinEdge(unsigned int rcvRightWinEdge)
3595 {
3596  this->rcvRightWinEdge = rcvRightWinEdge;
3597 }
3598 
3600 {
3601  return this->sndLeftWinEdge;
3602 }
3603 
3604 void ControlAckPDU::setSndLeftWinEdge(unsigned int sndLeftWinEdge)
3605 {
3606  this->sndLeftWinEdge = sndLeftWinEdge;
3607 }
3608 
3610 {
3611  return this->sndRightWinEdge;
3612 }
3613 
3614 void ControlAckPDU::setSndRightWinEdge(unsigned int sndRightWinEdge)
3615 {
3616  this->sndRightWinEdge = sndRightWinEdge;
3617 }
3618 
3619 unsigned int ControlAckPDU::getRcvRate() const
3620 {
3621  return this->rcvRate;
3622 }
3623 
3624 void ControlAckPDU::setRcvRate(unsigned int rcvRate)
3625 {
3626  this->rcvRate = rcvRate;
3627 }
3628 
3629 class ControlAckPDUDescriptor : public omnetpp::cClassDescriptor
3630 {
3631  private:
3632  mutable const char **propertynames;
3633  public:
3635  virtual ~ControlAckPDUDescriptor();
3636 
3637  virtual bool doesSupport(omnetpp::cObject *obj) const override;
3638  virtual const char **getPropertyNames() const override;
3639  virtual const char *getProperty(const char *propertyname) const override;
3640  virtual int getFieldCount() const override;
3641  virtual const char *getFieldName(int field) const override;
3642  virtual int findField(const char *fieldName) const override;
3643  virtual unsigned int getFieldTypeFlags(int field) const override;
3644  virtual const char *getFieldTypeString(int field) const override;
3645  virtual const char **getFieldPropertyNames(int field) const override;
3646  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
3647  virtual int getFieldArraySize(void *object, int field) const override;
3648 
3649  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
3650  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
3651 
3652  virtual const char *getFieldStructName(int field) const override;
3653  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
3654 };
3655 
3657 
3658 ControlAckPDUDescriptor::ControlAckPDUDescriptor() : omnetpp::cClassDescriptor("ControlAckPDU", "ControlPDU")
3659 {
3660  propertynames = nullptr;
3661 }
3662 
3664 {
3665  delete[] propertynames;
3666 }
3667 
3668 bool ControlAckPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
3669 {
3670  return dynamic_cast<ControlAckPDU *>(obj)!=nullptr;
3671 }
3672 
3674 {
3675  if (!propertynames) {
3676  static const char *names[] = { nullptr };
3677  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3678  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
3679  propertynames = mergeLists(basenames, names);
3680  }
3681  return propertynames;
3682 }
3683 
3684 const char *ControlAckPDUDescriptor::getProperty(const char *propertyname) const
3685 {
3686  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3687  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
3688 }
3689 
3691 {
3692  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3693  return basedesc ? 6+basedesc->getFieldCount() : 6;
3694 }
3695 
3696 unsigned int ControlAckPDUDescriptor::getFieldTypeFlags(int field) const
3697 {
3698  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3699  if (basedesc) {
3700  if (field < basedesc->getFieldCount())
3701  return basedesc->getFieldTypeFlags(field);
3702  field -= basedesc->getFieldCount();
3703  }
3704  static unsigned int fieldTypeFlags[] = {
3705  FD_ISEDITABLE,
3706  FD_ISEDITABLE,
3707  FD_ISEDITABLE,
3708  FD_ISEDITABLE,
3709  FD_ISEDITABLE,
3710  FD_ISEDITABLE,
3711  };
3712  return (field>=0 && field<6) ? fieldTypeFlags[field] : 0;
3713 }
3714 
3715 const char *ControlAckPDUDescriptor::getFieldName(int field) const
3716 {
3717  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3718  if (basedesc) {
3719  if (field < basedesc->getFieldCount())
3720  return basedesc->getFieldName(field);
3721  field -= basedesc->getFieldCount();
3722  }
3723  static const char *fieldNames[] = {
3724  "lastCtrlSeqNumRcv",
3725  "rcvLeftWinEdge",
3726  "rcvRightWinEdge",
3727  "sndLeftWinEdge",
3728  "sndRightWinEdge",
3729  "rcvRate",
3730  };
3731  return (field>=0 && field<6) ? fieldNames[field] : nullptr;
3732 }
3733 
3734 int ControlAckPDUDescriptor::findField(const char *fieldName) const
3735 {
3736  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3737  int base = basedesc ? basedesc->getFieldCount() : 0;
3738  if (fieldName[0]=='l' && strcmp(fieldName, "lastCtrlSeqNumRcv")==0) return base+0;
3739  if (fieldName[0]=='r' && strcmp(fieldName, "rcvLeftWinEdge")==0) return base+1;
3740  if (fieldName[0]=='r' && strcmp(fieldName, "rcvRightWinEdge")==0) return base+2;
3741  if (fieldName[0]=='s' && strcmp(fieldName, "sndLeftWinEdge")==0) return base+3;
3742  if (fieldName[0]=='s' && strcmp(fieldName, "sndRightWinEdge")==0) return base+4;
3743  if (fieldName[0]=='r' && strcmp(fieldName, "rcvRate")==0) return base+5;
3744  return basedesc ? basedesc->findField(fieldName) : -1;
3745 }
3746 
3748 {
3749  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3750  if (basedesc) {
3751  if (field < basedesc->getFieldCount())
3752  return basedesc->getFieldTypeString(field);
3753  field -= basedesc->getFieldCount();
3754  }
3755  static const char *fieldTypeStrings[] = {
3756  "unsigned int",
3757  "unsigned int",
3758  "unsigned int",
3759  "unsigned int",
3760  "unsigned int",
3761  "unsigned int",
3762  };
3763  return (field>=0 && field<6) ? fieldTypeStrings[field] : nullptr;
3764 }
3765 
3767 {
3768  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3769  if (basedesc) {
3770  if (field < basedesc->getFieldCount())
3771  return basedesc->getFieldPropertyNames(field);
3772  field -= basedesc->getFieldCount();
3773  }
3774  switch (field) {
3775  default: return nullptr;
3776  }
3777 }
3778 
3779 const char *ControlAckPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
3780 {
3781  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3782  if (basedesc) {
3783  if (field < basedesc->getFieldCount())
3784  return basedesc->getFieldProperty(field, propertyname);
3785  field -= basedesc->getFieldCount();
3786  }
3787  switch (field) {
3788  default: return nullptr;
3789  }
3790 }
3791 
3792 int ControlAckPDUDescriptor::getFieldArraySize(void *object, int field) const
3793 {
3794  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3795  if (basedesc) {
3796  if (field < basedesc->getFieldCount())
3797  return basedesc->getFieldArraySize(object, field);
3798  field -= basedesc->getFieldCount();
3799  }
3800  ControlAckPDU *pp = (ControlAckPDU *)object; (void)pp;
3801  switch (field) {
3802  default: return 0;
3803  }
3804 }
3805 
3806 std::string ControlAckPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
3807 {
3808  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3809  if (basedesc) {
3810  if (field < basedesc->getFieldCount())
3811  return basedesc->getFieldValueAsString(object,field,i);
3812  field -= basedesc->getFieldCount();
3813  }
3814  ControlAckPDU *pp = (ControlAckPDU *)object; (void)pp;
3815  switch (field) {
3816  case 0: return ulong2string(pp->getLastCtrlSeqNumRcv());
3817  case 1: return ulong2string(pp->getRcvLeftWinEdge());
3818  case 2: return ulong2string(pp->getRcvRightWinEdge());
3819  case 3: return ulong2string(pp->getSndLeftWinEdge());
3820  case 4: return ulong2string(pp->getSndRightWinEdge());
3821  case 5: return ulong2string(pp->getRcvRate());
3822  default: return "";
3823  }
3824 }
3825 
3826 bool ControlAckPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
3827 {
3828  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3829  if (basedesc) {
3830  if (field < basedesc->getFieldCount())
3831  return basedesc->setFieldValueAsString(object,field,i,value);
3832  field -= basedesc->getFieldCount();
3833  }
3834  ControlAckPDU *pp = (ControlAckPDU *)object; (void)pp;
3835  switch (field) {
3836  case 0: pp->setLastCtrlSeqNumRcv(string2ulong(value)); return true;
3837  case 1: pp->setRcvLeftWinEdge(string2ulong(value)); return true;
3838  case 2: pp->setRcvRightWinEdge(string2ulong(value)); return true;
3839  case 3: pp->setSndLeftWinEdge(string2ulong(value)); return true;
3840  case 4: pp->setSndRightWinEdge(string2ulong(value)); return true;
3841  case 5: pp->setRcvRate(string2ulong(value)); return true;
3842  default: return false;
3843  }
3844 }
3845 
3847 {
3848  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3849  if (basedesc) {
3850  if (field < basedesc->getFieldCount())
3851  return basedesc->getFieldStructName(field);
3852  field -= basedesc->getFieldCount();
3853  }
3854  switch (field) {
3855  default: return nullptr;
3856  };
3857 }
3858 
3859 void *ControlAckPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
3860 {
3861  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3862  if (basedesc) {
3863  if (field < basedesc->getFieldCount())
3864  return basedesc->getFieldStructValuePointer(object, field, i);
3865  field -= basedesc->getFieldCount();
3866  }
3867  ControlAckPDU *pp = (ControlAckPDU *)object; (void)pp;
3868  switch (field) {
3869  default: return nullptr;
3870  }
3871 }
3872 
3874 
3875 RendezvousPDU::RendezvousPDU(const char *name, int kind) : ::ControlAckPDU(name,kind)
3876 {
3877  this->setType(RENDEZVOUS_PDU);
3878 
3879  this->rendezSeqNum = 0;
3880 }
3881 
3883 {
3884  copy(other);
3885 }
3886 
3888 {
3889 }
3890 
3892 {
3893  if (this==&other) return *this;
3894  ::ControlAckPDU::operator=(other);
3895  copy(other);
3896  return *this;
3897 }
3898 
3900 {
3901  this->rendezSeqNum = other.rendezSeqNum;
3902 }
3903 
3904 void RendezvousPDU::parsimPack(omnetpp::cCommBuffer *b) const
3905 {
3907  doParsimPacking(b,this->rendezSeqNum);
3908 }
3909 
3910 void RendezvousPDU::parsimUnpack(omnetpp::cCommBuffer *b)
3911 {
3914 }
3915 
3917 {
3918  return this->rendezSeqNum;
3919 }
3920 
3921 void RendezvousPDU::setRendezSeqNum(unsigned int rendezSeqNum)
3922 {
3923  this->rendezSeqNum = rendezSeqNum;
3924 }
3925 
3926 class RendezvousPDUDescriptor : public omnetpp::cClassDescriptor
3927 {
3928  private:
3929  mutable const char **propertynames;
3930  public:
3932  virtual ~RendezvousPDUDescriptor();
3933 
3934  virtual bool doesSupport(omnetpp::cObject *obj) const override;
3935  virtual const char **getPropertyNames() const override;
3936  virtual const char *getProperty(const char *propertyname) const override;
3937  virtual int getFieldCount() const override;
3938  virtual const char *getFieldName(int field) const override;
3939  virtual int findField(const char *fieldName) const override;
3940  virtual unsigned int getFieldTypeFlags(int field) const override;
3941  virtual const char *getFieldTypeString(int field) const override;
3942  virtual const char **getFieldPropertyNames(int field) const override;
3943  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
3944  virtual int getFieldArraySize(void *object, int field) const override;
3945 
3946  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
3947  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
3948 
3949  virtual const char *getFieldStructName(int field) const override;
3950  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
3951 };
3952 
3954 
3955 RendezvousPDUDescriptor::RendezvousPDUDescriptor() : omnetpp::cClassDescriptor("RendezvousPDU", "ControlAckPDU")
3956 {
3957  propertynames = nullptr;
3958 }
3959 
3961 {
3962  delete[] propertynames;
3963 }
3964 
3965 bool RendezvousPDUDescriptor::doesSupport(omnetpp::cObject *obj) const
3966 {
3967  return dynamic_cast<RendezvousPDU *>(obj)!=nullptr;
3968 }
3969 
3971 {
3972  if (!propertynames) {
3973  static const char *names[] = { nullptr };
3974  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3975  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
3976  propertynames = mergeLists(basenames, names);
3977  }
3978  return propertynames;
3979 }
3980 
3981 const char *RendezvousPDUDescriptor::getProperty(const char *propertyname) const
3982 {
3983  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3984  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
3985 }
3986 
3988 {
3989  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3990  return basedesc ? 1+basedesc->getFieldCount() : 1;
3991 }
3992 
3993 unsigned int RendezvousPDUDescriptor::getFieldTypeFlags(int field) const
3994 {
3995  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
3996  if (basedesc) {
3997  if (field < basedesc->getFieldCount())
3998  return basedesc->getFieldTypeFlags(field);
3999  field -= basedesc->getFieldCount();
4000  }
4001  static unsigned int fieldTypeFlags[] = {
4002  FD_ISEDITABLE,
4003  };
4004  return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
4005 }
4006 
4007 const char *RendezvousPDUDescriptor::getFieldName(int field) const
4008 {
4009  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
4010  if (basedesc) {
4011  if (field < basedesc->getFieldCount())
4012  return basedesc->getFieldName(field);
4013  field -= basedesc->getFieldCount();
4014  }
4015  static const char *fieldNames[] = {
4016  "rendezSeqNum",
4017  };
4018  return (field>=0 && field<1) ? fieldNames[field] : nullptr;
4019 }
4020 
4021 int RendezvousPDUDescriptor::findField(const char *fieldName) const
4022 {
4023  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
4024  int base = basedesc ? basedesc->getFieldCount() : 0;
4025  if (fieldName[0]=='r' && strcmp(fieldName, "rendezSeqNum")==0) return base+0;
4026  return basedesc ? basedesc->findField(fieldName) : -1;
4027 }
4028 
4030 {
4031  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
4032  if (basedesc) {
4033  if (field < basedesc->getFieldCount())
4034  return basedesc->getFieldTypeString(field);
4035  field -= basedesc->getFieldCount();
4036  }
4037  static const char *fieldTypeStrings[] = {
4038  "unsigned int",
4039  };
4040  return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
4041 }
4042 
4044 {
4045  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
4046  if (basedesc) {
4047  if (field < basedesc->getFieldCount())
4048  return basedesc->getFieldPropertyNames(field);
4049  field -= basedesc->getFieldCount();
4050  }
4051  switch (field) {
4052  default: return nullptr;
4053  }
4054 }
4055 
4056 const char *RendezvousPDUDescriptor::getFieldProperty(int field, const char *propertyname) const
4057 {
4058  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
4059  if (basedesc) {
4060  if (field < basedesc->getFieldCount())
4061  return basedesc->getFieldProperty(field, propertyname);
4062  field -= basedesc->getFieldCount();
4063  }
4064  switch (field) {
4065  default: return nullptr;
4066  }
4067 }
4068 
4069 int RendezvousPDUDescriptor::getFieldArraySize(void *object, int field) const
4070 {
4071  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
4072  if (basedesc) {
4073  if (field < basedesc->getFieldCount())
4074  return basedesc->getFieldArraySize(object, field);
4075  field -= basedesc->getFieldCount();
4076  }
4077  RendezvousPDU *pp = (RendezvousPDU *)object; (void)pp;
4078  switch (field) {
4079  default: return 0;
4080  }
4081 }
4082 
4083 std::string RendezvousPDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
4084 {
4085  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
4086  if (basedesc) {
4087  if (field < basedesc->getFieldCount())
4088  return basedesc->getFieldValueAsString(object,field,i);
4089  field -= basedesc->getFieldCount();
4090  }
4091  RendezvousPDU *pp = (RendezvousPDU *)object; (void)pp;
4092  switch (field) {
4093  case 0: return ulong2string(pp->getRendezSeqNum());
4094  default: return "";
4095  }
4096 }
4097 
4098 bool RendezvousPDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
4099 {
4100  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
4101  if (basedesc) {
4102  if (field < basedesc->getFieldCount())
4103  return basedesc->setFieldValueAsString(object,field,i,value);
4104  field -= basedesc->getFieldCount();
4105  }
4106  RendezvousPDU *pp = (RendezvousPDU *)object; (void)pp;
4107  switch (field) {
4108  case 0: pp->setRendezSeqNum(string2ulong(value)); return true;
4109  default: return false;
4110  }
4111 }
4112 
4114 {
4115  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
4116  if (basedesc) {
4117  if (field < basedesc->getFieldCount())
4118  return basedesc->getFieldStructName(field);
4119  field -= basedesc->getFieldCount();
4120  }
4121  switch (field) {
4122  default: return nullptr;
4123  };
4124 }
4125 
4126 void *RendezvousPDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
4127 {
4128  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
4129  if (basedesc) {
4130  if (field < basedesc->getFieldCount())
4131  return basedesc->getFieldStructValuePointer(object, field, i);
4132  field -= basedesc->getFieldCount();
4133  }
4134  RendezvousPDU *pp = (RendezvousPDU *)object; (void)pp;
4135  switch (field) {
4136  default: return nullptr;
4137  }
4138 }
4139 
4140 
virtual int findField(const char *fieldName) const override
const char ** propertynames
virtual unsigned int getFieldTypeFlags(int field) const override
virtual int getFieldCount() const override
const char ** propertynames
virtual unsigned int getFieldTypeFlags(int field) const override
virtual const char * getFieldTypeString(int field) const override
virtual void parsimPack(omnetpp::cCommBuffer *b) const
void copy(const AckFlowPDU &other)
virtual ~AckOnlyPDUDescriptor()
virtual void setNewLeftWinEdge(unsigned int newLeftWinEdge)
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual unsigned int getSndRightWinEdge() const
virtual const char ** getPropertyNames() const override
virtual const char * getProperty(const char *propertyname) const override
virtual int getFieldArraySize(void *object, int field) const override
virtual int getFieldCount() const override
SelectiveNAckFlow & operator=(const SelectiveNAckFlow &other)
virtual const char ** getFieldPropertyNames(int field) const override
virtual const char * getFieldName(int field) const override
NackOnlyPDU(const char *name=nullptr, int kind=0)
virtual ~FlowControlOnlyPDU()
virtual void setRcvRate(unsigned int rcvRate)
virtual const char * getProperty(const char *propertyname) const override
virtual unsigned int getFieldTypeFlags(int field) const override
virtual const char * getFieldStructName(int field) const override
virtual const char * getFieldName(int field) const override
virtual const char * getProperty(const char *propertyname) const override
virtual const char ** getPropertyNames() const override
virtual const char * getProperty(const char *propertyname) const override
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual int getFieldCount() const override
virtual const char * getFieldName(int field) const override
virtual const char ** getFieldPropertyNames(int field) const override
virtual unsigned int getFieldTypeFlags(int field) const override
unsigned int rendezSeqNum
Definition: ControlPDU_m.h:595
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
NAckPDU & operator=(const NAckPDU &other)
virtual ~FlowControlPDUDescriptor()
virtual void setRcvRightWinEdge(unsigned int rcvRightWinEdge)
virtual int getFieldArraySize(void *object, int field) const override
virtual ~AckFlowPDUDescriptor()
virtual const char * getFieldStructName(int field) const override
virtual const char * getFieldTypeString(int field) const override
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
void copy(const ControlAckPDU &other)
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual int getFieldArraySize(void *object, int field) const override
virtual const char ** getPropertyNames() const override
virtual const char * getFieldTypeString(int field) const override
virtual unsigned int getFieldTypeFlags(int field) const override
virtual int getFieldArraySize(void *object, int field) const override
SelectiveNackFlowPDU & operator=(const SelectiveNackFlowPDU &other)
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual const char * getFieldStructName(int field) const override
virtual const char ** getFieldPropertyNames(int field) const override
NackOnlyPDU & operator=(const NackOnlyPDU &other)
virtual const char * getFieldTypeString(int field) const override
virtual const char ** getPropertyNames() const override
FlowControlPDU(const char *name=nullptr, int kind=0)
virtual int findField(const char *fieldName) const override
virtual void setSndRightWinEdge(unsigned int sndRightWinEdge)
virtual unsigned int getSndRate() const
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
virtual const char * getProperty(const char *propertyname) const override
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual const char ** getPropertyNames() const override
virtual const char * getFieldStructName(int field) const override
unsigned int sndRightWinEdge
Definition: ControlPDU_m.h:543
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual int findField(const char *fieldName) const override
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual const char * getFieldStructName(int field) const override
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
virtual const char ** getPropertyNames() const override
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual const char ** getPropertyNames() const override
ControlAckPDU(const char *name=nullptr, int kind=0)
void copy(const ControlPDU &other)
virtual const char ** getFieldPropertyNames(int field) const override
virtual const char * getFieldTypeString(int field) const override
virtual void setNackListLen(unsigned int nackListLen)
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual const char * getFieldTypeString(int field) const override
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual int findField(const char *fieldName) const override
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual const char ** getPropertyNames() const override
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual const char ** getFieldPropertyNames(int field) const override
AckOnlyPDU & operator=(const AckOnlyPDU &other)
virtual unsigned int getFieldTypeFlags(int field) const override
virtual const char ** getPropertyNames() const override
virtual const char * getFieldTypeString(int field) const override
virtual const char ** getFieldPropertyNames(int field) const override
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual const char * getFieldTypeString(int field) const override
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual unsigned int getLastCtrlSeqNumRcv() const
virtual ~NAckPDU()
virtual bool doesSupport(omnetpp::cObject *obj) const override
RendezvousPDU & operator=(const RendezvousPDU &other)
virtual const char * getFieldName(int field) const override
ControlPDU & operator=(const ControlPDU &other)
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual int findField(const char *fieldName) const override
NackFlowPDU(const char *name=nullptr, int kind=0)
virtual void setTimeUnit(unsigned long timeUnit)
virtual unsigned int getSndLeftWinEdge() const
virtual bool doesSupport(omnetpp::cObject *obj) const override
SelectiveAckFlowPDU(const char *name=nullptr, int kind=0)
virtual ~ControlPDUDescriptor()
void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector< T, A > &v)
Definition: PDU_m.cc:22
virtual int getFieldCount() const override
virtual unsigned int getFieldTypeFlags(int field) const override
virtual const char * getFieldName(int field) const override
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual const char ** getPropertyNames() const override
virtual void setType(int type)
Definition: PDU_m.cc:351
virtual int getFieldArraySize(void *object, int field) const override
unsigned int newLeftWinEdge
Definition: ControlPDU_m.h:345
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual const char * getFieldTypeString(int field) const override
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual unsigned int getFieldTypeFlags(int field) const override
virtual unsigned int getRcvLeftWinEdge() const
unsigned int sndLeftWinEdge
Definition: ControlPDU_m.h:116
virtual int getFieldArraySize(void *object, int field) const override
virtual int getFieldArraySize(void *object, int field) const override
virtual unsigned int getNackListArraySize() const
virtual const char * getFieldStructName(int field) const override
void copy(const SelectiveAckPDU &other)
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
unsigned int sndRate
Definition: ControlPDU_m.h:118
void copy(const NAckPDU &other)
SelectiveAckPDU & operator=(const SelectiveAckPDU &other)
SelectiveNackPDU(const char *name=nullptr, int kind=0)
virtual ~SelectiveNackFlowPDU()
AckFlowPDU(const char *name=nullptr, int kind=0)
virtual unsigned int getFieldTypeFlags(int field) const override
unsigned int sndLeftWinEdge
Definition: ControlPDU_m.h:542
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
unsigned int rcvRate
Definition: ControlPDU_m.h:544
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual const char * getFieldName(int field) const override
unsigned int rcvRightWinEdge
Definition: ControlPDU_m.h:541
virtual unsigned int getRcvRate() const
virtual void setNackList(unsigned int k, unsigned int nackList)
virtual int findField(const char *fieldName) const override
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual const char * getProperty(const char *propertyname) const override
void copy(const SelectiveAckFlowPDU &other)
virtual unsigned int getFieldTypeFlags(int field) const override
Definition: PDU.h:42
virtual void setAckNackSeqNum(unsigned int ackNackSeqNum)
void copy(const FlowControlOnlyPDU &other)
virtual const char ** getFieldPropertyNames(int field) const override
virtual int findField(const char *fieldName) const override
virtual ~NackOnlyPDUDescriptor()
virtual int getFieldCount() const override
void copy(const FlowControlPDU &other)
virtual int getFieldCount() const override
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual int getFieldCount() const override
virtual void parsimPack(omnetpp::cCommBuffer *b) const
Definition: PDU_m.cc:242
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual const char * getProperty(const char *propertyname) const override
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual ~NackOnlyPDU()
virtual ~RendezvousPDU()
void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector< T, A > &v)
Definition: PDU_m.cc:31
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual const char * getFieldStructName(int field) const override
virtual unsigned int getFieldTypeFlags(int field) const override
virtual int getFieldArraySize(void *object, int field) const override
virtual unsigned int getNewLeftWinEdge() const
virtual const char ** getFieldPropertyNames(int field) const override
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual const char * getFieldStructName(int field) const override
virtual ~AckOnlyPDU()
virtual unsigned int getRcvRate() const
virtual const char ** getFieldPropertyNames(int field) const override
unsigned int rcvRate
Definition: ControlPDU_m.h:114
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
virtual ~SelectiveNAckFlow()
NAckPDU(const char *name=nullptr, int kind=0)
virtual const char * getFieldName(int field) const override
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
const char ** propertynames
virtual ~SelectiveAckPDU()
virtual int findField(const char *fieldName) const override
void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
Definition: PDU_m.cc:114
virtual void setRcvLeftWinEdge(unsigned int rcvLeftWinEdge)
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual unsigned int getFieldTypeFlags(int field) const override
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
virtual const char ** getFieldPropertyNames(int field) const override
virtual int getFieldArraySize(void *object, int field) const override
virtual int getFieldArraySize(void *object, int field) const override
virtual const char ** getFieldPropertyNames(int field) const override
virtual const char * getProperty(const char *propertyname) const override
virtual const char * getFieldProperty(int field, const char *propertyname) const override
unsigned long timeUnit
Definition: ControlPDU_m.h:115
virtual int findField(const char *fieldName) const override
virtual const char * getFieldName(int field) const override
const char ** propertynames
virtual int getFieldCount() const override
virtual unsigned int getFieldTypeFlags(int field) const override
unsigned int ackNackSeqNum
Definition: ControlPDU_m.h:70
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual ~RendezvousPDUDescriptor()
virtual const char * getFieldTypeString(int field) const override
Register_Class(ControlPDU)
virtual int getFieldCount() const override
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual ~NackFlowPDUDescriptor()
void copy(const NackFlowPDU &other)
virtual unsigned int getRcvRightWinEdge() const
virtual const char ** getPropertyNames() const override
virtual int getFieldCount() const override
virtual const char * getFieldTypeString(int field) const override
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
SelectiveNAckFlow(const char *name=nullptr, int kind=0)
virtual int getFieldCount() const override
virtual const char ** getPropertyNames() const override
ControlPDU(const char *name=nullptr, int kind=0)
RendezvousPDU(const char *name=nullptr, int kind=0)
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual const char ** getPropertyNames() const override
NackFlowPDU & operator=(const NackFlowPDU &other)
virtual const char * getFieldStructName(int field) const override
virtual const char * getProperty(const char *propertyname) const override
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual unsigned int getNackList(unsigned int k) const
virtual int getFieldArraySize(void *object, int field) const override
virtual const char * getFieldStructName(int field) const override
ControlAckPDU & operator=(const ControlAckPDU &other)
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual const char ** getPropertyNames() const override
AckOnlyPDU(const char *name=nullptr, int kind=0)
virtual const char * getProperty(const char *propertyname) const override
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
unsigned int lastCtrlSeqNumRcv
Definition: ControlPDU_m.h:539
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual void setRcvRate(unsigned int rcvRate)
virtual unsigned int getRendezSeqNum() const
virtual const char * getFieldName(int field) const override
unsigned int rcvRightWinEdge
Definition: ControlPDU_m.h:113
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
unsigned int * nackList
Definition: ControlPDU_m.h:347
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual unsigned int getNackListLen() const
virtual const char * getFieldTypeString(int field) const override
virtual int findField(const char *fieldName) const override
virtual unsigned int getFieldTypeFlags(int field) const override
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
void copy(const AckOnlyPDU &other)
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual ~ControlPDU()
virtual int getFieldCount() const override
virtual int getFieldArraySize(void *object, int field) const override
void copy(const NackOnlyPDU &other)
virtual ~ControlAckPDUDescriptor()
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
unsigned int rcvLeftWinEdge
Definition: ControlPDU_m.h:540
Definition: PDU_m.cc:15
FlowControlOnlyPDU(const char *name=nullptr, int kind=0)
const char ** propertynames
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual ~SelectiveAckFlowPDU()
FlowControlPDU & operator=(const FlowControlPDU &other)
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual void setLastCtrlSeqNumRcv(unsigned int lastCtrlSeqNumRcv)
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
Definition: PDU_m.cc:259
virtual int findField(const char *fieldName) const override
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
SelectiveNackFlowPDU(const char *name=nullptr, int kind=0)
virtual int findField(const char *fieldName) const override
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
virtual void setRcvRightWinEdge(unsigned int rcvRightWinEdge)
virtual const char * getFieldName(int field) const override
Register_ClassDescriptor(ControlPDUDescriptor)
virtual const char * getFieldName(int field) const override
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual void setSndRate(unsigned int sndRate)
virtual void parsimPack(omnetpp::cCommBuffer *b) const
const char ** propertynames
void copy(const RendezvousPDU &other)
virtual ~SelectiveNackPDU()
virtual const char ** getFieldPropertyNames(int field) const override
virtual void setSndRightWinEdge(unsigned int sndRightWinEdge)
virtual void setNackListArraySize(unsigned int size)
virtual const char * getFieldStructName(int field) const override
virtual const char ** getFieldPropertyNames(int field) const override
virtual const char * getProperty(const char *propertyname) const override
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual const char * getProperty(const char *propertyname) const override
virtual void setSndLeftWinEdge(unsigned int sndLeftWinEdge)
virtual const char * getFieldProperty(int field, const char *propertyname) const override
void copy(const SelectiveNackFlowPDU &other)
void copy(const SelectiveNAckFlow &other)
unsigned int nackListLen
Definition: ControlPDU_m.h:346
virtual unsigned int getAckNackSeqNum() const
unsigned int sndRightWinEdge
Definition: ControlPDU_m.h:117
virtual const char ** getFieldPropertyNames(int field) const override
FlowControlOnlyPDU & operator=(const FlowControlOnlyPDU &other)
virtual const char * getFieldName(int field) const override
virtual const char * getProperty(const char *propertyname) const override
virtual ~ControlAckPDU()
virtual ~NackFlowPDU()
virtual ~NAckPDUDescriptor()
virtual int findField(const char *fieldName) const override
SelectiveAckPDU(const char *name=nullptr, int kind=0)
virtual unsigned int getSndRightWinEdge() const
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual int getFieldArraySize(void *object, int field) const override
virtual unsigned int getSndLeftWinEdge() const
virtual bool doesSupport(omnetpp::cObject *obj) const override
std::ostream & operator<<(std::ostream &out, const std::vector< T, A > &vec)
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual const char * getFieldTypeString(int field) const override
virtual const char * getFieldName(int field) const override
virtual const char * getFieldStructName(int field) const override
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual ~FlowControlPDU()
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual unsigned int getFieldTypeFlags(int field) const override
virtual unsigned int getRcvRightWinEdge() const
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
SelectiveAckFlowPDU & operator=(const SelectiveAckFlowPDU &other)
const char ** propertynames
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual const char * getFieldName(int field) const override
virtual const char ** getPropertyNames() const override
virtual void setRendezSeqNum(unsigned int rendezSeqNum)
const char ** propertynames
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual const char * getFieldName(int field) const override
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
virtual bool doesSupport(omnetpp::cObject *obj) const override
AckFlowPDU & operator=(const AckFlowPDU &other)
virtual void setSndLeftWinEdge(unsigned int sndLeftWinEdge)
virtual int findField(const char *fieldName) const override
virtual int getFieldCount() const override
virtual const char * getFieldStructName(int field) const override
virtual const char * getFieldProperty(int field, const char *propertyname) const override
virtual unsigned long getTimeUnit() const
virtual void parsimPack(omnetpp::cCommBuffer *b) const
virtual bool doesSupport(omnetpp::cObject *obj) const override
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
const char ** propertynames
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
virtual const char * getFieldTypeString(int field) const override
virtual const char * getFieldStructName(int field) const override
virtual const char * getProperty(const char *propertyname) const override
virtual int findField(const char *fieldName) const override
virtual int getFieldArraySize(void *object, int field) const override
virtual int getFieldArraySize(void *object, int field) const override
virtual int getFieldCount() const override
virtual int getFieldCount() const override
void copy(const SelectiveNackPDU &other)
void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
Definition: PDU_m.cc:107
virtual ~AckFlowPDU()
for($i=0;$i< $p;$i++) for($i=0;$i< $p;$i++) for($i=0;$i< $f;$i++) for($i=0;$i< $e;$i++) for($i=0;$i< $p;$i++) for($i=0;$i< $p;$i++) for($i=0;$i< $e;$i++) for($i=0;$i< $f;$i++)
Definition: ini.php:169
virtual const char * getFieldTypeString(int field) const override
virtual void parsimPack(omnetpp::cCommBuffer *b) const
unsigned int nackList_arraysize
Definition: ControlPDU_m.h:348
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
virtual const char * getFieldProperty(int field, const char *propertyname) const override
SelectiveNackPDU & operator=(const SelectiveNackPDU &other)
virtual const char ** getFieldPropertyNames(int field) const override
virtual const char * getFieldStructName(int field) const override
virtual const char * getProperty(const char *propertyname) const override