indi 5.1.1

Client library for interfacing with the Instrument Neutral Distributed Interface (INDI) protocol.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use futures::{
    stream::{SplitSink, SplitStream},
    Sink, Stream, StreamExt,
};
use twinkle_client::MaybeSend;

use crate::{
    client::{
        sink::SinkStringWrapper, stream::StringCommandStream, AsyncClientConnection, Connectable,
    },
    serialization, DeError,
};
use std::{future::Future, pin::Pin};
use tokio_tungstenite_wasm::{Error, Message, WebSocketStream};

impl AsyncClientConnection for tokio_tungstenite_wasm::WebSocketStream {
    type Writer = SinkStringWrapper<WebSocketCommandWriter<SplitSink<WebSocketStream, Message>>>;
    type Reader = StringCommandStream<
        Result<String, DeError>,
        WebSocketCommandReader<SplitStream<WebSocketStream>>,
    >;

    fn to_indi(self) -> (Self::Writer, Self::Reader) {
        let (writer, reader) = self.split();

        (
            WebSocketCommandWriter { writer }.into(),
            WebSocketCommandReader { reader }.into(),
        )
    }
}

impl Connectable for tokio_tungstenite_wasm::WebSocketStream {
    type ConnectionError = tokio_tungstenite_wasm::Error;

    fn connect(
        addr: String,
    ) -> impl Future<Output = Result<Self, Self::ConnectionError>> + MaybeSend {
        tokio_tungstenite_wasm::connect(addr)
    }
}

pub struct WebSocketCommandReader<S: Stream<Item = Result<Message, Error>>> {
    reader: S,
}

impl<S: Stream<Item = Result<Message, Error>> + Unpin> Stream for WebSocketCommandReader<S> {
    type Item = Result<String, DeError>;

    fn poll_next(
        mut self: Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match Pin::new(&mut self.reader).poll_next(cx) {
            std::task::Poll::Ready(Some(Ok(msg))) => std::task::Poll::Ready(match msg {
                Message::Text(text) => Some(Ok(text)),
                Message::Close(_) => None,
                Message::Binary(p) => Some(Err(DeError::UnexpectedTungsteniteWasmMessage(
                    Message::Binary(p),
                ))),
            }),
            std::task::Poll::Ready(Some(Err(e))) => std::task::Poll::Ready(Some(Err(e.into()))),
            std::task::Poll::Ready(None) => std::task::Poll::Ready(None),
            std::task::Poll::Pending => std::task::Poll::Pending,
        }
    }
}
pub struct WebSocketCommandWriter<S> {
    writer: S,
}

impl<S> Sink<String> for WebSocketCommandWriter<S>
where
    S: Sink<Message> + std::marker::Unpin,
    serialization::DeError: From<<S as futures::Sink<Message>>::Error>,
{
    type Error = crate::DeError;

    fn poll_ready(
        mut self: Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        match Pin::new(&mut self.writer).poll_ready(cx) {
            std::task::Poll::Ready(Ok(r)) => std::task::Poll::Ready(Ok(r)),
            std::task::Poll::Ready(Err(e)) => std::task::Poll::Ready(Err(e.into())),
            std::task::Poll::Pending => std::task::Poll::Pending,
        }
    }

    fn start_send(mut self: Pin<&mut Self>, item: String) -> Result<(), Self::Error> {
        Ok(Pin::new(&mut self.writer).start_send(Message::Text(item))?)
    }

    fn poll_flush(
        mut self: Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        match Pin::new(&mut self.writer).poll_flush(cx) {
            std::task::Poll::Ready(Ok(r)) => std::task::Poll::Ready(Ok(r)),
            std::task::Poll::Ready(Err(e)) => std::task::Poll::Ready(Err(e.into())),
            std::task::Poll::Pending => std::task::Poll::Pending,
        }
    }

    fn poll_close(
        mut self: Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        match Pin::new(&mut self.writer).poll_close(cx) {
            std::task::Poll::Ready(Ok(r)) => std::task::Poll::Ready(Ok(r)),
            std::task::Poll::Ready(Err(e)) => std::task::Poll::Ready(Err(e.into())),
            std::task::Poll::Pending => std::task::Poll::Pending,
        }
    }
}