pub fn json_op_async<F, V, R, RV>(op_fn: F) -> Box<OpFn>
where
  F: Fn(Rc<RefCell<OpState>>, V, BufVec) -> R + 'static,
  V: DeserializeOwned,
  R: Future<Output = Result<RV, AnyError>> + 'static,
  RV: Serialize,
{
  let try_dispatch_op =
    move |state: Rc<RefCell<OpState>>, bufs: BufVec| -> Result<Op, AnyError> {
      let request_id = bufs[0]
        .get(0..8)
        .map(|b| u64::from_le_bytes(b.try_into().unwrap()))
        .ok_or_else(|| type_error("missing or invalid `requestId`"))?;
      let args = serde_json::from_slice(&bufs[0][8..])?;
      let bufs = bufs[1..].into();
      use crate::futures::FutureExt;
      let fut = op_fn(state.clone(), args, bufs).map(move |result| {
        json_serialize_op_result(
          Some(request_id),
          result,
          state.borrow().get_error_class_fn,
        )
      });
      Ok(Op::Async(Box::pin(fut)))
    };

  Box::new(move |state: Rc<RefCell<OpState>>, bufs: BufVec| -> Op {
    match try_dispatch_op(state.clone(), bufs) {
      Ok(op) => op,
      Err(err) => Op::Sync(json_serialize_op_result(
        None,
        Err::<(), AnyError>(err),
        state.borrow().get_error_class_fn,
      )),
    }
  })
}
/// Creates an op that passes data asynchronously using JSON.
///
/// The provided function `op_fn` has the following parameters:
/// * `Rc<RefCell<OpState>`: the op state, can be used to read/write resources in the runtime from an op.
/// * `V`: the deserializable value that is passed to the Rust function.
/// * `BufVec`: raw bytes passed along, usually not needed if the JSON value is used.
///
/// `op_fn` returns a future, whose output is a serializable value. This value will be asynchronously
/// returned to JavaScript.
///
/// When registering an op like this...
/// ```ignore
/// let mut runtime = JsRuntime::new(...);
/// runtime.register_op("hello", deno_core::json_op_async(Self::hello_op));
/// ```
///
/// ...it can be invoked from JS using the provided name, for example:
/// ```js
/// Deno.core.ops();
/// let future = Deno.core.jsonOpAsync("function_name", args);
/// ```
///
/// The `Deno.core.ops()` statement is needed once before any op calls, for initialization.
/// A more complete example is available in the examples directory.
Creates an op that passes data asynchronously using JSON.
The provided function `op_fn` has the following parameters:
`Rc`: the op state, can be used to read/write resources in the runtime from an op.
`V`: the deserializable value that is passed to the Rust function.
`BufVec`: raw bytes passed along, usually not needed if the JSON value is used.

`op_fn` returns a future, whose output is a serializable value. This value will be asynchronously
returned to JavaScript.





The `Deno.core.ops()` statement is needed once before any op calls, for initialization.
A more complete example is available in the examples directory.
Creates an op that passes data asynchronously using JSON . The provided function ` op_fn ` has the following parameters : ` Rc ` : the op state can be used to read / write resources in the runtime from an op . ` V ` : the deserializable value that is passed to the Rust function . ` BufVec ` : raw bytes passed along usually not needed if the JSON value is used . ` op_fn ` returns a future whose output is a serializable value . This value will be asynchronously returned to JavaScript . The ` Deno . core . ops () ` statement is needed once before any op calls for initialization . A more complete example is available in the examples directory .
pub fn json_op_async<F, V, R, RV>(op_fn: F) -> Box<OpFn>
where
  F: Fn(Rc<RefCell<OpState>>, V, BufVec) -> R + 'static,
  V: DeserializeOwned,
  R: Future<Output = Result<RV, AnyError>> + 'static,
  RV: Serialize,
{
  let try_dispatch_op =
    move |state: Rc<RefCell<OpState>>, bufs: BufVec| -> Result<Op, AnyError> {
      let request_id = bufs[0]
        .get(0..8)
        .map(|b| u64::from_le_bytes(b.try_into().unwrap()))
        .ok_or_else(|| type_error("missing or invalid `requestId`"))?;
      let args = serde_json::from_slice(&bufs[0][8..])?;
      let bufs = bufs[1..].into();
      use crate::futures::FutureExt;
      let fut = op_fn(state.clone(), args, bufs).map(move |result| {
        json_serialize_op_result(
          Some(request_id),
          result,
          state.borrow().get_error_class_fn,
        )
      });
      Ok(Op::Async(Box::pin(fut)))
    };
  Box::new(move |state: Rc<RefCell<OpState>>, bufs: BufVec| -> Op {
    match try_dispatch_op(state.clone(), bufs) {
      Ok(op) => op,
      Err(err) => Op::Sync(json_serialize_op_result(
        None,
        Err::<(), AnyError>(err),
        state.borrow().get_error_class_fn,
      )),
    }
  })
}
pub fn json_op_async < F , V , R , RV > ( op_fn : F ) -> Box < OpFn > where F : Fn ( Rc < RefCell < OpState > > , V , BufVec ) -> R + ' static , V : DeserializeOwned , R : Future < Output = Result < RV , AnyError > > + ' static , RV : Serialize , { let try_dispatch_op = move | state : Rc < RefCell < OpState > > , bufs : BufVec | -> Result < Op , AnyError > { let request_id = bufs [ 0 ] . get ( 0 .. 8 ) . map ( | b | u64 :: from_le_bytes ( b . try_into ( ) . unwrap ( ) ) ) . ok_or_else ( | | type_error ( " " ) ) ? ; let args = serde_json :: from_slice ( & bufs [ 0 ] [ 8 .. ] ) ? ; let bufs = bufs [ 1 .. ] . into ( ) ; use crate :: futures :: FutureExt ; let fut = op_fn ( state . clone ( ) , args , bufs ) . map ( move | result | { json_serialize_op_result ( Some ( request_id ) , result , state . borrow ( ) . get_error_class_fn , ) } ) ; Ok ( Op :: Async ( Box :: pin ( fut ) ) ) } ; Box :: new ( move | state : Rc < RefCell < OpState > > , bufs : BufVec | -> Op { match try_dispatch_op ( state . clone ( ) , bufs ) { Ok ( op ) => op , Err ( err ) => Op :: Sync ( json_serialize_op_result ( None , Err :: < ( ) , AnyError > ( err ) , state . borrow ( ) . get_error_class_fn , ) ) , } } ) }
Creates an op that passes data asynchronously using JSON.
Creates an op that passes data asynchronously using JSON .
op_fn
F
op_fn
F