fn process_events()

in neqo-http3/src/server.rs [162:268]
107 lines of code
5 McCabe index (conditional complexity)

    fn process_events(&mut self, conn: &ConnectionRef, now: Instant) {
        let mut remove = false;
        let http3_parameters = &self.http3_parameters;
        {
            let handler = self.http3_handlers.entry(conn.clone()).or_insert_with(|| {
                Rc::new(RefCell::new(Http3ServerHandler::new(
                    http3_parameters.clone(),
                )))
            });
            handler
                .borrow_mut()
                .process_http3(&mut conn.borrow_mut(), now);
            let mut handler_borrowed = handler.borrow_mut();
            while let Some(e) = handler_borrowed.next_event() {
                match e {
                    Http3ServerConnEvent::Headers {
                        stream_info,
                        headers,
                        fin,
                    } => self.events.headers(
                        Http3OrWebTransportStream::new(
                            conn.clone(),
                            Rc::clone(handler),
                            stream_info,
                        ),
                        headers,
                        fin,
                    ),
                    Http3ServerConnEvent::DataReadable { stream_info } => {
                        prepare_data(
                            stream_info,
                            &mut handler_borrowed,
                            conn,
                            handler,
                            now,
                            &self.events,
                        );
                    }
                    Http3ServerConnEvent::DataWritable { stream_info } => self
                        .events
                        .data_writable(conn.clone(), Rc::clone(handler), stream_info),
                    Http3ServerConnEvent::StreamReset { stream_info, error } => {
                        self.events.stream_reset(
                            conn.clone(),
                            Rc::clone(handler),
                            stream_info,
                            error,
                        );
                    }
                    Http3ServerConnEvent::StreamStopSending { stream_info, error } => {
                        self.events.stream_stop_sending(
                            conn.clone(),
                            Rc::clone(handler),
                            stream_info,
                            error,
                        );
                    }
                    Http3ServerConnEvent::StateChange(state) => {
                        self.events
                            .connection_state_change(conn.clone(), state.clone());
                        if let Http3State::Closed { .. } = state {
                            remove = true;
                        }
                    }
                    Http3ServerConnEvent::PriorityUpdate {
                        stream_id,
                        priority,
                    } => {
                        self.events.priority_update(stream_id, priority);
                    }
                    Http3ServerConnEvent::ExtendedConnect { stream_id, headers } => {
                        self.events.webtransport_new_session(
                            WebTransportRequest::new(conn.clone(), Rc::clone(handler), stream_id),
                            headers,
                        );
                    }
                    Http3ServerConnEvent::ExtendedConnectClosed {
                        stream_id,
                        reason,
                        headers,
                        ..
                    } => self.events.webtransport_session_closed(
                        WebTransportRequest::new(conn.clone(), Rc::clone(handler), stream_id),
                        reason,
                        headers,
                    ),
                    Http3ServerConnEvent::ExtendedConnectNewStream(stream_info) => self
                        .events
                        .webtransport_new_stream(Http3OrWebTransportStream::new(
                            conn.clone(),
                            Rc::clone(handler),
                            stream_info,
                        )),
                    Http3ServerConnEvent::ExtendedConnectDatagram {
                        session_id,
                        datagram,
                    } => self.events.webtransport_datagram(
                        WebTransportRequest::new(conn.clone(), Rc::clone(handler), session_id),
                        datagram,
                    ),
                }
            }
        }
        if remove {
            self.http3_handlers.remove(&conn.clone());
        }
    }