mtsCommandWrite.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
 
/*
  Author(s):  Ankur Kapoor, Peter Kazanzides, Anton Deguet
  Created on: 2004-04-30
 
  (C) Copyright 2004-2014 Johns Hopkins University (JHU), All Rights
  Reserved.
 
--- begin cisst license - do not edit ---
 
This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.
 
--- end cisst license ---
*/
 

 
#ifndef _mtsCommandWrite_h
#define _mtsCommandWrite_h
 
 
#include <cisstMultiTask/mtsCommandWriteBase.h>
#include <cisstMultiTask/mtsGenericObjectProxy.h>
 

template <class _classType, class _argumentType>
class mtsCommandWrite: public mtsCommandWriteBase {
 
public:
    typedef _argumentType ArgumentType;
    typedef mtsCommandWriteBase BaseType;

    typedef _classType ClassType;

    typedef mtsCommandWrite<ClassType, ArgumentType> ThisType;

    typedef void(_classType::*ActionType)(const ArgumentType&);
 
private:
    inline mtsCommandWrite(const ThisType & CMN_UNUSED(other));
 
protected:
    ActionType Action;

    ClassType * ClassInstantiation;
 
    template<bool, typename dummy=void>
    class ConditionalCast {
        // Default case: ArgumentType not derived from mtsGenericObjectProxy
    public:
        static mtsExecutionResult CallMethod(ClassType *ClassInst, ActionType Action, const mtsGenericObject &argument)
        {
            const ArgumentType * data = mtsGenericTypes<ArgumentType>::CastArg(argument);
            if (data == 0) {
                return mtsExecutionResult::INVALID_INPUT_TYPE;
            }
            (ClassInst->*Action)(*data);
            return mtsExecutionResult::COMMAND_SUCCEEDED;
        }
    };
    template<typename dummy>
    class ConditionalCast<true, dummy> {
        // Specialization: ArgumentType is derived from mtsGenericObjectProxy (and thus also from mtsGenericObject)
        // In this case, we may need to create a temporary Proxy object.
    public:
        static mtsExecutionResult CallMethod(ClassType *ClassInst, ActionType Action, const mtsGenericObject &argument)
        {
            // First, check if a Proxy object was passed.
            const ArgumentType *data = dynamic_cast<const ArgumentType *>(&argument);
            if (data) {
                (ClassInst->*Action)(*data);
                return mtsExecutionResult::COMMAND_SUCCEEDED;
            }
            // If it isn't a Proxy, maybe it is a ProxyRef
            typedef typename ArgumentType::RefType ArgumentRefType;
            const ArgumentRefType *dataref = dynamic_cast<const ArgumentRefType *>(&argument);
            if (!dataref) {
                CMN_LOG_INIT_ERROR << "Write CallMethod could not cast from " << typeid(argument).name()
                                   << " to const " << typeid(ArgumentRefType).name() << std::endl;
                return mtsExecutionResult::INVALID_INPUT_TYPE;
            }
            // Now, make the call using the temporary
            ArgumentType temp;
            temp.Assign(*dataref);
            (ClassInst->*Action)(temp);
            return mtsExecutionResult::COMMAND_SUCCEEDED;
        }
    };
 
private:
    mtsCommandWrite(void): BaseType() {}
 
public:
    mtsCommandWrite(ActionType action, ClassType * classInstantiation, const std::string & name,
                    const ArgumentType & argumentPrototype):
        BaseType(name),
        Action(action),
        ClassInstantiation(classInstantiation)
    {
        this->ArgumentPrototype = mtsGenericTypes<ArgumentType>::ConditionalCreate(argumentPrototype, name);
    }
 

    virtual ~mtsCommandWrite() {
        if (this->ArgumentPrototype) {
            delete this->ArgumentPrototype;
        }
    }
 

    mtsExecutionResult Execute(const mtsGenericObject & argument,
                               mtsBlockingType CMN_UNUSED(blocking)) {
        if (this->IsEnabled()) {
            return ConditionalCast<cmnIsDerivedFromTemplated<ArgumentType, mtsGenericObjectProxy>::IS_DERIVED
                                  >::CallMethod(ClassInstantiation, Action, argument);
        }
        return mtsExecutionResult::COMMAND_DISABLED;
    }

    inline mtsExecutionResult Execute(const ArgumentType & argument,
                                      mtsBlockingType CMN_UNUSED(blocking)) {
        if (this->IsEnabled()) {
            (ClassInstantiation->*Action)(argument);
            return mtsExecutionResult::COMMAND_SUCCEEDED;
        }
        return mtsExecutionResult::COMMAND_DISABLED;
    }
 
    inline mtsExecutionResult Execute(const mtsGenericObject & argument, mtsBlockingType blocking,
                                      mtsCommandWriteBase * CMN_UNUSED(finishedEventHandler)) {
        return Execute(argument, blocking);
    }
 
    /* commented in base class */
    virtual void ToStream(std::ostream & outputStream) const {
        outputStream << "mtsCommandWrite: ";
        if (this->ClassInstantiation) {
            outputStream << this->Name << "(const " << this->ArgumentPrototype->Services()->GetName() << "&) using class/object \""
                         << mtsObjectName(this->ClassInstantiation) << "\" currently "
                         << (this->IsEnabled() ? "enabled" : "disabled");
        } else {
            outputStream << "Not initialized properly";
        }
    }
};
 
 
 
 
 
 
 
template <class _classType>
class mtsCommandWriteGeneric: public mtsCommandWriteBase {
 
public:
    typedef mtsCommandWriteBase BaseType;

    typedef _classType ClassType;

    typedef mtsCommandWriteGeneric<ClassType> ThisType;

    typedef void(_classType::*ActionType)(const mtsGenericObject &);
 
private:
    inline mtsCommandWriteGeneric(const ThisType & CMN_UNUSED(other));
 
protected:
    ActionType Action;

    ClassType * ClassInstantiation;
 
private:
    mtsCommandWriteGeneric(void): BaseType() {}
 
public:
    mtsCommandWriteGeneric(ActionType action, ClassType * classInstantiation, const std::string & name,
                           const mtsGenericObject * argumentPrototype):
        BaseType(name),
        Action(action),
        ClassInstantiation(classInstantiation)
    {
        // use dynamic creation with copy constructor if argument prototype has been provided
        if (argumentPrototype) {
            cmnGenericObject * prototypePointer = argumentPrototype->Services()->Create(*argumentPrototype);
            CMN_ASSERT(prototypePointer);
            this->ArgumentPrototype = dynamic_cast<mtsGenericObject *>(prototypePointer);
            CMN_ASSERT(this->ArgumentPrototype);
        } else {
            this->ArgumentPrototype = 0;
        }
    }
 

    virtual ~mtsCommandWriteGeneric() {
        if (this->ArgumentPrototype) {
            delete this->ArgumentPrototype;
        }
    }
 

    mtsExecutionResult Execute(const mtsGenericObject & argument,
                               mtsBlockingType CMN_UNUSED(blocking)) {
        if (this->IsEnabled()) {
            (ClassInstantiation->*Action)(argument);
            return mtsExecutionResult::COMMAND_SUCCEEDED;
        }
        return mtsExecutionResult::COMMAND_DISABLED;
    }
 
    inline mtsExecutionResult Execute(const mtsGenericObject & argument, mtsBlockingType blocking,
                                      mtsCommandWriteBase * CMN_UNUSED(finishedEventHandler)) {
        return Execute(argument, blocking);
    }
 
    /* documented in base class */
    void ToStream(std::ostream & outputStream) const {
        outputStream << "mtsCommandWriteGeneric: ";
        if (this->ClassInstantiation) {
            outputStream << this->Name << "(const mtsGenericObject *) using class/object \""
                         << mtsObjectName(this->ClassInstantiation) << "\" currently "
                         << (this->IsEnabled() ? "enabled" : "disabled");
        } else {
            outputStream << "Not initialized properly";
        }
    }
};
 
 
#endif // _mtsCommandWrite_h