NodeHandle Class Reference

#include <NodeHandle.h>

List of all members.

---

Detailed Description

This class implements a common node handle.

It covers the complete node information, like IP-Address, port, NodeID and some additional flags for Simulation behaviour. The information can be sparse, so parts can be omited by setting the property to an unspecified value.

Author:

Markus Mauch

Sebastian Mies

Public Types
typedef hash_set< NodeHandle, hashFcn >	Set
Public Member Functions
	NodeHandle ()
	Constructs a unspecified NodeHandle.
	NodeHandle (const NodeHandle &handle)
	Copy constructor.
	NodeHandle (const OverlayKey &key, const IPvXAddress &ip, int port, int moduleId=-1)
	Complete constructor.
bool	operator== (const NodeHandle &rhs) const
bool	operator!= (const NodeHandle &rhs) const
bool	operator< (const NodeHandle &rhs) const
bool	operator> (const NodeHandle &rhs) const
bool	operator<= (const NodeHandle &rhs) const
bool	operator>= (const NodeHandle &rhs) const
NodeHandle &	operator= (const NodeHandle &rhs)
void	setAddress (const IPvXAddress &ip, int port=-1)
void	setPort (int port)
void	setModuleId (int moduleId)
void	setKey (const OverlayKey &key)
const IPvXAddress &	getAddress () const
int	getPort () const
int	getModuleId () const
const OverlayKey &	getKey () const
bool	isUnspecified () const
bool	isMalicious () const
size_t	hash () const
void	netPack (cCommBuffer *b)
void	netUnpack (cCommBuffer *b)
Public Attributes
IPvXAddress	ip
OverlayKey	key
int	port
int	moduleId
Static Public Attributes
static const NodeHandle	UNSPECIFIED_NODE
Private Member Functions
void	assertUnspecified (const NodeHandle &handle) const
Friends
std::ostream &	operator<< (std::ostream &os, const NodeHandle &n)
Classes
class	hashFcn

---

Member Typedef Documentation

typedef hash_set<NodeHandle, hashFcn> NodeHandle::Set

---

Constructor & Destructor Documentation

NodeHandle::NodeHandle

(

)

Constructs a unspecified NodeHandle.

{
    moduleId = -1;
    port = -1;
    key = OverlayKey::UNSPECIFIED_KEY;
}

NodeHandle::NodeHandle

(

const NodeHandle &

handle

)

Copy constructor.

Parameters:

handle

The NodeHandle to copy

{
    moduleId = handle.moduleId;
    key = handle.key;
    port = handle.port;
    ip = handle.ip;
}

NodeHandle::NodeHandle	(	const OverlayKey &	key,
		const IPvXAddress &	ip,
		int	port,
		int	moduleId = -1
	)

Complete constructor.

Parameters:

	key	The OverlayKey
	ip	The IPvXAddress
	port	The UDP-Port
	moduleId	The simulation module id

{
    this->moduleId = moduleId;
    this->ip = ip;
    this->port = port;
    this->key = key;
}

---

Member Function Documentation

void NodeHandle::assertUnspecified

(

const NodeHandle &

handle

)

const [inline, private]

{
    if ( this->isUnspecified() || handle.isUnspecified() )
        opp_error("NodeHandle: Trying to compare unspecified nodeHandle!");
}

const IPvXAddress & NodeHandle::getAddress

(

)

const

{
    return ip;
}

const OverlayKey & NodeHandle::getKey

(

)

const

{
    return key;
}

int NodeHandle::getModuleId

(

)

const

{
    return moduleId;
}

int NodeHandle::getPort

(

)

const

{
    return port;
}

size_t NodeHandle::hash

(

)

const

{
    size_t iphash;
    if (ip.isIPv6()) {
        uint32_t* addr = ip.get6().words();
        iphash = (size_t)(addr[0]^addr[1]^addr[2]^addr[3]);
    } else {
        iphash = (size_t)ip.get4().getInt();
    }

    return (size_t)(iphash^port^key.hash());
}

bool NodeHandle::isMalicious

(

)

const

{
    BaseOverlay* overlay
        = dynamic_cast<BaseOverlay*>(simulation.module(moduleId));
    if (overlay==NULL)
        opp_error("NodeHandle not associated with a BaseOverlay Module");
    return overlay->isMalicious();
}

bool NodeHandle::isUnspecified

(

)

const

{
    return (moduleId == -1);
}

void NodeHandle::netPack

(

cCommBuffer *

b

)

{
    //cMessage::netPack(b);
    doPacking(b,this->ip);
    doPacking(b,this->key);
    doPacking(b,this->port);
    doPacking(b,this->moduleId);
}

void NodeHandle::netUnpack

(

cCommBuffer *

b

)

{
    //cMessage::netUnpack(b);
    doUnpacking(b,this->ip);
    doUnpacking(b,this->key);
    doUnpacking(b,this->port);
    doUnpacking(b,this->moduleId);
}

bool NodeHandle::operator!=

(

const NodeHandle &

rhs

)

const

{
    assertUnspecified( rhs );
    return !( this->moduleId == rhs.moduleId &&
              this->key == rhs.key &&
              this->ip == rhs.ip && this->port == rhs.port );
}

bool NodeHandle::operator<

(

const NodeHandle &

rhs

)

const

{
    assertUnspecified(rhs);
    return this->key < rhs.key;
}

bool NodeHandle::operator<=

(

const NodeHandle &

rhs

)

const

{
    assertUnspecified(rhs);
    return this->key <= rhs.key;
}

NodeHandle & NodeHandle::operator=

(

const NodeHandle &

rhs

)

{
    this->key = rhs.key;
    this->ip = rhs.ip;
    this->port = rhs.port;
    this->moduleId = rhs.moduleId;

    return *this;
}

bool NodeHandle::operator==

(

const NodeHandle &

rhs

)

const

{
    assertUnspecified( rhs );
    return ( this->moduleId == rhs.moduleId &&
             this->key == rhs.key &&
             this->ip == rhs.ip && this->port == rhs.port );
}

bool NodeHandle::operator>

(

const NodeHandle &

rhs

)

const

{
    assertUnspecified(rhs);
    return this->key > rhs.key;
}

bool NodeHandle::operator>=

(

const NodeHandle &

rhs

)

const

{
    assertUnspecified(rhs);
    return this->key >= rhs.key;
}

void NodeHandle::setAddress	(	const IPvXAddress &	ip,
		int	port = -1
	)

{
    this->ip = ip;
    if (port!=-1)
        this->port = port;
}

void NodeHandle::setKey

(

const OverlayKey &

key

)

{
    this->key = key;
}

void NodeHandle::setModuleId

(

int

moduleId

)

{
    this->moduleId = moduleId;
}

void NodeHandle::setPort

(

int

port

)

{
    this->port = port;
}

---

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		const NodeHandle &	n
	)			[friend]

{
    if (n.isUnspecified()) {
        os << "<unspec>";
    } else {
        os << n.ip << ":" << n.port << " " << n.key
        << " " << n.moduleId;
    }

    return os;
};

---

Member Data Documentation

IPvXAddress NodeHandle::ip

OverlayKey NodeHandle::key

int NodeHandle::moduleId

int NodeHandle::port

const NodeHandle NodeHandle::UNSPECIFIED_NODE [static]

---

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

• NodeHandle.h
• NodeHandle.cc

---