Struct vtubestudio::data::RequestEnvelope

pub struct RequestEnvelope {
    pub api_name: Cow<'static, str>,
    pub api_version: Cow<'static, str>,
    pub request_id: Option<RequestId>,
    pub message_type: EnumString<RequestType>,
    pub data: OpaqueValue,
}

A VTube Studio API request.

Fields

api_name: Cow<'static, str>

API name, typically "VTubeStudioPublicAPI".

api_version: Cow<'static, str>

API version, typically "1.0".

request_id: Option<RequestId>

The original request ID.

message_type: EnumString<RequestType>

The request type.

data: OpaqueValue

The request data.

Implementations

impl RequestEnvelope

pub fn new<Req: Request>(data: &Req) -> Result<Self, Error>

Creates a request with the underlying typed data.

pub fn set_data<Req: Request>(&mut self, data: &Req) -> Result<(), Error>

Sets the data field of a request.

pub fn with_id<T: Into<Option<RequestId>>>(self, id: T) -> Self

Sets the request ID.

Trait Implementations

impl Clone for RequestEnvelope

fn clone(&self) -> RequestEnvelope

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RequestEnvelope

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RequestEnvelope

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RequestEnvelope

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Policy<RequestEnvelope, ResponseEnvelope, Error> for RetryPolicy

type Future = Ready<RetryPolicy>

The Future type returned by Policy::retry.

fn retry( &self, req: &RequestEnvelope, result: Result<&ResponseEnvelope, &Error>, ) -> Option<Self::Future>

Check the policy if a certain request should be retried.

fn clone_request(&self, req: &RequestEnvelope) -> Option<RequestEnvelope>

Tries to clone a request before being passed to the inner service.

impl Serialize for RequestEnvelope

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Service<RequestEnvelope> for ApiService<T>

where T: Sink<RequestEnvelope> + TryStream<Ok = ResponseEnvelope> + 'static, BoxError: From<<T as Sink<RequestEnvelope>>::Error> + From<<T as TryStream>::Error>,

type Response = ResponseEnvelope

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<ApiService<T> as Service<RequestEnvelope>>::Response, <ApiService<T> as Service<RequestEnvelope>>::Error>> + Send>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: RequestEnvelope) -> Self::Future

Process the request and return the response asynchronously.

impl<S> Service<RequestEnvelope> for Authentication<S>

where S: Service<RequestEnvelope, Response = ResponseEnvelope> + Clone + Send + 'static, S::Future: Send, S::Error: Send, Error: From<S::Error>,

type Response = ResponseWithToken

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<Authentication<S> as Service<RequestEnvelope>>::Response, <Authentication<S> as Service<RequestEnvelope>>::Error>> + Send>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: RequestEnvelope) -> Self::Future

Process the request and return the response asynchronously.

impl<T, C> Sink<RequestEnvelope> for ApiTransport<T, C>

where T: Sink<C::Output>, C: MessageCodec, BoxError: From<T::Error>,

type Error = Box<dyn Error + Sync + Send>

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send( self: Pin<&mut Self>, item: RequestEnvelope, ) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.