text: //
  // Generated file, do not edit! Created by nedtool 5.0 from castalia/src/node/communication/routing/multipathRingsRouting/MultipathRingsRoutingControl.msg.
  //
  
  // Disable warnings about unused variables, empty switch stmts, etc:
  #ifdef _MSC_VER
  #  pragma warning(disable:4101)
  #  pragma warning(disable:4065)
  #endif
  
  #include <iostream>
  #include <sstream>
  #include "MultipathRingsRoutingControl_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;
  }
  
  EXECUTE_ON_STARTUP(
      omnetpp::cEnum *e = omnetpp::cEnum::find("multipathRingsRoutingControlDef");
      if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("multipathRingsRoutingControlDef"));
      e->insert(MPRINGS_NOT_CONNECTED, "MPRINGS_NOT_CONNECTED");
      e->insert(MPRINGS_CONNECTED_TO_TREE, "MPRINGS_CONNECTED_TO_TREE");
      e->insert(MPRINGS_TREE_LEVEL_UPDATED, "MPRINGS_TREE_LEVEL_UPDATED");
  );
  
  Register_Class(MultipathRingsRoutingControlMessage);
  
  MultipathRingsRoutingControlMessage::MultipathRingsRoutingControlMessage(const char *name, int kind) : ::omnetpp::cMessage(name,kind)
  {
      this->multipathRingsRoutingControlMessageKind = 0;
      this->sinkID = 0;
      this->level = 0;
  }
  
  MultipathRingsRoutingControlMessage::MultipathRingsRoutingControlMessage(const MultipathRingsRoutingControlMessage& other) : ::omnetpp::cMessage(other)
  {
      copy(other);
  }
  
  MultipathRingsRoutingControlMessage::~MultipathRingsRoutingControlMessage()
  {
  }
  
  MultipathRingsRoutingControlMessage& MultipathRingsRoutingControlMessage::operator=(const MultipathRingsRoutingControlMessage& other)
  {
      if (this==&other) return *this;
      ::omnetpp::cMessage::operator=(other);
      copy(other);
      return *this;
  }
  
  void MultipathRingsRoutingControlMessage::copy(const MultipathRingsRoutingControlMessage& other)
  {
      this->multipathRingsRoutingControlMessageKind = other.multipathRingsRoutingControlMessageKind;
      this->sinkID = other.sinkID;
      this->level = other.level;
  }
  
  void MultipathRingsRoutingControlMessage::parsimPack(omnetpp::cCommBuffer *b) const
  {
      ::omnetpp::cMessage::parsimPack(b);
      doParsimPacking(b,this->multipathRingsRoutingControlMessageKind);
      doParsimPacking(b,this->sinkID);
      doParsimPacking(b,this->level);
  }
  
  void MultipathRingsRoutingControlMessage::parsimUnpack(omnetpp::cCommBuffer *b)
  {
      ::omnetpp::cMessage::parsimUnpack(b);
      doParsimUnpacking(b,this->multipathRingsRoutingControlMessageKind);
      doParsimUnpacking(b,this->sinkID);
      doParsimUnpacking(b,this->level);
  }
  
  int MultipathRingsRoutingControlMessage::getMultipathRingsRoutingControlMessageKind() const
  {
      return this->multipathRingsRoutingControlMessageKind;
  }
  
  void MultipathRingsRoutingControlMessage::setMultipathRingsRoutingControlMessageKind(int multipathRingsRoutingControlMessageKind)
  {
      this->multipathRingsRoutingControlMessageKind = multipathRingsRoutingControlMessageKind;
  }
  
  int MultipathRingsRoutingControlMessage::getSinkID() const
  {
      return this->sinkID;
  }
  
  void MultipathRingsRoutingControlMessage::setSinkID(int sinkID)
  {
      this->sinkID = sinkID;
  }
  
  int MultipathRingsRoutingControlMessage::getLevel() const
  {
      return this->level;
  }
  
  void MultipathRingsRoutingControlMessage::setLevel(int level)
  {
      this->level = level;
  }
  
  class MultipathRingsRoutingControlMessageDescriptor : public omnetpp::cClassDescriptor
  {
    private:
      mutable const char **propertynames;
    public:
      MultipathRingsRoutingControlMessageDescriptor();
      virtual ~MultipathRingsRoutingControlMessageDescriptor();
  
      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 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(MultipathRingsRoutingControlMessageDescriptor);
  
  MultipathRingsRoutingControlMessageDescriptor::MultipathRingsRoutingControlMessageDescriptor() : omnetpp::cClassDescriptor("MultipathRingsRoutingControlMessage", "omnetpp::cMessage")
  {
      propertynames = nullptr;
  }
  
  MultipathRingsRoutingControlMessageDescriptor::~MultipathRingsRoutingControlMessageDescriptor()
  {
      delete[] propertynames;
  }
  
  bool MultipathRingsRoutingControlMessageDescriptor::doesSupport(omnetpp::cObject *obj) const
  {
      return dynamic_cast<MultipathRingsRoutingControlMessage *>(obj)!=nullptr;
  }
  
  const char **MultipathRingsRoutingControlMessageDescriptor::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 *MultipathRingsRoutingControlMessageDescriptor::getProperty(const char *propertyname) const
  {
      omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
      return basedesc ? basedesc->getProperty(propertyname) : nullptr;
  }
  
  int MultipathRingsRoutingControlMessageDescriptor::getFieldCount() const
  {
      omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
      return basedesc ? 3+basedesc->getFieldCount() : 3;
  }
  
  unsigned int MultipathRingsRoutingControlMessageDescriptor::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,
      };
      return (field>=0 && field<3) ? fieldTypeFlags[field] : 0;
  }
  
  const char *MultipathRingsRoutingControlMessageDescriptor::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[] = {
          "multipathRingsRoutingControlMessageKind",
          "sinkID",
          "level",
      };
      return (field>=0 && field<3) ? fieldNames[field] : nullptr;
  }
  
  int MultipathRingsRoutingControlMessageDescriptor::findField(const char *fieldName) const
  {
      omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
      int base = basedesc ? basedesc->getFieldCount() : 0;
      if (fieldName[0]=='m' && strcmp(fieldName, "multipathRingsRoutingControlMessageKind")==0) return base+0;
      if (fieldName[0]=='s' && strcmp(fieldName, "sinkID")==0) return base+1;
      if (fieldName[0]=='l' && strcmp(fieldName, "level")==0) return base+2;
      return basedesc ? basedesc->findField(fieldName) : -1;
  }
  
  const char *MultipathRingsRoutingControlMessageDescriptor::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[] = {
          "int",
          "int",
          "int",
      };
      return (field>=0 && field<3) ? fieldTypeStrings[field] : nullptr;
  }
  
  const char **MultipathRingsRoutingControlMessageDescriptor::getFieldPropertyNames(int field) const
  {
      omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
      if (basedesc) {
          if (field < basedesc->getFieldCount())
              return basedesc->getFieldPropertyNames(field);
          field -= basedesc->getFieldCount();
      }
      switch (field) {
          case 0: {
              static const char *names[] = { "enum",  nullptr };
              return names;
          }
          default: return nullptr;
      }
  }
  
  const char *MultipathRingsRoutingControlMessageDescriptor::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) {
          case 0:
              if (!strcmp(propertyname,"enum")) return "multipathRingsRoutingControlDef";
              return nullptr;
          default: return nullptr;
      }
  }
  
  int MultipathRingsRoutingControlMessageDescriptor::getFieldArraySize(void *object, int field) const
  {
      omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
      if (basedesc) {
          if (field < basedesc->getFieldCount())
              return basedesc->getFieldArraySize(object, field);
          field -= basedesc->getFieldCount();
      }
      MultipathRingsRoutingControlMessage *pp = (MultipathRingsRoutingControlMessage *)object; (void)pp;
      switch (field) {
          default: return 0;
      }
  }
  
  std::string MultipathRingsRoutingControlMessageDescriptor::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();
      }
      MultipathRingsRoutingControlMessage *pp = (MultipathRingsRoutingControlMessage *)object; (void)pp;
      switch (field) {
          case 0: return enum2string(pp->getMultipathRingsRoutingControlMessageKind(), "multipathRingsRoutingControlDef");
          case 1: return long2string(pp->getSinkID());
          case 2: return long2string(pp->getLevel());
          default: return "";
      }
  }
  
  bool MultipathRingsRoutingControlMessageDescriptor::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();
      }
      MultipathRingsRoutingControlMessage *pp = (MultipathRingsRoutingControlMessage *)object; (void)pp;
      switch (field) {
          case 0: pp->setMultipathRingsRoutingControlMessageKind((multipathRingsRoutingControlDef)string2enum(value, "multipathRingsRoutingControlDef")); return true;
          case 1: pp->setSinkID(string2long(value)); return true;
          case 2: pp->setLevel(string2long(value)); return true;
          default: return false;
      }
  }
  
  const char *MultipathRingsRoutingControlMessageDescriptor::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 *MultipathRingsRoutingControlMessageDescriptor::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();
      }
      MultipathRingsRoutingControlMessage *pp = (MultipathRingsRoutingControlMessage *)object; (void)pp;
      switch (field) {
          default: return nullptr;
      }
  }
  
  
  