Struct Server

pub struct Server<RW, C>
where
    RW: AsyncRead + AsyncWrite + Unpin,
    C: HandlerConstructor<StreamWrapper<RW>>,
{ /* private fields */ }

The server instance of the Sheave

This consists of:

• Some stream instance which can both of read and write.
• Context data in the server.
• Some type parameter which implemented the HandlerConstructor trait.

The server wraps streams into Arc as a way of sharing streams among communication steps. And also wraps contexts because of the same purpose.

The server makes any foreign handler to be able to construct via the PhantomData, where a type parameter of PhantomData requires to implement the HandlerConstructor trait. That is, its type parameter behaves as the constructor injection.

Examples

use std::{
    io::Result as IOResult,
    marker::PhantomData,
    pin::Pin,
    sync::Arc,
    task::{
        Context as FutureContext,
        Poll
    }
};
use tokio::io::{
    AsyncRead,
    AsyncWrite
};
use sheave_core::handlers::{
    AsyncHandler,
    HandlerConstructor,
    RtmpContext,
    StreamWrapper,
    VecStream
};
use sheave_server::Server;

struct SomethingHandler<RW: AsyncRead + AsyncWrite + Unpin>(Arc<StreamWrapper<RW>>);

impl<RW: AsyncRead + AsyncWrite + Unpin> AsyncHandler for SomethingHandler<RW> {
    fn poll_handle(self: Pin<&mut Self>, _cx: &mut FutureContext<'_>, _rtmp_context: &mut RtmpContext) -> Poll<IOResult<()>> {
        Poll::Ready(Ok(()))
    }
}

impl<RW: AsyncRead + AsyncWrite + Unpin> HandlerConstructor<StreamWrapper<RW>> for SomethingHandler<RW> {
    fn new(stream: Arc<StreamWrapper<RW>>) -> Self {
        Self(stream)
    }
}

#[tokio::main]
async fn main() {
    let stream = VecStream::default();
    let rtmp_context = RtmpContext::default();
    let mut server = Server::new(stream, rtmp_context, PhantomData::<SomethingHandler<VecStream>>);
    let result = server.await;
    assert!(result.is_ok())
}

Implementations

impl<RW, C> Server<RW, C>

where RW: AsyncRead + AsyncWrite + Unpin, C: HandlerConstructor<StreamWrapper<RW>>,

pub fn new( stream: RW, rtmp_context: RtmpContext, handler_constructor: PhantomData<C>, ) -> Self

Constructs a Server instance.

Trait Implementations

impl<RW, C> Debug for Server<RW, C>

where RW: AsyncRead + AsyncWrite + Unpin + Debug, C: HandlerConstructor<StreamWrapper<RW>> + Debug,

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

Formats the value using the given formatter.

impl<RW, C> Future for Server<RW, C>

where RW: AsyncRead + AsyncWrite + Unpin, C: HandlerConstructor<StreamWrapper<RW>>,

type Output = Result<(), Error>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut FutureContext<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.