/*
 * File:   MTTimer.cc
 * Author: jgaebler
 *
 * Created on April 29, 2010, 10:41 AM
 */

#include "MTTimer.h"

#include "mt/MessageTransfer.h"
#include "Dispatcher.h"
#include "ReferenceMonitorTimer.h"


namespace ubeeme {
    namespace moversight {

        /**
         * @brief Constructor
         * @param aMt the Message Transfer reference
         */
        MTTimer::MTTimer(MessageTransfer & aMt) : ReferenceMonitorTimer<MessageReference>(aMt), mt(aMt) {
            setNumberOfRetries(MT_NUMBER_OF_MAX_RETRIES);
        }

        /**
         * @brief Copy Constructor
         * @param other The instance to copy
         */
        MTTimer::MTTimer(const MTTimer& other) : ReferenceMonitorTimer<MessageReference>(other), mt(other.mt) {
            operator =(other);
        }

        /**
         * @brief Destructor
         */
        MTTimer::~MTTimer() {
        }

        // missingPeers methods

        /**
         * @brief Returns the number of missing peers stored within this timer.
         * @return the number of currently missed peers for this timer
         */
        size_t
        MTTimer::getNumberOfMissingPeers() {
            const PeerIDList list = getPeerIDList();
            return list.size();
        }

        /**
         * @brief Removes the given address from the list of missing peers
         * @param pId the ID to remove from the list of missing peers
         */
        void
        MTTimer::removeMissingPeer(PeerID pId) {
            PeerIDList list = getPeerIDList();
            list.remove(pId);
            setPeerIDList(list);
        }

        // foreignMissingPeers methods

        /**
         * @brief Returns the size of the foreign missing peers list.
         * @return the size of the foreign missing peers list
         */
        size_t
        MTTimer::getNumberOfForeignMissingPeers() {
            return getForeignMissingPeers().size();
        }

        /**
         * @brief Removes a peer from the list of foreign missed peers.
         * @param pId the peer to remove
         */
        void
        MTTimer::removeForeignMissingPeer(PeerID pId) {
            getForeignMissingPeers().remove(pId);
        }

        /**
         * @brief Assignment operator
         * @param other The instance to assign
         * @return a reference to this instance
         */
        MTTimer&
                MTTimer::operator=(const MTTimer& other) {

            if (this == &other) return *this;

            ReferenceMonitorTimer<MessageReference>::operator=(other);

            return *this;
        }

        /**
         * @brief Returns the local time
         * @return local time
         */
        VirtualLogicalTime
        MTTimer::getLt() {
            return storage.get<VirtualLogicalTime>("lt");
        }

        /**
         * @brief Sets the local time
         * @param aLt The local time to be set
         */
        void
        MTTimer::setLt(const VirtualLogicalTime& aLt) {
            storage.set<VirtualLogicalTime>("lt", aLt);
        }

        /**
         * @brief returns the list of missing peers
         * @return the PeerIDLIst of missing peers
         */
        PeerIDList
        MTTimer::getMissingPeers()  {
            return getPeerIDList();
        }

        /**
         * @brief Sets the missing peers
         * @param list The PeerIDList to be set as missing
         */
        void
        MTTimer::setMissingPeers(const PeerIDList& list) {
            setPeerIDList(list);
        }

        /**
         * @brief Returns the foreign missing peers
         * @return PeerIDList of the foreign missing peers
         */
        PeerIDList
        MTTimer::getForeignMissingPeers() {
            return storage.get<PeerIDList>("foreignMissingPeers");
        }

        /**
         * @brief Sets the foreign missings peers
         * @param foreignMissingPeers the PeerIDlist of foreign missing peers
         */
        void
        MTTimer::setForeignMissingPeers(const PeerIDList& foreignMissingPeers) {
            storage.set<PeerIDList>("foreignMissingPeers", foreignMissingPeers);
        }
    }
}