User Manual, Developers Guide and API Documentation

CommandProxy.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_COMMANDPROXY_HPP
#define WNS_LDK_COMMANDPROXY_HPP

#include <WNS/container/Registry.hpp>
#include <WNS/Singleton.hpp>
#include <WNS/logger/Logger.hpp>

#include <WNS/osi/PCI.hpp>

#include <vector>
#include <cstdlib>

namespace wns { namespace ldk {

    class Command;
    class CommandPool;
    class CommandTypeSpecifierInterface;
    class CopyCommandInterface;
    class CommandReaderInterface;

    namespace fun {
        class FUN;
    }

    class CommandProxy
    {
    public:
        typedef unsigned long int CommandIDType;
    private:

        // During registration, each FunctionalUnit will be tagged with
        // the position within the CommandPool using
        // CommandTypeSpecifierInterface::setPCIID().
        //
        // Later on, each FunctionalUnit can be queried for its Command
        // position within the commandPool by calling
        // CommandTypeSpecifierInterface::getPCIID().

        friend class CommandReaderInterface;
        friend class CommandPool;

        typedef std::vector<CommandTypeSpecifierInterface*>
        CommandTypeSpecifierContainer;

        typedef std::vector<bool>
        BoolContainer;

        typedef wns::container::Registry<std::string, CommandIDType>
        CommandIDRegistry;

        typedef wns::container::Registry<CommandIDType, CommandReaderInterface*, wns::container::registry::DeleteOnErase>
        CommandReaderRegistry;

        typedef wns::container::Registry<CommandIDType, CopyCommandInterface*, wns::container::registry::DeleteOnErase>
        CopyCommandInterfaceRegistry;

        wns::logger::Logger logger;

    public:
        CommandProxy() :
            logger("default","default"),
            commandTypeSpecifiers(),
            commandTypeSpecifierCloned()
        {
            wns::simulator::getResetSignal()->connect(&wns::ldk::CommandProxy::clearRegistries); 
        }

        CommandProxy(const wns::pyconfig::View& config);

        ~CommandProxy();

        void
        addFunctionalUnit(
            const std::string& commandName,
            CommandTypeSpecifierInterface* functionalUnit);

        void
        removeFunctionalUnit(const std::string& commandName);

        CommandPool*
        createCommandPool(const fun::FUN* origin = NULL) const;

        CommandPool*
        createReply(
            const CommandPool* original,
            const CommandTypeSpecifierInterface* questioner) const;

        void
        calculateSizes(
            const CommandPool* commandPool,
            Bit& commandPoolSize, Bit& sduSize,
            const CommandTypeSpecifierInterface* questioner = NULL) const;

        void
        commitSizes(CommandPool* commandPool,
                const CommandTypeSpecifierInterface* commiter = NULL) const;

        void
        commitSizes(CommandPool* commandPool,
                    const CommandIDType& id) const;

        Command*
        getCommand(
            const CommandPool* commandPool,
            const CommandTypeSpecifierInterface* kind) const;

        Command*
        getCommand(const CommandPool* commandPool, CommandIDType n) const;

        template <typename COMMANDTYPE>
        COMMANDTYPE*
                getCommand(const CommandPool* commandPool, const std::string& role) const
        {
            assure(this->getCommandIDRegistry().knows(role), "Argument for unknown role="<<role<<" requested.");
            Command* theCommand = this->getCommand(commandPool, this->getCommandIDRegistry().find(role));
            assureType(theCommand, COMMANDTYPE*);
            return dynamic_cast<COMMANDTYPE*>(theCommand);
        } // getCommand

        CommandReaderInterface*
                getCommandReader(const std::string& role) const;

        static Command*
        activateCommand(
            CommandPool* commandPool,
            const CommandTypeSpecifierInterface* kind);

        Command*
        activateCommand(
            CommandPool* commandPool,
            const CommandIDType& id);

        bool
        commandIsActivated(
            const CommandPool* commandPool,
            const CommandTypeSpecifierInterface* kind) const;

        bool
        commandIsActivated(
            const CommandPool* commandPool,
            const CommandIDType& id) const;

        void
        copy(CommandPool* dst, const CommandPool* src) const;

        void
        partialCopy(
            const CommandTypeSpecifierInterface* initiator,
            CommandPool* dst, const CommandPool* src) const;

        static void
        clearRegistries();

            std::string
            printCommandIDRegistryKeys()
            {
                return dumpCommandIDRegistry();
            }

#ifndef NDEBUG
        size_t
        getCommandObjSize(const CommandIDType& id) const;
#endif
    private:
        void
        cleanup(CommandPool* commandPool) const;

        wns::ldk::Command*
        commit(CommandPool* commandPool,
               const CommandTypeSpecifierInterface* commiter = NULL) const;

        const CommandTypeSpecifierInterface*
        getCommandTypeSpecifier(CommandIDType id) const;

        const CommandTypeSpecifierInterface*
        getNext(
            const CommandPool* commandPool,
            const CommandTypeSpecifierInterface* questioner) const;

        CommandTypeSpecifierContainer commandTypeSpecifiers;

        BoolContainer commandTypeSpecifierCloned;

        static CommandIDType serial;

        static CommandIDRegistry&
        getCommandIDRegistry();

        static std::string
        dumpCommandIDRegistry();

        static CopyCommandInterfaceRegistry&
        getCopyCommandRegistry();

        static CommandReaderRegistry&
        getCommandReaderRegistry();

    };

} // ldk
} // wns

#endif // NOT defined WNS_LDK_COMMANDPROXY_HPP

---