|
@@ -0,0 +1,537 @@
|
|
|
+//
|
|
|
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/ack.msg.
|
|
|
+//
|
|
|
+
|
|
|
+// Disable warnings about unused variables, empty switch stmts, etc:
|
|
|
+#ifdef _MSC_VER
|
|
|
+# pragma warning(disable:4101)
|
|
|
+# pragma warning(disable:4065)
|
|
|
+#endif
|
|
|
+
|
|
|
+#if defined(__clang__)
|
|
|
+# pragma clang diagnostic ignored "-Wshadow"
|
|
|
+# pragma clang diagnostic ignored "-Wconversion"
|
|
|
+# pragma clang diagnostic ignored "-Wunused-parameter"
|
|
|
+# pragma clang diagnostic ignored "-Wc++98-compat"
|
|
|
+# pragma clang diagnostic ignored "-Wunreachable-code-break"
|
|
|
+# pragma clang diagnostic ignored "-Wold-style-cast"
|
|
|
+#elif defined(__GNUC__)
|
|
|
+# pragma GCC diagnostic ignored "-Wshadow"
|
|
|
+# pragma GCC diagnostic ignored "-Wconversion"
|
|
|
+# pragma GCC diagnostic ignored "-Wunused-parameter"
|
|
|
+# pragma GCC diagnostic ignored "-Wold-style-cast"
|
|
|
+# pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
|
|
|
+# pragma GCC diagnostic ignored "-Wfloat-conversion"
|
|
|
+#endif
|
|
|
+
|
|
|
+#include <iostream>
|
|
|
+#include <sstream>
|
|
|
+#include "ack_m.h"
|
|
|
+
|
|
|
+namespace omnetpp {
|
|
|
+
|
|
|
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
|
|
|
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
|
|
|
+
|
|
|
+// Packing/unpacking an std::vector
|
|
|
+template<typename T, typename A>
|
|
|
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
|
|
|
+{
|
|
|
+ int n = v.size();
|
|
|
+ doParsimPacking(buffer, n);
|
|
|
+ for (int i = 0; i < n; i++)
|
|
|
+ doParsimPacking(buffer, v[i]);
|
|
|
+}
|
|
|
+
|
|
|
+template<typename T, typename A>
|
|
|
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
|
|
|
+{
|
|
|
+ int n;
|
|
|
+ doParsimUnpacking(buffer, n);
|
|
|
+ v.resize(n);
|
|
|
+ for (int i = 0; i < n; i++)
|
|
|
+ doParsimUnpacking(buffer, v[i]);
|
|
|
+}
|
|
|
+
|
|
|
+// Packing/unpacking an std::list
|
|
|
+template<typename T, typename A>
|
|
|
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
|
|
|
+{
|
|
|
+ doParsimPacking(buffer, (int)l.size());
|
|
|
+ for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
|
|
|
+ doParsimPacking(buffer, (T&)*it);
|
|
|
+}
|
|
|
+
|
|
|
+template<typename T, typename A>
|
|
|
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
|
|
|
+{
|
|
|
+ int n;
|
|
|
+ doParsimUnpacking(buffer, n);
|
|
|
+ for (int i=0; i<n; i++) {
|
|
|
+ l.push_back(T());
|
|
|
+ doParsimUnpacking(buffer, l.back());
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// Packing/unpacking an std::set
|
|
|
+template<typename T, typename Tr, typename A>
|
|
|
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
|
|
|
+{
|
|
|
+ doParsimPacking(buffer, (int)s.size());
|
|
|
+ for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
|
|
|
+ doParsimPacking(buffer, *it);
|
|
|
+}
|
|
|
+
|
|
|
+template<typename T, typename Tr, typename A>
|
|
|
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
|
|
|
+{
|
|
|
+ int n;
|
|
|
+ doParsimUnpacking(buffer, n);
|
|
|
+ for (int i=0; i<n; i++) {
|
|
|
+ T x;
|
|
|
+ doParsimUnpacking(buffer, x);
|
|
|
+ s.insert(x);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// Packing/unpacking an std::map
|
|
|
+template<typename K, typename V, typename Tr, typename A>
|
|
|
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
|
|
|
+{
|
|
|
+ doParsimPacking(buffer, (int)m.size());
|
|
|
+ for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
|
|
|
+ doParsimPacking(buffer, it->first);
|
|
|
+ doParsimPacking(buffer, it->second);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+template<typename K, typename V, typename Tr, typename A>
|
|
|
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
|
|
|
+{
|
|
|
+ int n;
|
|
|
+ doParsimUnpacking(buffer, n);
|
|
|
+ for (int i=0; i<n; i++) {
|
|
|
+ K k; V v;
|
|
|
+ doParsimUnpacking(buffer, k);
|
|
|
+ doParsimUnpacking(buffer, v);
|
|
|
+ m[k] = v;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// Default pack/unpack function for arrays
|
|
|
+template<typename T>
|
|
|
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
|
|
|
+{
|
|
|
+ for (int i = 0; i < n; i++)
|
|
|
+ doParsimPacking(b, t[i]);
|
|
|
+}
|
|
|
+
|
|
|
+template<typename T>
|
|
|
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
|
|
|
+{
|
|
|
+ for (int i = 0; i < n; i++)
|
|
|
+ doParsimUnpacking(b, t[i]);
|
|
|
+}
|
|
|
+
|
|
|
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
|
|
|
+template<typename T>
|
|
|
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
|
|
|
+{
|
|
|
+ throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
|
|
|
+}
|
|
|
+
|
|
|
+template<typename T>
|
|
|
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
|
|
|
+{
|
|
|
+ throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace omnetpp
|
|
|
+
|
|
|
+
|
|
|
+// forward
|
|
|
+template<typename T, typename A>
|
|
|
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
|
|
|
+
|
|
|
+// Template rule which fires if a struct or class doesn't have operator<<
|
|
|
+template<typename T>
|
|
|
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
|
|
|
+
|
|
|
+// operator<< for std::vector<T>
|
|
|
+template<typename T, typename A>
|
|
|
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
|
|
|
+{
|
|
|
+ out.put('{');
|
|
|
+ for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
|
|
|
+ {
|
|
|
+ if (it != vec.begin()) {
|
|
|
+ out.put(','); out.put(' ');
|
|
|
+ }
|
|
|
+ out << *it;
|
|
|
+ }
|
|
|
+ out.put('}');
|
|
|
+
|
|
|
+ char buf[32];
|
|
|
+ sprintf(buf, " (size=%u)", (unsigned int)vec.size());
|
|
|
+ out.write(buf, strlen(buf));
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+Register_Class(Ack)
|
|
|
+
|
|
|
+Ack::Ack() : ::omnetpp::cObject()
|
|
|
+{
|
|
|
+ this->type = 0;
|
|
|
+ this->num_Blocks = 0;
|
|
|
+ this->largest_Acknowledged = 0;
|
|
|
+ this->ack_Delay = 0;
|
|
|
+}
|
|
|
+
|
|
|
+Ack::Ack(const Ack& other) : ::omnetpp::cObject(other)
|
|
|
+{
|
|
|
+ copy(other);
|
|
|
+}
|
|
|
+
|
|
|
+Ack::~Ack()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+Ack& Ack::operator=(const Ack& other)
|
|
|
+{
|
|
|
+ if (this==&other) return *this;
|
|
|
+ ::omnetpp::cObject::operator=(other);
|
|
|
+ copy(other);
|
|
|
+ return *this;
|
|
|
+}
|
|
|
+
|
|
|
+void Ack::copy(const Ack& other)
|
|
|
+{
|
|
|
+ this->type = other.type;
|
|
|
+ this->num_Blocks = other.num_Blocks;
|
|
|
+ this->largest_Acknowledged = other.largest_Acknowledged;
|
|
|
+ this->ack_Delay = other.ack_Delay;
|
|
|
+ this->ack_Block_Section = other.ack_Block_Section;
|
|
|
+}
|
|
|
+
|
|
|
+void Ack::parsimPack(omnetpp::cCommBuffer *b) const
|
|
|
+{
|
|
|
+ doParsimPacking(b,this->type);
|
|
|
+ doParsimPacking(b,this->num_Blocks);
|
|
|
+ doParsimPacking(b,this->largest_Acknowledged);
|
|
|
+ doParsimPacking(b,this->ack_Delay);
|
|
|
+ doParsimPacking(b,this->ack_Block_Section);
|
|
|
+}
|
|
|
+
|
|
|
+void Ack::parsimUnpack(omnetpp::cCommBuffer *b)
|
|
|
+{
|
|
|
+ doParsimUnpacking(b,this->type);
|
|
|
+ doParsimUnpacking(b,this->num_Blocks);
|
|
|
+ doParsimUnpacking(b,this->largest_Acknowledged);
|
|
|
+ doParsimUnpacking(b,this->ack_Delay);
|
|
|
+ doParsimUnpacking(b,this->ack_Block_Section);
|
|
|
+}
|
|
|
+
|
|
|
+uint8_t Ack::getType() const
|
|
|
+{
|
|
|
+ return this->type;
|
|
|
+}
|
|
|
+
|
|
|
+void Ack::setType(uint8_t type)
|
|
|
+{
|
|
|
+ this->type = type;
|
|
|
+}
|
|
|
+
|
|
|
+uint8_t Ack::getNum_Blocks() const
|
|
|
+{
|
|
|
+ return this->num_Blocks;
|
|
|
+}
|
|
|
+
|
|
|
+void Ack::setNum_Blocks(uint8_t num_Blocks)
|
|
|
+{
|
|
|
+ this->num_Blocks = num_Blocks;
|
|
|
+}
|
|
|
+
|
|
|
+uint64_t Ack::getLargest_Acknowledged() const
|
|
|
+{
|
|
|
+ return this->largest_Acknowledged;
|
|
|
+}
|
|
|
+
|
|
|
+void Ack::setLargest_Acknowledged(uint64_t largest_Acknowledged)
|
|
|
+{
|
|
|
+ this->largest_Acknowledged = largest_Acknowledged;
|
|
|
+}
|
|
|
+
|
|
|
+uint16_t Ack::getAck_Delay() const
|
|
|
+{
|
|
|
+ return this->ack_Delay;
|
|
|
+}
|
|
|
+
|
|
|
+void Ack::setAck_Delay(uint16_t ack_Delay)
|
|
|
+{
|
|
|
+ this->ack_Delay = ack_Delay;
|
|
|
+}
|
|
|
+
|
|
|
+const char * Ack::getAck_Block_Section() const
|
|
|
+{
|
|
|
+ return this->ack_Block_Section.c_str();
|
|
|
+}
|
|
|
+
|
|
|
+void Ack::setAck_Block_Section(const char * ack_Block_Section)
|
|
|
+{
|
|
|
+ this->ack_Block_Section = ack_Block_Section;
|
|
|
+}
|
|
|
+
|
|
|
+class AckDescriptor : public omnetpp::cClassDescriptor
|
|
|
+{
|
|
|
+ private:
|
|
|
+ mutable const char **propertynames;
|
|
|
+ public:
|
|
|
+ AckDescriptor();
|
|
|
+ virtual ~AckDescriptor();
|
|
|
+
|
|
|
+ virtual bool doesSupport(omnetpp::cObject *obj) const override;
|
|
|
+ virtual const char **getPropertyNames() const override;
|
|
|
+ virtual const char *getProperty(const char *propertyname) const override;
|
|
|
+ virtual int getFieldCount() const override;
|
|
|
+ virtual const char *getFieldName(int field) const override;
|
|
|
+ virtual int findField(const char *fieldName) const override;
|
|
|
+ virtual unsigned int getFieldTypeFlags(int field) const override;
|
|
|
+ virtual const char *getFieldTypeString(int field) const override;
|
|
|
+ virtual const char **getFieldPropertyNames(int field) const override;
|
|
|
+ virtual const char *getFieldProperty(int field, const char *propertyname) const override;
|
|
|
+ virtual int getFieldArraySize(void *object, int field) const override;
|
|
|
+
|
|
|
+ virtual const char *getFieldDynamicTypeString(void *object, int field, int i) 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;
|
|
|
+
|
|
|
+ virtual const char *getFieldStructName(int field) const override;
|
|
|
+ virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
|
|
|
+};
|
|
|
+
|
|
|
+Register_ClassDescriptor(AckDescriptor)
|
|
|
+
|
|
|
+AckDescriptor::AckDescriptor() : omnetpp::cClassDescriptor("Ack", "omnetpp::cObject")
|
|
|
+{
|
|
|
+ propertynames = nullptr;
|
|
|
+}
|
|
|
+
|
|
|
+AckDescriptor::~AckDescriptor()
|
|
|
+{
|
|
|
+ delete[] propertynames;
|
|
|
+}
|
|
|
+
|
|
|
+bool AckDescriptor::doesSupport(omnetpp::cObject *obj) const
|
|
|
+{
|
|
|
+ return dynamic_cast<Ack *>(obj)!=nullptr;
|
|
|
+}
|
|
|
+
|
|
|
+const char **AckDescriptor::getPropertyNames() const
|
|
|
+{
|
|
|
+ if (!propertynames) {
|
|
|
+ static const char *names[] = { nullptr };
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
|
|
|
+ propertynames = mergeLists(basenames, names);
|
|
|
+ }
|
|
|
+ return propertynames;
|
|
|
+}
|
|
|
+
|
|
|
+const char *AckDescriptor::getProperty(const char *propertyname) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ return basedesc ? basedesc->getProperty(propertyname) : nullptr;
|
|
|
+}
|
|
|
+
|
|
|
+int AckDescriptor::getFieldCount() const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ return basedesc ? 5+basedesc->getFieldCount() : 5;
|
|
|
+}
|
|
|
+
|
|
|
+unsigned int AckDescriptor::getFieldTypeFlags(int field) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->getFieldTypeFlags(field);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ static unsigned int fieldTypeFlags[] = {
|
|
|
+ FD_ISEDITABLE,
|
|
|
+ FD_ISEDITABLE,
|
|
|
+ FD_ISEDITABLE,
|
|
|
+ FD_ISEDITABLE,
|
|
|
+ FD_ISEDITABLE,
|
|
|
+ };
|
|
|
+ return (field>=0 && field<5) ? fieldTypeFlags[field] : 0;
|
|
|
+}
|
|
|
+
|
|
|
+const char *AckDescriptor::getFieldName(int field) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->getFieldName(field);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ static const char *fieldNames[] = {
|
|
|
+ "type",
|
|
|
+ "num_Blocks",
|
|
|
+ "largest_Acknowledged",
|
|
|
+ "ack_Delay",
|
|
|
+ "ack_Block_Section",
|
|
|
+ };
|
|
|
+ return (field>=0 && field<5) ? fieldNames[field] : nullptr;
|
|
|
+}
|
|
|
+
|
|
|
+int AckDescriptor::findField(const char *fieldName) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ int base = basedesc ? basedesc->getFieldCount() : 0;
|
|
|
+ if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
|
|
|
+ if (fieldName[0]=='n' && strcmp(fieldName, "num_Blocks")==0) return base+1;
|
|
|
+ if (fieldName[0]=='l' && strcmp(fieldName, "largest_Acknowledged")==0) return base+2;
|
|
|
+ if (fieldName[0]=='a' && strcmp(fieldName, "ack_Delay")==0) return base+3;
|
|
|
+ if (fieldName[0]=='a' && strcmp(fieldName, "ack_Block_Section")==0) return base+4;
|
|
|
+ return basedesc ? basedesc->findField(fieldName) : -1;
|
|
|
+}
|
|
|
+
|
|
|
+const char *AckDescriptor::getFieldTypeString(int field) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->getFieldTypeString(field);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ static const char *fieldTypeStrings[] = {
|
|
|
+ "uint8_t",
|
|
|
+ "uint8_t",
|
|
|
+ "uint64_t",
|
|
|
+ "uint16_t",
|
|
|
+ "string",
|
|
|
+ };
|
|
|
+ return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
|
|
|
+}
|
|
|
+
|
|
|
+const char **AckDescriptor::getFieldPropertyNames(int field) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->getFieldPropertyNames(field);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ switch (field) {
|
|
|
+ default: return nullptr;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+const char *AckDescriptor::getFieldProperty(int field, const char *propertyname) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->getFieldProperty(field, propertyname);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ switch (field) {
|
|
|
+ default: return nullptr;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+int AckDescriptor::getFieldArraySize(void *object, int field) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->getFieldArraySize(object, field);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ Ack *pp = (Ack *)object; (void)pp;
|
|
|
+ switch (field) {
|
|
|
+ default: return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+const char *AckDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->getFieldDynamicTypeString(object,field,i);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ Ack *pp = (Ack *)object; (void)pp;
|
|
|
+ switch (field) {
|
|
|
+ default: return nullptr;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+std::string AckDescriptor::getFieldValueAsString(void *object, int field, int i) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->getFieldValueAsString(object,field,i);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ Ack *pp = (Ack *)object; (void)pp;
|
|
|
+ switch (field) {
|
|
|
+ case 0: return ulong2string(pp->getType());
|
|
|
+ case 1: return ulong2string(pp->getNum_Blocks());
|
|
|
+ case 2: return uint642string(pp->getLargest_Acknowledged());
|
|
|
+ case 3: return ulong2string(pp->getAck_Delay());
|
|
|
+ case 4: return oppstring2string(pp->getAck_Block_Section());
|
|
|
+ default: return "";
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+bool AckDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->setFieldValueAsString(object,field,i,value);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ Ack *pp = (Ack *)object; (void)pp;
|
|
|
+ switch (field) {
|
|
|
+ case 0: pp->setType(string2ulong(value)); return true;
|
|
|
+ case 1: pp->setNum_Blocks(string2ulong(value)); return true;
|
|
|
+ case 2: pp->setLargest_Acknowledged(string2uint64(value)); return true;
|
|
|
+ case 3: pp->setAck_Delay(string2ulong(value)); return true;
|
|
|
+ case 4: pp->setAck_Block_Section((value)); return true;
|
|
|
+ default: return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+const char *AckDescriptor::getFieldStructName(int field) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->getFieldStructName(field);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ switch (field) {
|
|
|
+ default: return nullptr;
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+void *AckDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
|
|
|
+{
|
|
|
+ omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
|
|
|
+ if (basedesc) {
|
|
|
+ if (field < basedesc->getFieldCount())
|
|
|
+ return basedesc->getFieldStructValuePointer(object, field, i);
|
|
|
+ field -= basedesc->getFieldCount();
|
|
|
+ }
|
|
|
+ Ack *pp = (Ack *)object; (void)pp;
|
|
|
+ switch (field) {
|
|
|
+ default: return nullptr;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|