CallableFlow.hxx

Go to the documentation of this file.

 
#ifndef _EXECUTOR_CALLABLEFLOW_HXX_
#define _EXECUTOR_CALLABLEFLOW_HXX_
 
#include "executor/StateFlow.hxx"
 
struct CallableFlowRequestBase {
    void reset_base() {
        resultCode = 0;
    }
 
    int resultCode;
    BarrierNotifiable done;
};
 
 
template<class RequestType> class CallableFlow : public StateFlow<Buffer<RequestType>, QList<1> > {
public:
    CallableFlow(Service* s) :  StateFlow<Buffer<RequestType>, QList<1> >(s) {}
 
protected:
    using Action = StateFlowBase::Action;
    
    RequestType *request()
    {
        if (!this->message())
        {
            // This is not an assert macro, because this function gets inlined
            // into a lot of places, and we want the shortest possible code
            // size. However, letting this pass into a hard fault due to the
            // nullptr dereference is extremely hard to debug.
            abort();
        }
        return this->message()->data();
    }
 
    bool has_request()
    {
        return this->message() != nullptr;
    }
 
    Action return_ok()
    {
        return return_with_error(0);
    }
 
    Action wait_and_return_ok()
    {
        return this->wait_and_call(STATE(wait_done));
    }
 
    Action wait_done()
    {
        return return_ok();
    }
 
    Action return_with_error(int error)
    {
        request()->resultCode = error;
        this->return_buffer();
        return this->exit();
    }
};
 
template<class T, typename... Args>
BufferPtr<T> invoke_flow(FlowInterface<Buffer<T>>* flow, Args &&... args) {
    SyncNotifiable n;
    BufferPtr<T> b(flow->alloc());
    b->data()->reset(std::forward<Args>(args)...);
    b->data()->done.reset(&n);
    flow->send(b->ref());
    n.wait_for_notification();
    return b;
}
 
#endif // _EXECUTOR_CALLABLEFLOW_HXX_