TaskContext.hpp

Go to the documentation of this file.

/***************************************************************************
  tag: Peter Soetens  Tue Dec 21 22:43:08 CET 2004  TaskContext.hpp

                        TaskContext.hpp -  description
                           -------------------
    begin                : Tue December 21 2004
    copyright            : (C) 2004 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_TASK_CONTEXT_HPP
#define ORO_TASK_CONTEXT_HPP


#include "rtt-config.h"
#include "Service.hpp"
#include "ServiceRequester.hpp"
#include "DataFlowInterface.hpp"
#include "ExecutionEngine.hpp"
#include "base/TaskCore.hpp"
#include <boost/make_shared.hpp>

#include <string>
#include <map>

namespace RTT
{
    class RTT_API TaskContext
        : public base::TaskCore
    {
    public:
        typedef std::vector< std::string > PeerList;

        TaskContext( const std::string& name, TaskState initial_state = Stopped );

        TaskContext(const std::string& name, ExecutionEngine* parent, TaskState initial_state = Stopped );

        virtual ~TaskContext();

        virtual const std::string& getName() const { return tcservice->getName(); }

        bool setActivity( base::ActivityInterface* new_act );

        base::ActivityInterface* getActivity();

        template<typename T>
        T* getActivity() { return dynamic_cast<T*>(getActivity()); }

        virtual void clear();

        virtual bool ready();

        virtual bool start();
        virtual bool stop();

        virtual bool addPeer( TaskContext* peer, std::string alias = "" );

        virtual void removePeer( const std::string& name );

        virtual void removePeer( TaskContext* peer );

        virtual bool connectPeers( TaskContext* peer );

        virtual void disconnect();

        virtual void disconnectPeers( const std::string& name );

        virtual PeerList getPeerList() const;

        virtual bool hasPeer( const std::string& peer_name ) const;

        virtual TaskContext* getPeer(const std::string& peer_name ) const;
        Service::shared_ptr provides() { return tcservice; }

        Service::shared_ptr provides(const std::string& service_name) { return tcservice->provides(service_name); }

        ServiceRequester::shared_ptr requires() { return tcrequests; }

        ServiceRequester::shared_ptr requires(const std::string& service_name) {
            return tcrequests->requires(service_name);
        }

        virtual bool connectServices( TaskContext* peer);

        template<class ServiceType>
        boost::shared_ptr<ServiceType> getProvider(const std::string& name) {
            if (!prepareProvide(name)) return boost::shared_ptr<ServiceType>();
            LocalServices::iterator it = localservs.find(name);
            if (  it != localservs.end() ) {
                return boost::dynamic_pointer_cast<ServiceType>(it->second);
            }
            boost::shared_ptr<ServiceType> st = boost::make_shared<ServiceType>(this);
            st->connectTo( provides(name) );
            localservs[name] = st;
            return st;
        }

        bool loadService(const std::string& service_name);

        template<class Signature>
        Operation<Signature>& addOperation( Operation<Signature>& op )
        {
            return tcservice->addOperation(op);
        }

        template<class Func, class Service>
        Operation< typename internal::GetSignature<Func>::Signature >&
        addOperation( const std::string name, Func func, Service* serv, ExecutionThread et = ClientThread )
        {
            return tcservice->addOperation(name,func, serv, et);
        }

        template<class Signature>
        Operation< Signature >&
        addOperation( const std::string name, Signature* func, ExecutionThread et = ClientThread )
        {
            return tcservice->addOperation(name, func, et);
        }

        OperationInterfacePart* getOperation( std::string name )
        {
            return tcservice->getOperation(name);
        }

        OperationInterface* operations() { return this->provides().get(); }

        template<class T>
        bool addAttribute( const std::string& name, T& attr) {
            return tcservice->addAttribute(name, attr);
        }

        template<class T>
        bool addConstant( const std::string& name, const T& attr) {
            return tcservice->addConstant(name, attr);
        }

        bool addAttribute( base::AttributeBase& a )
        {
            return tcservice->addAttribute(a);
        }

        base::AttributeBase* getAttribute( const std::string& name ) const
        {
            return tcservice->getAttribute(name);
        }

        ConfigurationInterface* attributes() { return this->provides().get(); }

        template<class T>
        Property<T>& addProperty( const std::string& name, T& attr) {
            return tcservice->addProperty(name, attr);
        }

        bool addProperty( base::PropertyBase& pb ) {
            return tcservice->addProperty(pb);
        }

        base::PropertyBase* getProperty(const std::string& name) const
        {
            return tcservice->getProperty(name);
        }

        PropertyBag* properties() { return this->provides()->properties(); }

        base::PortInterface& addPort(const std::string& name, base::PortInterface& port) {
            port.setName(name);
            return ports()->addPort(port);
        }

        base::PortInterface& addPort(base::PortInterface& port) {
            return ports()->addPort(port);
        }

        typedef boost::function<void(base::PortInterface*)> SlotFunction;
        base::InputPortInterface& addEventPort(const std::string& name, base::InputPortInterface& port, SlotFunction callback = SlotFunction() ) {
            port.setName(name);
            return ports()->addEventPort(port,callback);
        }

        base::InputPortInterface& addEventPort(base::InputPortInterface& port, SlotFunction callback = SlotFunction() ) {
            return ports()->addEventPort(port,callback);
        }

        base::PortInterface* getPort(const std::string& name) const {
            return ports()->getPort(name);
        }


        DataFlowInterface* ports() {
            return tcservice.get();
        }

        const DataFlowInterface* ports() const {
            return tcservice.get();
        }

        virtual bool connectPorts( TaskContext* peer );
    protected:
        void forceActivity( base::ActivityInterface* new_act);

        virtual bool dataOnPortHook( base::PortInterface* port );

    private:

        typedef std::map< std::string, TaskContext* > PeerMap;
        typedef std::vector< TaskContext* > Users;
        PeerMap         _task_map;
        Users         musers;

        void addUser(TaskContext* user);

        void removeUser(TaskContext* user);

        void setup();

        friend class DataFlowInterface;
        internal::MWSRQueue<base::PortInterface*>* portqueue;
        typedef std::map<base::PortInterface*, SlotFunction > UserCallbacks;
        UserCallbacks user_callbacks;

        void dataOnPort(base::PortInterface* port);
        bool dataOnPortSize(unsigned int max);
        void dataOnPortCallback(base::InputPortInterface* port, SlotFunction callback);
        void dataOnPortRemoved(base::PortInterface* port);

        void prepareUpdateHook();

        bool prepareProvide(const std::string& name);

        typedef std::map<std::string, boost::shared_ptr<ServiceRequester> > LocalServices;
        LocalServices localservs;

        Service::shared_ptr tcservice;
        ServiceRequester::shared_ptr tcrequests;
        os::Mutex mportlock;

        // non copyable
        TaskContext( TaskContext& );

        base::ActivityInterface::shared_ptr our_act;
    };

    RTT_API bool connectPorts(TaskContext* A, TaskContext* B);

    RTT_API bool connectPeers(TaskContext* A, TaskContext* B);
}

#endif