invoke()

fl::tuple< TypeConversionResult, json > fl::detail::RuntimeRpcBinding::invoke ( const json & jsonArgs )

overridevirtual

Implements fl::detail::ErasedInvoker.

Definition at line 41 of file runtime_rpc_binding.cpp.hpp.

                                                                                               {
    TypeConversionResult result;
 
    if (!jsonArgs.is_array()) {
        result.setError("arguments must be a JSON array");
        return fl::make_tuple(result, json(nullptr));
    }
 
    fl::size received = jsonArgs.size();
    if (received != mArgCount) {
        result.setError("argument count mismatch: expected " +
                        fl::to_string(static_cast<fl::i64>(mArgCount)) +
                        ", got " + fl::to_string(static_cast<fl::i64>(received)));
        return fl::make_tuple(result, json(nullptr));
    }
 
    fl::vector<unsigned char*> raw_slots;
    fl::vector<void*> slot_ptrs;
    raw_slots.reserve(mArgCount);
    slot_ptrs.reserve(mArgCount);
 
    RuntimeRpcSlotCleanup cleanup(mArgTypes, raw_slots);
 
    for (fl::size i = 0; i < mArgCount; ++i) {
        const RpcTypeOps* ops = mArgTypes[i];
        // `operator new[]` on `unsigned char` returns memory aligned to at
        // least alignof(max_align_t), which is sufficient for every type
        // currently routable through `rpc_storage_type<T>::type`
        // (fl::string, ints, floats, ConstCharPtrWrapper, ConstSpanWrapper).
        // Raw byte buffer for placement-new of `T` -- ops drives lifetime.
        unsigned char* buf = new unsigned char[ops->storage_size];  // ok bare allocation
        raw_slots.push_back(buf);
        slot_ptrs.push_back(buf);
        ops->default_construct(buf);
        cleanup.constructed = i + 1;
 
        TypeConversionResult convResult = ops->decode(jsonArgs[i], buf);
        for (fl::size w = 0; w < convResult.warnings().size(); ++w) {
            result.addWarning("arg " + fl::to_string(static_cast<fl::i64>(i)) +
                              ": " + convResult.warnings()[w]);
        }
        if (convResult.hasError()) {
            result.setError("arg " + fl::to_string(static_cast<fl::i64>(i)) +
                            ": " + convResult.errorMessage());
            return fl::make_tuple(result, json(nullptr));
        }
    }
 
    if (mResultType) {
        // Raw byte buffer for placement-new of `R`; same pattern as arg slots.
        unsigned char* result_buf = new unsigned char[mResultType->storage_size];  // ok bare allocation
        mResultType->default_construct(result_buf);
        mTrampoline(mUserFn, result_buf, slot_ptrs.data());
        json jsonResult = mResultType->encode(result_buf);
        mResultType->destroy(result_buf);
        delete[] result_buf;  // ok bare allocation
        return fl::make_tuple(result, jsonResult);
    }
 
    mTrampoline(mUserFn, nullptr, slot_ptrs.data());
    return fl::make_tuple(result, json(nullptr));
}

References fl::vector< T >::data(), fl::detail::RpcTypeOps::decode, fl::detail::RpcTypeOps::default_construct, fl::TypeConversionResult::errorMessage(), fl::FL_NO_EXCEPT, fl::TypeConversionResult::hasError(), fl::make_tuple(), mArgCount, mArgTypes, mResultType, mTrampoline, mUserFn, fl::vector< T >::push_back(), fl::vector< T >::reserve(), fl::detail::RpcTypeOps::storage_size, fl::to_string(), and fl::TypeConversionResult::warnings().

Here is the call graph for this function: