NTree.h

Go to the documentation of this file.

//
// Copyright (C) 2006 Institut fuer Telematik, Universitaet Karlsruhe (TH)
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#ifndef __NTREE_H_
#define __NTREE_H_

#include <omnetpp.h>
#include <NodeHandle.h>
#include <BaseOverlay.h>
#include "NTreeHelper.h"
#include "NTree_m.h"

class NTree : public BaseOverlay
{
    public:
        // OMNeT++
        virtual ~NTree();
        virtual void initializeOverlay(int stage);
        virtual void finishOverlay();
        virtual void handleUDPMessage(BaseOverlayMessage* msg);
        virtual void handleTimerEvent(cMessage* msg);
        virtual void handleAppMessage(cMessage* msg);
        virtual bool handleRpcCall(BaseCallMessage* msg);
        virtual void handleRpcResponse(BaseResponseMessage *msg,
                                       cPolymorphic* context,
                                       int rpcId, simtime_t rtt);
        virtual void handleRpcTimeout(BaseCallMessage *msg,
                                      const TransportAddress & dest,
                                      cPolymorphic* context,
                                      int rpcId, const OverlayKey &destKey);

    protected:

        void setBootstrapedIcon();
        void handleMove( GameAPIPositionMessage* posMsg );
        void handleMoveMessage( NTreeMoveMessage* moveMsg );
        void handleJoinCall( NTreeJoinCall* joinCall );
        void handleJoinResponse( NTreeJoinResponse* joinResp );
        void handleJoinCallTimeout( NTreeJoinCall* joinCall, const TransportAddress& oldNode );
        void handlePingCall( NTreePingCall* pingCall );
        void handlePingResponse( NTreePingResponse* pingResp, NTreePingContext* context );
        void handlePingCallTimeout( NTreePingCall* pingCall, const TransportAddress& oldNode, NTreePingContext* context );
        void handleDivideCall( NTreeDivideCall* divideCall );
        void handleDivideResponse( NTreeDivideResponse* divideResp, NTreeGroupDivideContext* context );
        void handleDivideCallTimeout( NTreeDivideCall* divideCall, const TransportAddress& oldNode, NTreeGroupDivideContext* context );
        void handleAddMessage( NTreeGroupAddMessage* addMsg );
        void handleDeleteMessage( NTreeGroupDeleteMessage* deleteMsg );
        void handleLeaveMessage( NTreeLeaveMessage* leaveMsg );
        void handleCollapseMessage( NTreeCollapseMessage* collapseMsg );
        void handleReplaceMessage( NTreeReplaceNodeMessage* replaceMsg );
        void handleTakeOverMessage( NTreeTakeOverMessage* takeMsg );

        void handleNodeGracefulLeaveNotification();

        void divideNode( NTreeGroupDivideContext* context );
        void collapseTree( std::map<NTreeScope,NTreeNode>::iterator node );
        void joinGroup( Vector2D position );

        void leaveGroup( Vector2D position, bool force = false);

        void pingNodes();

        void checkParentTimeout();

        void routeViaNTree( const Vector2D& pos, cPacket* msg, bool forward = false);

        void sendToGroup( const NTreeGroup& grp, cPacket* msg, bool keepMsg = false);

        void sendToGroup( const std::set<NodeHandle>& grp, cPacket* msg, bool keepMsg = false);

        void sendMessage(const TransportAddress& dest, cPacket* msg, bool forward = false);

        void changeState( int state );

        unsigned int AOIWidth;
        unsigned int maxChildren;
        double areaDimension;
        Vector2D position;
        NTreeGroup* currentGroup;

        simtime_t pingInterval;

        cMessage* joinTimer;
        cMessage* pingTimer;

        std::list<NTreeGroup> groups;
        std::map<NTreeScope,NTreeNode> ntreeNodes;

        std::list<NTreeGroup>::iterator findGroup(const Vector2D& pos);
        std::list<NTreeGroup>::iterator findGroup(const Vector2D& pos, double size);
        std::map<NTreeScope,NTreeNode>::iterator findNTreeNode(const Vector2D& pos);
        std::map<NTreeScope,NTreeNode>::iterator findNTreeNode(const Vector2D& pos, double size);

        NodeHandle getRandomNode( std::set<NodeHandle> invalidNodes = std::set<NodeHandle>() );

        // statistics
        unsigned int joinsSend;
        unsigned int joinBytes;
        unsigned int joinTimeout;

        unsigned int divideCount;
        unsigned int collapseCount;

        unsigned int treeMaintenanceMessages;
        unsigned int treeMaintenanceBytes;

        unsigned int movesSend;
        unsigned int moveBytes;
};

#endif