---

EtherCtrl_m.cc

Go to the documentation of this file.

//
// Generated file, do not edit! Created by opp_msgc.
//

// 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 "EtherCtrl_m.h"

// Template rule which fires if a struct or class doesn't have operator<<
template<typename T> std::ostream& operator<<(std::ostream& out,const T&) {return out;}

EXECUTE_ON_STARTUP(EtherMessageKind,
    cEnum *e = findEnum("EtherMessageKind");
    if (!e) enums.instance()->add(e = new cEnum("EtherMessageKind"));
    e->insert(JAM_SIGNAL, "JAM_SIGNAL");
    e->insert(ETH_FRAME, "ETH_FRAME");
    e->insert(ETH_PAUSE, "ETH_PAUSE");
    e->insert(ETHCTRL_DATA, "ETHCTRL_DATA");
    e->insert(ETHCTRL_REGISTER_DSAP, "ETHCTRL_REGISTER_DSAP");
    e->insert(ETHCTRL_DEREGISTER_DSAP, "ETHCTRL_DEREGISTER_DSAP");
    e->insert(ETHCTRL_SENDPAUSE, "ETHCTRL_SENDPAUSE");
);

EXECUTE_ON_STARTUP(EtherType,
    cEnum *e = findEnum("EtherType");
    if (!e) enums.instance()->add(e = new cEnum("EtherType"));
    e->insert(ETHERTYPE_IP, "ETHERTYPE_IP");
    e->insert(ETHERTYPE_ARP, "ETHERTYPE_ARP");
    e->insert(ETHERTYPE_RARP, "ETHERTYPE_RARP");
);

EXECUTE_ON_STARTUP(SAPCode,
    cEnum *e = findEnum("SAPCode");
    if (!e) enums.instance()->add(e = new cEnum("SAPCode"));
    e->insert(SAP_IBM_SNA, "SAP_IBM_SNA");
    e->insert(SAP_IP, "SAP_IP");
    e->insert(SAP_3COM, "SAP_3COM");
    e->insert(SAP_SNAP, "SAP_SNAP");
    e->insert(SAP_BANYAN, "SAP_BANYAN");
    e->insert(SAP_NOVELL_IPX, "SAP_NOVELL_IPX");
    e->insert(SAP_LAN_MANAGER, "SAP_LAN_MANAGER");
    e->insert(SAP_CLNS, "SAP_CLNS");
);

EtherCtrl::EtherCtrl() : cPolymorphic()
{
    unsigned int i;
    this->etherType_var = 0;
    this->ssap_var = 0;
    this->dsap_var = 0;
    this->pauseUnits_var = 0;
}

EtherCtrl::EtherCtrl(const EtherCtrl& other) : cPolymorphic()
{
    unsigned int i;
    operator=(other);
}

EtherCtrl::~EtherCtrl()
{
    unsigned int i;
}

EtherCtrl& EtherCtrl::operator=(const EtherCtrl& other)
{
    if (this==&other) return *this;
    unsigned int i;
    cPolymorphic::operator=(other);
    this->src_var = other.src_var;
    this->dest_var = other.dest_var;
    this->etherType_var = other.etherType_var;
    this->ssap_var = other.ssap_var;
    this->dsap_var = other.dsap_var;
    this->pauseUnits_var = other.pauseUnits_var;
    return *this;
}

MACAddress& EtherCtrl::getSrc()
{
    return src_var;
}

void EtherCtrl::setSrc(const MACAddress& src_var)
{
    this->src_var = src_var;
}

MACAddress& EtherCtrl::getDest()
{
    return dest_var;
}

void EtherCtrl::setDest(const MACAddress& dest_var)
{
    this->dest_var = dest_var;
}

int EtherCtrl::getEtherType() const
{
    return etherType_var;
}

void EtherCtrl::setEtherType(int etherType_var)
{
    this->etherType_var = etherType_var;
}

int EtherCtrl::getSsap() const
{
    return ssap_var;
}

void EtherCtrl::setSsap(int ssap_var)
{
    this->ssap_var = ssap_var;
}

int EtherCtrl::getDsap() const
{
    return dsap_var;
}

void EtherCtrl::setDsap(int dsap_var)
{
    this->dsap_var = dsap_var;
}

int EtherCtrl::getPauseUnits() const
{
    return pauseUnits_var;
}

void EtherCtrl::setPauseUnits(int pauseUnits_var)
{
    this->pauseUnits_var = pauseUnits_var;
}

class EtherCtrlDescriptor : public cStructDescriptor
{
  public:
    EtherCtrlDescriptor(void *p=NULL);
    virtual ~EtherCtrlDescriptor();
    EtherCtrlDescriptor& operator=(const EtherCtrlDescriptor& other);
    virtual cObject *dup() const {return new EtherCtrlDescriptor(*this);}

    virtual int getFieldCount();
    virtual const char *getFieldName(int field);
    virtual int getFieldType(int field);
    virtual const char *getFieldTypeString(int field);
    virtual const char *getFieldEnumName(int field);
    virtual int getArraySize(int field);

    virtual bool getFieldAsString(int field, int i, char *resultbuf, int bufsize);
    virtual bool setFieldAsString(int field, int i, const char *value);

    virtual const char *getFieldStructName(int field);
    virtual void *getFieldStructPointer(int field, int i);
    virtual sFieldWrapper *getFieldWrapper(int field, int i);
};

Register_Class(EtherCtrlDescriptor);

EtherCtrlDescriptor::EtherCtrlDescriptor(void *p) : cStructDescriptor(p)
{
}

EtherCtrlDescriptor::~EtherCtrlDescriptor()
{
}

int EtherCtrlDescriptor::getFieldCount()
{
    return 6;
}

int EtherCtrlDescriptor::getFieldType(int field)
{
    switch (field) {
        case 0: return FT_STRUCT;
        case 1: return FT_STRUCT;
        case 2: return FT_BASIC;
        case 3: return FT_BASIC;
        case 4: return FT_BASIC;
        case 5: return FT_BASIC;
        default: return FT_INVALID;
    }
}

const char *EtherCtrlDescriptor::getFieldName(int field)
{
    switch (field) {
        case 0: return "src";
        case 1: return "dest";
        case 2: return "etherType";
        case 3: return "ssap";
        case 4: return "dsap";
        case 5: return "pauseUnits";
        default: return NULL;
    }
}

const char *EtherCtrlDescriptor::getFieldTypeString(int field)
{
    switch (field) {
        case 0: return "MACAddress";
        case 1: return "MACAddress";
        case 2: return "int";
        case 3: return "int";
        case 4: return "int";
        case 5: return "int";
        default: return NULL;
    }
}

const char *EtherCtrlDescriptor::getFieldEnumName(int field)
{
    switch (field) {
        default: return NULL;
    }
}

int EtherCtrlDescriptor::getArraySize(int field)
{
    EtherCtrl *pp = (EtherCtrl *)p;
    switch (field) {
        default: return 0;
    }
}

bool EtherCtrlDescriptor::getFieldAsString(int field, int i, char *resultbuf, int bufsize)
{
    EtherCtrl *pp = (EtherCtrl *)p;
    switch (field) {
        case 0: {std::stringstream out; out << pp->getSrc(); opp_strprettytrunc(resultbuf,out.str().c_str(),bufsize-1); return true;}
        case 1: {std::stringstream out; out << pp->getDest(); opp_strprettytrunc(resultbuf,out.str().c_str(),bufsize-1); return true;}
        case 2: long2string(pp->getEtherType(),resultbuf,bufsize); return true;
        case 3: long2string(pp->getSsap(),resultbuf,bufsize); return true;
        case 4: long2string(pp->getDsap(),resultbuf,bufsize); return true;
        case 5: long2string(pp->getPauseUnits(),resultbuf,bufsize); return true;
        default: return false;
    }
}

bool EtherCtrlDescriptor::setFieldAsString(int field, int i, const char *value)
{
    EtherCtrl *pp = (EtherCtrl *)p;
    switch (field) {
        case 0: return false;
        case 1: return false;
        case 2: pp->setEtherType(string2long(value)); return true;
        case 3: pp->setSsap(string2long(value)); return true;
        case 4: pp->setDsap(string2long(value)); return true;
        case 5: pp->setPauseUnits(string2long(value)); return true;
        default: return false;
    }
}

const char *EtherCtrlDescriptor::getFieldStructName(int field)
{
    switch (field) {
        case 0: return "MACAddress"; break;
        case 1: return "MACAddress"; break;
        default: return NULL;
    }
}

void *EtherCtrlDescriptor::getFieldStructPointer(int field, int i)
{
    EtherCtrl *pp = (EtherCtrl *)p;
    switch (field) {
        case 0: return (void *)&pp->getSrc(); break;
        case 1: return (void *)&pp->getDest(); break;
        default: return NULL;
    }
}

sFieldWrapper *EtherCtrlDescriptor::getFieldWrapper(int field, int i)
{
    return NULL;
}

---