User Manual, Developers Guide and API Documentation

ARQ.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * 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 WNS_LDK_ARQ_HPP
#define WNS_LDK_ARQ_HPP

#include <WNS/ldk/arq/statuscollector/Interface.hpp>

#include <WNS/ldk/FunctionalUnit.hpp>
#include <WNS/ldk/Command.hpp>
#include <WNS/ldk/FUNConfigCreator.hpp>
#include <WNS/ldk/Delayed.hpp>

#include <WNS/Birthmark.hpp>
#include <WNS/Cloneable.hpp>
#include <WNS/pyconfig/View.hpp>
#include <WNS/StaticFactory.hpp>

namespace wns { namespace ldk { namespace arq {

    class ARQCommand :
        public Command
    {
    public:
        ARQCommand() :
            localTransmissionCounter(0)
        {
        }

        typedef long long int SequenceNumber;

        virtual bool
        isACK() const = 0;

        size_t localTransmissionCounter;
    };

    class ARQ :
        virtual public FunctionalUnit,
        virtual public DelayedInterface
    {
    public:
        ARQ(const wns::pyconfig::View& config) :
            isPreferingACK(true)
        {
            pyconfig::View statusCollectorConfig(config, "arqStatusCollector");
            std::string statusCollectorName = statusCollectorConfig.get<std::string>("__plugin__");
            this->statusCollector = statuscollector::StatusCollectorFactory::creator(statusCollectorName)->create(statusCollectorConfig);
        }

        virtual
        ~ARQ()
        {
            delete this->statusCollector;
        }

        void
        preferACK(bool _isPreferingACK)
        {
            isPreferingACK = _isPreferingACK;
        }

        bool
        preferACK() const
        {
            return isPreferingACK;
        }

        //
        // partial Delayed interface implementation
        //

        virtual const CompoundPtr
        hasSomethingToSend() const
        {
            CompoundPtr it;
            if(preferACK())
            {
                it = hasACK();
                if(!it)
                {
                    it = hasData();
                }
            }
            else
            {
                it = hasData();
                if(!it)
                {
                    it = hasACK();
                }
            }
            return it;
        } // hasSomethingToSend()

        virtual CompoundPtr
        getSomethingToSend()
        {
            assure(
                hasSomethingToSend(),
                "hasSomethingToSend has not been called to check wheter there is something to send.");

            if(preferACK())
            {
                if(hasACK())
                {
                    return getACK();
                }
                return getData();
            }
            else
            {
                if(hasData())
                {
                    return getData();
                }
                return getACK();
            }
        } // getSomethingToSend

        double
        getSuccessRate(const CompoundPtr& compound)
        {
            return(this->statusCollector->getSuccessRate(compound));
        }

        void
        resetStatusCollector()
        {
            this->statusCollector->reset();
        }

    protected:
        virtual const CompoundPtr
        hasACK() const = 0;

        virtual const CompoundPtr
        hasData() const = 0;

        virtual CompoundPtr
        getACK() = 0;

        virtual CompoundPtr
        getData() = 0;
        
        statuscollector::Interface* statusCollector;
        
//      /**
//       * @brief Returns the distance between two sequence numbres
//       *
//       * @intern This method enables different implementations of
//       * sequence numbers. For the implementation we're currently
//       * using (long long int) the method is very easy. For real sequence
//       * numbers, that warp around, it's a little bit harder (see
//       * commented code below).
//       */
//      static int
//      distance(
//          const ARQCommand::SequenceNumber& a,
//          const ARQCommand::SequenceNumber& b)
//      {
//          assure(a>=0, "Negative Sequence Number");
//          assure(b>=0, "Negative Sequence Number");

//          return a - b;

//          // assure(windowSize>=2, "Bad windowSize");
//          // assure(sequenceNumberSize>= 2*windowSize, "Too small modDivisor");
//          // return (a - b + sequenceNumberSize) % sequenceNumberSize;
//      }
        
    private:
        bool isPreferingACK;
    };

    typedef FUNConfigCreator<ARQ> ARQCreator;
    typedef wns::StaticFactory<ARQCreator> ARQFactory;
    
    
}}}

#endif // NOT defined WNS_LDK_ARQ_HPP

---