User Manual, Developers Guide and API Documentation

Wire.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2009
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 5, D-52074 Aachen, Germany
 * phone: ++49-241-80-27910,
 * fax: ++49-241-80-22242
 * email: info@openwns.org
 * www: http://www.openwns.org
 * _____________________________________________________________________________
 *
 * openWNS is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 2 as published by the
 * Free Software Foundation;
 *
 * openWNS 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 Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

#ifndef COPPER_WIRE_HPP
#define COPPER_WIRE_HPP

#include <COPPER/Transmission.hpp>
#include <COPPER/ReceiverInterface.hpp>

#include <WNS/events/CanTimeout.hpp>
#include <WNS/pyconfig/View.hpp>
#include <WNS/Broker.hpp>
#include <WNS/Singleton.hpp>
#include <WNS/RoundRobin.hpp>
#include <WNS/logger/Logger.hpp>
#include <WNS/osi/PDU.hpp>
#include <WNS/service/dll/Address.hpp>
#include <WNS/events/scheduler/Interface.hpp>
#include <WNS/osi/PDU.hpp>

#include <list>
#include <map>

namespace copper
{
    class WireInterface
    {
    public:
        virtual
        ~WireInterface()
        {}

        virtual void
        sendData(const UnicastTransmissionPtr& ut, simTimeType duration) = 0;

        virtual void
        sendData(const BroadcastTransmissionPtr& bt, simTimeType duration) = 0;

        virtual void
        stopTransmission(const wns::osi::PDUPtr& pdu) = 0;

        virtual simTimeType
        blockedSince() const = 0;

        virtual void
        addReceiver(
            ReceiverInterface* r,
            const wns::service::dll::UnicastAddress& macAddress) = 0;
    };

    class Wire :
        public virtual WireInterface
    {
    public:
        explicit
        Wire(const wns::pyconfig::View& config);

        void
        sendData(const UnicastTransmissionPtr& ut, simTimeType duration);

        void
        sendData(const BroadcastTransmissionPtr& bt, simTimeType duration);

        void
        stopTransmission(const wns::osi::PDUPtr& pdu);

        simTimeType
        blockedSince() const;

        void
        addReceiver(
            ReceiverInterface* r,
            const wns::service::dll::UnicastAddress& macAddress);

    private:
        class TransmissionEndEventBase
        {
        public:
            virtual
            ~TransmissionEndEventBase()
            {}

            virtual TransmissionPtr
            getTransmission() const = 0;
        };

        template<typename TRANSMISSIONTYPE>
        class TransmissionEndEvent :
            public TransmissionEndEventBase
        {
        public:
            TransmissionEndEvent(Wire* w, const TRANSMISSIONTYPE& t) :
                wire(w),
                transmission(t)
            {
                assure(this->wire, "must be non-NULL");
                assure(this->transmission, "must be non-NULL");
            }

            void
            operator()()
            {
                this->wire->stopTransmission(transmission);
            }

            virtual TransmissionPtr
            getTransmission() const
            {
                return this->transmission;
            }

        private:
            Wire* wire;

            TRANSMISSIONTYPE transmission;
        };

        typedef std::map< wns::osi::PDUPtr, wns::events::scheduler::IEventPtr >
        TransmissionEndEventContainer;

        typedef std::map< wns::osi::PDUPtr, TransmissionPtr >
        Transmissions;

        typedef std::map<wns::service::dll::UnicastAddress, ReceiverInterface*>
        Address2ReceiverContainer;

        void
        stopTransmission(const UnicastTransmissionPtr& ut);

        void
        stopTransmission(const BroadcastTransmissionPtr& bt);

        bool
        isFree() const;

        void
        checkForCollision(const TransmissionPtr& t);

        void
        signalCopperFreeAgainToReceivers();

        template <typename TRANSMISSIONTYPE>
        void
        addTransmissionEndEvent(const TRANSMISSIONTYPE& t, simTimeType arrivalTime)
        {
            assure(t, "must be non-NULL");
            assure(
                this->transmissions.find(t->pdu) == this->transmissions.end(),
                "already got this event");

            TransmissionEndEvent<TRANSMISSIONTYPE> te (this, t);

            
            this->transmissions[t->pdu] = te.getTransmission();
            this->transmissionEndEvents[t->pdu] =
                wns::simulator::getEventScheduler()->schedule(te, arrivalTime);
            
        }

        template <typename TRANSMISSIONTYPE>
        wns::simulator::Time
        sendDataGeneric(const TRANSMISSIONTYPE& transmission, simTimeType duration)
        {
            assure(transmission, "must be non-NULL");
            // if wire is not already blocked set time to now and
            // tell every Receiver the wire is busy
            if (this->isFree())
            {
                this->timeWireBlocked = wns::simulator::getEventScheduler()->getTime();
                std::for_each(
                    receivers.begin(),
                    receivers.end(),
                    std::mem_fun(&ReceiverInterface::onCopperBusy));
            }

            wns::simulator::Time arrivalTime =
                wns::simulator::getEventScheduler()->getTime() + duration;
            this->checkForCollision(transmission);

            this->addTransmissionEndEvent(transmission, arrivalTime);
            return arrivalTime;
        }

        void
        removeTransmissionEndEvent(const TransmissionPtr& transmission);

        std::string name;

        wns::RoundRobin<ReceiverInterface*> roundRobin;

        std::list<ReceiverInterface*> receivers;

        TransmissionEndEventContainer transmissionEndEvents;

        Transmissions transmissions;

        Address2ReceiverContainer addressMapping;

        wns::logger::Logger logger;

        simTimeType timeWireBlocked;
    };

    typedef wns::Broker<Wire> WireBroker;
}

#endif // NOT defined COPPER_WIRE_HPP

---