EventService.hpp

/***************************************************************************
  tag: Peter Soetens  Wed Jan 18 14:11:40 CET 2006  EventService.hpp

                        EventService.hpp -  description
                           -------------------
    begin                : Wed January 18 2006
    copyright            : (C) 2006 Peter Soetens
    email                : peter.soetens@mech.kuleuven.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 EVENT_SERVICE_HPP
#define EVENT_SERVICE_HPP

#include "Logger.hpp"
#include "FunctorFactory.hpp"
#include "OperationFactory.hpp"
#include "EventHook.hpp"
#include "Event.hpp"
#include "CompletionProcessor.hpp"
#include "EventC.hpp"
#include "ConnectionC.hpp"
#include "DataSourceArgsEvent.hpp"
#include <boost/static_assert.hpp>
#include <boost/type_traits/function_traits.hpp>

namespace RTT
{

    class ExecutionEngine;

    class RTT_API EventService
        : public OperationFactory< ActionInterface* >
    {
        // creates event hooks
        typedef std::map<std::string, detail::FunctorFactoryPart<detail::EventHookBase*>* > Hooks;
        Hooks mhooks;
        // creates emittor objects
        typedef std::map<std::string, boost::shared_ptr<ActionInterface> > Events;
        Events mevents;

        ExecutionEngine* eeproc;
        EventProcessor* eproc;
    public:
        typedef OperationFactory< ActionInterface* > Factory;

        EventService( ExecutionEngine* ee );

        EventService( EventProcessor* ep = 0 );

        ~EventService();

        EventProcessor* getEventProcessor();

        void setEventProcessor(EventProcessor* ep);

        void clear();

        std::vector<std::string> getEvents() const;

        template< class EventT>
        bool addEvent( EventT* e ) {
            Logger::In in("EventService");
            // All addEvent functions below first call this function.
            // Hence all these checks are always performed.
            std::string ename = e->getName();
            if ( ename.empty() || e->ready() == false ) {
                log(Error) << "Can not use addEvent with uninitialised Event: give your event a name upon construction." << endlog();
                return false;
            }

            if ( mevents.count(ename) != 0 ) {
                log(Error) << "Can not add Event '"<<ename<<"': name already used." << endlog();
                return false;
            }

            mevents[ename] = e->getImplementation();
            return true;
        }

        template<class Signature>
        boost::shared_ptr<ActionInterface> getEvent(const std::string& ename)
        {
            if ( mevents.count(ename) )
                return mevents[ename];
            return boost::shared_ptr<ActionInterface>();
        }

        template< class EventT>
        bool addEvent( EventT* e, const char* description )
        {
            BOOST_STATIC_ASSERT( boost::function_traits<typename EventT::Signature>::arity == 0 );

            if ( this->addEvent( e ) == false)
                return false;

            this->add(e->getName(),
                      new detail::OperationFactoryPart0<ActionInterface*,
                      detail::DataSourceArgsEvent<typename EventT::Signature> >( boost::bind(&EventT::operator(),e), description) );

            this->mhooks[e->getName()]
                = new detail::FunctorFactoryPart0<detail::EventHookBase*, detail::EventHookGenerator<EventT> >( detail::EventHookGenerator<EventT>(e) );

            return true;
        }

        template< class EventT>
        bool addEvent( EventT* e, const char* description,
                       const char* arg1, const char* arg1_description )
        {
            BOOST_STATIC_ASSERT( boost::function_traits<typename EventT::Signature>::arity == 1 );

            if ( this->addEvent( e ) == false)
                return false;
            this->add(e->getName(),
                      new detail::OperationFactoryPart1<ActionInterface*,
                      detail::DataSourceArgsEvent<typename EventT::Signature> >( boost::bind(&EventT::operator(),e, _1),
                      description,
                      arg1, arg1_description) );

            this->mhooks[e->getName()]
                = new detail::FunctorFactoryPart1<detail::EventHookBase*, detail::EventHookGenerator<EventT> >( detail::EventHookGenerator<EventT>(e) );

            return true;
        }

        template< class EventT>
        bool addEvent( EventT* e, const char* description,
                       const char* arg1, const char* arg1_description,
                       const char* arg2, const char* arg2_description )
        {
            BOOST_STATIC_ASSERT( boost::function_traits<typename EventT::Signature>::arity == 2 );

            if ( this->addEvent( e ) == false)
                return false;
            this->add(e->getName(),
                      new detail::OperationFactoryPart2<ActionInterface*,
                      detail::DataSourceArgsEvent<typename EventT::Signature> >( boost::bind(&EventT::operator(),e,_1,_2),
                      description,
                      arg1, arg1_description,
                      arg2, arg2_description) );

            this->mhooks[e->getName()]
                = new detail::FunctorFactoryPart2<detail::EventHookBase*, detail::EventHookGenerator<EventT> >( detail::EventHookGenerator<EventT>(e) );

            return true;
        }

        template< class EventT>
        bool addEvent( EventT* e, const char* description,
                       const char* arg1, const char* arg1_description,
                       const char* arg2, const char* arg2_description,
                       const char* arg3, const char* arg3_description)
        {
            BOOST_STATIC_ASSERT( boost::function_traits<typename EventT::Signature>::arity == 3 );

            if ( this->addEvent( e ) == false)
                return false;
            this->add(e->getName(),
                      new detail::OperationFactoryPart3<ActionInterface*,
                      detail::DataSourceArgsEvent<typename EventT::Signature> >( boost::bind(&EventT::operator(),e,_1,_2,_3),
                      description,
                      arg1, arg1_description,
                      arg2, arg2_description,
                      arg3, arg3_description));

            this->mhooks[e->getName()]
                = new detail::FunctorFactoryPart3<detail::EventHookBase*, detail::EventHookGenerator<EventT> >( detail::EventHookGenerator<EventT>(e) );
            return true;
        }

        template< class EventT>
        bool addEvent( EventT* e, const char* description,
                       const char* arg1, const char* arg1_description,
                       const char* arg2, const char* arg2_description,
                       const char* arg3, const char* arg3_description,
                       const char* arg4, const char* arg4_description )
        {
            BOOST_STATIC_ASSERT( boost::function_traits<typename EventT::Signature>::arity == 4 );

            if ( this->addEvent( e ) == false)
                return false;
            this->add(e->getName(),
                      new detail::OperationFactoryPart4<ActionInterface*,
                      detail::DataSourceArgsEvent<typename EventT::Signature> >( boost::bind(&EventT::operator(),e,_1,_2,_3,_4),
                      description,
                      arg1, arg1_description,
                      arg2, arg2_description,
                      arg3, arg3_description,
                      arg4, arg4_description));

            this->mhooks[e->getName()]
                = new detail::FunctorFactoryPart4<detail::EventHookBase*, detail::EventHookGenerator<EventT> >( detail::EventHookGenerator<EventT>(e) );
            return true;
        }


        bool hasEvent(const std::string& ename) const;

        int arity(const std::string& name) const;

        bool removeEvent( const std::string& ename );

        EventC setupEmit(const std::string& ename) const;

        ConnectionC setupConnection(const std::string& ename) const;

        Handle setupSyn(const std::string& ename,
                        boost::function<void(void)> func,
                        std::vector<DataSourceBase::shared_ptr> args ) const;

        Handle setupAsyn(const std::string& ename,
                         boost::function<void(void)> afunc,
                         const std::vector<DataSourceBase::shared_ptr>& args,
                         EventProcessor* ep = CompletionProcessor::Instance(),
                         EventProcessor::AsynStorageType s_type = EventProcessor::OnlyFirst) const;

        ActionInterface* getEvent(const std::string& ename,const std::vector<DataSourceBase::shared_ptr>& args) const;

    };


}

#endif