bindings: Vec<Binding>,

}

trait Binds<T> {

    fn bind(&mut self, coupling: Coupling, addr: SocketAddr) -> T;

}

impl Binds<InPort> for Connecting {

    fn bind(&mut self, coupling: Coupling, addr: SocketAddr) -> InPort {

        self.bindings.push(Binding { coupling, polarity: Polarity::Getter, addr });

        InPort(Port(self.bindings.len() - 1))

    }

}

impl Binds<OutPort> for Connecting {

    fn bind(&mut self, coupling: Coupling, addr: SocketAddr) -> OutPort {

        self.bindings.push(Binding { coupling, polarity: Polarity::Putter, addr });

        OutPort(Port(self.bindings.len() - 1))

    }

}

#[derive(Debug, Clone)]

pub enum ConnectErr {

    BindErr(SocketAddr),

    NewSocketErr(SocketAddr),

    AcceptErr(SocketAddr),

    ConnectionShutdown(SocketAddr),

    EndpointErr(Port, EndpointErr),

    PollInitFailed,

    PollingFailed,

    Timeout,

}

#[derive(Debug)]

struct Component {

    protocol: Arc<ProtocolD>,

    port_set: HashSet<Port>,

    identifier: Arc<[u8]>,

    state: ProtocolS,

}

impl From<PollDeadlineErr> for ConnectErr {

    fn from(e: PollDeadlineErr) -> Self {

        use PollDeadlineErr as P;

        match e {

            P::PollingFailed => Self::PollingFailed,

            P::Timeout => Self::Timeout,

        }

    }

}

impl From<MessengerRecvErr> for ConnectErr {

                            ms.poll.deregister(&stream).expect("wt");

                            std::thread::sleep(Duration::from_millis(backoff_millis));

                            backoff_millis = ((backoff_millis as f32) * 1.2) as u64 + 3;

                            let stream = TcpStream::connect(&binding.addr).unwrap();

                            ms.poll.register(&stream, token, ready_w, edge).expect("PAC 3");

                            Todo::ActiveConnecting { stream }

                        };

                        todos[index] = Some(todo);

                    }

                    Some(Todo::PassiveConnecting { mut stream, channel_id }) => {

                        if !Self::test_stream_connectivity(&mut stream) {

                            return Err(ConnectionShutdown(binding.addr));

                        }

                        ms.poll.reregister(&stream, token, ready_r, edge).expect("55");

                        let polarity = binding.polarity;

                        let info = EndpointInfo { polarity, channel_id };

                        let msg = Msg::SetupMsg(SetupMsg::ChannelSetup { info });

                        let mut endpoint = Endpoint::from_fresh_stream(stream);

                        endpoint.send(msg).map_err(|e| EndpointErr(Port(index), e))?;

                        let endpoint_ext = EndpointExt { endpoint, info };

                        endpoint_exts.occupy_reserved(index, endpoint_ext);

                        num_todos_remaining -= 1;

                    }

                    Some(Todo::ActiveRecving { mut endpoint }) => {

                        'recv_loop: while let Some(msg) =

                        {

                            if let Msg::SetupMsg(SetupMsg::ChannelSetup { info }) = msg {

                                if info.polarity == binding.polarity {

                                }

                                let channel_id = info.channel_id;

                                let info = EndpointInfo { polarity: binding.polarity, channel_id };

                                ms.polled_undrained.insert(ekey);

                                let endpoint_ext = EndpointExt { endpoint, info };

                                endpoint_exts.occupy_reserved(index, endpoint_ext);

                                num_todos_remaining -= 1;

                                break 'recv_loop;

                            } else {

                                ms.delayed.push(ReceivedMsg { recipient: ekey, msg });

                            }

                        }

                    }

                }

            }

        }

        assert_eq!(None, endpoint_exts.iter_reserved().next());

        drop(todos);

        ///////////////////////////////////////////////////////

        // 1. construct `family', i.e. perform the sink tree setup procedure

        use {Msg::SetupMsg as S, SetupMsg::*};

        let mut messenger = (&mut ms, &mut endpoint_exts);

        impl Messengerlike for (&mut MessengerState, &mut VecStorage<EndpointExt>) {

}

// dummy fn for the actual synchronous round

fn sync_inner<'c, 'b>(

    _connected: &'c mut Connected,

    _buf: &'b mut [u8],

) -> (usize, &'b HashMap<Port, Range<usize>>) {

    todo!()

}

unsafe fn as_mut_slice<'a, T>(len: usize, ptr: *mut T) -> &'a mut [T] {

    std::slice::from_raw_parts_mut(ptr, len)

}

unsafe fn as_const_slice<'a, T>(len: usize, ptr: *const T) -> &'a [T] {

    std::slice::from_raw_parts(ptr, len)

}

#[test]

fn api_connecting() {

    let addrs: [SocketAddr; 3] = [

        "127.0.0.1:8888".parse().unwrap(),

        "127.0.0.1:8889".parse().unwrap(),

        "127.0.0.1:8890".parse().unwrap(),

    ];

    let handles = vec![

        std::thread::spawn(move || {

            let mut connecting = Connecting::default();

            println!("A: {:#?}", connected);

        }),

        std::thread::spawn(move || {

            let mut connecting = Connecting::default();

            println!("B: {:#?}", connected);

        }),

    ];

    for h in handles {

        h.join().unwrap();

    }

}