Method.hpp

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

                        Method.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_METHOD_HPP
#define ORO_TASK_METHOD_HPP

#include <boost/function.hpp>
#include <string>
#include "UnMember.hpp"
#include "MethodBase.hpp"
#include "LocalMethod.hpp"
#include "ActionInterface.hpp"
#include "Logger.hpp"

namespace RTT
{
    template<class FunctionT>
    class Method
        : public detail::InvokerSignature<boost::function_traits<FunctionT>::arity,
                                          FunctionT,
                                          boost::shared_ptr< detail::MethodBase<FunctionT> > >
    {
        std::string mname;
        typedef detail::InvokerSignature<boost::function_traits<FunctionT>::arity,
                                         FunctionT,
                                         boost::shared_ptr< detail::MethodBase<FunctionT> > > Base;
    public:
        typedef FunctionT Signature;
        typedef typename boost::function_traits<Signature>::result_type result_type;
        typedef boost::function_traits<Signature> traits;
        typedef boost::shared_ptr< detail::MethodBase<FunctionT> > MethodBasePtr;

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

        Method(std::string name)
            : Base(), mname(name)
        {}

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

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

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

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

        template<class M, class ObjectType>
        Method(std::string name, M meth, ObjectType object)
            : Base( MethodBasePtr(new detail::LocalMethod<Signature>(meth, object) ) ),
              mname(name)
        {}

        template<class M>
        Method(std::string name, M meth)
            : Base( MethodBasePtr(new detail::LocalMethod<Signature>(meth) ) ),
              mname(name)
        {}

        ~Method()
        {
        }

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


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

        const MethodBasePtr getMethodImpl() const {
            return this->impl;
        }

        void setMethodImpl( MethodBasePtr new_impl) const {
            this->impl = new_impl;
        }

        template<class M, class ObjectType>
        void setMethod(M meth, ObjectType object)
        {
            this->impl = MethodBasePtr(new detail::LocalMethod<Signature>(meth, object) );
        }

        template<class M>
        void setMethod(M meth)
        {
            this->impl = MethodBasePtr(new detail::LocalMethod<Signature>(meth) );
        }
    };

    template<class F, class O>
    Method< typename detail::UnMember<F>::type > method(std::string name, F method, O object) {
        return Method<  typename detail::UnMember<F>::type >(name, method, object);
    }

    template<class F>
    Method<F> method(std::string name, F method) {
        return Method<F>(name, method);
    }
    template<class F>
    Method< typename detail::ArgMember<F>::type > method_ds(std::string name, F method) {
        return Method<  typename detail::ArgMember<F>::type >(name, method);
    }
}

#endif