Event.hpp

/***************************************************************************
 tag: Peter Soetens  Wed Apr 17 13:49:58 CEST 2002  Event.h

                       Event.hpp -  description
                          -------------------
   begin                : Wed April 17 2002
   copyright            : (C) 2002 Peter Soetens
   email                : peter.soetens@mech.kuleuven.ac.be

 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU General Public                   *
 *   License as published by the Free Software Foundation;                 *
 *   version 2 of the License.                                             *
 *                                                                         *
 *   As a special exception, you may use this file as part of a free       *
 *   software library without restriction.  Specifically, if other files   *
 *   instantiate templates or use macros or inline functions from this     *
 *   file, or you compile this file and link it with other files to        *
 *   produce an executable, this file does not by itself cause the         *
 *   resulting executable to be covered by the GNU General Public          *
 *   License.  This exception does not however invalidate any other        *
 *   reasons why the executable file might be covered by the GNU General   *
 *   Public License.                                                       *
 *                                                                         *
 *   This library 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 General Public             *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef ORO_CORELIB_EVENT_HPP
#define ORO_CORELIB_EVENT_HPP

#include "Signal.hpp"
#include "Handle.hpp"
#include "LocalEvent.hpp"
#include <boost/call_traits.hpp>
#include <boost/function.hpp>
#include "NameServerRegistrator.hpp"
#include "Invoker.hpp"

#include "Logger.hpp"
#include "EventProcessor.hpp"
#include <cassert>

namespace RTT
{

    template<
        typename SignatureT // function type R (T1, T2, ..., TN)
    >
    class Event
        : public detail::InvokerSignature<boost::function_traits<SignatureT>::arity,
                                          SignatureT,
                                          boost::shared_ptr< detail::EventBase<SignatureT> > >,
          private NameServerRegistrator<Event<SignatureT>*>
    {
        typedef SignatureT FunctionT;
        std::string mname;
        typedef boost::shared_ptr< detail::EventBase<FunctionT> > EventBasePtr;
        typedef detail::InvokerSignature<boost::function_traits<FunctionT>::arity,
                                         FunctionT,
                                         EventBasePtr > Base;
    public:
        typedef EventProcessor::AsynStorageType AsynStorageType;

        typedef boost::function<SignatureT> SlotFunction;

        typedef Event<SignatureT> EventType;

        typedef SignatureT Signature;

        typedef typename boost::function_traits<SignatureT>::result_type result_type;

        explicit Event(const std::string name )
            : Base( EventBasePtr(new detail::LocalEvent<Signature>()) ),
              NameServerRegistrator<EventType*>(nameserver, name, this),
              mname(name)
        {
            Logger::log() << Logger::Debug << "Event Created with name  : "<< name << Logger::endl;
        }

        Event()
        {
        }

        Event(const Event& m)
            : Base(m),
              mname(m.mname)
        {}

        Event& operator=(const Event& m)
        {
            if ( this == &m )
                return *this;
            mname = m.mname;
            this->impl = m.impl;
            return *this;
        }

        Event(boost::shared_ptr<ActionInterface> implementation)
            : Base( boost::dynamic_pointer_cast< detail::EventBase<Signature> >(implementation) ),
              mname()
        {
            if ( !this->impl && implementation ) {
                log(Error) << "Tried to construct Event from incompatible type."<< endlog();
            }
        }

        Event& operator=(boost::shared_ptr<ActionInterface> implementation)
        {
            if (this->impl == implementation)
                return *this;
            this->impl = boost::dynamic_pointer_cast< detail::EventBase<Signature> >(implementation);
            if ( !this->impl && implementation ) {
                log(Error) << "Tried to assign Event '"<< mname <<"' from incompatible type."<< endlog();
            }
            return *this;
        }

        bool ready() const {
            return this->impl;
        }

        const std::string& getName() const { return mname; }

        int arity() const { return this->impl ? this->impl->arity() : -1; }

        Handle connect(const SlotFunction& f)
        {
            return this->impl ? this->impl->connect( f ) : Handle();
        }

        Handle connect( const SlotFunction& l, EventProcessor* ep, AsynStorageType t = EventProcessor::OnlyFirst)
        {
            return this->impl ? ep->connect( l, *this, t ) : Handle();
        }

        Handle setup(const SlotFunction& f)
        {
            return this->impl ? this->impl->setup( f ) : Handle();
        }

        Handle setup( const SlotFunction& l, EventProcessor* ep, AsynStorageType t = EventProcessor::OnlyFirst)
        {
            return this->impl ? ep->setup( l, *this, t ) : Handle();
        }

        EventBasePtr getImplementation() const { return this->impl; }

        static NameServer<EventType*> nameserver;
    };


    template<
        typename SignatureT
    >
    NameServer<Event<SignatureT>*>
    Event<SignatureT>::nameserver;

}

#endif

---