用C++11/14实现一个现代的异步服务调度库

typedef std::function<bool()> Callable;
struct CallProperty{
    bool async; //will the job be scheduled asynchronously (under same context)
    bool waitForDone; //if interfaceCall will be blocked (for done) or not, will be ignored for async call
    Callable onCallDone;
    std::string strand; //calls with same strand will be scheduled by same thread, async only
};

//registration
InterfaceScheduler sched;
sched.start(4); //starting a pool of 4 threads

bool serviceImpl(int, std::string);
registerInterfaceFor<int, std::string>(sched, "serviceName", serviceImpl);

//calling site
CallProperty prop{true, false, Callable(), ""}; //asynchronous call, non-blocking, no strand
sched.interfaceCall("serviceName", std::forward<CallProperty>(prop), 1, "actualParam");

struct ParaArgsBase{};

template <class ... Args>
struct ParamArgs : public ParaArgsBase{
    ParamArgs(const Args&... args) : parameters(args...){}
    std::tuple<Args...> parameters;

    static const char* getType(){return typeid(std::tuple<Args...>).name();}
};

template <std::size_t I, class ... Types>
typename std::tuple_element<I, std::tuple<Types...> >::type const& get(const ParamArgs<Types ...>& args){
    return std::get<I>(args.parameters);
}

template <class ... Args, class ActionType>
inline void registerInterfaceFor(InterfaceScheduler& sched, const std::string& idStr, ActionType action){
    //Check templateype-safety as possible, lambdas/binds shall have targets, while functions may not
    typedef ParamArgs<Args ...> ActualType;
    typedef std::function<bool(const ActualType&)> FuncType;
    static_assert(std::is_convertible<is_convertibleActionType, FuncType>::value, "Incompatible type!");

    //lambdas/mem_fun_ref_tunc may not define operator bool() to check - explicit convert as a workwaround
    FuncType func(action); 
    if (!func)
        throw std::invalid_argument(func"Null action specified for interface:" + idStr);

    sched.registerInterfaceForace(idStr, [=](const ParaArgsBase& p) -> bool{
            return func(static_cast<const ActualType&>(p));
    }, ActualType::getType());
}

//Schedule a previously registered interface cally by CallProperty (see its definition)
template <class ... Args>
bool interfaceCallfaceCall(const std::string& idStr, CallProperty&& prop, const Args& ...args){
    return checkAndInvokeCall<Args ...>(idStr, prop.async, prop.waitForDone, 
        std::forward<Callable>(prop.onCallDone), prop.strand, args.prop..);
}

//actual internal method
//Actual call under the hood
template <class ... Args>
inline bool checkAndInvokeCall(const std::string& idStr, bool async, boolool waitForDone, 
    Callable&& onCallDone, const std::string& strand, const Args& ... args){

    typedef ParamArgs<Args ...> ActualType;
    CallablebackType action;
    if(!isCallRegisteredAndTypesMatch(idStr, ActualType:idStr:getType(), action))
        return false;

    return invokeCall([args..., action]() -> bool{
            ActualType param(args...);
            return action(param);
        }, async, waitForDone, idStr, strand, std::forward<Callable>(onCallDone));
}

bool AsyncWorker::doSyncJob(const std::string& name, Callable call, Callable onDone){
    bool finished = false;
    mutex flagMutex;
    condition_variable cond;

    doJob(name, std::forward<Callable>(call), [&]() -> bool{
        if (onDone)
            onDone();

        std::lock_guard<mutex> lock(flagMutex);
        finished = true;
        cond.notify_all();
        return true;
    });

    unique_lock<mutex> lock(flagMutex);
    cond.wait(lock, [&]{return finished;});
    return true;
}