Orocos OperationCaller 解析

OperationCallerBase

template<class F>  // 这个F是函数原型，例如： bool(int)
struct OperationCallerBase
: public internal::InvokerBase<F>,
public OperationCallerInterface
{
typedef boost::shared_ptr<OperationCallerBase<F> > shared_ptr;
virtual ~OperationCallerBase() {}
virtual OperationCallerBase<F>* cloneI(ExecutionEngine* caller) const = 0;

};

struct RTT_API OperationCallerInterface: public DisposableInterface
{
...
protected：
ExecutionEngine* myengine;
ExecutionEngine* caller;
}

template<int, class F>
struct InvokerBaseImpl;

/**
* This is the base class that defines the interface
* of all invocable method implementations.
* Any invocable method implementation must inherit
* from this class such that it can be used transparantly
* by the OperationCaller, Operation and SendHandle containers.
*/
template<class F>
struct InvokerBase
: public InvokerBaseImpl<boost::function_traits<F>::arity, F>
{};

template<class F>
struct InvokerBaseImpl<0,F>
{
typedef typename boost::function_traits<F>::result_type result_type;
typedef typename boost::function_traits<F>::result_type result_reference;
virtual ~InvokerBaseImpl() {}
virtual SendHandle<F> send() = 0;
virtual result_type call() = 0;
};

template<class F>
struct InvokerBaseImpl<1,F>
{
typedef typename boost::function_traits<F>::result_type result_type;
typedef typename boost::function<F>::arg1_type arg1_type;
virtual ~InvokerBaseImpl() {}
virtual result_type call(arg1_type a1) = 0;
virtual SendHandle<F> send(arg1_type a1) = 0;
};

...

关于如何关联 Operation 和 OperationCaller:

internal::LocalOperationCaller<Signature>::shared_ptr impl

// 在 Operation 端：
impl = boost::make_shared<internal::LocalOperationCaller<Signature> >( boost::function<Signature>(), this->mowner, null_caller, ClientThread)

// 在 OperationCaller 端：
boost::dynamic_pointer_cast< base::OperationCallerBase<Signature> >(impl)
// 上面这个地方是关键，如果Operation端和OperationCaller端定义的函数签名不同，dynamic_pointer_cast会得到一个空指针，并报告函数签名不同。

LocalOperationCaller

如何被调用：

class LocalOperationCaller
...LocalOperationCallerImpl
...

template<class T1>
result_type call_impl(T1 a1)
{
SendHandle<Signature> h;
if ( this->isSend() ) {  // true 表示在Operation的线程中执行， false表示在 Caller 的线程中执行
// 如果在 Operation 的线程中执行，则需要保存参数，将该函数添加到 ExecutionEngine 的函数指针 Queue 中, 然后到了 ExecutionEngine 的执行点再执行
// 见下述 RStore 和 BindStorage 类
h = send_impl<T1>(a1);
if ( h.collect() == SendSuccess )
return h.ret(a1);
else
throw SendFailure;
} else{
// 如果在 Caller 的线程中执行就简单了，直接调用即可.
if ( this->mmeth )
return this->mmeth(a1);
else
return NA<result_type>::na();
}
return NA<result_type>::na();
}

new

LocalOperationCaller

shared_ptr cl = this->cloneRT();

cl->store( a1, a2, ... );

{

if ( pred() )  // pred 即第四步中 boost::bind 返回的可调用对象

return;

// only to be called from the thread not executing step().

os::MutexLock lock(msg_lock);

while (!pred()) { // the mutex guards that processMessages can not run between !pred and the wait().

msg_cond.wait(msg_lock); // unlock & 阻塞，并且只有 pred() 返回true才能被唤醒。

}

new

RStore

RStore

BindStorage

// 返回值对象
template<>
struct RStore<void> {
bool executed;  // 判断对应的函数是否已被调用过
bool error;     //判断在调用过程中是否出错
RStore() : executed(false), error(false) {}

void checkError() const {
if(error) throw std::runtime_error("Unable to complete the operation call. The called operation has thrown an exception");
}

bool isError() const {
return error;
}

bool isExecuted() const {  // 就是第四部中 waitForMessages 中调用的函数，判断是否已经被执行过了
return executed;
}

template<class F>
void exec(F f) {
error = false;
try{
f();  // 最终调用函数的地方
} catch (std::exception& e) {
log(Error) << "Exception raised while executing an operation : "  << e.what() << endlog();
error = true;
} catch (...) {
log(Error) << "Unknown exception raised while executing an operation." << endlog();
error = true;
}
executed = true;
}

void result() { checkError(); return; }
};

// ...其他类型的返回值对象的定义 继承自 RStore<void> ... 如：
//template<class T>
//    struct RStore : public RStore<void> {
//      T arg;  // 实际返回值, 调用过程为 arg = f();
//      ...
//}

template<class ToBind>
struct BindStorage  // 就是这个类，保存着调用的实体
: public BindStorageImpl<boost::function_traits<ToBind>::arity, ToBind>
{};

template<class ToBind>
struct BindStorageImpl<1, ToBind>
{
typedef typename boost::function_traits<ToBind>::result_type result_type;
typedef typename boost::function_traits<ToBind>::arg1_type   arg1_type;
typedef RStore<result_type> RStoreType;  // RStore 类

// stores the original function pointer, supplied by the user.
boost::function<ToBind>  mmeth;  // 被调用的函数对象
// Store the argument.
mutable AStore<arg1_type> a1;  // 参数对象 1，参数也需要保存，因为有些函数是传递引用的，参数也可能会被修改。
mutable RStore<result_type> retv;  // 返回值对象
// the list of all our storage.
bf::vector< RStore<result_type>&, AStore<arg1_type>& > vStore;
#ifdef ORO_SIGNALLING_OPERATIONS
typename Signal<ToBind>::shared_ptr msig;
#endif

BindStorageImpl() : vStore(retv,a1) {}
BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1)
#ifdef ORO_SIGNALLING_OPERATIONS
, msig(orig.msig)
#endif
{}
void store(arg1_type t1) { a1(t1); }  // 保存函数的各个参数
void exec() {
#ifdef ORO_SIGNALLING_OPERATIONS
if (msig) (*msig)(a1.get());
#endif
if (mmeth)
retv.exec( boost::bind(mmeth, boost::ref(a1.get()) ) );  // 调用函数
else
retv.executed = true;
}

// ...234567个参数的定义形式...

总结：

OperationCaller& operator=(boost::shared_ptr<base::DisposableInterface> implementation)  // 关键！该智能指针指向 Operation 的成员： LocalOperationCaller， 此处关联 Operation 和 OperationCalle 两个对象
{
if (this->impl && this->impl == implementation)
return *this;
OperationCaller<Signature> tmp(implementation, mcaller);
*this = tmp;  // 更新自己为带 impl
return *this;
}

result_type OperationCaller::operator()()
{
// impl为一个智能指针：boost::shared_ptr< base::OperationCallerBase<SignatureT>
// 该智能指针在 setImplementation 之后非空，否则为空
if (impl)
return impl->call();  // 所以最后又回到了调用 LocalOperationCaller 的 call 函数，然后判断是否在被调用端的线程中执行，详见 “如何被调用” 段落。 if ( this->mmeth ) return this->mmeth(arg1, arg2 ...); else return NA<result_type>::na();
return NA<result_type>::na();  // 否则返回一个默认的返回值
}

impl

operator()

imp->call()

rtt/Service.hpp

OperationInterfacePartFused

OperationInterfacePart

rtt/rtt/internal/FusedFunctorDataSource.hpp

evaluate()