4     ErrorCode, get_unicast_hop_limit, is_valid_address_family, is_valid_remote_address,
160     ) -> Result<Self, ErrorCode> {  in new()  argument
239     pub(crate) fn as_std_view(&self) -> Result<SocketlikeView<'_, std::net::TcpStream>, ErrorCode> {  in as_std_view()  argument
248                 Err(ErrorCode::InvalidState)  in as_std_view()
255     pub(crate) fn start_bind(&mut self, addr: SocketAddr) -> Result<(), ErrorCode> {  in start_bind()  argument
258             return Err(ErrorCode::InvalidArgument);  in start_bind()
272                 Err(ErrorCode::InvalidState)  in start_bind()
277     pub(crate) fn finish_bind(&mut self) -> Result<(), ErrorCode> {  in finish_bind()  argument
286                 Err(ErrorCode::NotInProgress)  in finish_bind()
294     ) -> Result<tokio::net::TcpSocket, ErrorCode> {  in start_connect()  argument
298                 return Err(ErrorCode::ConcurrencyConflict);  in start_connect()
300             _ => return Err(ErrorCode::InvalidState),  in start_connect()
307             return Err(ErrorCode::InvalidArgument);  in start_connect()
324     ) -> Result<(), ErrorCode> {  in set_pending_connect()  argument
330             _ => Err(ErrorCode::InvalidState),  in set_pending_connect()
344     ) -> Result<Option<io::Result<tokio::net::TcpStream>>, ErrorCode> {  in take_pending_connect()  argument
359                 Err(ErrorCode::NotInProgress)  in take_pending_connect()
367     ) -> Result<(), ErrorCode> {  in finish_connect()  argument
369             return Err(ErrorCode::InvalidState);  in finish_connect()
378                 Err(ErrorCode::from(err))  in finish_connect()
384     pub(crate) fn start_listen_p2(&mut self) -> Result<(), ErrorCode> {  in start_listen_p2()  argument
392                 Err(ErrorCode::InvalidState)  in start_listen_p2()
397     pub(crate) fn finish_listen_p2(&mut self) -> Result<(), ErrorCode> {  in finish_listen_p2()  argument
402                 return Err(ErrorCode::NotInProgress);  in finish_listen_p2()
411     pub(crate) fn listen_p3(&mut self) -> Result<(), ErrorCode> {  in listen_p3()  argument
448                 return Err(ErrorCode::InvalidState);  in listen_p3()
455     fn listen_common(&mut self, tokio_socket: tokio::net::TcpSocket) -> Result<(), ErrorCode> {  in listen_common()  argument
486     pub(crate) fn accept(&mut self) -> Result<Option<Self>, ErrorCode> {  in accept()  argument
492             return Err(ErrorCode::InvalidState);  in accept()
511     pub(crate) fn local_address(&self) -> Result<SocketAddr, ErrorCode> {  in local_address()  argument
518             _ => Err(ErrorCode::InvalidState),  in local_address()
522     pub(crate) fn remote_address(&self) -> Result<SocketAddr, ErrorCode> {  in remote_address()  argument
527             _ => Err(ErrorCode::InvalidState),  in remote_address()
539     pub(crate) fn set_listen_backlog_size(&mut self, value: u64) -> Result<(), ErrorCode> {  in set_listen_backlog_size()  argument
544             return Err(ErrorCode::InvalidArgument);  in set_listen_backlog_size()
561                     return Err(ErrorCode::NotSupported);  in set_listen_backlog_size()
568             _ => Err(ErrorCode::InvalidState),  in set_listen_backlog_size()
572     pub(crate) fn keep_alive_enabled(&self) -> Result<bool, ErrorCode> {  in keep_alive_enabled()  argument
578     pub(crate) fn set_keep_alive_enabled(&self, value: bool) -> Result<(), ErrorCode> {  in set_keep_alive_enabled()  argument
584     pub(crate) fn keep_alive_idle_time(&self) -> Result<u64, ErrorCode> {  in keep_alive_idle_time()  argument
590     pub(crate) fn set_keep_alive_idle_time(&mut self, value: u64) -> Result<(), ErrorCode> {  in set_keep_alive_idle_time()  argument
599     pub(crate) fn keep_alive_interval(&self) -> Result<u64, ErrorCode> {  in keep_alive_interval()  argument
605     pub(crate) fn set_keep_alive_interval(&self, value: u64) -> Result<(), ErrorCode> {  in set_keep_alive_interval()  argument
611     pub(crate) fn keep_alive_count(&self) -> Result<u32, ErrorCode> {  in keep_alive_count()  argument
617     pub(crate) fn set_keep_alive_count(&self, value: u32) -> Result<(), ErrorCode> {  in set_keep_alive_count()  argument
623     pub(crate) fn hop_limit(&self) -> Result<u8, ErrorCode> {  in hop_limit()  argument
629     pub(crate) fn set_hop_limit(&mut self, value: u8) -> Result<(), ErrorCode> {  in set_hop_limit()  argument
638     pub(crate) fn receive_buffer_size(&self) -> Result<u64, ErrorCode> {  in receive_buffer_size()  argument
644     pub(crate) fn set_receive_buffer_size(&mut self, value: u64) -> Result<(), ErrorCode> {  in set_receive_buffer_size()  argument
653     pub(crate) fn send_buffer_size(&self) -> Result<u64, ErrorCode> {  in send_buffer_size()  argument
659     pub(crate) fn set_send_buffer_size(&mut self, value: u64) -> Result<(), ErrorCode> {  in set_send_buffer_size()  argument
674     pub(crate) fn tcp_listener_arc(&self) -> Result<&Arc<tokio::net::TcpListener>, ErrorCode> {  in tcp_listener_arc()  argument
679             _ => Err(ErrorCode::InvalidState),  in tcp_listener_arc()
683     pub(crate) fn take_receive_stream(&mut self) -> Result<Arc<tokio::net::TcpStream>, ErrorCode> {  in take_receive_stream()  argument
687     pub(crate) fn take_send_stream(&mut self) -> Result<Arc<tokio::net::TcpStream>, ErrorCode> {  in take_send_stream()  argument
694     ) -> Result<Arc<tokio::net::TcpStream>, ErrorCode> {  in take_stream()  argument
703                     return Err(ErrorCode::InvalidState);  in take_stream()
710             _ => Err(ErrorCode::InvalidState),  in take_stream()
714     pub(crate) fn p2_streaming_state(&self) -> Result<&P2TcpStreamingState, ErrorCode> {  in p2_streaming_state()  argument
722             _ => Err(ErrorCode::InvalidState),  in p2_streaming_state()
729     ) -> Result<(), ErrorCode> {  in set_p2_streaming_state()  argument
734             Err(ErrorCode::InvalidState)  in set_p2_streaming_state()