User Manual, Developers Guide and API Documentation

StrategyInterface.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 WNS_SCHEDULER_STRATEGY_STRATEGYINTERFACE_HPP
#define WNS_SCHEDULER_STRATEGY_STRATEGYINTERFACE_HPP

#include <WNS/service/phy/phymode/PhyModeInterface.hpp>
#include <WNS/service/phy/ofdma/DataTransmission.hpp>
#include <WNS/scheduler/strategy/apcstrategy/APCStrategyInterface.hpp>
#include <WNS/scheduler/strategy/dsastrategy/DSAStrategyInterface.hpp>
//#include <WNS/scheduler/MapInfoProviderInterface.hpp>
#include <WNS/scheduler/CallBackInterface.hpp>
#include <WNS/scheduler/SchedulingMap.hpp>
#include <WNS/scheduler/SchedulerTypes.hpp>
#include <WNS/StaticFactory.hpp>
#include <WNS/PyConfigViewCreator.hpp>
#include <WNS/SmartPtr.hpp>

namespace wns { namespace scheduler {
        namespace queue {
            class QueueInterface;
        }
        namespace harq {
            class HARQInterface;
        }
        namespace grouper {
            class GroupingProviderInterface;
        }
        namespace strategy { namespace tests {
                class StrategyTest; // friend
            }}

        class RegistryProxyInterface;
        class CallBackInterface;
    }} // forward declarations

namespace wns { namespace scheduler { namespace strategy {
            class StrategyInput // NEW [rs]
            {
            public:
                StrategyInput(int _fChannels,
                              double _slotLength,
                              int _numberOfTimeSlots,
                              int _maxSpatialLayers,
                              CallBackInterface* _callBackObject);

                StrategyInput(MapInfoEntryPtr _mapInfoEntryFromMaster,
                              CallBackInterface* _callBackObject);

                StrategyInput(int _fChannels,
                              double _slotLength,
                              int _numberOfTimeSlots,
                              int _maxSpatialLayers,
                              MapInfoEntryPtr _mapInfoEntryFromMaster,
                              CallBackInterface* _callBackObject);

                StrategyInput();

                ~StrategyInput();

                virtual void 
                setFrameNr(int _frameNr);

                virtual int 
                getFrameNr() const { return frameNr; };

                virtual int 
                getFChannels() const { return fChannels; };

                virtual double 
                getSlotLength() const { return slotLength; };

                virtual int 
                getNumberOfTimeSlots() const { return numberOfTimeSlots; };

                virtual int 
                getMaxSpatialLayers() const { return maxSpatialLayers; };

                virtual bool 
                frameNrIsValid() const;

                virtual void 
                setDefaultPhyMode(wns::service::phy::phymode::PhyModeInterfacePtr _phyModePtr);

                virtual void 
                setDefaultTxPower(wns::Power _txPower);

                virtual 
                wns::scheduler::SchedulingMapPtr getEmptySchedulingMap() const;

                virtual 
                wns::scheduler::SchedulingMapPtr getInputSchedulingMap() const;

                virtual void 
                setInputSchedulingMap(wns::scheduler::SchedulingMapPtr _inputSchedulingMap);

                virtual std::string toString() const;
            public:
                int fChannels;

                double slotLength;

                int numberOfTimeSlots;

                int numberOfAntennas;

                bool beamforming;

                int maxSpatialLayers; 

                CallBackInterface* callBackObject;

                MapInfoEntryPtr mapInfoEntryFromMaster;

                wns::scheduler::SchedulingMapPtr inputSchedulingMap;

                wns::service::phy::phymode::PhyModeInterfacePtr defaultPhyModePtr;

                wns::Power defaultTxPower;

                int frameNr;
            }; // class StrategyInput

            class StrategyResult // NEW [rs]
                    : virtual public wns::RefCountable
            {
            public:
                StrategyResult(wns::scheduler::SchedulingMapPtr _schedulingMap,
                               wns::scheduler::MapInfoCollectionPtr _bursts);

                StrategyResult(wns::scheduler::SchedulingMapPtr _schedulingMap,
                               wns::scheduler::MapInfoCollectionPtr _bursts,
                               wns::scheduler::GroupingPtr _sdmaGrouping);

                virtual 
                ~StrategyResult();

                virtual std::string 
                toString() const;

                virtual float 
                getResourceUsage() const;

                virtual int 
                getNumberOfCompoundsInBursts() const;

                virtual void 
                deleteCompoundsInBursts();
            public:
                wns::scheduler::SchedulingMapPtr schedulingMap;

                MapInfoCollectionPtr bursts; // historic name

                //wns::scheduler::AntennaPatternsPerUser antennaPatterns;
                wns::scheduler::GroupingPtr sdmaGrouping;
            }; // class StrategyResult

            typedef SmartPtr<StrategyResult> StrategyResultPtr;

            typedef std::vector< StrategyResultPtr > StrategyResultHistory;

            class StrategyInterface
            {
            public:
                virtual ~StrategyInterface() {};

                virtual MapInfoCollectionPtr getMapInfo() const = 0;

                virtual void 
                setColleagues(queue::QueueInterface* _queue,
                   grouper::GroupingProviderInterface* _grouper,
                   RegistryProxyInterface* _registry,
                   wns::scheduler::harq::HARQInterface* _harq) = 0;

                virtual void 
                onColleaguesKnown() = 0;

                virtual void 
                setFriends(wns::service::phy::ofdma::BFInterface* ) = 0;

                virtual StrategyResult
                startScheduling(const StrategyInput& StrategyInput) = 0;

                virtual wns::scheduler::SchedulerSpotType
                getSchedulerSpotType() const = 0;

                virtual bool 
                isTx() const = 0;


                virtual bool 
                isNewStrategy() const = 0;

                virtual wns::scheduler::PowerCapabilities
                getPowerCapabilities(const UserID user) const = 0;

                virtual float 
                getResourceUsage() const = 0;

            protected:
                virtual StrategyResult
                doStartScheduling(SchedulerStatePtr schedulerState,
                                  SchedulingMapPtr schedulingMap) = 0;

                virtual SchedulerStatePtr
                getNewSchedulerState() = 0;

                virtual SchedulerStatePtr
                revolveSchedulerState(const StrategyInput& strategyInput) = 0;

                virtual SchedulerStatePtr
                getSchedulerState() = 0;

            private:
                friend class wns::scheduler::strategy::tests::StrategyTest;
            };

            typedef wns::PyConfigViewCreator<StrategyInterface, StrategyInterface> StrategyCreator;
            typedef wns::StaticFactory<StrategyCreator> StrategyFactory;

        }}} // namespace wns::scheduler::strategy
#endif // WNS_SCHEDULER_STRATEGY_STRATEGYINTERFACE_HPP

---