Command.hpp

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

                        Command.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_COMMAND_HPP
#define ORO_TASK_COMMAND_HPP

#include <string>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include "CommandBase.hpp"
#include "LocalCommand.hpp"
#include "UnMember.hpp"

namespace RTT
{
    template<class CommandT>
    class Command
        : public detail::InvokerSignature<boost::function_traits<CommandT>::arity, CommandT, detail::CommandBase<CommandT>* >
    {
    protected:
        std::string mname;
        typedef detail::InvokerSignature<boost::function_traits<CommandT>::arity, CommandT, detail::CommandBase<CommandT>* > Base;

        BOOST_STATIC_ASSERT(( boost::is_same<typename boost::function_traits<CommandT>::result_type,bool>::value ));
    public:
        typedef CommandT Signature;

        typedef DispatchInterface::Status Status;

        Command()
            : Base(0), mname()
        {}

        Command(std::string name)
            : Base(0), mname(name)
        {}

        Command(const Command& c)
            : Base( c.impl ? c.impl->cloneI() : 0), mname(c.mname)
        {
        }

        Command& operator=(const Command& c)
        {
            if ( &c == this )
                return *this;
            this->mname = c.mname;
            delete this->impl;
            this->impl = 0;
            if ( c.impl )
                this->impl = c.impl->cloneI();
            return *this;
        }

        template<class CommandF, class ConditionF, class ObjectT>
        Command(std::string name, CommandF com, ConditionF con, ObjectT t, bool invert = false)
            : Base( new detail::LocalCommand<CommandT>(com,con,t, invert)),
              mname(name)
        {
        }

        template<class CommandF, class ConditionF, class ObjectT>
        Command(std::string name, CommandF com, ConditionF con, ObjectT t, CommandProcessor* commandp, bool invert = false)
            : Base( new detail::LocalCommand<CommandT>(com,con,t,commandp, invert)),
              mname(name)
        {
        }

        template<class CommandF, class ConditionF>
        Command(std::string name, CommandF com, ConditionF con, CommandProcessor* commandp, bool invert = false)
            : Base( new detail::LocalCommand<CommandT>(com,con,commandp, invert)),
              mname(name)
        {
        }

        Command(DispatchInterface* implementation)
            : Base( dynamic_cast< detail::CommandBase<CommandT>* >(implementation) ),
              mname()
        {
            // If not convertible, delete the implementation.
            if ( !this->impl && implementation) {
                log(Error) << "Tried to assign Command from incompatible type."<< endlog();
                delete implementation;
            }
        }

        ~Command()
        {
            delete this->impl;
        }

        Command& operator=(DispatchInterface* implementation)
        {
            if ( this->impl && this->impl == implementation)
                return *this;
            delete this->impl;
            this->impl = dynamic_cast< detail::CommandBase<CommandT>* >(implementation);
            if (this->impl == 0 && implementation) {
                log(Error) << "Tried to assign Command from incompatible type."<< endlog();
                delete implementation;
            }
            return *this;
        }

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

        bool done() const {
            if (!this->impl) return false;
            return this->impl->done();
        }

        void reset() {
            if (!this->impl) return;
            return this->impl->reset();
        }

        bool sent() const {
            if (!this->impl) return false;
            return this->impl->sent();
        }

        bool accepted() const {
            if (!this->impl) return false;
            return this->impl->accepted();
        }

        bool executed() const {
            if (!this->impl) return false;
            return this->impl->executed();
        }

        bool valid() const {
            if (!this->impl) return false;
            return this->impl->valid();
        }

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

        detail::CommandBase<CommandT>* getCommandImpl() const {
            return this->impl;
        }

        void setCommandImpl(detail::CommandBase<CommandT>* new_impl) const {
            delete this->impl;
            return this->impl = new_impl;
        }
    };

    template<class ComF, class ConF, class Object>
    Command< typename detail::UnMember<ComF>::type > command(std::string name, ComF command, ConF condition, Object object, bool invert = false) {
        return Command<  typename detail::UnMember<ComF>::type >(name, command, condition, object, invert);
    }

    template<class ComF, class ConF, class Object>
    Command< typename detail::UnMember<ComF>::type > command(std::string name, ComF command, ConF condition, Object object, CommandProcessor* cp, bool invert = false) {
        return Command<  typename detail::UnMember<ComF>::type >(name, command, condition, object, cp, invert);
    }

    template<class ComF, class ConF>
    Command< typename detail::UnMember<ComF>::type > command(std::string name, ComF command, ConF condition, CommandProcessor* cp, bool invert = false) {
        return Command<  typename detail::UnMember<ComF>::type >(name, command, condition, cp, invert);
    }

}
#endif