OperationCaller.hpp

Go to the documentation of this file.

/***************************************************************************
  tag: FMTC  do nov 2 13:06:07 CET 2006  OperationCaller.hpp

                        OperationCaller.hpp -  description
                           -------------------
    begin                : do november 02 2006
    copyright            : (C) 2006 FMTC
    email                : peter.soetens@fmtc.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_OPERATION_CALLER_HPP
#define ORO_TASK_OPERATION_CALLER_HPP

#include <string>
#include <boost/function.hpp>
#include "base/OperationCallerBase.hpp"
#ifdef ORO_TEST_OPERATION_CALLER
#include "internal/UnMember.hpp"
#include "internal/LocalOperationCaller.hpp"
#endif
#include "internal/InvokerSignature.hpp"
#include "base/OperationCallerBaseInvoker.hpp"
#include "Logger.hpp"
#include "Service.hpp"
#ifdef ORO_REMOTING
#include "OperationInterface.hpp"
#include "internal/RemoteOperationCaller.hpp"
#endif

namespace RTT
{
    template<class SignatureT>
    class OperationCaller
        : public internal::InvokerSignature<boost::function_traits<SignatureT>::arity,
                                          SignatureT,
                                          boost::shared_ptr< base::OperationCallerBase<SignatureT> > >,
          public base::OperationCallerBaseInvoker
    {
        std::string mname;
        ExecutionEngine* mcaller;
    public:
        typedef SignatureT Signature;
        typedef internal::InvokerSignature<boost::function_traits<Signature>::arity,
                                         Signature,
                                         boost::shared_ptr< base::OperationCallerBase<Signature> > > Base;
        typedef typename boost::function_traits<Signature>::result_type result_type;
        typedef boost::function_traits<Signature> traits;
        typedef boost::shared_ptr< base::OperationCallerBase<Signature> > OperationCallerBasePtr;

        OperationCaller()
            : Base(), mname()
        {}

        OperationCaller(std::string name, ExecutionEngine* caller = 0)
            : Base(), mname(name), mcaller(caller)
        {}

        OperationCaller(const OperationCaller& m)
            : Base(m.impl ? boost::shared_ptr< base::OperationCallerBase<Signature> >(m.impl->cloneI(m.mcaller)) : m.impl ),
              mname(m.mname), mcaller(m.mcaller)
        {}

        OperationCaller& operator=(const OperationCaller& m)
        {
            if ( this == &m )
                return *this;
            mname = m.mname;
            mcaller = m.mcaller;
            if (m.impl)
                this->impl.reset( m.impl->cloneI(mcaller) );
            else
                this->impl.reset();
            return *this;
        }

        OperationCaller(boost::shared_ptr<base::DisposableInterface> implementation, ExecutionEngine* caller = 0)
            : Base( boost::dynamic_pointer_cast< base::OperationCallerBase<Signature> >(implementation) ),
              mname(), mcaller(caller)
        {
            if ( !this->impl && implementation ) {
                log(Error) << "Tried to construct OperationCaller from incompatible local operation."<< endlog();
            } else {
                if (this->impl) {
                    this->impl.reset( this->impl->cloneI(mcaller) );
                }
            }
        }

        OperationCaller(OperationInterfacePart* part, ExecutionEngine* caller = 0)
            : Base(),
              mname(), mcaller(caller)
        {
            if (part) {
                 mname = part->getName();
                 this->impl = boost::dynamic_pointer_cast< base::OperationCallerBase<Signature> >( part->getLocalOperation() );
                 setupOperationCaller( part );
            }
        }

        OperationCaller(const std::string& name, ServicePtr service, ExecutionEngine* caller = 0)
            : Base(),
              mname(name), mcaller(caller)
        {
            if (service) {
                 this->impl = boost::dynamic_pointer_cast< base::OperationCallerBase<Signature> >( service->getLocalOperation(name) );
                 if (service->hasMember(name))
                     setupOperationCaller( service->getOperation(name) );
            }
        }

        OperationCaller& operator=(boost::shared_ptr<base::DisposableInterface> implementation)
        {
            if (this->impl && this->impl == implementation)
                return *this;
            OperationCaller<Signature> tmp(implementation);
            *this = tmp;
            return *this;
        }

        OperationCaller& operator=(OperationInterfacePart* part)
        {
            if (part == 0) {
                log(Warning) << "Assigning OperationCaller from null part."<<endlog();
                this->impl.reset();
            }
            if (this->impl && this->impl == part->getLocalOperation() )
                return *this;
            OperationCaller<Signature> tmp(part);
            *this = tmp;
            return *this;
        }

        OperationCaller& operator=(ServicePtr service)
        {
            if ( !service ) {
                log(Warning) << "Assigning OperationCaller from null service."<<endlog();
                this->impl.reset();
            }
            if (this->mname.empty()) {
                log(Error) << "Can't initialise unnamed OperationCaller from service '"<<service->getName() <<"'."<<endlog();
                return *this;
            }
            OperationCaller<Signature> tmp(mname,service);
            *this = tmp;
            return *this;
        }

#ifdef ORO_TEST_OPERATION_CALLER

        template<class M, class ObjectType>
        OperationCaller(std::string name, M meth, ObjectType object, ExecutionEngine* ee = 0, ExecutionEngine* caller = 0, ExecutionThread et = ClientThread)
            : Base( OperationCallerBasePtr(new internal::LocalOperationCaller<Signature>(meth, object, ee, caller, et) ) ),
              mname(name), mcaller(caller)
        {}

        template<class M>
        OperationCaller(std::string name, M meth, ExecutionEngine* ee = 0, ExecutionEngine* caller = 0, ExecutionThread et = ClientThread)
            : Base( OperationCallerBasePtr(new internal::LocalOperationCaller<Signature>(meth,ee,caller, et) ) ),
              mname(name), mcaller(caller)
        {}
#endif
#ifdef ORO_REMOTING

        template<class M>
        OperationCaller(std::string name, OperationInterfacePart* orp, ExecutionEngine* caller = 0)
            : Base( OperationCallerBasePtr(new internal::RemoteOperationCaller<Signature>(orp,caller) ) ),
              mname(name)
        {}
#endif

        ~OperationCaller()
        {
        }

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


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

        bool setImplementation(boost::shared_ptr<base::DisposableInterface> implementation, ExecutionEngine* caller = 0) {
            *this = implementation;
            if ( this->impl ) {
                this->mcaller = caller;
                this->impl->setCaller(caller);
            }
            return ready();
        }

        bool setImplementationPart(OperationInterfacePart* orp, ExecutionEngine* caller = 0) {
            OperationCaller<Signature> tmp(orp, caller);
            if (tmp.ready()) {
                *this = tmp;
                return true;
            }
            return false;
        }

        const OperationCallerBasePtr getOperationCallerImpl() const {
            return this->impl;
        }

        void setOperationCallerImpl( OperationCallerBasePtr new_impl) const {
            this->impl = new_impl;
        }

        void setCaller(ExecutionEngine* caller) {
            this->mcaller = caller;
            if (this->impl)
                this->impl->setCaller(caller);
        }

        void disconnect()
        {
            this->impl.reset();
        }
    protected:
        void setupOperationCaller(OperationInterfacePart* part) {
            if ( !this->impl ) {
#ifdef ORO_REMOTING
                // try differently
                try {
                    this->impl.reset( new internal::RemoteOperationCaller<Signature>( part, mname, mcaller ));
                } catch( std::exception& e ) {
                    log(Error) << "Constructing RemoteOperationCaller for "<< mname <<" was not possible."<<endlog();
                    log(Error) << "Probable cause: " << e.what() <<endlog();
                    return;
                }
                if (this->impl->ready()) {
                    log(Debug) << "Constructed OperationCaller from remote implementation '"<< mname<<"'."<< endlog();
                    this->impl->setCaller(mcaller);
                } else {
                    this->impl.reset(); // clean up.
                    log(Error) << "Tried to construct OperationCaller from incompatible operation '"<< mname<<"'."<< endlog();
                }
#else
                log(Error) << "Tried to construct remote OperationCaller but ORO_REMOTING was disabled."<< endlog();
#endif
            } else {
                // finally clone and set caller on clone.
                this->impl.reset( this->impl->cloneI(mcaller) );
            }
        }

    };

#ifdef ORO_TEST_OPERATION_CALLER

    template<class F, class O>
    OperationCaller< typename internal::UnMember<F>::type > method(std::string name, F method, O object, ExecutionEngine* ee = 0, ExecutionEngine* caller = 0) {
        return OperationCaller<  typename internal::UnMember<F>::type >(name, method, object, ee, caller);
    }

    template<class F>
    OperationCaller<F> method(std::string name, F method, ExecutionEngine* ee = 0, ExecutionEngine* caller = 0) {
        return OperationCaller<F>(name, method, ee, caller);
    }
    template<class F>
    OperationCaller< typename internal::ArgMember<F>::type > method_ds(std::string name, F method, ExecutionEngine* ee = 0, ExecutionEngine* caller = 0) {
        return OperationCaller<  typename internal::ArgMember<F>::type >(name, method, ee, caller);
    }
#endif
}

#endif