//

// Generated file, do not edit! Created by nedtool 5.6 from

vanetsim/routing/gpsrwr/GPSRWR.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 <memory>
#include "GPSRWR_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

namespace {
template <class T> inline
typename std::enable_if<std::is_polymorphic<T>::value &&
std::is_base_of<omnetpp::cObject,T>::value, void *>::type
toVoidPtr(T* t)
{
return (void *)(static_cast<const omnetpp::cObject *>(t));
}

template <class T> inline

typename std::enable_if<std::is_polymorphic<T>::value && !
std::is_base_of<omnetpp::cObject,T>::value, void *>::type
toVoidPtr(T* t)
{
return (void *)dynamic_cast<const void *>(t);
}
template <class T> inline
typename std::enable_if<!std::is_polymorphic<T>::value, void *>::type
toVoidPtr(T* t)
{
return (void *)static_cast<const void *>(t);
}

namespace inet {

// forward
template<typename T, typename A>
std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);

// Template rule to generate operator<< for shared_ptr<T>

template<typename T>
inline std::ostream& operator<<(std::ostream& out,const std::shared_ptr<T>& t)
{ return out << t.get(); }

// 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("inet::GPSRWRForwardingMode");
if (!e) omnetpp::enums.getInstance()->add(e = new
omnetpp::cEnum("inet::GPSRWRForwardingMode"));
e->insert(GPSRWR_GREEDY_ROUTING, "GPSRWR_GREEDY_ROUTING");
e->insert(GPSRWR_PERIMETER_ROUTING, "GPSRWR_PERIMETER_ROUTING");
)

EXECUTE_ON_STARTUP(
omnetpp::cEnum *e = omnetpp::cEnum::find("inet::GPSRWRPlanarizationMode");
if (!e) omnetpp::enums.getInstance()->add(e = new
omnetpp::cEnum("inet::GPSRWRPlanarizationMode"));
e->insert(GPSRWR_NO_PLANARIZATION, "GPSRWR_NO_PLANARIZATION");
e->insert(GPSRWR_GG_PLANARIZATION, "GPSRWR_GG_PLANARIZATION");
 e->insert(GPSRWR_RNG_PLANARIZATION, "GPSRWR_RNG_PLANARIZATION");
)

Register_Class(GPSRWRBeacon)

GPSRWRBeacon::GPSRWRBeacon() : ::inet::FieldsChunk()
{
}

GPSRWRBeacon::GPSRWRBeacon(const GPSRWRBeacon& other) : ::inet::FieldsChunk(other)

{
copy(other);
}

GPSRWRBeacon::~GPSRWRBeacon()
{
}

GPSRWRBeacon& GPSRWRBeacon::operator=(const GPSRWRBeacon& other)

{
if (this == &other) return *this;
::inet::FieldsChunk::operator=(other);
copy(other);
return *this;
}

void GPSRWRBeacon::copy(const GPSRWRBeacon& other)

{
this->address = other.address;
this->position = other.position;
this->velocity = other.velocity;
this->acceleration = other.acceleration;
this->direction = other.direction;
}

void GPSRWRBeacon::parsimPack(omnetpp::cCommBuffer *b) const

{
::inet::FieldsChunk::parsimPack(b);
doParsimPacking(b,this->address);
doParsimPacking(b,this->position);
doParsimPacking(b,this->velocity);
doParsimPacking(b,this->acceleration);
doParsimPacking(b,this->direction);
}

void GPSRWRBeacon::parsimUnpack(omnetpp::cCommBuffer *b)

{
::inet::FieldsChunk::parsimUnpack(b);
doParsimUnpacking(b,this->address);
doParsimUnpacking(b,this->position);
doParsimUnpacking(b,this->velocity);
doParsimUnpacking(b,this->acceleration);
doParsimUnpacking(b,this->direction);
}

const L3Address& GPSRWRBeacon::getAddress() const

{
return this->address;
}
void GPSRWRBeacon::setAddress(const L3Address& address)
{
handleChange();
this->address = address;
}

const Coord& GPSRWRBeacon::getPosition() const

{
return this->position;
}

void GPSRWRBeacon::setPosition(const Coord& position)

{
handleChange();
this->position = position;
}

const Coord& GPSRWRBeacon::getVelocity() const

{
return this->velocity;
}

void GPSRWRBeacon::setVelocity(const Coord& velocity)

{
handleChange();
this->velocity = velocity;
}

const Coord& GPSRWRBeacon::getAcceleration() const

{
return this->acceleration;
}

void GPSRWRBeacon::setAcceleration(const Coord& acceleration)

{
handleChange();
this->acceleration = acceleration;
}

const Quaternion& GPSRWRBeacon::getDirection() const

{
return this->direction;
}

void GPSRWRBeacon::setDirection(const Quaternion& direction)

{
handleChange();
this->direction = direction;
}

class GPSRWRBeaconDescriptor : public omnetpp::cClassDescriptor

{
private:
mutable const char **propertynames;
enum FieldConstants {
FIELD_address,
FIELD_position,
FIELD_velocity,
 FIELD_acceleration,
FIELD_direction,
};
public:
GPSRWRBeaconDescriptor();
virtual ~GPSRWRBeaconDescriptor();

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(GPSRWRBeaconDescriptor)

GPSRWRBeaconDescriptor::GPSRWRBeaconDescriptor() :
omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(inet::GPSRWRBeacon)),
"inet::FieldsChunk")
{
propertynames = nullptr;
}

GPSRWRBeaconDescriptor::~GPSRWRBeaconDescriptor()
{
delete[] propertynames;
}

bool GPSRWRBeaconDescriptor::doesSupport(omnetpp::cObject *obj) const

{
return dynamic_cast<GPSRWRBeacon *>(obj)!=nullptr;
}

const char **GPSRWRBeaconDescriptor::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 *GPSRWRBeaconDescriptor::getProperty(const char *propertyname) const

{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int GPSRWRBeaconDescriptor::getFieldCount() const

{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
return basedesc ? 5+basedesc->getFieldCount() : 5;
}

unsigned int GPSRWRBeaconDescriptor::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[] = {
0, // FIELD_address
FD_ISCOMPOUND, // FIELD_position
FD_ISCOMPOUND, // FIELD_velocity
FD_ISCOMPOUND, // FIELD_acceleration
FD_ISCOMPOUND, // FIELD_direction
};
return (field >= 0 && field < 5) ? fieldTypeFlags[field] : 0;
}

const char *GPSRWRBeaconDescriptor::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[] = {
"address",
"position",
"velocity",
"acceleration",
"direction",
};
return (field >= 0 && field < 5) ? fieldNames[field] : nullptr;
}

int GPSRWRBeaconDescriptor::findField(const char *fieldName) const

{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
int base = basedesc ? basedesc->getFieldCount() : 0;
if (fieldName[0] == 'a' && strcmp(fieldName, "address") == 0) return base+0;
if (fieldName[0] == 'p' && strcmp(fieldName, "position") == 0) return base+1;
if (fieldName[0] == 'v' && strcmp(fieldName, "velocity") == 0) return base+2;
if (fieldName[0] == 'a' && strcmp(fieldName, "acceleration") == 0) return
base+3;
if (fieldName[0] == 'd' && strcmp(fieldName, "direction") == 0) return base+4;
return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *GPSRWRBeaconDescriptor::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[] = {
"inet::L3Address", // FIELD_address
"inet::Coord", // FIELD_position
"inet::Coord", // FIELD_velocity
"inet::Coord", // FIELD_acceleration
"inet::Quaternion", // FIELD_direction
};
return (field >= 0 && field < 5) ? fieldTypeStrings[field] : nullptr;
}

const char **GPSRWRBeaconDescriptor::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 *GPSRWRBeaconDescriptor::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 GPSRWRBeaconDescriptor::getFieldArraySize(void *object, int field) const

{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
if (basedesc) {
if (field < basedesc->getFieldCount())
return basedesc->getFieldArraySize(object, field);
field -= basedesc->getFieldCount();
}
GPSRWRBeacon *pp = (GPSRWRBeacon *)object; (void)pp;
 switch (field) {
default: return 0;
}
}

const char *GPSRWRBeaconDescriptor::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();
}
GPSRWRBeacon *pp = (GPSRWRBeacon *)object; (void)pp;
switch (field) {
default: return nullptr;
}
}

std::string GPSRWRBeaconDescriptor::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();
}
GPSRWRBeacon *pp = (GPSRWRBeacon *)object; (void)pp;
switch (field) {
case FIELD_address: return pp->getAddress().str();
case FIELD_position: {std::stringstream out; out << pp->getPosition();
return out.str();}
case FIELD_velocity: {std::stringstream out; out << pp->getVelocity();
return out.str();}
case FIELD_acceleration: {std::stringstream out; out << pp-
>getAcceleration(); return out.str();}
case FIELD_direction: {std::stringstream out; out << pp->getDirection();
return out.str();}
default: return "";
}
}

bool GPSRWRBeaconDescriptor::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();
}
GPSRWRBeacon *pp = (GPSRWRBeacon *)object; (void)pp;
switch (field) {
default: return false;
}
}
const char *GPSRWRBeaconDescriptor::getFieldStructName(int field) const
{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
if (basedesc) {
if (field < basedesc->getFieldCount())
return basedesc->getFieldStructName(field);
field -= basedesc->getFieldCount();
}
switch (field) {
case FIELD_position: return omnetpp::opp_typename(typeid(Coord));
case FIELD_velocity: return omnetpp::opp_typename(typeid(Coord));
case FIELD_acceleration: return omnetpp::opp_typename(typeid(Coord));
case FIELD_direction: return omnetpp::opp_typename(typeid(Quaternion));
default: return nullptr;
};
}

void *GPSRWRBeaconDescriptor::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();
}
GPSRWRBeacon *pp = (GPSRWRBeacon *)object; (void)pp;
switch (field) {
case FIELD_address: return toVoidPtr(&pp->getAddress()); break;
case FIELD_position: return toVoidPtr(&pp->getPosition()); break;
case FIELD_velocity: return toVoidPtr(&pp->getVelocity()); break;
case FIELD_acceleration: return toVoidPtr(&pp->getAcceleration()); break;
case FIELD_direction: return toVoidPtr(&pp->getDirection()); break;
default: return nullptr;
}
}

Register_Class(GPSRWROption)

GPSRWROption::GPSRWROption() : ::inet::TlvOptionBase()
{
}

GPSRWROption::GPSRWROption(const GPSRWROption&
other) : ::inet::TlvOptionBase(other)
{
copy(other);
}

GPSRWROption::~GPSRWROption()
{
}

GPSRWROption& GPSRWROption::operator=(const GPSRWROption& other)

{
if (this == &other) return *this;
::inet::TlvOptionBase::operator=(other);
copy(other);
return *this;
}

void GPSRWROption::copy(const GPSRWROption& other)

{
this->routingMode = other.routingMode;
this->destinationPosition = other.destinationPosition;
this->perimeterRoutingStartPosition = other.perimeterRoutingStartPosition;
this->perimeterRoutingForwardPosition = other.perimeterRoutingForwardPosition;
this->currentFaceFirstSenderAddress = other.currentFaceFirstSenderAddress;
this->currentFaceFirstReceiverAddress = other.currentFaceFirstReceiverAddress;
this->senderAddress = other.senderAddress;
}

void GPSRWROption::parsimPack(omnetpp::cCommBuffer *b) const

{
::inet::TlvOptionBase::parsimPack(b);
doParsimPacking(b,this->routingMode);
doParsimPacking(b,this->destinationPosition);
doParsimPacking(b,this->perimeterRoutingStartPosition);
doParsimPacking(b,this->perimeterRoutingForwardPosition);
doParsimPacking(b,this->currentFaceFirstSenderAddress);
doParsimPacking(b,this->currentFaceFirstReceiverAddress);
doParsimPacking(b,this->senderAddress);
}

void GPSRWROption::parsimUnpack(omnetpp::cCommBuffer *b)

{
::inet::TlvOptionBase::parsimUnpack(b);
doParsimUnpacking(b,this->routingMode);
doParsimUnpacking(b,this->destinationPosition);
doParsimUnpacking(b,this->perimeterRoutingStartPosition);
doParsimUnpacking(b,this->perimeterRoutingForwardPosition);
doParsimUnpacking(b,this->currentFaceFirstSenderAddress);
doParsimUnpacking(b,this->currentFaceFirstReceiverAddress);
doParsimUnpacking(b,this->senderAddress);
}

inet::GPSRWRForwardingMode GPSRWROption::getRoutingMode() const

{
return this->routingMode;
}

void GPSRWROption::setRoutingMode(inet::GPSRWRForwardingMode routingMode)

{
this->routingMode = routingMode;
}

const Coord& GPSRWROption::getDestinationPosition() const

{
return this->destinationPosition;
}

void GPSRWROption::setDestinationPosition(const Coord& destinationPosition)

{
this->destinationPosition = destinationPosition;
}

const Coord& GPSRWROption::getPerimeterRoutingStartPosition() const

{
 return this->perimeterRoutingStartPosition;
}

void GPSRWROption::setPerimeterRoutingStartPosition(const Coord&

perimeterRoutingStartPosition)
{
this->perimeterRoutingStartPosition = perimeterRoutingStartPosition;
}

const Coord& GPSRWROption::getPerimeterRoutingForwardPosition() const

{
return this->perimeterRoutingForwardPosition;
}

void GPSRWROption::setPerimeterRoutingForwardPosition(const Coord&

perimeterRoutingForwardPosition)
{
this->perimeterRoutingForwardPosition = perimeterRoutingForwardPosition;
}

const L3Address& GPSRWROption::getCurrentFaceFirstSenderAddress() const

{
return this->currentFaceFirstSenderAddress;
}

void GPSRWROption::setCurrentFaceFirstSenderAddress(const L3Address&

currentFaceFirstSenderAddress)
{
this->currentFaceFirstSenderAddress = currentFaceFirstSenderAddress;
}

const L3Address& GPSRWROption::getCurrentFaceFirstReceiverAddress() const

{
return this->currentFaceFirstReceiverAddress;
}

void GPSRWROption::setCurrentFaceFirstReceiverAddress(const L3Address&

currentFaceFirstReceiverAddress)
{
this->currentFaceFirstReceiverAddress = currentFaceFirstReceiverAddress;
}

const L3Address& GPSRWROption::getSenderAddress() const

{
return this->senderAddress;
}

void GPSRWROption::setSenderAddress(const L3Address& senderAddress)

{
this->senderAddress = senderAddress;
}

class GPSRWROptionDescriptor : public omnetpp::cClassDescriptor

{
private:
mutable const char **propertynames;
enum FieldConstants {
FIELD_routingMode,
FIELD_destinationPosition,
 FIELD_perimeterRoutingStartPosition,
FIELD_perimeterRoutingForwardPosition,
FIELD_currentFaceFirstSenderAddress,
FIELD_currentFaceFirstReceiverAddress,
FIELD_senderAddress,
};
public:
GPSRWROptionDescriptor();
virtual ~GPSRWROptionDescriptor();

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(GPSRWROptionDescriptor)

GPSRWROptionDescriptor::GPSRWROptionDescriptor() :
omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(inet::GPSRWROption)),
"inet::TlvOptionBase")
{
propertynames = nullptr;
}

GPSRWROptionDescriptor::~GPSRWROptionDescriptor()
{
delete[] propertynames;
}

bool GPSRWROptionDescriptor::doesSupport(omnetpp::cObject *obj) const

{
return dynamic_cast<GPSRWROption *>(obj)!=nullptr;
}

const char **GPSRWROptionDescriptor::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 *GPSRWROptionDescriptor::getProperty(const char *propertyname) const

{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int GPSRWROptionDescriptor::getFieldCount() const

{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
return basedesc ? 7+basedesc->getFieldCount() : 7;
}

unsigned int GPSRWROptionDescriptor::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, // FIELD_routingMode
FD_ISCOMPOUND, // FIELD_destinationPosition
FD_ISCOMPOUND, // FIELD_perimeterRoutingStartPosition
FD_ISCOMPOUND, // FIELD_perimeterRoutingForwardPosition
0, // FIELD_currentFaceFirstSenderAddress
0, // FIELD_currentFaceFirstReceiverAddress
0, // FIELD_senderAddress
};
return (field >= 0 && field < 7) ? fieldTypeFlags[field] : 0;
}

const char *GPSRWROptionDescriptor::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[] = {
"routingMode",
"destinationPosition",
"perimeterRoutingStartPosition",
"perimeterRoutingForwardPosition",
"currentFaceFirstSenderAddress",
"currentFaceFirstReceiverAddress",
"senderAddress",
};
return (field >= 0 && field < 7) ? fieldNames[field] : nullptr;
}

int GPSRWROptionDescriptor::findField(const char *fieldName) const

{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
int base = basedesc ? basedesc->getFieldCount() : 0;
if (fieldName[0] == 'r' && strcmp(fieldName, "routingMode") == 0) return
base+0;
if (fieldName[0] == 'd' && strcmp(fieldName, "destinationPosition") == 0)
return base+1;
if (fieldName[0] == 'p' && strcmp(fieldName, "perimeterRoutingStartPosition")
== 0) return base+2;
if (fieldName[0] == 'p' && strcmp(fieldName, "perimeterRoutingForwardPosition")
== 0) return base+3;
if (fieldName[0] == 'c' && strcmp(fieldName, "currentFaceFirstSenderAddress")
== 0) return base+4;
if (fieldName[0] == 'c' && strcmp(fieldName, "currentFaceFirstReceiverAddress")
== 0) return base+5;
if (fieldName[0] == 's' && strcmp(fieldName, "senderAddress") == 0) return
base+6;
return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *GPSRWROptionDescriptor::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[] = {
"inet::GPSRWRForwardingMode", // FIELD_routingMode
"inet::Coord", // FIELD_destinationPosition
"inet::Coord", // FIELD_perimeterRoutingStartPosition
"inet::Coord", // FIELD_perimeterRoutingForwardPosition
"inet::L3Address", // FIELD_currentFaceFirstSenderAddress
"inet::L3Address", // FIELD_currentFaceFirstReceiverAddress
"inet::L3Address", // FIELD_senderAddress
};
return (field >= 0 && field < 7) ? fieldTypeStrings[field] : nullptr;
}

const char **GPSRWROptionDescriptor::getFieldPropertyNames(int field) const

{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
if (basedesc) {
if (field < basedesc->getFieldCount())
return basedesc->getFieldPropertyNames(field);
field -= basedesc->getFieldCount();
}
switch (field) {
case FIELD_routingMode: {
static const char *names[] = { "enum", nullptr };
return names;
}
default: return nullptr;
}
}

const char *GPSRWROptionDescriptor::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 FIELD_routingMode:
if (!strcmp(propertyname, "enum")) return "inet::GPSRWRForwardingMode";
return nullptr;
default: return nullptr;
}
}

int GPSRWROptionDescriptor::getFieldArraySize(void *object, int field) const

{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
if (basedesc) {
if (field < basedesc->getFieldCount())
return basedesc->getFieldArraySize(object, field);
field -= basedesc->getFieldCount();
}
GPSRWROption *pp = (GPSRWROption *)object; (void)pp;
switch (field) {
default: return 0;
}
}

const char *GPSRWROptionDescriptor::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();
}
GPSRWROption *pp = (GPSRWROption *)object; (void)pp;
switch (field) {
default: return nullptr;
}
}

std::string GPSRWROptionDescriptor::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();
}
GPSRWROption *pp = (GPSRWROption *)object; (void)pp;
switch (field) {
case FIELD_routingMode: return enum2string(pp->getRoutingMode(),
"inet::GPSRWRForwardingMode");
case FIELD_destinationPosition: {std::stringstream out; out << pp-
>getDestinationPosition(); return out.str();}
 case FIELD_perimeterRoutingStartPosition: {std::stringstream out; out <<
pp->getPerimeterRoutingStartPosition(); return out.str();}
case FIELD_perimeterRoutingForwardPosition: {std::stringstream out; out <<
pp->getPerimeterRoutingForwardPosition(); return out.str();}
case FIELD_currentFaceFirstSenderAddress: return pp-
>getCurrentFaceFirstSenderAddress().str();
case FIELD_currentFaceFirstReceiverAddress: return pp-
>getCurrentFaceFirstReceiverAddress().str();
case FIELD_senderAddress: return pp->getSenderAddress().str();
default: return "";
}
}

bool GPSRWROptionDescriptor::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();
}
GPSRWROption *pp = (GPSRWROption *)object; (void)pp;
switch (field) {
case FIELD_routingMode: pp-
>setRoutingMode((inet::GPSRWRForwardingMode)string2enum(value,
"inet::GPSRWRForwardingMode")); return true;
default: return false;
}
}

const char *GPSRWROptionDescriptor::getFieldStructName(int field) const

{
omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
if (basedesc) {
if (field < basedesc->getFieldCount())
return basedesc->getFieldStructName(field);
field -= basedesc->getFieldCount();
}
switch (field) {
case FIELD_destinationPosition: return
omnetpp::opp_typename(typeid(Coord));
case FIELD_perimeterRoutingStartPosition: return
omnetpp::opp_typename(typeid(Coord));
case FIELD_perimeterRoutingForwardPosition: return
omnetpp::opp_typename(typeid(Coord));
default: return nullptr;
};
}

void *GPSRWROptionDescriptor::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();
}
 GPSRWROption *pp = (GPSRWROption *)object; (void)pp;
switch (field) {
case FIELD_destinationPosition: return toVoidPtr(&pp-
>getDestinationPosition()); break;
case FIELD_perimeterRoutingStartPosition: return toVoidPtr(&pp-
>getPerimeterRoutingStartPosition()); break;
case FIELD_perimeterRoutingForwardPosition: return toVoidPtr(&pp-
>getPerimeterRoutingForwardPosition()); break;
case FIELD_currentFaceFirstSenderAddress: return toVoidPtr(&pp-
>getCurrentFaceFirstSenderAddress()); break;
case FIELD_currentFaceFirstReceiverAddress: return toVoidPtr(&pp-
>getCurrentFaceFirstReceiverAddress()); break;
case FIELD_senderAddress: return toVoidPtr(&pp->getSenderAddress()); break;
default: return nullptr;
}
}

} // namespace inet