//! Re-exports of the async_std runtime for use with arti.

//!

//! This crate helps define a slim API around our async runtime so that we

//! can easily swap it out.

//!

//! We'll probably want to support tokio as well in the future.

/// Types used for networking (async_std implementation)

mod net {

    use crate::traits;

    use async_std_crate::net::{TcpListener, TcpStream};

    use async_trait::async_trait;

    use futures::future::Future;

    use futures::stream::Stream;

    use std::io::Result as IoResult;

    use std::net::SocketAddr;

    use std::pin::Pin;

    use std::task::{Context, Poll};

    /// A `Stream` of incoming TCP streams.

    ///

    /// Differs from the output of [`TcpListener::incoming`] in that this

    /// struct is a real type, and that it returns a TCP stream and an address

    /// for each input.

    pub struct IncomingStreams {

        /// A state object, stored in an Option so we can take ownership of it

        /// while poll is being called.

        // TODO(nickm): I hate using this trick.  At some point in the

        // future, once Rust has nice support for async traits, maybe

        // we can refactor it.

        state: Option<IncomingStreamsState>,

    }

    /// The result type returned by [`take_and_poll`].

    ///

    /// It has to include the TcpListener, since take_and_poll() has

    /// ownership of the listener.

    type FResult = (IoResult<(TcpStream, SocketAddr)>, TcpListener);

    /// Helper to implement [`IncomingStreams`]

    ///

    /// This function calls [`TcpListener::accept`] while owning the

    /// listener.  Thus, it returns a future that itself owns the listener,

    /// and we don't have lifetime troubles.

    /// The possible states for an [`IncomingStreams`].

    enum IncomingStreamsState {

        /// We're ready to call `accept` on the listener again.

        Ready(TcpListener),

        /// We've called `accept` on the listener, and we're waiting

        /// for a future to complete.

        Accepting(Pin<Box<dyn Future<Output = FResult>>>),

    }

    impl IncomingStreams {

        /// Create a new IncomingStreams from a TcpListener.

    }

    impl Stream for IncomingStreams {

        type Item = IoResult<(TcpStream, SocketAddr)>;

            };

                }

                Poll::Pending => {

                }

            }

    }

    #[async_trait]

    impl traits::TcpListener for TcpListener {

        type TcpStream = TcpStream;

        type Incoming = IncomingStreams;

    }

    #[async_trait]

    impl traits::TcpProvider for async_executors::AsyncStd {

        type TcpStream = TcpStream;

        type TcpListener = TcpListener;

    }

}

// ==============================

use futures::{Future, FutureExt};

use std::pin::Pin;

use std::time::Duration;

use crate::traits::*;

/// Create and return a new `async_std` runtime.

impl SleepProvider for async_executors::AsyncStd {

    type SleepFuture = Pin<Box<dyn Future<Output = ()> + Send + 'static>>;

}

impl BlockOn for async_executors::AsyncStd {

}