inet::PIMHello Class Reference

#include <PIMPacket.h>

Inheritance diagram for inet::PIMHello:

Public Member Functions
	PIMHello (const char *name=nullptr, int kind=0)
	PIMHello (const PIMHello &other)
virtual	~PIMHello ()
PIMHello &	operator= (const PIMHello &other)
virtual PIMHello *	dup () const override
virtual void	parsimPack (cCommBuffer *b) const override
virtual void	parsimUnpack (cCommBuffer *b) override
virtual void	setOptionsArraySize (unsigned int size) override
virtual unsigned int	getOptionsArraySize () const override
virtual HelloOptionPtr &	getOptions (unsigned int k) override
virtual const HelloOptionPtr &	getOptions (unsigned int k) const override
virtual void	setOptions (unsigned int k, const HelloOptionPtr &options) override
Public Member Functions inherited from inet::PIMHello_Base
virtual	~PIMHello_Base ()
virtual void	parsimPack (omnetpp::cCommBuffer *b) const override
virtual void	parsimUnpack (omnetpp::cCommBuffer *b) override
Public Member Functions inherited from inet::PIMPacket
	PIMPacket (const char *name=nullptr, short kind=0)
	PIMPacket (const PIMPacket &other)
virtual	~PIMPacket ()
PIMPacket &	operator= (const PIMPacket &other)
virtual short	getVersion () const
virtual void	setVersion (short version)
virtual short	getType () const
virtual void	setType (short type)

Protected Member Functions
bool	operator== (const PIMHello &)
Protected Member Functions inherited from inet::PIMHello_Base
bool	operator== (const PIMHello_Base &)
	PIMHello_Base (const char *name=nullptr, short kind=0)
	PIMHello_Base (const PIMHello_Base &other)
PIMHello_Base &	operator= (const PIMHello_Base &other)
Protected Member Functions inherited from inet::PIMPacket
bool	operator== (const PIMPacket &)

Protected Attributes
HelloOptionPtr *	options_var
unsigned int	options_arraysize
Protected Attributes inherited from inet::PIMPacket
short	version
short	type

Private Member Functions
void	copy (const PIMHello &other)

Constructor & Destructor Documentation

inet::PIMHello::PIMHello	(	const char *	name = nullptr,
		int	kind = 0
	)

                                             : PIMHello_Base(name, kind)
{
    this->setType(Hello);

    options_arraysize = 0;
    this->options_var = nullptr;
}

inet::PIMHello::PIMHello

(

const PIMHello &

other

)

                                        : PIMHello_Base(other)
{
    options_arraysize = 0;
    this->options_var = nullptr;
    copy(other);
}

inet::PIMHello::~PIMHello ( )

virtual

{
    if (options_var) {
        for (unsigned int i = 0; i < options_arraysize; i++)
            delete options_var[i];
    }
    delete[] options_var;
}

Member Function Documentation

void inet::PIMHello::copy ( const PIMHello &  other )

private

Referenced by operator=(), and PIMHello().

{
    for (unsigned int i = 0; i < options_arraysize; i++)
        delete options_var[i];
    delete[] options_var;

    this->options_var = (other.options_arraysize == 0) ? nullptr : new HelloOptionPtr[other.options_arraysize];
    options_arraysize = other.options_arraysize;
    for (unsigned int i = 0; i < options_arraysize; i++)
        this->options_var[i] = other.options_var[i]->dup();
}

virtual PIMHello* inet::PIMHello::dup ( ) const

inlineoverridevirtual

Reimplemented from inet::PIMHello_Base.

{ return new PIMHello(*this); }

HelloOptionPtr & inet::PIMHello::getOptions ( unsigned int  k )

overridevirtual

Implements inet::PIMHello_Base.

Referenced by inet::PIMBase::processHelloPacket().

{
    if (k >= options_arraysize)
        throw cRuntimeError("Array of size %d indexed by %d", options_arraysize, k);
    return options_var[k];
}

virtual const HelloOptionPtr& inet::PIMHello::getOptions ( unsigned int  k ) const

inlineoverridevirtual

Reimplemented from inet::PIMHello_Base.

Referenced by getOptions().

{ return const_cast<PIMHello *>(this)->getOptions(k); }

unsigned int inet::PIMHello::getOptionsArraySize ( ) const

overridevirtual

Implements inet::PIMHello_Base.

Referenced by inet::PIMBase::processHelloPacket().

{
    return options_arraysize;
}

PIMHello & inet::PIMHello::operator=

(

const PIMHello &

other

)

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

bool inet::PIMHello::operator== ( const PIMHello &  )

protected

void inet::PIMHello::parsimPack ( cCommBuffer *  b ) const

overridevirtual

{
    PIMHello_Base::parsimPack(b);
    b->pack(options_arraysize);
    for (unsigned int i = 0; i < options_arraysize; i++) {
        if (options_var[i]) {
            doParsimPacking(b, options_var[i]->getType());
            doParsimPacking(b, options_var[i]);
        }
        else
            doParsimPacking(b, (short int)0);
    }
}

void inet::PIMHello::parsimUnpack ( cCommBuffer *  b )

overridevirtual

{
    PIMHello_Base::parsimUnpack(b);
    for (unsigned int i = 0; i < options_arraysize; i++)
        delete options_var[i];
    delete[] this->options_var;
    b->unpack(options_arraysize);
    if (options_arraysize == 0) {
        this->options_var = nullptr;
    }
    else {
        this->options_var = new HelloOptionPtr[options_arraysize];
        for (unsigned int i = 0; i < options_arraysize; i++) {
            short int type;
            doParsimUnpacking(b, type);
            switch (type) {
                case 0:
                    options_var[i] = nullptr;
                    break;

                case Holdtime:
                    options_var[i] = new HoldtimeOption();
                    break;

                case LANPruneDelay:
                    options_var[i] = new LANPruneDelayOption();
                    break;

                case DRPriority:
                    options_var[i] = new DRPriorityOption();
                    break;

                case GenerationID:
                    options_var[i] = new GenerationIDOption();
                    break;

                //case StateRefreshCapable: TODO  break;
                //case AddressList: break;
                default:
                    throw cRuntimeError("PIMHello::parsimUnpack(): unknown option type: %sd.", type);
            }
            if (options_var[i])
                doParsimUnpacking(b, *options_var[i]);
        }
    }
}

void inet::PIMHello::setOptions ( unsigned int  k, const HelloOptionPtr &  options  )

overridevirtual

Implements inet::PIMHello_Base.

Referenced by inet::PIMBase::sendHelloPacket().

{
    if (k >= options_arraysize)
        throw cRuntimeError("Array of size %d indexed by %d", options_arraysize, k);
    delete this->options_var[k];
    this->options_var[k] = options;
}

void inet::PIMHello::setOptionsArraySize ( unsigned int  size )

overridevirtual

Implements inet::PIMHello_Base.

Referenced by inet::PIMBase::sendHelloPacket().

{
    HelloOptionPtr *options_var2 = (size == 0) ? nullptr : new HelloOptionPtr[size];
    for (unsigned int i = 0; i < size; i++)
        options_var2[i] = i < options_arraysize ? options_var[i] : nullptr;
    for (unsigned int i = size; i < options_arraysize; i++)
        delete options_var[i];
    options_arraysize = size;
    delete[] options_var;
    this->options_var = options_var2;
}

Member Data Documentation

unsigned int inet::PIMHello::options_arraysize

protected

Referenced by copy(), getOptions(), getOptionsArraySize(), parsimPack(), parsimUnpack(), PIMHello(), setOptions(), setOptionsArraySize(), and ~PIMHello().

HelloOptionPtr* inet::PIMHello::options_var

protected

Referenced by copy(), getOptions(), parsimPack(), parsimUnpack(), PIMHello(), setOptions(), setOptionsArraySize(), and ~PIMHello().

---

The documentation for this class was generated from the following files:

• PIMPacket.h
• PIMPacket.cc