/*
 * File:   Dispatcher.cc
 * Author: jgaebler
 *
 * Created on September 20, 2010, 1:30 PM
 */
#include "Dispatcher.h"

#include "Moversight.h"
#include "app/Application.h"
#include "common/container/PeerIDList.h"
#include "common/container/PeerIDSet.h"
#include "common/container/SubscriberSet.h"
#include "common/transport/MoversightMessageTypes.h"
#include "common/transport/msg/ExteriorMessage.h"
#include "common/validator/MessageValidator.h"
#include "common/validator/MessageValidatorType.h"
#include "common/validator/StandardValidator.h"
#include "common/validator/SemanticSplitValidator.h"
#include "common/validator/NVBValidator.h"
#include "event/DeliverableObject.h"
#include "event/ObjectListener.h"
#include "event/events/ConnectionLostEvent.h"
#include "event/events/ConnectionReEstablishedEvent.h"
#include "event/events/FlushDoneEvent.h"
#include "fd/NetworkFailureDetector.h"
#include "mrs/sync/NextViewBuffer.h"
#include "ms/Peer.h"
#include "ms/Invitation.h"
#include "ms/MemberRegister.h"
#include "ms/Roster.h"
#include "ms/events/GroupClosedEvent.h"
#include "ms/events/JoinAbortedEvent.h"
#include "ms/events/LocalPeerUpdatedEvent.h"
#include "mt/msg/MulticastMessage.h"
#include "st/msg/StreamMessage.h"

#if UBEEME
#include "app/events/GroupCreatedEvent.h"
#include "app/events/GroupClosedEvent.h"
#include "app/events/JoinGroupDoneEvent.h"
#include "app/events/LocalPeerUpdateEvent.h"
#include "app/events/PeerIsPendingEvent.h"
#include "app/events/PeerJoinedEvent.h"
#include "app/events/PeerLeftEvent.h"
#include "app/events/PeerReconnectedEvent.h"
#include "app/events/SplitNotifyEvent.h"
#include "app/events/SplitDoneEvent.h"
#include "app/events/MergeNotifyEvent.h"
#include "app/events/MergeDoneEvent.h"
#include "debug.h"
#endif

namespace ubeeme {
    namespace moversight {

#undef DEBUG
#define DEBUG(msg) if (module.isPrintDebugDIS()) MOV_DEBUG << "DIS@" << ms.getLocalAddress() << " "<<msg<<endl;

        /**
         * @brief Constructor
         * @param mov A reference to the moversight module.
         * @param aApp A reference to the moversight application callback interface.
         */
        Dispatcher::Dispatcher(Moversight & mov, Application & aApp) :

        ObjectListener("Dispatcher"),
        app(aApp),
        module(mov),

        ms(*this),
        es(*this),
        ct(*this),
        st(*this),
        ut(*this),
        mt(*this),
        fd(*this),
        mob(*this),
        merge(*this),
        split(*this),
        ts(*this),
        mrs(*this),
        rvd(*this),
        nvb(*this),
        uc(*this),
        messageValidator(NULL),
        logMemberRegister(*this) {
        }

        /**
         * @brief Initialize the dispatcher.
         */
        void
        Dispatcher::initialise() {

            es.initialise();
            subscribe<FlushDoneEvent>(this);
            subscribe<GroupClosedEvent>(this);

            ms.initialise();
            ct.initialise();
            st.initialise();
            ut.initialise();
            mt.initialise();
            fd.initialise();
            mob.initialise();
            merge.initialise();
            split.initialise();
            ts.initialise();
            uc.initialise();
            nvb.initialise();
            mrs.initialise();
            rvd.initialise();

            setStandardMessageValidator();

            int modulID =module.getLocalAddress().getHostAddress().get4().getDByte(3);
            std::stringstream stringBufffer;
            stringBufffer << "memberRegisterDump-" << modulID << "-" << GenericTime::currentTime().toString() << ".json";
            logMemberRegister.setTargetFileName(stringBufffer.str().c_str());
            logMemberRegister.initialise();
        }

        /**
         * @brief Assignment operator.
         * @param other The instance to assign.
         * @return A reference of the current object.
         */
        Dispatcher & Dispatcher::operator=(Dispatcher const & other) {

            if (this != &other) {

                app = other.app;
                module = other.module;
                ms = other.ms;
                es = other.es;
                ct = other.ct;
                st = other.st;
                ut = other.ut;
                mt = other.mt;
                fd = other.fd;
                mob = other.mob;
                merge = other.merge;
                split = other.split;
                ts = other.ts;
                mrs = other.mrs;
                nvb = other.nvb;
                rvd = other.rvd;
                uc = other.uc;

                messageValidator = other.messageValidator;
                logMemberRegister = other.logMemberRegister;

            }//End if

            return *this;

        }

        /**
         * @brief Finalize the current moversight session and set it ready to reinitialize.
         */
        void
        Dispatcher::finalise() {

            es.finalise();
            ms.finalise();
            ct.finalise();
            st.finalise();
            ut.finalise();
            mt.finalise();
            fd.finalise();
            mob.finalise();
            merge.finalise();
            split.finalise();
            ts.finalise();
            uc.finalise();
            mrs.finalise();
            nvb.finalise();
            rvd.finalise();

            if (messageValidator != NULL) {
                delete messageValidator;
                messageValidator = NULL;
            }//End if

            logMemberRegister.finalise();
        }

        /**
         * @brief Destructor
         */
        Dispatcher::~Dispatcher() {
            finalise();
        }

        /**
         * @brief Application Interface, which distributes a message reliable and totaly ordered within the peer group.
         * @param msg the message to send
         */
        void
        Dispatcher::sendMessage(MulticastMessage & msg) {
//            if (getLocalSubState() == WAITING_FOR_REJOIN ||
//                getLocalSubState() == REJOIN_IN_PROGRESS) {
//                switch (msg.getType()) {
//                    case LT: // LTMessage
//                    case GT: // GTMessage
//                    case LA: // LeaveAnnounce
//                    case RA: // RejoinAnnounce
//                    case RRO: // RejoinRoster
//                    case RCA: // ReconnectAnnounce
//                    case RJRO: // RejoinRoster
//                    case RJRC: // RejoinRosterConfirm
//                    case ROA: // RejoinRosterAnnounce
//                    case RD: // RejoinDone
//                    case RF: // RejoinFailed
//                        mt.send(msg);
//                        break;
//
//                    default:
//                        DEBUG("Sorry you are either a secondary group or a rejoin is going on. Messages are not allowed to be sent.")
//                        break;
//                }
//            }
//            else {

                if (nvb.isLockedSendMsgSemaphoreActivated()) {
                    nvb.pushSendMsg(&msg);
                }
                else {
                    if (nvb.isViewChangeAbleMessageType(msg.getType())) {
                        nvb.setLockedSendMsgSemaphoreAndStartFlush();
                    }

                    mt.send(msg);
                }
//            }
        }

        /**
         * @brief Application Interface, which distributes a stream message within the peer group.
         * @param msg the message to send
         */
        void
        Dispatcher::sendMessage(StreamMessage& msg) {
            st.send(msg);
        }

        /**
         * @brief This method handles all incoming messages from the network and distribute these to the submodules
         * @param msg the received message to distribute to the submodules
         *
         * @NOTE In future we will define a generic IOHandler that is responsible for handling messages
         * when they arrive. Such an IOHandler will be the UnicastTransfer service.
         */
        void
        Dispatcher::handleMessage(MoversightMessage * msg) {

//            if (getLocalSubState() == FLUSHING) {
//
//                switch (msg->getType()) {
//                    case LT:
//                    case GT:
//                    case CM:
//                    case CMC:
//                    case SMDT:
//                    case UM:
//                    case UMC:
                        msg->handleReceive(*this);
//                        break;
//
//                    default:
//                        //std::cerr<<module.getLocalAddress()<<" state: "<<getLocalState()<<" "<<getLocalSubState()<<" add message to temp queue "<<msg->getFullName()<<"\n";
//                        //tempMessageQueue.add(new MoversightMessage(*msg));
//                        if(dynamic_cast<MulticastMessage*>(msg) != NULL){
//                                getMaintenanceRoleService().getNextViewBuffer().pushReceiveMsg(dynamic_cast<MulticastMessage*>(msg));
//                        }
//                        break;
//                }
//            }//End if
//            else {
//                // because of the stateOperation "LOCK" a further differentiation is needed.
//                if (getLocalStateOperation() != LOCKED) {
//                    msg->handleReceive(*this);
//                }
//                else {
//                    switch (msg->getType()) {
//                            //case RRO:
//                        case RJRO:
//                        case RJRC:
//                        case RCA:
//                        case RRO:
//                        case ROA:
//                        case RD:
//                        case RF:
//                        case LT:
//                        case GT:
//                            msg->handleReceive(*this);
//                            break;
//
//                        case NDC:
//                            break;
//
//                        default:
//
//                            //std::cerr<<"add message to temp queue - locked "<<msg->getFullName()<<"\n";;
//                            //tempMessageQueue.add(new MoversightMessage(*msg)); // should save the belated data-transmission on both sides of the partition
//                            if(dynamic_cast<MulticastMessage*>(msg) != NULL){
//                                getMaintenanceRoleService().getNextViewBuffer().pushReceiveMsg(dynamic_cast<MulticastMessage*>(msg));
//                            }
//                            DEBUG("Peer is locked at the moment because of an ongoing rejoin - sending messages not belonging to rejoin forbidden!");
//                            break;
//                    }
//                }
//            }//End else

            // start processing pending events, signaled during message handling.
            es.process();
        }

        /**
         * @brief Handle temporary saved messages during flush operations.
         */
        void
        Dispatcher::handleSavedMessages() {
            //            for (size_t i = 0; i < tempMessageQueue.size(); i++) {
            //                DEBUG("handle stored: " << tempMessageQueue.get(i)->getType());
            //std::cerr<<module.getLocalAddress()<<" state: "<<getLocalState()<<" "<<getLocalSubState()<<" handle stored: " << tempMessageQueue.get(i)->getFullName()<<"\n";
            //                MoversightMessage * pdu = tempMessageQueue.get(i);
            //                handleMessage(pdu);
            //                delete pdu;
            //            }//End for
            //
            //            //clear saved messages, because all send again
            //            tempMessageQueue.clear();
        }

        /**
         * @brief Invites a peer to a group.
         *
         * This method invites a peer to a group. The invitation is only executed,
         * if the destination transport address diverse from the local peer address.
         * @param destTa The transport address of the peer to invite.
         * @note API method
         * @throw FlushModeException If while a flush a new member want join
         */
        void
        Dispatcher::invitePeer(TransportAddress & destTa, PeerDescription & pDesc) {

            if (getLocalSubState() == FLUSHING) {
                throw FlushModeException("flush in progress - please try later");
            }
            else if (getLocalSubState() == WAITING_FOR_REJOIN) {
                DEBUG("Peer does NOT belong to the primary group - it's not allowed to invite a new peer!");
                return;
            }

            if (getLocalPeer().getLocalAddress() != destTa) {
                ms.invitePeer(destTa, pDesc);
            }//End if
            else {
                std::string reason("peer already member of the current group");
                signal(new JoinAbortedEvent(destTa, reason));
            }
        }

        /**
         * @brief Cancel the current inviting process.
         * Calling this method performs a JoinAbort operation from the user to moversight.
         * @note API method
         * @param ta The transport address of the peer to invite.
         * @param reason The cancel reason.
         */
        void
        Dispatcher::cancelInvitation(TransportAddress & ta, std::string reason) {
            ms.cancelInvitation(ta, reason);
        }

        /**
         * @brief Accepts a invitation to joining a group.
         *
         * This method accepts a invitation for joining the current group.
         * @note API method
         * @param inv The invitation instance, used to response to the correct inviter.
         * @param comment A short message from the application to the group (e.g. "hello message").
         * @param pDesc A short description of the joining peer, provided by the application.
         * @param resource A generic representation of the resources available at the local peer.
         */
        void
        Dispatcher::acceptInvitation(const Invitation & inv, const std::string & comment, const PeerDescription & pDesc, const PeerResources & resource) {
            ms.responseInvitation(inv, true, comment, pDesc, resource);
        }

        /**
         * @brief Rejects a invitation to joining a group.
         *
         * This method rejectes a invitation for joining the current group.
         * @note API method
         * @param inv The invitation instance, used to response to the correct inviter.
         * @param reason A short message from the application, why the invitation is rejected.
         */
        void
        Dispatcher::rejectInvitation(const Invitation & inv, const std::string & reason) {
            PeerDescription pDesc("not available");
            PeerResources resource;
            ms.responseInvitation(inv, false, reason, pDesc, resource);
        }

        /**
         * @brief Leaves the current group.
         *
         * This method is called, if the local peer aims to leave the group.
         * A leave announce message is disseminated within the group. The group have to closed afterwards.
         * @note API method
         * @throw FlushModeException If while a flush an peer want to leave
         */
        void
        Dispatcher::leaveGroup() {
            if (getLocalSubState() == FLUSHING) {
                throw FlushModeException("flush in progress - please try later");
            }//End if

            ms.leaveGroup();
        }

        /**
         * @brief Starts the SPLIT service at the topology control module
         * @param options Contents the Flags for synchronising the message queues and SPLIT behaviour
         * @param splitPeers Contents the PeerIDs of the splitting peers
         * @note API method
         * @throw FlushModeException If while a flush an other split occurs
         */
        void
        Dispatcher::splitGroup(unsigned char options, PeerIDList splitPeers) {
            split.splitGroup(options, splitPeers);
        }

        /**
         * @brief Try to start a merge with second group.
         * @param destTa The transport address of the peer to lead the merge in second group.
         * @note API method.
         * @throw FlushModeException If a merge will request while a flush
         */
        void
        Dispatcher::mergeGroup(TransportAddress & destTa) {
            merge.mergeGroup(destTa);
        }

        /**
         * @brief The App accept the requesting merge.
         * @note API method.
         *
         */
        void
        Dispatcher::acceptGroupMerge() {
            merge.responseMerge();
        }

        /**
         * @brief The App reject the requesting merge.
         * @param reason The reason of the rejection.
         * @note API method.
         *
         */
        void
        Dispatcher::rejectGroupMerge(std::string & reason) {
            merge.cancelMerge(reason);
        }

        /**
         * @brief Returns the local peer.
         * @return A reference to the local peer instance.
         */
        Peer &
        Dispatcher::getLocalPeer() {
            return ms.getLocalPeer();
        }

        /**
         * @brief Returns the current view ID.
         * @return The desired view ID.
         */
        ViewID
        Dispatcher::getViewID() const {
            return getMembershipService().getViewID();
        }

        /**
         * @brief Permits access to the moversight call back
         * @return The moversight call back.
         */
        Application &
        Dispatcher::getMoversightCallback() {
            return app;
        }

        /**
         * @brief Permits access to the moversight call back
         * @return The moversight call back.
         */
        const Application &
        Dispatcher::getMoversightCallback() const {
            return app;
        }

        /**
         * @brief Permits access to the moversight
         * @return the moversight
         */
        Moversight &
        Dispatcher::getMoversight() {
            return module;
        }

        /**
         * @brief Permits access to the moversight
         * @return the moversight
         */
        const Moversight &
        Dispatcher::getMoversight() const {
            return module;
        }

        /**
         * @brief Permits access to the moversight membership service.
         * @return The current membership service instance.
         */
        MembershipService &
        Dispatcher::getMembershipService() {
            return ms;
        }

        /**
         * @brief Permits access to the moversight membership service.
         * @return The current membership service instance.
         */
        const MembershipService &
        Dispatcher::getMembershipService() const {
            return ms;
        }

        /**
         * @brief Permits access to the moversight event service.
         * @return The current event service instance.
         */
        EventService &
        Dispatcher::getEventService() {
            return es;
        }

        /**
         * @brief Permits access to the moversight event service.
         * @return The current event service instance.
         */
        const EventService &
        Dispatcher::getEventService() const {
            return es;
        }

        /**
         * @brief Permits access to the moversight message transfer.
         * @return  The current message transfer instance.
         */
        MessageTransfer &
        Dispatcher::getMessageTransfer() {
            return mt;
        }

        /**
         * @brief Permits access to the moversight message transfer.
         * @return  The current message transfer instance.
         */
        const MessageTransfer &
        Dispatcher::getMessageTransfer() const {
            return mt;
        }

        /**
         * @brief Permits access to the moversight causal transfer service.
         * @return  The current causal transfer service instance.
         */
        CausalTransfer &
        Dispatcher::getCausalTransfer() {
            return ct;
        }

        /**
         * @brief Permits access to the moversight causal transfer service.
         * @return  The current causal transfer service instance.
         */
        const CausalTransfer &
        Dispatcher::getCausalTransfer() const {
            return ct;
        }

        /**
         * @brief Permits access to the moversight stream transfer service.
         * @return  The current stream transfer service instance.
         */
        StreamTransfer &
        Dispatcher::getStreamTransfer() {
            return st;
        }

        /**
         * @brief Permits access to the moversight stream transfer service.
         * @return  The current stream transfer service instance.
         */
        const StreamTransfer &
        Dispatcher::getStreamTransfer() const {
            return st;
        }

        /**
         * @brief Permits access to the moversight unicast transfer service.
         * @return  The current unciast transfer service instance.
         */
        UnicastTransfer &
        Dispatcher::getUnicastTransfer() {
            return ut;
        }

        /**
         * @brief Permits access to the moversight unicast transfer service.
         * @return  The current uncast transfer service instance.
         */
        const UnicastTransfer &
        Dispatcher::getUnicastTransfer() const {
            return ut;
        }

        /**
         * @brief Permits access to the moversight failure detector.
         * @return  The current failure detector instance.
         */
        FailureDetector &
        Dispatcher::getFailureDetector() {
            return fd;
        }

        /**
         * @brief Permits access to the moversight failure detector.
         * @return  The current failure detector instance.
         */
        const FailureDetector &
        Dispatcher::getFailureDetector() const {
            return fd;
        }


        /**
         * @brief Permits access to the moversight network failure detector.
         * @return  The current network failure detector instance.
         */
        NetworkFailureDetector &
        Dispatcher::getNetworkFailureDetector() {
            return fd.getNetworkFailureDetector();
        }

        /**
         * @brief Permits access to the moversight network failure detector.
         * @return  The current network failure detector instance.
         */
        const NetworkFailureDetector &
        Dispatcher::getNetworkFailureDetector() const {
            return fd.getNetworkFailureDetector();
        }

        /**
         * @brief Permits access to the moversight time service.
         * @return The current time service.
         */
        TimeService &
        Dispatcher::getTimeService() {
            return ts;
        }

        /**
         * @brief Permits access to the moversight time service.
         * @return The current time service.
         */
        const TimeService &
        Dispatcher::getTimeService() const {
            return ts;
        }

        /**
         * @brief Permits access to the moversight merge service.
         * @return The current merge service.
         */
        MergeService &
        Dispatcher::getMergeService() {
            return merge;
        }

        /**
         * @brief Permits access to the moversight merge service.
         * @return The current merge service.
         */
        const MergeService &
        Dispatcher::getMergeService() const {
            return merge;
        }

        /**
         * @brief Permits access to the moversight split service.
         * @return The current split service instance.
         */
        SplitService &
        Dispatcher::getSplitService() {
            return split;
        }

        /**
         * @brief Permits access to the moversight split service.
         * @return The current split service instance.
         */
        const SplitService &
        Dispatcher::getSplitService() const {
            return split;
        }

        /**
         * @brief Permits access to the moversight mobility support service.
         * @return  The current mobility support service instance.
         */
        MobilitySupport &
        Dispatcher::getMobilitySupport() {
            return mob;
        }

        /**
         * @brief Permits access to the moversight mobility support service.
         * @return  The current mobility support service instance.
         */
        const MobilitySupport &
        Dispatcher::getMobilitySupport() const {
            return mob;
        }

        /**
         * @brief Permits access to the local peer state.
         * @return The state of the local peer.
         */
        const State &
        Dispatcher::getLocalState() const {
            return getMembershipService().getLocalState();
        }

        /**
         * @brief Permits access to the local peer state.
         * @return The state of the local peer.
         */
        const SubState &
        Dispatcher::getLocalSubState() const {
            return getMembershipService().getLocalPeer().getSubState();
        }

        /**
         * @brief Permits access to the local peer state operation.
         * @return The state operation of the local peer.
         */
        const StateOperation &
        Dispatcher::getLocalStateOperation() const {
            return getMembershipService().getLocalPeer().getStateOperation();
        }

        // -----------------------------------------------------------------
        // Event service interface
        // -----------------------------------------------------------------

        /**
         * @brief Signal the object <o>.
         * @param o Type of the event
         * @param recipient (optional) Mark this object as to be delivered only to <recipient>
         *
         * This will forward  <o> to the event service.
         */
        void
        Dispatcher::signal(DeliverableObject* o, ObjectListener* recipient) {
            es.signal(o, recipient);
        }

        /**
         * @brief Unsubscribe all subscriptions at the event service for the
         * given object listener.
         * @param ol The object listener to unsubscribe.
         */
        void
        Dispatcher::unsubscribeAll(ObjectListener * ol) {
            es.unsubscribeAll(ol);
        }

        /**
         * @brief Handle an incoming GroupClosedEvent.
         * @param e The event.
         */
        void
        Dispatcher::handleEvent(const GroupClosedEvent & e) {
            finalise();
            initialise();
        }

        /**
         * @brief Handle an incoming FlushDoneEvent.
         * @param e The event.
         */
        void
        Dispatcher::handleEvent(const FlushDoneEvent & e) {
//            if (getLocalSubState() == FLUSHING) {
//                handleSavedMessages();
//            }
        }

        /**
         * @brief Signals the loss of the network connection. At ubeeme, the signal is emitted by the ubeeme mobility manager.
         * If Moversight runs without the base ubeeme framework, the signal receiver has be connected to the local network manager of thrown elsewhere.
         * @see connectionReEstablished
         */
        void
        Dispatcher::signalConnectionLost() {
            signal(new ConnectionLostEvent());
        }

        /**
         * @brief Signals that a network connection is re-established after a connection lost. At ubeeme, the signal is emitted by the ubeeme mobility manager.
         * If Moversight runs without the base ubeeme framework, the signal receiver has be connected to the local network manager of thrown elsewhere.
         * @see connectionLost
         */
        void
        Dispatcher::signalConnectionReEstablished() {
            signal(new ConnectionReEstablishedEvent());
        }

        /**
         * @brief Returns the peer address of the peer, identified by the given PeerID.
         * @param pId The ID of the peer to retrieve its local address.
         * @throw PeerNotFoundException Is the desired peer not member of the group.
         * @return The desired address, if the peer found.
         */
        TransportAddress
        Dispatcher::getLocalAddressFromPeer(PeerID pId) {
            return ms.getPeer(pId).getLocalAddress();
        }

        /**
         * @brief Returns the user selected peer placing strategy type.
         * @see PeerPlacingStrategy.h
         * @return The selected strategy type.
         */
        const PeerPlacingStrategyType &
        Dispatcher::getPeerPlacingStrategyType() const {
            return module.getPeerPlacingStrategyType();
        }

        /**
         * @brief Setups the group from a given roster.
         *
         * This method re-initialise moversight and installs a dedicated view, according the given roster.
         * Some minor plausibility will be run before, but note: In general the view is installed without any warranty of correctness or synchrony.
         * These properties have to be assured by the calling user.
         * @param roster Describes the group to setup.
         * @param localPeerID The peer ID of the local peer to setup.
         * @note This method is only for debug and testing purposes.
         * @throws LogicException Thrown, if the given parameter not setup properly.
         */
        void
        Dispatcher::setupGroupFromRoster(Roster & roster, PeerID localPeerID) {
            //setup all modules
            DEBUG("setupGroupFromRoster - re-initialise moversight");
            initialise();

            //setup the group
            ms.setupGroupFromRoster(roster, localPeerID);

        }

        /**
         * @brief The method sets the standard message validator as active validator.
         */
        void
        Dispatcher::setStandardMessageValidator() {

            //setMessageValidator(STANDARD_VALIDATOR);
            setMessageValidator(NVB_VALIDATOR);
        }

        /**
         * @brief Sets the message validator to the given type. A parameter
         * exception is thrown when the given type is not supported or unknown.
         * @param type The type of the message validator to set.
         */
        void
        Dispatcher::setMessageValidator(MessageValidatorType type) {
            switch (type) {
                case STANDARD_VALIDATOR:
                {
                    if (messageValidator != NULL) {
                        delete messageValidator;
                    }// end if

                    messageValidator = new StandardValidator(*this);
                    break;
                }

                case SEMANTIC_SPLIT_VALIDATOR:
                {
                    if (messageValidator != NULL) {
                        delete messageValidator;
                    }// end if

                    messageValidator = new SemanticSplitValidator(*this);
                    break;
                }

                case NVB_VALIDATOR:
                {
                    if (messageValidator != NULL) {
                        delete messageValidator;
                    }// end if

                    messageValidator = new NVBValidator(*this);
                    break;
                }

                default:
                {
                    DEBUG("setMessageValidator - the given type parameter value " << type << " is not supported by the method");
                    throw ParameterException("setMessageValidator - the given type parameter value is not supported by the method");
                }
            }//End switch
        }

        /**
         * @brief This method permits access to the currently used message validator.
         */
        const MessageValidator *
        Dispatcher::getMessageValidator() const {
            return messageValidator;
        }

        /**
         * @brief Returns the number of peers within the group.
         * @return The size of the group.
         */
        size_t
        Dispatcher::getGroupSize() const {
            return ms.getNumberOfPeers();
        }

        /**
         * @brief Permits access to the maintenance role service.
         * @return A instance of the maintenance role service.
         */
        MaintenanceRoleService &
        Dispatcher::getMaintenanceRoleService() {
            return mrs;
        }

        /**
         * @brief Permits access to the maintenance role service.
         * @return A instance of the maintenance role service.
         */
        const MaintenanceRoleService &
        Dispatcher::getMaintenanceRoleService() const {
            return mrs;
        }

        /**
         * @brief method returns a const reference of the PeerPlacingStrategyMetricType
         * @return const reference of the PeerPlacingStrategyMetricType
         */
        const PeerPlacingStrategyMetricType &
        Dispatcher::getPeerPlacingStrategyMetricType() const {
            return module.getPeerPlacingStrategyMetricType();
        }

        /**
         * @brief method returns a const reference of the MaintanceMomentMetricType
         * @return const reference of the MaintanceMomentMetricType
         */
        const MaintanceMomentMetricType &
        Dispatcher::getMaintanceMomentMetricType() const {
            return module.getMaintanceMomentMetricType();
        }

        /**
         * @brief method returns a const reference of the ResourceValueDistributor
         * @return const reference of the ResourceValueDistributor
         */
        ResourceValueDistributor &
        Dispatcher::getResourceValueDistributor() {
            return rvd;
        }

        /**
         * @brief method returns a const reference of the ResourceValueDistributor
         * @return const reference of the ResourceValueDistributor
         */
        const ResourceValueDistributor &
        Dispatcher::getResourceValueDistributor() const {
            return rvd;
        }

        /**
         * @brief method returns a const reference of the NextViewBuffer
         * @return const reference of the NextViewBuffer
         */
        NextViewBuffer &
        Dispatcher::getNextViewBuffer() {
            return nvb;
        }

        /**
         * @brief method returns a const reference of the NextViewBuffer
         * @return const reference of the NextViewBufferr
         */
        const NextViewBuffer &
        Dispatcher::getNextViewBuffer() const {
            return nvb;
        }

        /**
         * @brief Sets the local peer resources object.
         * @param pres The peer resources object to set.
         */
        void
        Dispatcher::setLocalPeerResources(const PeerResources & pres) {
            ms.setLocalPeerResources(pres);
        }

        /**
         * @brief Permits access to the local peer resources object.
         * @return The local peer resources object.
         */
        const PeerResources &
        Dispatcher::getLocalPeerResources() const {
            return ms.getLocalPeerResources();
        }
    }
}