RINASim  October 2016
Documentation of framework for OMNeT++
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
PDU_m.cc
Go to the documentation of this file.
1 //
2 // Generated file, do not edit! Created by nedtool 5.0 from Common/PDU.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 "PDU_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  omnetpp::cEnum *e = omnetpp::cEnum::find("PDUType");
166  if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("PDUType"));
167  e->insert(MANAGEMENT_PDU, "MANAGEMENT_PDU");
168  e->insert(DATA_TRANSFER_PDU, "DATA_TRANSFER_PDU");
169  e->insert(CONTROL_ACK_PDU, "CONTROL_ACK_PDU");
170  e->insert(ACK_ONLY_PDU, "ACK_ONLY_PDU");
171  e->insert(NACK_ONLY_PDU, "NACK_ONLY_PDU");
172  e->insert(FLOW_ONLY_PDU, "FLOW_ONLY_PDU");
173  e->insert(ACK_FLOW_PDU, "ACK_FLOW_PDU");
174  e->insert(NACK_FLOW_PDU, "NACK_FLOW_PDU");
175  e->insert(SELECT_ACK_PDU, "SELECT_ACK_PDU");
176  e->insert(SELECT_NACK_PDU, "SELECT_NACK_PDU");
177  e->insert(SELECT_ACK_FLOW_PDU, "SELECT_ACK_FLOW_PDU");
178  e->insert(SELECT_NACK_FLOW_PDU, "SELECT_NACK_FLOW_PDU");
179  e->insert(RENDEZVOUS_PDU, "RENDEZVOUS_PDU");
180 );
181 
183  omnetpp::cEnum *e = omnetpp::cEnum::find("PDUTypeBits");
184  if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("PDUTypeBits"));
185  e->insert(PDU_ACK_BIT, "PDU_ACK_BIT");
186  e->insert(PDU_NACK_BIT, "PDU_NACK_BIT");
187  e->insert(PDU_FC_BIT, "PDU_FC_BIT");
188  e->insert(PDU_SEL_BIT, "PDU_SEL_BIT");
189 );
190 
192  omnetpp::cEnum *e = omnetpp::cEnum::find("FLAGS");
193  if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("FLAGS"));
194 );
195 
196 PDU_Base::PDU_Base(const char *name, int kind) : ::omnetpp::cPacket(name,kind)
197 {
198  this->setByteLength(10);
199  this->setSchedulingPriority(-1);
200 
201  this->version = 1;
202  this->type = 0;
203  this->flags = 0;
204  this->pduLen = PDU_HEADER_LEN;
205  this->seqNum = 0;
206  this->hopCount = 255;
207 }
208 
209 PDU_Base::PDU_Base(const PDU_Base& other) : ::omnetpp::cPacket(other)
210 {
211  copy(other);
212 }
213 
215 {
216 }
217 
219 {
220  if (this==&other) return *this;
221  ::omnetpp::cPacket::operator=(other);
222  copy(other);
223  return *this;
224 }
225 
226 void PDU_Base::copy(const PDU_Base& other)
227 {
228  this->displayString = other.displayString;
229  this->version = other.version;
230  this->srcAddr = other.srcAddr;
231  this->dstAddr = other.dstAddr;
232  this->srcApn = other.srcApn;
233  this->dstApn = other.dstApn;
234  this->connId = other.connId;
235  this->type = other.type;
236  this->flags = other.flags;
237  this->pduLen = other.pduLen;
238  this->seqNum = other.seqNum;
239  this->hopCount = other.hopCount;
240 }
241 
242 void PDU_Base::parsimPack(omnetpp::cCommBuffer *b) const
243 {
244  ::omnetpp::cPacket::parsimPack(b);
246  doParsimPacking(b,this->version);
247  doParsimPacking(b,this->srcAddr);
248  doParsimPacking(b,this->dstAddr);
249  doParsimPacking(b,this->srcApn);
250  doParsimPacking(b,this->dstApn);
251  doParsimPacking(b,this->connId);
252  doParsimPacking(b,this->type);
253  doParsimPacking(b,this->flags);
254  doParsimPacking(b,this->pduLen);
255  doParsimPacking(b,this->seqNum);
256  doParsimPacking(b,this->hopCount);
257 }
258 
259 void PDU_Base::parsimUnpack(omnetpp::cCommBuffer *b)
260 {
261  ::omnetpp::cPacket::parsimUnpack(b);
263  doParsimUnpacking(b,this->version);
264  doParsimUnpacking(b,this->srcAddr);
265  doParsimUnpacking(b,this->dstAddr);
266  doParsimUnpacking(b,this->srcApn);
267  doParsimUnpacking(b,this->dstApn);
268  doParsimUnpacking(b,this->connId);
269  doParsimUnpacking(b,this->type);
270  doParsimUnpacking(b,this->flags);
271  doParsimUnpacking(b,this->pduLen);
272  doParsimUnpacking(b,this->seqNum);
273  doParsimUnpacking(b,this->hopCount);
274 }
275 
276 const char * PDU_Base::getDisplayString() const
277 {
278  return this->displayString.c_str();
279 }
280 
281 void PDU_Base::setDisplayString(const char * displayString)
282 {
283  this->displayString = displayString;
284 }
285 
286 unsigned int PDU_Base::getVersion() const
287 {
288  return this->version;
289 }
290 
291 void PDU_Base::setVersion(unsigned int version)
292 {
293  this->version = version;
294 }
295 
297 {
298  return this->srcAddr;
299 }
300 
301 void PDU_Base::setSrcAddr(const Address& srcAddr)
302 {
303  this->srcAddr = srcAddr;
304 }
305 
307 {
308  return this->dstAddr;
309 }
310 
311 void PDU_Base::setDstAddr(const Address& dstAddr)
312 {
313  this->dstAddr = dstAddr;
314 }
315 
317 {
318  return this->srcApn;
319 }
320 
321 void PDU_Base::setSrcApn(const APN& srcApn)
322 {
323  this->srcApn = srcApn;
324 }
325 
327 {
328  return this->dstApn;
329 }
330 
331 void PDU_Base::setDstApn(const APN& dstApn)
332 {
333  this->dstApn = dstApn;
334 }
335 
337 {
338  return this->connId;
339 }
340 
342 {
343  this->connId = connId;
344 }
345 
346 int PDU_Base::getType() const
347 {
348  return this->type;
349 }
350 
351 void PDU_Base::setType(int type)
352 {
353  this->type = type;
354 }
355 
357 {
358  return this->flags;
359 }
360 
361 void PDU_Base::setFlags(int flags)
362 {
363  this->flags = flags;
364 }
365 
366 unsigned int PDU_Base::getPduLen() const
367 {
368  return this->pduLen;
369 }
370 
371 void PDU_Base::setPduLen(unsigned int pduLen)
372 {
373  this->pduLen = pduLen;
374 }
375 
376 unsigned int PDU_Base::getSeqNum() const
377 {
378  return this->seqNum;
379 }
380 
381 void PDU_Base::setSeqNum(unsigned int seqNum)
382 {
383  this->seqNum = seqNum;
384 }
385 
386 unsigned int PDU_Base::getHopCount() const
387 {
388  return this->hopCount;
389 }
390 
391 void PDU_Base::setHopCount(unsigned int hopCount)
392 {
393  this->hopCount = hopCount;
394 }
395 
396 class PDUDescriptor : public omnetpp::cClassDescriptor
397 {
398  private:
399  mutable const char **propertynames;
400  public:
401  PDUDescriptor();
402  virtual ~PDUDescriptor();
403 
404  virtual bool doesSupport(omnetpp::cObject *obj) const override;
405  virtual const char **getPropertyNames() const override;
406  virtual const char *getProperty(const char *propertyname) const override;
407  virtual int getFieldCount() const override;
408  virtual const char *getFieldName(int field) const override;
409  virtual int findField(const char *fieldName) const override;
410  virtual unsigned int getFieldTypeFlags(int field) const override;
411  virtual const char *getFieldTypeString(int field) const override;
412  virtual const char **getFieldPropertyNames(int field) const override;
413  virtual const char *getFieldProperty(int field, const char *propertyname) const override;
414  virtual int getFieldArraySize(void *object, int field) const override;
415 
416  virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
417  virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
418 
419  virtual const char *getFieldStructName(int field) const override;
420  virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
421 };
422 
424 
425 PDUDescriptor::PDUDescriptor() : omnetpp::cClassDescriptor("PDU", "omnetpp::cPacket")
426 {
427  propertynames = nullptr;
428 }
429 
431 {
432  delete[] propertynames;
433 }
434 
435 bool PDUDescriptor::doesSupport(omnetpp::cObject *obj) const
436 {
437  return dynamic_cast<PDU_Base *>(obj)!=nullptr;
438 }
439 
441 {
442  if (!propertynames) {
443  static const char *names[] = { "customize", nullptr };
444  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
445  const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
446  propertynames = mergeLists(basenames, names);
447  }
448  return propertynames;
449 }
450 
451 const char *PDUDescriptor::getProperty(const char *propertyname) const
452 {
453  if (!strcmp(propertyname,"customize")) return "true";
454  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
455  return basedesc ? basedesc->getProperty(propertyname) : nullptr;
456 }
457 
459 {
460  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
461  return basedesc ? 12+basedesc->getFieldCount() : 12;
462 }
463 
464 unsigned int PDUDescriptor::getFieldTypeFlags(int field) const
465 {
466  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
467  if (basedesc) {
468  if (field < basedesc->getFieldCount())
469  return basedesc->getFieldTypeFlags(field);
470  field -= basedesc->getFieldCount();
471  }
472  static unsigned int fieldTypeFlags[] = {
473  FD_ISEDITABLE,
474  FD_ISEDITABLE,
475  FD_ISCOMPOUND,
476  FD_ISCOMPOUND,
477  FD_ISCOMPOUND,
478  FD_ISCOMPOUND,
479  FD_ISCOMPOUND,
480  FD_ISEDITABLE,
481  FD_ISEDITABLE,
482  FD_ISEDITABLE,
483  FD_ISEDITABLE,
484  FD_ISEDITABLE,
485  };
486  return (field>=0 && field<12) ? fieldTypeFlags[field] : 0;
487 }
488 
489 const char *PDUDescriptor::getFieldName(int field) const
490 {
491  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
492  if (basedesc) {
493  if (field < basedesc->getFieldCount())
494  return basedesc->getFieldName(field);
495  field -= basedesc->getFieldCount();
496  }
497  static const char *fieldNames[] = {
498  "displayString",
499  "version",
500  "srcAddr",
501  "dstAddr",
502  "srcApn",
503  "dstApn",
504  "connId",
505  "type",
506  "flags",
507  "pduLen",
508  "seqNum",
509  "hopCount",
510  };
511  return (field>=0 && field<12) ? fieldNames[field] : nullptr;
512 }
513 
514 int PDUDescriptor::findField(const char *fieldName) const
515 {
516  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
517  int base = basedesc ? basedesc->getFieldCount() : 0;
518  if (fieldName[0]=='d' && strcmp(fieldName, "displayString")==0) return base+0;
519  if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
520  if (fieldName[0]=='s' && strcmp(fieldName, "srcAddr")==0) return base+2;
521  if (fieldName[0]=='d' && strcmp(fieldName, "dstAddr")==0) return base+3;
522  if (fieldName[0]=='s' && strcmp(fieldName, "srcApn")==0) return base+4;
523  if (fieldName[0]=='d' && strcmp(fieldName, "dstApn")==0) return base+5;
524  if (fieldName[0]=='c' && strcmp(fieldName, "connId")==0) return base+6;
525  if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+7;
526  if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+8;
527  if (fieldName[0]=='p' && strcmp(fieldName, "pduLen")==0) return base+9;
528  if (fieldName[0]=='s' && strcmp(fieldName, "seqNum")==0) return base+10;
529  if (fieldName[0]=='h' && strcmp(fieldName, "hopCount")==0) return base+11;
530  return basedesc ? basedesc->findField(fieldName) : -1;
531 }
532 
533 const char *PDUDescriptor::getFieldTypeString(int field) const
534 {
535  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
536  if (basedesc) {
537  if (field < basedesc->getFieldCount())
538  return basedesc->getFieldTypeString(field);
539  field -= basedesc->getFieldCount();
540  }
541  static const char *fieldTypeStrings[] = {
542  "string",
543  "unsigned int",
544  "Address",
545  "Address",
546  "APN",
547  "APN",
548  "ConnectionId",
549  "int",
550  "int",
551  "unsigned int",
552  "unsigned int",
553  "unsigned int",
554  };
555  return (field>=0 && field<12) ? fieldTypeStrings[field] : nullptr;
556 }
557 
558 const char **PDUDescriptor::getFieldPropertyNames(int field) const
559 {
560  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
561  if (basedesc) {
562  if (field < basedesc->getFieldCount())
563  return basedesc->getFieldPropertyNames(field);
564  field -= basedesc->getFieldCount();
565  }
566  switch (field) {
567  case 7: {
568  static const char *names[] = { "enum", nullptr };
569  return names;
570  }
571  default: return nullptr;
572  }
573 }
574 
575 const char *PDUDescriptor::getFieldProperty(int field, const char *propertyname) const
576 {
577  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
578  if (basedesc) {
579  if (field < basedesc->getFieldCount())
580  return basedesc->getFieldProperty(field, propertyname);
581  field -= basedesc->getFieldCount();
582  }
583  switch (field) {
584  case 7:
585  if (!strcmp(propertyname,"enum")) return "PDUType";
586  return nullptr;
587  default: return nullptr;
588  }
589 }
590 
591 int PDUDescriptor::getFieldArraySize(void *object, int field) const
592 {
593  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
594  if (basedesc) {
595  if (field < basedesc->getFieldCount())
596  return basedesc->getFieldArraySize(object, field);
597  field -= basedesc->getFieldCount();
598  }
599  PDU_Base *pp = (PDU_Base *)object; (void)pp;
600  switch (field) {
601  default: return 0;
602  }
603 }
604 
605 std::string PDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
606 {
607  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
608  if (basedesc) {
609  if (field < basedesc->getFieldCount())
610  return basedesc->getFieldValueAsString(object,field,i);
611  field -= basedesc->getFieldCount();
612  }
613  PDU_Base *pp = (PDU_Base *)object; (void)pp;
614  switch (field) {
615  case 0: return oppstring2string(pp->getDisplayString());
616  case 1: return ulong2string(pp->getVersion());
617  case 2: {std::stringstream out; out << pp->getSrcAddr(); return out.str();}
618  case 3: {std::stringstream out; out << pp->getDstAddr(); return out.str();}
619  case 4: {std::stringstream out; out << pp->getSrcApn(); return out.str();}
620  case 5: {std::stringstream out; out << pp->getDstApn(); return out.str();}
621  case 6: {std::stringstream out; out << pp->getConnId(); return out.str();}
622  case 7: return enum2string(pp->getType(), "PDUType");
623  case 8: return long2string(pp->getFlags());
624  case 9: return ulong2string(pp->getPduLen());
625  case 10: return ulong2string(pp->getSeqNum());
626  case 11: return ulong2string(pp->getHopCount());
627  default: return "";
628  }
629 }
630 
631 bool PDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
632 {
633  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
634  if (basedesc) {
635  if (field < basedesc->getFieldCount())
636  return basedesc->setFieldValueAsString(object,field,i,value);
637  field -= basedesc->getFieldCount();
638  }
639  PDU_Base *pp = (PDU_Base *)object; (void)pp;
640  switch (field) {
641  case 0: pp->setDisplayString((value)); return true;
642  case 1: pp->setVersion(string2ulong(value)); return true;
643  case 7: pp->setType((PDUType)string2enum(value, "PDUType")); return true;
644  case 8: pp->setFlags(string2long(value)); return true;
645  case 9: pp->setPduLen(string2ulong(value)); return true;
646  case 10: pp->setSeqNum(string2ulong(value)); return true;
647  case 11: pp->setHopCount(string2ulong(value)); return true;
648  default: return false;
649  }
650 }
651 
652 const char *PDUDescriptor::getFieldStructName(int field) const
653 {
654  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
655  if (basedesc) {
656  if (field < basedesc->getFieldCount())
657  return basedesc->getFieldStructName(field);
658  field -= basedesc->getFieldCount();
659  }
660  switch (field) {
661  case 2: return omnetpp::opp_typename(typeid(Address));
662  case 3: return omnetpp::opp_typename(typeid(Address));
663  case 4: return omnetpp::opp_typename(typeid(APN));
664  case 5: return omnetpp::opp_typename(typeid(APN));
665  case 6: return omnetpp::opp_typename(typeid(ConnectionId));
666  default: return nullptr;
667  };
668 }
669 
670 void *PDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
671 {
672  omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
673  if (basedesc) {
674  if (field < basedesc->getFieldCount())
675  return basedesc->getFieldStructValuePointer(object, field, i);
676  field -= basedesc->getFieldCount();
677  }
678  PDU_Base *pp = (PDU_Base *)object; (void)pp;
679  switch (field) {
680  case 2: return (void *)(&pp->getSrcAddr()); break;
681  case 3: return (void *)(&pp->getDstAddr()); break;
682  case 4: return (void *)(&pp->getSrcApn()); break;
683  case 5: return (void *)(&pp->getDstApn()); break;
684  case 6: return (void *)(&pp->getConnId()); break;
685  default: return nullptr;
686  }
687 }
688 
689 
int flags
Definition: PDU_m.h:183
const char ** propertynames
Definition: PDU_m.cc:399
virtual const char * getDisplayString() const
Definition: PDU_m.cc:276
virtual void setPduLen(unsigned int pduLen)
Definition: PDU_m.cc:371
ConnectionId connId
Definition: PDU_m.h:181
int type
Definition: PDU_m.h:182
virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override
Definition: PDU_m.cc:631
virtual APN & getSrcApn()
Definition: PDU_m.cc:316
void doParsimUnpacking(omnetpp::cCommBuffer *, T &t)
Definition: PDU_m.cc:128
virtual ~PDU_Base()
Definition: PDU_m.cc:214
Application Process Name class.
Definition: APN.h:36
void copy(const PDU_Base &other)
Definition: PDU_m.cc:226
APN srcApn
Definition: PDU_m.h:179
unsigned int hopCount
Definition: PDU_m.h:186
virtual int findField(const char *fieldName) const override
Definition: PDU_m.cc:514
Register_ClassDescriptor(PDUDescriptor)
virtual unsigned int getFieldTypeFlags(int field) const override
Definition: PDU_m.cc:464
unsigned int pduLen
Definition: PDU_m.h:184
PDU_Base(const char *name=nullptr, int kind=0)
Definition: PDU_m.cc:196
virtual void setDstApn(const APN &dstApn)
Definition: PDU_m.cc:331
virtual void setHopCount(unsigned int hopCount)
Definition: PDU_m.cc:391
Connection identifier as defined in specifications.
Definition: ConnectionId.h:42
void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector< T, A > &v)
Definition: PDU_m.cc:22
virtual void setSrcAddr(const Address &srcAddr)
Definition: PDU_m.cc:301
virtual void setType(int type)
Definition: PDU_m.cc:351
virtual ConnectionId & getConnId()
Definition: PDU_m.cc:336
virtual void setDstAddr(const Address &dstAddr)
Definition: PDU_m.cc:311
virtual bool doesSupport(omnetpp::cObject *obj) const override
Definition: PDU_m.cc:435
virtual const char * getFieldName(int field) const override
Definition: PDU_m.cc:489
virtual int getFieldCount() const override
Definition: PDU_m.cc:458
virtual const char * getProperty(const char *propertyname) const override
Definition: PDU_m.cc:451
virtual void setFlags(int flags)
Definition: PDU_m.cc:361
virtual ~PDUDescriptor()
Definition: PDU_m.cc:430
virtual APN & getDstApn()
Definition: PDU_m.cc:326
virtual void parsimPack(omnetpp::cCommBuffer *b) const
Definition: PDU_m.cc:242
virtual void setVersion(unsigned int version)
Definition: PDU_m.cc:291
virtual unsigned int getVersion() const
Definition: PDU_m.cc:286
void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector< T, A > &v)
Definition: PDU_m.cc:31
PDU_Base & operator=(const PDU_Base &other)
Definition: PDU_m.cc:218
Address dstAddr
Definition: PDU_m.h:178
void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
Definition: PDU_m.cc:114
virtual unsigned int getPduLen() const
Definition: PDU_m.cc:366
virtual const char ** getPropertyNames() const override
Definition: PDU_m.cc:440
virtual void * getFieldStructValuePointer(void *object, int field, int i) const override
Definition: PDU_m.cc:670
virtual unsigned int getSeqNum() const
Definition: PDU_m.cc:376
virtual Address & getDstAddr()
Definition: PDU_m.cc:306
void doParsimPacking(omnetpp::cCommBuffer *, const T &t)
Definition: PDU_m.cc:122
virtual Address & getSrcAddr()
Definition: PDU_m.cc:296
virtual void setSeqNum(unsigned int seqNum)
Definition: PDU_m.cc:381
EXECUTE_ON_STARTUP(omnetpp::cEnum *e=omnetpp::cEnum::find("PDUType");if(!e) omnetpp::enums.getInstance() ->add(e=new omnetpp::cEnum("PDUType"));e->insert(MANAGEMENT_PDU,"MANAGEMENT_PDU");e->insert(DATA_TRANSFER_PDU,"DATA_TRANSFER_PDU");e->insert(CONTROL_ACK_PDU,"CONTROL_ACK_PDU");e->insert(ACK_ONLY_PDU,"ACK_ONLY_PDU");e->insert(NACK_ONLY_PDU,"NACK_ONLY_PDU");e->insert(FLOW_ONLY_PDU,"FLOW_ONLY_PDU");e->insert(ACK_FLOW_PDU,"ACK_FLOW_PDU");e->insert(NACK_FLOW_PDU,"NACK_FLOW_PDU");e->insert(SELECT_ACK_PDU,"SELECT_ACK_PDU");e->insert(SELECT_NACK_PDU,"SELECT_NACK_PDU");e->insert(SELECT_ACK_FLOW_PDU,"SELECT_ACK_FLOW_PDU");e->insert(SELECT_NACK_FLOW_PDU,"SELECT_NACK_FLOW_PDU");e->insert(RENDEZVOUS_PDU,"RENDEZVOUS_PDU");)
virtual void setDisplayString(const char *displayString)
Definition: PDU_m.cc:281
virtual const char * getFieldTypeString(int field) const override
Definition: PDU_m.cc:533
PDUDescriptor()
Definition: PDU_m.cc:425
virtual void setSrcApn(const APN &srcApn)
Definition: PDU_m.cc:321
virtual const char * getFieldStructName(int field) const override
Definition: PDU_m.cc:652
virtual int getType() const
Definition: PDU_m.cc:346
::omnetpp::opp_string displayString
Definition: PDU_m.h:175
virtual const char ** getFieldPropertyNames(int field) const override
Definition: PDU_m.cc:558
virtual std::string getFieldValueAsString(void *object, int field, int i) const override
Definition: PDU_m.cc:605
PDUType
Definition: PDU_m.h:59
Definition: PDU_m.cc:15
virtual void parsimUnpack(omnetpp::cCommBuffer *b)
Definition: PDU_m.cc:259
unsigned int seqNum
Definition: PDU_m.h:185
Address srcAddr
Definition: PDU_m.h:177
unsigned int version
Definition: PDU_m.h:176
virtual int getFlags() const
Definition: PDU_m.cc:356
virtual unsigned int getHopCount() const
Definition: PDU_m.cc:386
virtual int getFieldArraySize(void *object, int field) const override
Definition: PDU_m.cc:591
APN dstApn
Definition: PDU_m.h:180
virtual const char * getFieldProperty(int field, const char *propertyname) const override
Definition: PDU_m.cc:575
virtual void setConnId(const ConnectionId &connId)
Definition: PDU_m.cc:341
Address class holds IPC Process identification.
Definition: Address.h:42
std::ostream & operator<<(std::ostream &out, const std::vector< T, A > &vec)
Definition: PDU_m.cc:146
void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
Definition: PDU_m.cc:107
#define PDU_HEADER_LEN
Definition: PDU_m.h:19