MethodRepository.hpp

/***************************************************************************
  tag: FMTC  do nov 2 13:06:08 CET 2006  MethodRepository.hpp 

                        MethodRepository.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_METHOD_REPOSITORY_HPP
#define ORO_METHOD_REPOSITORY_HPP

#include "OperationFactory.hpp"
#include "LocalMethod.hpp"
#include "DataSourceArgsMethod.hpp"
#include "MethodC.hpp"
#include <boost/shared_ptr.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/function_traits.hpp>

namespace RTT
{
    class MethodRepository
        : public OperationFactory<DataSourceBase*>
    {
        template<class T>
        inline T* getpointer(T& t) {
            return &t;
        }
        template<class T>
        inline T* getpointer(T* t) {
            return t;
        }
        
    protected:
        std::map<std::string,boost::shared_ptr<ActionInterface> > simplemethods;
    public:
        typedef MethodFactory Factory;

        ~MethodRepository()
        {
            clear();
        }

        void clear() {
            while ( !simplemethods.empty() ) {
                simplemethods.erase( simplemethods.begin() );
            }
            OperationFactory<DataSourceBase*>::clear();
        }

        std::vector<std::string> getMethods() const {
            return keys( simplemethods );
        }

        bool hasMethod(const std::string& name) const {
            return simplemethods.count(name) == 1;
        }

        template<class MethodT>
        bool addMethod( MethodT* meth )
        {
            Logger::In in("MethodRepository");
            if ( simplemethods.count( meth->getName() ) ) {
                log(Error) << "Failed to addMethod: '"<< meth->getName() <<"' already added." <<endlog();
                return false;
            }
            if ( meth->getName().empty() || !meth->ready() ) {
                log(Error) << "Failed to addMethod: '"<< meth->getName() <<"' was not ready() or has no name." <<endlog();
                return false;
            }
            simplemethods[meth->getName()] = meth->getMethodImpl();
            log(Debug) << "Added Method: '"<< meth->getName() <<"'." <<endlog();
            return true;
        }

        template<class Signature>
        boost::shared_ptr<ActionInterface> getMethod( std::string name )
        {
            Logger::In in("MethodRepository::getMethod");
            if ( simplemethods.count(name) ) {
                if ( boost::dynamic_pointer_cast< detail::MethodBase<Signature> >(simplemethods[name]) )
                    return simplemethods[name];
                else
                    log(Error) << "Method '"<< name <<"' found, but has wrong Signature."<<endlog();
                return boost::shared_ptr<ActionInterface>();
            }
            log(Warning) << "No such method: "<< name <<endlog();
            return boost::shared_ptr<ActionInterface>();
        }
        

        template<class MethodT>
        bool addMethod( MethodT meth, const char* description) 
        {
            typedef typename boost::remove_pointer<MethodT>::type MethodVT;
            typedef typename boost::add_pointer<MethodVT>::type MethodPT;
            BOOST_STATIC_ASSERT( boost::function_traits<typename MethodVT::Signature>::arity == 0 );

            MethodPT c = this->getpointer(meth);
            typedef typename MethodVT::Signature Sig;
            const detail::LocalMethod<Sig>* lm = dynamic_cast< const detail::LocalMethod<Sig>* >( c->getMethodImpl().get() );
            if ( !lm ) {
                log(Error) << "Failed to addMethod: '"<< c->getName() <<"' is not a local method." <<endlog();
                return false;
            }
            if ( this->addMethod( c ) == false )
                return false;
            this->add( c->getName(), new detail::OperationFactoryPart0<DataSourceBase*, detail::DataSourceArgsMethod<Sig> >( 
                  detail::DataSourceArgsMethod<Sig>( lm->getMethodFunction()), description) );
            return true;
        }

        template<class MethodT>
        bool addMethod( MethodT meth, const char* description,
                         const char* arg1, const char* arg1_description)
        {
            typedef typename boost::remove_pointer<MethodT>::type MethodVT;
            typedef typename boost::add_pointer<MethodVT>::type MethodPT;
            BOOST_STATIC_ASSERT( boost::function_traits<typename MethodVT::Signature>::arity == 1 );

            MethodPT c = this->getpointer(meth);
            typedef typename MethodVT::Signature Sig;
            const detail::LocalMethod<Sig>* lm = dynamic_cast< const detail::LocalMethod<Sig>* >( c->getMethodImpl().get() );
            if ( !lm ) {
                log(Error) << "Failed to addMethod: '"<< c->getName() <<"' is not a local method." <<endlog();
                return false;
            }
            if ( this->addMethod( c ) == false )
                return false;
            this->add( c->getName(), new detail::OperationFactoryPart1<DataSourceBase*, detail::DataSourceArgsMethod<Sig> >( 
                  detail::DataSourceArgsMethod<Sig>(lm->getMethodFunction()), 
                  description, arg1, arg1_description) );
            return true;
        }

        template<class MethodT>
        bool addMethod( MethodT meth, const char* description,
                        const char* arg1, const char* arg1_description,
                        const char* arg2, const char* arg2_description)
        {
            typedef typename boost::remove_pointer<MethodT>::type MethodVT;
            typedef typename boost::add_pointer<MethodVT>::type MethodPT;
            BOOST_STATIC_ASSERT( boost::function_traits<typename MethodVT::Signature>::arity == 2 );

            MethodPT c = this->getpointer(meth);
            typedef typename MethodVT::Signature Sig;
            const detail::LocalMethod<Sig>* lm = dynamic_cast< const detail::LocalMethod<Sig>* >( c->getMethodImpl().get() );
            if ( !lm ) {
                log(Error) << "Failed to addMethod: '"<< c->getName() <<"' is not a local method." <<endlog();
                return false;
            }
            if ( this->addMethod( c ) == false )
                return false;
            this->add( c->getName(), new detail::OperationFactoryPart2<DataSourceBase*, detail::DataSourceArgsMethod<Sig> >( 
                  detail::DataSourceArgsMethod<Sig>(lm->getMethodFunction()), 
                  description, 
                  arg1, arg1_description,
                  arg2, arg2_description) );
            return true;
        }

        template<class MethodT>
        bool addMethod( MethodT meth, const char* description,
                        const char* arg1, const char* arg1_description,
                        const char* arg2, const char* arg2_description,
                        const char* arg3, const char* arg3_description)
        {
            typedef typename boost::remove_pointer<MethodT>::type MethodVT;
            typedef typename boost::add_pointer<MethodVT>::type MethodPT;
            BOOST_STATIC_ASSERT( boost::function_traits<typename MethodVT::Signature>::arity == 3 );

            MethodPT c = this->getpointer(meth);
            typedef typename MethodVT::Signature Sig;
            const detail::LocalMethod<Sig>* lm = dynamic_cast< const detail::LocalMethod<Sig>* >( c->getMethodImpl().get() );
            if ( !lm ) {
                log(Error) << "Failed to addMethod: '"<< c->getName() <<"' is not a local method." <<endlog();
                return false;
            }
            if ( this->addMethod( c ) == false )
                return false;
            this->add( c->getName(), new detail::OperationFactoryPart3<DataSourceBase*, detail::DataSourceArgsMethod<Sig> >( 
                  detail::DataSourceArgsMethod<Sig>(lm->getMethodFunction()), 
                  description, 
                  arg1, arg1_description,
                  arg2, arg2_description,
                  arg3, arg3_description) );
            return true;
        }

        template<class MethodT>
        bool addMethod( MethodT meth, 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)
        {
            typedef typename boost::remove_pointer<MethodT>::type MethodVT;
            typedef typename boost::add_pointer<MethodVT>::type MethodPT;
            BOOST_STATIC_ASSERT( boost::function_traits<typename MethodVT::Signature>::arity == 4 );

            MethodPT c = this->getpointer(meth);
            typedef typename MethodVT::Signature Sig;
            const detail::LocalMethod<Sig>* lm = dynamic_cast< const detail::LocalMethod<Sig>* >( c->getMethodImpl().get() );
            if ( !lm ) {
                log(Error) << "Failed to addMethod: '"<< c->getName() <<"' is not a local method." <<endlog();
                return false;
            }
            if ( this->addMethod( c ) == false )
                return false;
            this->add( c->getName(), new detail::OperationFactoryPart4<DataSourceBase*, detail::DataSourceArgsMethod<Sig> >( 
                  detail::DataSourceArgsMethod<Sig>(lm->getMethodFunction()), 
                  description, 
                  arg1, arg1_description,
                  arg2, arg2_description,
                  arg3, arg3_description,
                  arg4, arg4_description) );
            return true;
        }

        template<class MethodT,class CompT>
        bool addMethodDS( DataSource< boost::weak_ptr<CompT> >* wp, MethodT c, const char* description) 
        {
            using namespace detail;
            typedef typename MethodT::Signature Sig;
            if ( this->hasMember(c.getName() ) )
                return false;
            const detail::LocalMethod<Sig>* lm = dynamic_cast< const detail::LocalMethod<Sig>* >( c.getMethodImpl().get() );
            if ( !lm )
                return false;
            typedef FunctorDataSourceDS0<CompT, boost::function<Sig> > FunctorT;
            typedef detail::DataSourceArgsMethod<Sig, FunctorT> DSMeth;
            
            this->add( c.getName(), new detail::OperationFactoryPart0<DataSourceBase*, DSMeth>( 
                        DSMeth( typename FunctorT::shared_ptr(new FunctorT(wp, lm->getMethodFunction()))),
                        description));
            return true;
        }

        template<class MethodT,class CompT>
        bool addMethodDS( DataSource< boost::weak_ptr<CompT> >* wp, MethodT c, const char* description, 
                          const char* a1, const char* d1) 
        {
            using namespace detail;
            typedef typename MethodT::Signature Sig;
            if ( this->hasMember(c.getName() ) )
                return false;
            const detail::LocalMethod<Sig>* lm = dynamic_cast< const detail::LocalMethod<Sig>* >( c.getMethodImpl().get() );
            if ( !lm )
                return false;
            typedef typename MethodT::traits::arg2_type arg1_type; // second arg is 1st data arg.
            typedef FunctorDataSourceDS1<CompT, boost::function<Sig>, arg1_type > FunctorT;
            typedef detail::DataSourceArgsMethod<Sig, FunctorT> DSMeth;
            this->add( c.getName(), new detail::OperationFactoryPart1<DataSourceBase*, DSMeth, arg1_type >( 
                        DSMeth( typename FunctorT::shared_ptr(new FunctorT(wp, lm->getMethodFunction()))),
                        description, a1, d1));
            return true;
        }

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

        MethodC create(std::string name) {
            return MethodC( this, name );
        }

        bool resetMethod(std::string name, ActionInterface::shared_ptr impl)
        {
            if (!hasMethod(name))
                return false;
            simplemethods[name] = impl;
            return true;
        }
    };
}


#endif

---