Service.hpp

Go to the documentation of this file.

/***************************************************************************
  tag: The SourceWorks  Tue Sep 7 00:55:18 CEST 2010  Service.hpp

                        Service.hpp -  description
                           -------------------
    begin                : Tue September 07 2010
    copyright            : (C) 2010 The SourceWorks
    email                : peter@thesourceworks.com

 ***************************************************************************
 *   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_SERVICE_PROVIDER_HPP
#define ORO_SERVICE_PROVIDER_HPP

#include "rtt-config.h"
#include "OperationInterface.hpp"
#include "DataFlowInterface.hpp"
#include "internal/OperationInterfacePartFused.hpp"
#include "internal/LocalOperationCaller.hpp"
#include "internal/OperationCallerC.hpp"
#include "internal/UnMember.hpp"
#include "internal/GetSignature.hpp"

#include "ConfigurationInterface.hpp"
#include "Operation.hpp"
#include <boost/shared_ptr.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/function_traits.hpp>
#include <boost/function_types/components.hpp>
#include <boost/enable_shared_from_this.hpp>
#if BOOST_VERSION >= 104000 && BOOST_VERSION < 105300
#include <boost/smart_ptr/enable_shared_from_this2.hpp>
#endif
#if BOOST_VERSION >= 105300
#include <boost/smart_ptr/enable_shared_from_raw.hpp>
#endif

namespace RTT
{
    namespace internal {
#if BOOST_VERSION >= 104000
#if BOOST_VERSION < 105300
        typedef  boost::enable_shared_from_this2<Service> shared_from_raw;
#else
        typedef  boost::enable_shared_from_raw shared_from_raw;
#endif
#else
        typedef  boost::enable_shared_from_this<Service> shared_from_raw;
#endif
    }
    class RTT_API Service
        : public OperationInterface,
          public ConfigurationInterface,
          public DataFlowInterface,
          public internal::shared_from_raw
    {
    public:
        typedef OperationInterface Factory;
        typedef boost::shared_ptr<Service> shared_ptr;
        typedef boost::shared_ptr<const Service> shared_constptr;
        typedef std::vector<std::string> ProviderNames;

#if BOOST_VERSION >= 105300
        Service::shared_ptr shared_from_this() { return boost::shared_from_raw(this); }
        Service::shared_constptr shared_from_this() const { return boost::shared_from_raw(this); }
#endif

        static Service::shared_ptr Create(const std::string& name, TaskContext* owner = 0);

        Service(const std::string& name, TaskContext* owner = 0);

        virtual ~Service();

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

        const std::string& doc() const { return mdescription; }

        void doc(const std::string& description) { mdescription = description; }

        void setName(const std::string& name) { mname = name;}

        void setOwner(TaskContext* new_owner);

        void setParent(shared_ptr new_parent);

        shared_ptr getParent() const { return parent; }

        virtual ProviderNames getProviderNames() const;

        TaskContext* getOwner() const { return mowner; }

        ExecutionEngine* getOwnerExecutionEngine() const;

        virtual bool addService( shared_ptr obj );

        virtual void removeService( std::string const& service_name );

        Service::shared_ptr provides();

        Service::shared_ptr provides(const std::string& service_name);

        shared_ptr getService(const std::string& service_name);

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

        void clear();

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

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

        bool addLocalOperation( base::OperationBase& op );

        boost::shared_ptr<base::DisposableInterface> getLocalOperation( std::string name );

        OperationInterfacePart* getOperation( std::string name );

        void removeOperation( const std::string& name );

        bool setOperationThread(std::string const& name, ExecutionThread et);

        template<class Signature>
        Operation<Signature>& addOperation( Operation<Signature>& op )
        {
            if ( this->addLocalOperation( op ) == false )
                return op;
            this->add( op.getName(), new internal::OperationInterfacePartFused<Signature>( &op ) );
            return op;
        }

#ifdef ORO_SIGNALLING_OPERATIONS

        template<class Signature>
        Operation<Signature>& addEventOperation( Operation<Signature>& op )
        {
            op.signals();
            if ( this->addLocalOperation( op ) == false )
                return op;
            this->add( op.getName(), new internal::EventOperationInterfacePartFused<Signature>( &op ) );
            return op;
        }
#endif

        template<class Signature>
        Operation<Signature>& addSynchronousOperation( Operation<Signature>& op )
        {
            if ( this->addLocalOperation( op ) == false )
                return op;
            this->add( op.getName(), new internal::SynchronousOperationInterfacePartFused<Signature>( &op ) );
            return op;
        }

        template<class Func, class Class>
        Operation< typename internal::GetSignature<Func>::Signature >&
        addOperation( const std::string name, Func func, Class* obj, ExecutionThread et = ClientThread )
        {
            typedef typename internal::GetSignature<Func>::Signature Signature;
            Operation<Signature>* op = new Operation<Signature>(name, func, obj, et, this->getOwnerExecutionEngine() );
            ownedoperations.push_back(op);
            return addOperation( *op );
        }

        template<class Func>
        Operation< Func >&
        addOperation( const std::string name, Func* func, ExecutionThread et = ClientThread )
        {
            typedef Func Signature;
            boost::function<Signature> bfunc = func;
            Operation<Signature>* op = new Operation<Signature>(name, bfunc, et, this->getOwnerExecutionEngine() );
            ownedoperations.push_back(op);
            return addOperation( *op );
        }

#ifdef ORO_SIGNALLING_OPERATIONS

        template<class Func>
        Operation< Func >&
        addEventOperation( const std::string name, Func* func, ExecutionThread et = ClientThread )
        {
            typedef Func Signature;
            boost::function<Signature> bfunc = func;
            Operation<Signature>* op = new Operation<Signature>(name, bfunc, et, this->getOwnerExecutionEngine() );
            ownedoperations.push_back(op);
            return addEventOperation( *op );
        }

        template<class Func, class Class>
        Operation< typename internal::GetSignature<Func>::Signature >&
        addEventOperation( const std::string name, Func func, Class* obj, ExecutionThread et = ClientThread )
        {
            typedef typename internal::GetSignature<Func>::Signature Signature;
            Operation<Signature>* op = new Operation<Signature>(name, func, obj, et, this->getOwnerExecutionEngine() );
            ownedoperations.push_back(op);
            return addEventOperation( *op );
        }
#endif

        template<class Func, class Class>
        Operation< typename internal::GetSignature<Func>::Signature >&
        addSynchronousOperation( const std::string name, Func func, Class* obj, ExecutionThread et = ClientThread )
        {
            typedef typename internal::GetSignature<Func>::Signature Signature;
            Operation<Signature>* op = new Operation<Signature>(name, func, obj, et, this->getOwnerExecutionEngine() );
            ownedoperations.push_back(op);
            return addSynchronousOperation( *op );
        }

        template<class Func,class ObjT>
        Operation< typename internal::GetSignatureDS<Func>::Signature>& addOperationDS( const std::string& name, Func func, internal::DataSource< boost::shared_ptr<ObjT> >* sp,
                ExecutionThread et = ClientThread)
        {
            typedef typename internal::GetSignatureDS<Func>::Signature SignatureDS;    // function signature with normal object pointer
            Operation<SignatureDS>* op = new Operation<SignatureDS>(name, boost::function<SignatureDS>(func), et, this->getOwnerExecutionEngine() );
            ownedoperations.push_back(op);
            return addOperationDS( sp, *op );
        }

        template<class Signature,class ObjT>
        Operation<Signature>& addOperationDS( internal::DataSource< boost::shared_ptr<ObjT> >* sp, Operation<Signature>& op)
        {
            if ( this->addLocalOperation( op ) == false ) {
                assert(false);
                return op; // should never be reached.
            }
            this->add( op.getName(), new internal::OperationInterfacePartFusedDS<Signature,ObjT>( sp, &op) );
            return op;
        }

        base::DataSourceBase::shared_ptr getOperation( std::string name,
                                   const std::vector<base::DataSourceBase::shared_ptr>& args, ExecutionEngine* caller) const
        {
            return this->produce(name, args, caller);
        }

        internal::OperationCallerC create(std::string name, ExecutionEngine* caller);

        bool resetOperation(std::string name, base::OperationBase* impl);
    protected:
        typedef std::map< std::string, shared_ptr > Services;
        Services services;

        bool testOperation(base::OperationBase& op);
        typedef std::map<std::string,base::OperationBase* > SimpleOperations;
        typedef std::vector<base::OperationBase*> OperationList;
        SimpleOperations simpleoperations;
        OperationList ownedoperations;
        std::string mname;
        std::string mdescription;
        TaskContext* mowner;
        shared_ptr parent;
    };
}


#endif