sep2_client 0.1.0

//! Flow Reservation Function Set
//!
//! This module contains an unimplemented interface for a Flow Reversation schedule, that takes in `FlowReservationResponse`.
//!
//! Unfortunately, it's very unclear how this schedule should operate based off the specification alone, and as such a generic implementation for this client library would be difficult to build.
//! Specifically, it is unclear when `FlowReservationResponseResponses` should be sent to the server, and with what `ResponseStatus` they should contain, as for whatever reason Flow Reservation is not included in Table 27.
//!
//! Regardless, end users of this library could easily implement a version of this scheduler for their specific use case, using the implemented schedulers as a reference.

use sep2_common::packages::flow_reservation::FlowReservationResponse;

use crate::event::{EventCallback, Schedule};

use std::{
    future::Future,
    sync::{atomic::AtomicI64, Arc},
    time::Duration,
};

use tokio::sync::RwLock;

use crate::{
    client::Client,
    device::SEDevice,
    event::{Events, Scheduler},
};

// Flow Reservation Schedule
impl Scheduler<FlowReservationResponse> for Schedule<FlowReservationResponse> {
    type Program = ();

    #[allow(unused_variables)]
    fn new(
        client: Client,
        device: Arc<RwLock<SEDevice>>,
        handler: impl EventCallback<FlowReservationResponse>,
        tickrate: Duration,
    ) -> Self {
        let (tx, rx) = tokio::sync::broadcast::channel::<()>(1);
        Schedule {
            client,
            device,
            events: Arc::new(RwLock::new(Events::new())),
            handler: Arc::new(move |ei| {
                let handler = handler.clone();
                Box::pin(async move { handler.event_update(ei).await })
            }),
            bc_sd: tx.clone(),
            tickrate,
            time_offset: Arc::new(AtomicI64::new(0)),
        }
    }

    #[allow(unused_variables)]
    fn add_event(
        &mut self,
        event: FlowReservationResponse,
        program: &Self::Program,
        server_id: u8,
    ) -> impl Future<Output = ()> + Send {
        async {}
    }
}