User Manual, Developers Guide and API Documentation

Subject.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. 16, 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_SUBJECT_HPP
#define WNS_SUBJECT_HPP

#include <WNS/Assure.hpp>
#include <WNS/ObserverInterface.hpp>
#include <WNS/SubjectInterface.hpp>
#include <WNS/IOutputStreamable.hpp>

#include <functional>
#include <list>
#include <algorithm>

namespace wns {

    template <typename NOTIFICATIONINTERFACE>
    class Subject :
        public virtual SubjectInterface<ObserverInterface<NOTIFICATIONINTERFACE> >
    {
    public:
        typedef NOTIFICATIONINTERFACE NotificationInterface;

        typedef ObserverInterface<NotificationInterface> ObserverType;

        typedef SubjectInterface<ObserverType> SubjectType;

        Subject() :
            observers(),
            modificationGuard_(false)
        {
        }

        Subject(const Subject& other) :
            SubjectInterface< ObserverInterface<NOTIFICATIONINTERFACE> >(other),
            observers(other.observers),
            modificationGuard_(other.modificationGuard_)
        {
            this->forEachObserver(
                std::bind2nd(
                    std::mem_fun(&ObserverType::addSubject),
                    this));
        }

        Subject&
        operator=(const Subject& other)
        {
            // remove own observers
            this->forEachObserver(
                std::bind2nd(
                    std::mem_fun(
                        &ObserverType::removeSubject),
                    this));

            // copy subjects from other
            observers = other.observers;

            // observe these subjects
            this->forEachObserver(
                std::bind2nd(
                    std::mem_fun(&ObserverType::addSubject),
                    this));

            return *this;
        }

        virtual
        ~Subject()
        {
            this->forEachObserver(
                std::bind2nd(
                    std::mem_fun(
                        &ObserverType::removeSubject),
                    this));
        }

        template <typename NOTIFICATIONFUNCTIONPTR>
        void
        sendNotifies(const NOTIFICATIONFUNCTIONPTR notificationFunctionPtr)
        {
            this->forEachObserver(std::mem_fun(notificationFunctionPtr));
        }

        template <typename NOTIFICATIONFUNCTIONPTR, typename ARG>
        void
        sendNotifies(const NOTIFICATIONFUNCTIONPTR notificationFunctionPtr, const ARG& arg)
        {
            this->forEachObserver(std::bind2nd(std::mem_fun(notificationFunctionPtr), arg));
        }

        template <typename FUNCTOR>
        FUNCTOR
        forEachObserver(const FUNCTOR& functor)
        {
            ObserverContainer tmp = this->observers;
            return std::for_each(tmp.begin(),
                                 tmp.end(),
                                 functor);
        }

        template <typename FUNCTOR>
        FUNCTOR
        forEachObserverNoDetachAllowed(const FUNCTOR& functor)
        {
            this->modificationGuard_ = true;
            FUNCTOR f = std::for_each(this->observers.begin(),
                                      this->observers.end(),
                                      functor);
            this->modificationGuard_ = false;
            return f;
        }

        bool
        hasObservers() const
        {
            return !observers.empty();
        }

    protected:
        typedef std::list<ObserverType*> ObserverContainer;

    private:
        virtual void
        addObserver(ObserverType* observer)
        {
            if (this->modificationGuard_ == true)
            {
                throw wns::Exception("Tried to modify observer list even though in protected operation");
            }
            assureNotNull(observer);
            assure(
                find(this->observers.begin(), this->observers.end(), observer) == this->observers.end(),
                "Already registered");
            this->observers.push_back(observer);
        }

        virtual void
        removeObserver(ObserverType* observer)
        {
            if (this->modificationGuard_ == true)
            {
                throw wns::Exception("Tried to modify observer list even though in protected operation");
            }
            assureNotNull(observer);
            assure(
                find(this->observers.begin(), this->observers.end(), observer) != this->observers.end(),
                "Not registered");

            this->observers.erase(find(this->observers.begin(), this->observers.end(), observer));
        }


        ObserverContainer observers;
        bool modificationGuard_;
    };
}

#endif // NOT defined WNS_SUBJECT_HPP

---