ergot 0.12.0

//! Toolkits
//!
//! Toolkits are a collection of types and methods useful when using a specific
//! profile of netstack. Ideally: end users should need relatively few `use` statements
//! outside of the given toolkit they plan to use.

pub mod null {
    #[cfg(feature = "std")]
    use mutex::raw_impls::cs::CriticalSectionRawMutex;

    use crate::interface_manager::profiles::null::Null;

    #[cfg(feature = "std")]
    use crate::interface_manager::ConstInit;

    pub type NullStack<R> = crate::NetStack<R, Null>;

    #[cfg(feature = "std")]
    pub type ArcNullStack = crate::net_stack::arc::ArcNetStack<CriticalSectionRawMutex, Null>;

    #[cfg(feature = "std")]
    pub fn new_arc_null_stack() -> ArcNullStack {
        crate::net_stack::arc::ArcNetStack::new_with_profile(Null::INIT)
    }
}

#[cfg(feature = "embedded-io-async-v0_6")]
pub mod embedded_io_async_v0_6 {
    use crate::{
        exports::bbq2::{
            prod_cons::stream::StreamProducer,
            queue::BBQueue,
            traits::{bbqhdl::BbqHandle, notifier::maitake::MaiNotSpsc, storage::Inline},
        },
        interface_manager::{
            profiles::direct_edge::{
                DirectEdge,
                eio_0_6::{self, EmbeddedIoManager},
            },
            utils::cobs_stream::Sink,
        },
    };
    use mutex::{ConstInit, ScopedRawMutex};

    use crate::NetStack;
    pub use crate::interface_manager::interface_impls::embedded_io::tx_worker;

    pub type Queue<const N: usize, C> = BBQueue<Inline<N>, C, MaiNotSpsc>;
    pub type Stack<Q, R> = NetStack<R, EmbeddedIoManager<Q>>;
    pub type BaseStack<Q, R> = crate::NetStack<R, EmbeddedIoManager<Q>>;
    pub type RxWorker<Q, R, D> = eio_0_6::RxWorker<&'static BaseStack<Q, R>, D>;

    pub const fn new_target_stack<Q, R>(producer: StreamProducer<Q>, mtu: u16) -> Stack<Q, R>
    where
        Q: BbqHandle + 'static,
        R: ScopedRawMutex + ConstInit + 'static,
    {
        NetStack::new_with_profile(DirectEdge::new_target(Sink::new(producer, mtu)))
    }
}

#[cfg(feature = "embassy-usb-v0_5")]
pub mod embassy_usb_v0_5 {
    use crate::{
        exports::bbq2::{
            prod_cons::framed::FramedProducer,
            queue::BBQueue,
            traits::{bbqhdl::BbqHandle, notifier::maitake::MaiNotSpsc, storage::Inline},
        },
        interface_manager::{
            profiles::direct_edge::{
                DirectEdge,
                eusb_0_5::{self, EmbassyUsbManager},
            },
            utils::framed_stream::Sink,
        },
    };
    use mutex::{ConstInit, ScopedRawMutex};

    use crate::NetStack;

    pub use crate::interface_manager::interface_impls::embassy_usb::{
        DEFAULT_TIMEOUT_MS_PER_FRAME, USB_FS_MAX_PACKET_SIZE,
        eusb_0_5::{WireStorage, tx_worker},
    };

    pub type Queue<const N: usize, C> = BBQueue<Inline<N>, C, MaiNotSpsc>;
    pub type Stack<Q, R> = NetStack<R, EmbassyUsbManager<Q>>;
    pub type BaseStack<Q, R> = crate::NetStack<R, EmbassyUsbManager<Q>>;
    pub type RxWorker<Q, R, D> = eusb_0_5::RxWorker<Q, &'static BaseStack<Q, R>, D>;

    pub const fn new_target_stack<Q, R>(producer: FramedProducer<Q, u16>, mtu: u16) -> Stack<Q, R>
    where
        Q: BbqHandle,
        R: ScopedRawMutex + ConstInit + 'static,
    {
        NetStack::new_with_profile(DirectEdge::new_target(Sink::new(producer, mtu)))
    }
}

#[cfg(feature = "embassy-net-v0_7")]
pub mod embassy_net_v0_7 {
    use crate::NetStack;
    use crate::interface_manager::InterfaceState;
    use crate::interface_manager::interface_impls::embassy_net_udp::EmbassyNetInterface;
    use crate::interface_manager::profiles::direct_edge::DirectEdge;
    use crate::interface_manager::utils::framed_stream::Sink;
    use bbq2::prod_cons::framed::FramedProducer;
    use bbq2::queue::BBQueue;
    use bbq2::traits::bbqhdl::BbqHandle;
    use bbq2::traits::notifier::maitake::MaiNotSpsc;
    use bbq2::traits::storage::Inline;
    use maitake_sync::blocking::{ConstInit, ScopedRawMutex};

    pub type Queue<const N: usize, C> = BBQueue<Inline<N>, C, MaiNotSpsc>;

    pub type EdgeStack<Q, R> = NetStack<R, DirectEdge<EmbassyNetInterface<Q>>>;

    pub const fn new_target_stack<Q, R>(producer: FramedProducer<Q>, mtu: u16) -> EdgeStack<Q, R>
    where
        Q: BbqHandle,
        R: ScopedRawMutex + ConstInit + 'static,
    {
        NetStack::new_with_profile(DirectEdge::new_target(Sink::new(producer, mtu)))
    }

    pub const fn new_controller_stack<Q, R>(
        producer: FramedProducer<Q>,
        mtu: u16,
    ) -> EdgeStack<Q, R>
    where
        Q: BbqHandle,
        R: ScopedRawMutex + ConstInit + 'static,
    {
        NetStack::new_with_profile(DirectEdge::new_controller(
            Sink::new(producer, mtu),
            InterfaceState::Down,
        ))
    }
}

#[cfg(feature = "tokio-std")]
pub mod tokio_tcp {
    use crate::interface_manager::{
        interface_impls::tokio_tcp::TokioTcpInterface,
        profiles::{
            direct_edge::{self, DirectEdge, tokio_tcp::SocketAlreadyActive},
            direct_router::{self, DirectRouter, tokio_tcp::Error},
        },
        utils::{cobs_stream, std::StdQueue},
    };
    use mutex::raw_impls::cs::CriticalSectionRawMutex;
    use tokio::net::TcpStream;

    pub use crate::interface_manager::utils::std::new_std_queue;

    use crate::net_stack::ArcNetStack;

    pub type RouterStack = ArcNetStack<CriticalSectionRawMutex, DirectRouter<TokioTcpInterface>>;
    pub type EdgeStack = ArcNetStack<CriticalSectionRawMutex, DirectEdge<TokioTcpInterface>>;

    pub async fn register_router_interface(
        stack: &RouterStack,
        socket: TcpStream,
        max_ergot_packet_size: u16,
        outgoing_buffer_size: usize,
    ) -> Result<u64, Error> {
        direct_router::tokio_tcp::register_interface(
            stack.clone(),
            socket,
            max_ergot_packet_size,
            outgoing_buffer_size,
        )
        .await
    }

    pub async fn register_edge_interface(
        stack: &EdgeStack,
        socket: TcpStream,
        queue: &StdQueue,
    ) -> Result<(), SocketAlreadyActive> {
        direct_edge::tokio_tcp::register_target_interface(stack.clone(), socket, queue.clone())
            .await
    }

    pub fn new_target_stack(queue: &StdQueue, mtu: u16) -> EdgeStack {
        EdgeStack::new_with_profile(DirectEdge::new_target(cobs_stream::Sink::new_from_handle(
            queue.clone(),
            mtu,
        )))
    }
}

#[cfg(feature = "tokio-std")]
pub mod tokio_udp {
    use crate::interface_manager::profiles::direct_edge::tokio_udp::InterfaceKind;
    use crate::interface_manager::profiles::direct_router;
    use crate::interface_manager::profiles::direct_router::DirectRouter;
    use crate::interface_manager::profiles::direct_router::tokio_udp::Error;
    use crate::interface_manager::utils::framed_stream;
    pub use crate::interface_manager::utils::std::new_std_queue;
    use crate::interface_manager::{
        InterfaceState,
        interface_impls::tokio_udp::TokioUdpInterface,
        profiles::direct_edge::{self, DirectEdge, tokio_udp::SocketAlreadyActive},
        utils::std::StdQueue,
    };
    use mutex::raw_impls::cs::CriticalSectionRawMutex;
    use tokio::net::UdpSocket;

    use crate::net_stack::ArcNetStack;

    pub type RouterStack = ArcNetStack<CriticalSectionRawMutex, DirectRouter<TokioUdpInterface>>;
    pub type EdgeStack = ArcNetStack<CriticalSectionRawMutex, DirectEdge<TokioUdpInterface>>;

    pub async fn register_router_interface(
        stack: &RouterStack,
        socket: UdpSocket,
        max_ergot_packet_size: u16,
        outgoing_buffer_size: usize,
    ) -> Result<u64, Error> {
        direct_router::tokio_udp::register_interface(
            stack.clone(),
            socket,
            max_ergot_packet_size,
            outgoing_buffer_size,
        )
        .await
    }

    pub async fn register_edge_interface(
        stack: &EdgeStack,
        socket: UdpSocket,
        queue: &StdQueue,
        interface_kind: InterfaceKind,
    ) -> Result<(), SocketAlreadyActive> {
        direct_edge::tokio_udp::register_interface(
            stack.clone(),
            socket,
            queue.clone(),
            interface_kind,
            (),
        )
        .await
    }

    pub fn new_target_stack(queue: &StdQueue, mtu: u16) -> crate::toolkits::tokio_udp::EdgeStack {
        crate::toolkits::tokio_udp::EdgeStack::new_with_profile(DirectEdge::new_target(
            framed_stream::Sink::new_from_handle(queue.clone(), mtu),
        ))
    }

    pub fn new_controller_stack(
        queue: &StdQueue,
        mtu: u16,
    ) -> crate::toolkits::tokio_udp::EdgeStack {
        crate::toolkits::tokio_udp::EdgeStack::new_with_profile(DirectEdge::new_controller(
            framed_stream::Sink::new_from_handle(queue.clone(), mtu),
            InterfaceState::Down,
        ))
    }
}

#[cfg(feature = "nusb-v0_1")]
pub mod nusb_v0_1 {
    use crate::interface_manager::{
        interface_impls::nusb_bulk::NusbBulk,
        profiles::direct_router::{self, DirectRouter, nusb_0_1::Error},
    };
    use mutex::raw_impls::cs::CriticalSectionRawMutex;

    use crate::net_stack::ArcNetStack;

    pub use crate::interface_manager::interface_impls::nusb_bulk::{NewDevice, find_new_devices};

    pub type RouterStack = ArcNetStack<CriticalSectionRawMutex, DirectRouter<NusbBulk>>;
    pub async fn register_router_interface(
        stack: &RouterStack,
        device: NewDevice,
        max_ergot_packet_size: u16,
        outgoing_buffer_size: usize,
    ) -> Result<u64, Error> {
        direct_router::nusb_0_1::register_interface(
            stack.clone(),
            device,
            max_ergot_packet_size,
            outgoing_buffer_size,
        )
        .await
    }
}

#[cfg(feature = "tokio-serial-v5")]
pub mod tokio_serial_v5 {
    use crate::interface_manager::{
        interface_impls::tokio_serial_cobs::TokioSerialInterface,
        profiles::{
            direct_edge::DirectEdge,
            direct_router::{self, DirectRouter, tokio_serial_5::Error},
        },
    };
    use mutex::raw_impls::cs::CriticalSectionRawMutex;

    pub use crate::interface_manager::utils::std::new_std_queue;

    use crate::net_stack::ArcNetStack;

    pub type RouterStack = ArcNetStack<CriticalSectionRawMutex, DirectRouter<TokioSerialInterface>>;
    pub type EdgeStack = ArcNetStack<CriticalSectionRawMutex, DirectEdge<TokioSerialInterface>>;

    pub async fn register_router_interface(
        stack: &RouterStack,
        port: &str,
        baud: u32,
        max_ergot_packet_size: u16,
        outgoing_buffer_size: usize,
    ) -> Result<u64, Error> {
        direct_router::tokio_serial_5::register_interface(
            stack.clone(),
            port,
            baud,
            max_ergot_packet_size,
            outgoing_buffer_size,
        )
        .await
    }
}