SYMBOL INDEX (588 symbols across 40 files)

FILE: src/broadcast_reuse_peer.rs
  type BroadcastReuser (line 28) | pub struct BroadcastReuser(pub Rc<dyn Specifier>);
  method construct (line 30) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type SailingBuffer (line 71) | type SailingBuffer = Rc<Vec<u8>>;
  type Clients (line 72) | type Clients = Slab<BroadcastClientIndex, mpsc::Sender<SailingBuffer>>;
  type Broadcaster (line 74) | pub struct Broadcaster {
  type HBroadCaster (line 78) | pub type HBroadCaster = Rc<RefCell<Option<Broadcaster>>>;
  type GlobalState (line 80) | pub type GlobalState = HBroadCaster;
  type PeerHandleW (line 82) | struct PeerHandleW(HBroadCaster);
  type PeerHandleR (line 83) | struct PeerHandleR(
  type InnerPeerReader (line 88) | struct InnerPeerReader(HBroadCaster, Vec<u8>);
  type Item (line 91) | type Item = ();
  type Error (line 92) | type Error = ();
  method poll (line 93) | fn poll(&mut self) -> futures::Poll<(), ()> {
  method drop (line 141) | fn drop(&mut self) {
  method read (line 152) | fn read(&mut self, b: &mut [u8]) -> Result<usize, IoError> {
  method write (line 179) | fn write(&mut self, b: &[u8]) -> Result<usize, IoError> {
  method flush (line 186) | fn flush(&mut self) -> Result<(), IoError> {
  method shutdown (line 195) | fn shutdown(&mut self) -> futures::Poll<(), IoError> {
  function makeclient (line 206) | fn makeclient(ps: HBroadCaster, queue_len: usize) -> Peer {
  function connection_reuser (line 219) | pub fn connection_reuser<F: FnOnce() -> BoxedNewPeerFuture>(

FILE: src/crypto_peer.rs
  type Crypto (line 22) | pub struct Crypto<T: Specifier>(pub T);
  method construct (line 24) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type Mode (line 68) | enum Mode {
  function crypto_peer (line 73) | pub fn crypto_peer(inner_peer: Peer, key: [u8; 32], reverse: bool) -> Bo...
  type CryptoWrapperR (line 85) | struct CryptoWrapperR(Box<dyn AsyncRead>, ChaCha20Poly1305, Mode);
  method read (line 88) | fn read(&mut self, b: &mut [u8]) -> Result<usize, IoError> {
  type CryptoWrapperW (line 114) | struct CryptoWrapperW(Box<dyn AsyncWrite>, ChaCha20Poly1305, Mode);
  method write (line 117) | fn write(&mut self, b: &[u8]) -> Result<usize, IoError> {
  method flush (line 134) | fn flush(&mut self) -> std::io::Result<()> {
  method shutdown (line 139) | fn shutdown(&mut self) -> std::result::Result<Async<()>, std::io::Error> {
  function process_data (line 144) | fn process_data(buf: &[u8], crypto: &ChaCha20Poly1305, mode: Mode) -> Re...
  function interpret_opt (line 174) | pub fn interpret_opt(x: &str) -> crate::Result<[u8; 32]> {

FILE: src/file_peer.rs
  type ReadFile (line 17) | pub struct ReadFile(pub PathBuf);
  method construct (line 19) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type WriteFile (line 49) | pub struct WriteFile(pub PathBuf);
  method construct (line 51) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type AppendFile (line 82) | pub struct AppendFile(pub PathBuf);
  method construct (line 84) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type ReadFileWrapper (line 113) | pub struct ReadFileWrapper(pub File);
  method read (line 117) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...
  type WriteFileWrapper (line 122) | struct WriteFileWrapper(File);
  method shutdown (line 125) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 130) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 133) | fn flush(&mut self) -> IoResult<()> {

FILE: src/foreachmsg_peer.rs
  type Foreachmsg (line 17) | pub struct Foreachmsg(pub Rc<dyn Specifier>);
  method construct (line 19) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type State2 (line 47) | struct State2 {
  type Phase (line 52) | enum Phase {
  type State (line 60) | struct State {
    method poll (line 80) | fn poll(&mut self) -> Poll<&mut Peer, Box<dyn (::std::error::Error)>> {
    method reconnect (line 147) | fn reconnect(&mut self) {
  type PeerHandle (line 132) | struct PeerHandle(Rc<RefCell<State>>);
  method read (line 158) | fn read(&mut self, b: &mut [u8]) -> Result<usize, IoError> {
  method write (line 220) | fn write(&mut self, b: &[u8]) -> Result<usize, IoError> {
  method flush (line 354) | fn flush(&mut self) -> Result<(), IoError> {
  method shutdown (line 360) | fn shutdown(&mut self) -> futures::Poll<(), IoError> {
  function foreachmsg_peer (line 366) | pub fn foreachmsg_peer(s: Rc<dyn Specifier>, cp: ConstructParams) -> Box...

FILE: src/help.rs
  function spechelp (line 3) | fn spechelp(sc: &dyn SpecifierClass, overlays: bool, advanced: bool) {
  function shorthelp (line 27) | pub fn shorthelp() {
  function longhelp (line 99) | pub fn longhelp() {
  function specdoc (line 124) | fn specdoc(sc: &dyn SpecifierClass, overlays: bool) {
  function dochelp (line 157) | pub fn dochelp() {

FILE: src/http_peer.rs
  type HttpRequest (line 27) | pub struct HttpRequest<T: Specifier>(pub T);
  method construct (line 29) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type Http (line 73) | pub struct Http<T: Specifier>(pub T, pub Uri);
  method construct (line 75) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type HttpHeaderEndDetectionState (line 142) | enum HttpHeaderEndDetectionState {
  type WaitForHttpHead (line 150) | struct WaitForHttpHead<R : AsyncRead>
  type WaitForHttpHeadResult (line 158) | struct WaitForHttpHeadResult {
  function new (line 165) | pub fn new(r:R) -> WaitForHttpHead<R> {
  type Item (line 176) | type Item = (WaitForHttpHeadResult, R);
  type Error (line 177) | type Error = Box<dyn std::error::Error>;
  method poll (line 179) | fn poll(&mut self) -> ::futures::Poll<Self::Item, Self::Error> {
  function http_request_peer (line 231) | pub fn http_request_peer(
  type HttpPostSse (line 291) | pub struct HttpPostSse<T: Specifier>(pub T);
  method construct (line 293) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type ModeOfOperation (line 326) | enum ModeOfOperation {
  function http_response_post_sse_peer (line 331) | pub fn http_response_post_sse_peer(
  type SseState (line 450) | enum SseState {
  type SseStream (line 457) | struct SseStream<W : Write>
  function new (line 465) | pub fn new(w: W) -> Self {
  method shutdown (line 475) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 481) | fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
  method flush (line 544) | fn flush(&mut self) -> std::io::Result<()> {
  function test_basic_sse_stream (line 550) | fn test_basic_sse_stream() {

FILE: src/http_serve.rs
  constant BAD_REQUEST (line 17) | const BAD_REQUEST :&[u8] = b"HTTP/1.1 400 Bad Request\r\nServer: websoca...
  constant NOT_FOUND (line 19) | const NOT_FOUND: &[u8] = b"HTTP/1.1 404 Not Found\r\nServer: websocat\r\...
  constant NOT_FOUND2 (line 21) | const NOT_FOUND2: &[u8] = b"HTTP/1.1 500 Not Found\r\nServer: websocat\r...
  constant BAD_METHOD (line 23) | const BAD_METHOD :&[u8] = b"HTTP/1.1 400 Bad Request\r\nServer: websocat...
  constant BAD_URI_FORMAT (line 25) | const BAD_URI_FORMAT :&[u8] = b"HTTP/1.1 400 Bad Request\r\nServer: webs...
  function get_static_file_reply (line 27) | pub fn get_static_file_reply(len: Option<u64>, ct: &str) -> Vec<u8> {
  function http_serve (line 42) | pub fn http_serve(

FILE: src/jsonrpc_peer.rs
  type JsonRpc (line 14) | pub struct JsonRpc<T: Specifier>(pub T);
  method construct (line 16) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  function jsonrpc_peer (line 40) | pub fn jsonrpc_peer(inner_peer: Peer, omit_jsonrpc: bool) -> BoxedNewPee...
  type JsonRpcWrapper (line 45) | struct JsonRpcWrapper(Box<dyn AsyncRead>, u64, bool);
  method read (line 48) | fn read(&mut self, b: &mut [u8]) -> Result<usize, IoError> {

FILE: src/lengthprefixed_peer.rs
  type LengthPrefixed (line 16) | pub struct LengthPrefixed<T: Specifier>(pub T);
  method construct (line 18) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  function lengthprefixed_peer (line 64) | pub fn lengthprefixed_peer(
  type Lengthprefixed2PacketWrapper (line 106) | struct Lengthprefixed2PacketWrapper {
  method read (line 116) | fn read(&mut self, buf: &mut [u8]) -> Result<usize, IoError> {
  type Packet2LengthPrefixedWrapper (line 177) | struct Packet2LengthPrefixedWrapper {
  method write (line 188) | fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
  method flush (line 223) | fn flush(&mut self) -> std::io::Result<()> {
  method shutdown (line 229) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {

FILE: src/lib.rs
  type Result (line 52) | type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
  type WebsocatConfiguration1 (line 55) | pub struct WebsocatConfiguration1 {
    method parse1 (line 64) | pub fn parse1(self) -> Result<WebsocatConfiguration2> {
  type WebsocatConfiguration2 (line 80) | pub struct WebsocatConfiguration2 {
    method parse2 (line 87) | pub fn parse2(self) -> Result<WebsocatConfiguration3> {
  type WebsocatConfiguration3 (line 98) | pub struct WebsocatConfiguration3 {
    method serve (line 105) | pub fn serve<OE>(self, onerror: std::rc::Rc<OE>) -> impl Future<Item =...
  type ProgramState (line 117) | pub struct ProgramState(
  type LeftSpecToRightSpec (line 124) | pub struct LeftSpecToRightSpec {
  type L2rWriter (line 133) | pub type L2rWriter = Rc<RefCell<LeftSpecToRightSpec>>;
  type L2rReader (line 134) | pub type L2rReader = Rc<LeftSpecToRightSpec>;
  type L2rUser (line 137) | pub enum L2rUser {
  type HupToken (line 143) | pub type HupToken = Box<dyn Future<Item=(), Error=Box<dyn std::error::Er...
  type Peer (line 145) | pub struct Peer(Box<dyn AsyncRead>, Box<dyn AsyncWrite>, Option<HupToken>);
  type BoxedNewPeerFuture (line 147) | pub type BoxedNewPeerFuture = Box<dyn Future<Item = Peer, Error = Box<dy...
  type BoxedNewPeerStream (line 148) | pub type BoxedNewPeerStream = Box<dyn Stream<Item = Peer, Error = Box<dy...
  type PeerOverlay (line 210) | pub type PeerOverlay = Rc<dyn Fn(Peer, L2rUser) -> BoxedNewPeerFuture>;
  type PeerConstructor (line 212) | pub enum PeerConstructor {
  function spawn_hack (line 221) | pub fn spawn_hack<T>(f: T)
  type Transfer (line 237) | pub struct Transfer {
  type Session (line 241) | pub struct Session {

FILE: src/line_peer.rs
  type Message2Line (line 14) | pub struct Message2Line<T: Specifier>(pub T);
  method construct (line 16) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type Line2Message (line 51) | pub struct Line2Message<T: Specifier>(pub T);
  method construct (line 53) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  function packet2line_peer (line 87) | pub fn packet2line_peer(inner_peer: Peer, null_terminated: bool) -> Boxe...
  type Packet2LineWrapper (line 92) | struct Packet2LineWrapper(Box<dyn AsyncRead>, bool);
  method read (line 95) | fn read(&mut self, b: &mut [u8]) -> Result<usize, IoError> {
  function line2packet_peer (line 140) | pub fn line2packet_peer(
  type Line2PacketWrapper (line 158) | struct Line2PacketWrapper {
    method deliver_the_line (line 170) | fn deliver_the_line(&mut self, buf: &mut [u8], mut n: usize) -> Option...
  method read (line 204) | fn read(&mut self, buf: &mut [u8]) -> Result<usize, IoError> {

FILE: src/lints.rs
  type StdioUsageStatus (line 17) | pub enum StdioUsageStatus {
  type ClassExt (line 28) | trait ClassExt {
    method is_stdio (line 29) | fn is_stdio(&self) -> bool;
    method is_reuser (line 30) | fn is_reuser(&self) -> bool;
    method is_stdio (line 37) | fn is_stdio(&self) -> bool {
    method is_reuser (line 44) | fn is_reuser(&self) -> bool {
  type OnWarning (line 33) | pub type OnWarning = Box<dyn for<'a> Fn(&'a str) + 'static>;
  type SpecifierStackExt (line 52) | pub trait SpecifierStackExt {
    method stdio_usage_status (line 53) | fn stdio_usage_status(&self) -> StdioUsageStatus;
    method reuser_count (line 54) | fn reuser_count(&self) -> usize;
    method contains (line 55) | fn contains(&self, t: &'static str) -> bool;
    method is_multiconnect (line 56) | fn is_multiconnect(&self) -> bool;
    method is_stream_oriented (line 57) | fn is_stream_oriented(&self) -> bool;
    method autotoreconn_misuse (line 58) | fn autotoreconn_misuse(&self)  -> bool;
    method insert_line_class_in_proper_place (line 59) | fn insert_line_class_in_proper_place(&mut self, x: Rc<dyn SpecifierCla...
    method stdio_usage_status (line 62) | fn stdio_usage_status(&self) -> StdioUsageStatus {
    method reuser_count (line 80) | fn reuser_count(&self) -> usize {
    method contains (line 89) | fn contains(&self, t: &'static str) -> bool {
    method autotoreconn_misuse (line 97) | fn autotoreconn_misuse(&self)  -> bool {
    method is_multiconnect (line 111) | fn is_multiconnect(&self) -> bool {
    method is_stream_oriented (line 127) | fn is_stream_oriented(&self) -> bool {
    method insert_line_class_in_proper_place (line 143) | fn insert_line_class_in_proper_place(&mut self, x: Rc<dyn SpecifierCla...
  method inetd_mode (line 158) | pub fn inetd_mode(&self) -> bool {
  method websocket_used (line 164) | pub fn websocket_used(&self) -> bool {
  method exec_used (line 174) | pub fn exec_used(&self) -> bool {
  method contains_class (line 181) | pub fn contains_class(&self, x: &'static str) -> bool {
  method get_exec_parameter (line 185) | pub fn get_exec_parameter(&self) -> Option<&str> {
  method l_stdio (line 195) | fn l_stdio(&mut self, multiconnect: bool, reuser_has_been_inserted: &mut...
  method l_reuser (line 240) | fn l_reuser(&mut self, reuser_has_been_inserted: bool) -> Result<()> {
  method l_linemode (line 250) | fn l_linemode(&mut self) -> Result<()> {
  method l_listener_on_the_right (line 277) | fn l_listener_on_the_right(&mut self, on_warning: &OnWarning) -> Result<...
  method l_reuser_for_append (line 283) | fn l_reuser_for_append(&mut self, multiconnect: bool) -> Result<()> {
  method l_exec (line 296) | fn l_exec(&mut self, on_warning: &OnWarning) -> Result<()> {
  method l_uri_staticfiles (line 309) | fn l_uri_staticfiles(&mut self, on_warning: &OnWarning) -> Result<()> {
  method l_environ (line 337) | fn l_environ(&mut self, on_warning: &OnWarning) -> Result<()> {
  method l_closebug (line 353) | fn l_closebug(&mut self, on_warning: &OnWarning) -> Result<()> {
  method l_socks5_c (line 369) | fn l_socks5_c(
  method l_socks5 (line 439) | fn l_socks5(&mut self, on_warning: &OnWarning) -> Result<()> {
  method l_ssl (line 488) | fn l_ssl(&mut self, _on_warning: &OnWarning) -> Result<()> {
  method l_ping (line 514) | fn l_ping(&mut self, _on_warning: &OnWarning) -> Result<()> {
  method l_proto (line 541) | fn l_proto(&mut self, _on_warning: &OnWarning) -> Result<()> {
  method l_eeof_unidir (line 562) | fn l_eeof_unidir(&mut self, _on_warning: &OnWarning) -> Result<()> {
  method l_udp (line 572) | fn l_udp(&mut self, _on_warning: &OnWarning) -> Result<()> {
  method l_crypto (line 599) | fn l_crypto(&mut self, _on_warning: &OnWarning) -> Result<()> {
  method l_prometheus (line 608) | fn l_prometheus(&mut self, _on_warning: &OnWarning) -> Result<()> {
  method l_sizelimits (line 619) | fn l_sizelimits(&mut self, _on_warning: &OnWarning) -> Result<()> {
  method l_compress (line 625) | fn l_compress(&mut self, _on_warning: &OnWarning) -> Result<()> {
  method l_autoreconn_reuse (line 650) | fn l_autoreconn_reuse(&mut self, _on_warning: &OnWarning) -> Result<()> {
  method lint_and_fixup (line 657) | pub fn lint_and_fixup(&mut self, on_warning: OnWarning) -> Result<()> {

FILE: src/main.rs
  type Result (line 39) | type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
  type Opt (line 59) | struct Opt {
  function interpret_custom_header (line 650) | fn interpret_custom_header(x: &str) -> Result<(String, Vec<u8>)> {
  function interpret_custom_header2 (line 665) | fn interpret_custom_header2(x: &str) -> Result<(http::header::HeaderName...
  function interpret_static_file (line 683) | fn interpret_static_file(x: &str) -> Result<StaticFile> {
  function interpret_socks_destination (line 706) | fn interpret_socks_destination(x: &str) -> Result<SocksSocketAddr> {
  function setup_env_logger (line 740) | pub fn setup_env_logger(ll: u8) -> Result<(), Box<dyn (::std::error::Err...
  function run (line 767) | fn run() -> Result<()> {
  function main (line 1127) | fn main() {

FILE: src/mirror_peer.rs
  type Mirror (line 22) | pub struct Mirror;
  method construct (line 24) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type LiteralReply (line 48) | pub struct LiteralReply(pub Vec<u8>);
    method fmt (line 56) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::result::Result<(), ...
  method construct (line 50) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type MirrorWrite (line 77) | struct MirrorWrite(mpsc::Sender<Vec<u8>>);
  type MirrorRead (line 78) | struct MirrorRead {
  function get_mirror_peer (line 83) | pub fn get_mirror_peer(debt_handling: DebtHandling) -> BoxedNewPeerFuture {
  function get_literal_reply_peer (line 93) | pub fn get_literal_reply_peer(content: Vec<u8>) -> BoxedNewPeerFuture {
  method read (line 108) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...
  method shutdown (line 128) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 134) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 141) | fn flush(&mut self) -> IoResult<()> {
  method drop (line 150) | fn drop(&mut self) {
  type LiteralReplyHandle (line 157) | struct LiteralReplyHandle(mpsc::Sender<()>);
  type LiteralReplyRead (line 158) | struct LiteralReplyRead {
  method shutdown (line 165) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 171) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 177) | fn flush(&mut self) -> IoResult<()> {
  method read (line 186) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...

FILE: src/my_copy.rs
  type CopyOptions (line 8) | pub struct CopyOptions {
  type Copy (line 25) | pub struct Copy<R, W> {
  function copy (line 54) | pub fn copy<R, W>(reader: R, writer: W, opts: CopyOptions, preamble: Vec...
  type Item (line 81) | type Item = (u64, R, W);
  type Error (line 82) | type Error = io::Error;
  method poll (line 84) | fn poll(&mut self) -> Poll<(u64, R, W), io::Error> {

FILE: src/net_peer.rs
  type TcpConnect (line 24) | pub struct TcpConnect(pub Vec<SocketAddr>);
  method construct (line 26) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type TcpListen (line 54) | pub struct TcpListen(pub SocketAddr);
  method construct (line 56) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type UdpConnect (line 83) | pub struct UdpConnect(pub SocketAddr);
  method construct (line 85) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type UdpListen (line 104) | pub struct UdpListen(pub SocketAddr);
  method construct (line 106) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type MyTcpStream (line 160) | struct MyTcpStream(Rc<TcpStream>, bool);
  method read (line 163) | fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
  method write (line 169) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 173) | fn flush(&mut self) -> IoResult<()> {
  method shutdown (line 181) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method drop (line 188) | fn drop(&mut self) {
  function tcp_race (line 196) | pub fn tcp_race(addrs: &[SocketAddr]) -> Box<dyn Future<Item = TcpStream...
  function tcp_connect_peer (line 233) | pub fn tcp_connect_peer(addrs: &[SocketAddr]) -> BoxedNewPeerFuture {
  function tcp_listen_peer (line 252) | pub fn tcp_listen_peer(addr: &SocketAddr, l2r: L2rUser, announce: bool) ...
  type UdpPeerState (line 290) | enum UdpPeerState {
  type UdpPeer (line 296) | struct UdpPeer {
  type UdpPeerHandle (line 303) | struct UdpPeerHandle(Rc<RefCell<UdpPeer>>);
  function get_zero_address (line 305) | fn get_zero_address(addr: &SocketAddr) -> SocketAddr {
  function apply_udp_options (line 314) | fn apply_udp_options(s: &UdpSocket, opts:&Rc<Options>) -> IoResult<()> {
  function get_udp (line 366) | pub fn get_udp(addr: &SocketAddr, opts: &Rc<Options>) -> IoResult<UdpSoc...
  function udp_connect_peer (line 379) | pub fn udp_connect_peer(addr: &SocketAddr, opts: &Rc<Options>) -> BoxedN...
  function udp_listen_peer (line 400) | pub fn udp_listen_peer(addr: &SocketAddr, opts: &Rc<Options>) -> BoxedNe...
  method read (line 422) | fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
  method write (line 458) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 481) | fn flush(&mut self) -> IoResult<()> {
  method shutdown (line 489) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  type UndeprecateNonpollSendRecv (line 495) | trait UndeprecateNonpollSendRecv {
    method recv2 (line 496) | fn recv2(&mut self, buf: &mut [u8]) -> std::io::Result<usize>;
    method recv_from2 (line 497) | fn recv_from2(&mut self, buf: &mut [u8]) -> std::io::Result<(usize, So...
    method send2 (line 498) | fn send2(&mut self, buf: &[u8]) -> std::io::Result<usize>;
    method send_to2 (line 499) | fn send_to2(&mut self, buf: &[u8], target: &SocketAddr) -> std::io::Re...
    method recv2 (line 503) | fn recv2(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
    method recv_from2 (line 510) | fn recv_from2(&mut self, buf: &mut [u8]) -> std::io::Result<(usize, So...
    method send2 (line 517) | fn send2(&mut self, buf: &[u8]) -> std::io::Result<usize> {
    method send_to2 (line 524) | fn send_to2(&mut self, buf: &[u8], target: &SocketAddr) -> std::io::Re...

FILE: src/options.rs
  type StaticFile (line 9) | pub struct StaticFile {
  type Options (line 20) | pub struct Options {

FILE: src/primitive_reuse_peer.rs
  type Reuser (line 18) | pub struct Reuser(pub Rc<dyn Specifier>);
  method construct (line 20) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type PeerSlot (line 60) | type PeerSlot = Rc<RefCell<Option<Peer>>>;
  type GlobalState (line 63) | pub struct GlobalState(PeerSlot);
  type PeerHandle (line 66) | struct PeerHandle(PeerSlot, bool);
  method read (line 69) | fn read(&mut self, b: &mut [u8]) -> Result<usize, IoError> {
  method write (line 80) | fn write(&mut self, b: &[u8]) -> Result<usize, IoError> {
  method flush (line 87) | fn flush(&mut self) -> Result<(), IoError> {
  method shutdown (line 96) | fn shutdown(&mut self) -> futures::Poll<(), IoError> {
  function connection_reuser (line 110) | pub fn connection_reuser<F: FnOnce() -> BoxedNewPeerFuture>(

FILE: src/process_peer.rs
  function needenv (line 22) | fn needenv(p: &ConstructParams) -> Option<&LeftSpecToRightSpec> {
  type Cmd (line 30) | pub struct Cmd(pub String);
  method construct (line 32) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type ShC (line 74) | pub struct ShC(pub String);
  method construct (line 76) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type Exec (line 115) | pub struct Exec(pub String);
  method construct (line 117) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  function process_connect_peer (line 156) | fn process_connect_peer(
  type ForgetfulProcess (line 187) | struct ForgetfulProcess {
  type ProcessPeer (line 192) | struct ProcessPeer {
  method read (line 199) | fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
  method write (line 213) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 237) | fn flush(&mut self) -> IoResult<()> {
  method shutdown (line 253) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method drop (line 281) | fn drop(&mut self) {

FILE: src/prometheus_peer.rs
  type GlobalStats (line 24) | pub struct GlobalStats {
  type HGlobalStats (line 102) | pub type HGlobalStats = Rc<GlobalStats>;
  type GlobalState (line 104) | pub type GlobalState = (HGlobalStats, Rc<RefCell<Option<prometheus::Hist...
  type Droppie (line 106) | struct Droppie {
    method new (line 116) | fn new(handle: HGlobalStats) -> Droppie {
  method drop (line 130) | fn drop(&mut self) {
  function new_global_stats (line 145) | pub fn new_global_stats() -> GlobalState {
  function serve (line 149) | pub fn serve(psa: SocketAddr) -> crate::Result<()> {
  type Prometheus (line 170) | pub struct Prometheus<T: Specifier>(pub T);
  method construct (line 172) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  function prometheus_peer (line 197) | pub fn prometheus_peer(inner_peer: Peer, stats: GlobalState) -> BoxedNew...
  type StatsWrapperR (line 210) | struct StatsWrapperR(Box<dyn AsyncRead>, Rc<Droppie>);
  method read (line 213) | fn read(&mut self, b: &mut [u8]) -> Result<usize, IoError> {
  type StatsWrapperW (line 238) | struct StatsWrapperW(Box<dyn AsyncWrite>, Rc<Droppie>);
  method write (line 241) | fn write(&mut self, b: &[u8]) -> Result<usize, IoError> {
  method flush (line 265) | fn flush(&mut self) -> std::io::Result<()> {
  method shutdown (line 270) | fn shutdown(&mut self) -> std::result::Result<Async<()>, std::io::Error> {

FILE: src/readdebt.rs
  type DebtHandling (line 4) | pub enum DebtHandling {
  type ZeroMessagesHandling (line 10) | pub enum ZeroMessagesHandling {
  type ProcessMessageResult (line 15) | pub enum ProcessMessageResult {
  type ReadDebt (line 21) | pub struct ReadDebt(pub Option<Vec<u8>>, pub DebtHandling, pub ZeroMessa...
    method process_message (line 23) | pub fn process_message(&mut self, buf: &mut [u8], buf_in: &[u8]) -> Pr...
    method check_debt (line 57) | pub fn check_debt(

FILE: src/reconnect_peer.rs
  type AutoReconnect (line 20) | pub struct AutoReconnect(pub Rc<dyn Specifier>);
  method construct (line 22) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type State2 (line 52) | struct State2 {
  type State (line 56) | struct State {
    method poll (line 74) | fn poll(&mut self) -> Poll<&mut Peer, Box<dyn (::std::error::Error)>> {
    method reconnect (line 166) | fn reconnect(&mut self) {
  type PeerHandle (line 151) | struct PeerHandle(Rc<RefCell<State>>);
  method read (line 217) | fn read(&mut self, b: &mut [u8]) -> Result<usize, IoError> {
  method write (line 225) | fn write(&mut self, b: &[u8]) -> Result<usize, IoError> {
  method flush (line 230) | fn flush(&mut self) -> Result<(), IoError> {
  method shutdown (line 236) | fn shutdown(&mut self) -> futures::Poll<(), IoError> {
  function autoreconnector (line 243) | pub fn autoreconnector(s: Rc<dyn Specifier>, cp: ConstructParams) -> Box...
  function waitfordata (line 263) | pub fn waitfordata(s: Rc<dyn Specifier>, cp: ConstructParams) -> BoxedNe...
  type WaitForData (line 284) | pub struct WaitForData(pub Rc<dyn Specifier>);
  method construct (line 286) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {

FILE: src/sessionserve.rs
  method run (line 13) | pub fn run(self) -> Box<dyn Future<Item = (), Error = Box<dyn std::error...
  method new (line 87) | pub fn new(peer1: Peer, peer2: Peer, opts: Rc<Options>) -> Self {
  function l2r_new (line 104) | fn l2r_new() -> L2rWriter {
  function serve (line 108) | pub fn serve<OE>(
  function serve_impl (line 121) | fn serve_impl<OE>(

FILE: src/socks5_peer.rs
  type SocksHostAddr (line 16) | pub enum SocksHostAddr {
  type SocksSocketAddr (line 22) | pub struct SocksSocketAddr {
  type SocksProxy (line 28) | pub struct SocksProxy<T: Specifier>(pub T);
  method construct (line 30) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type SocksBind (line 59) | pub struct SocksBind<T: Specifier>(pub T);
  method construct (line 61) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type RSRRet (line 98) | type RSRRet =
  function read_socks_reply (line 100) | fn read_socks_reply(p: Peer) -> RSRRet {
  function socks5_peer (line 195) | pub fn socks5_peer(
  function authenticate_no_auth (line 280) | fn authenticate_no_auth(
  function authenticate_username_password (line 287) | fn authenticate_username_password(
  function build_socks5_request (line 331) | fn build_socks5_request(

FILE: src/specifier.rs
  type ClassMessageBoundaryStatus (line 7) | pub enum ClassMessageBoundaryStatus {
  type ClassMulticonnectStatus (line 13) | pub enum ClassMulticonnectStatus {
  type SpecifierClass (line 22) | pub trait SpecifierClass: std::fmt::Debug {
    method get_name (line 24) | fn get_name(&self) -> &'static str;
    method get_prefixes (line 26) | fn get_prefixes(&self) -> Vec<&'static str>;
    method help (line 28) | fn help(&self) -> &'static str;
    method construct (line 31) | fn construct(&self, arg: &str) -> Result<Rc<dyn Specifier>>;
    method construct_overlay (line 33) | fn construct_overlay(&self, inner: Rc<dyn Specifier>) -> Result<Rc<dyn...
    method is_overlay (line 35) | fn is_overlay(&self) -> bool;
    method message_boundary_status (line 37) | fn message_boundary_status(&self) -> ClassMessageBoundaryStatus;
    method multiconnect_status (line 39) | fn multiconnect_status(&self) -> ClassMulticonnectStatus;
    method alias_info (line 41) | fn alias_info(&self) -> Option<&'static str>;
  type SpecifierNode (line 170) | pub struct SpecifierNode {
  type SpecifierStack (line 176) | pub struct SpecifierStack {
  type ConstructParams (line 183) | pub struct ConstructParams {
    method reset_l2r (line 192) | pub fn reset_l2r(&mut self) {
    method reply (line 205) | pub fn reply(&self) -> Self {
    method deep_clone (line 217) | pub fn deep_clone(&self) -> Self {
    method global (line 234) | pub fn global<T:std::any::Any, F>(&self, def:F) -> std::cell::RefMut<T>
  type Specifier (line 249) | pub trait Specifier: std::fmt::Debug {
    method construct (line 251) | fn construct(&self, p: ConstructParams) -> PeerConstructor;
    method is_multiconnect (line 254) | fn is_multiconnect(&self) -> bool;
    method uses_global_state (line 255) | fn uses_global_state(&self) -> bool;
    method construct (line 259) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
    method is_multiconnect (line 263) | fn is_multiconnect(&self) -> bool {
    method uses_global_state (line 266) | fn uses_global_state(&self) -> bool {

FILE: src/specparse.rs
  function spec (line 6) | pub fn spec(s: &str) -> Result<Rc<dyn Specifier>> {
  function some_checks (line 10) | fn some_checks(s: &str) -> Result<()> {
  type Err (line 63) | type Err = Box<dyn (::std::error::Error)>;
  method from_str (line 65) | fn from_str(s: &str) -> Result<SpecifierStack> {
  function from_stack (line 124) | pub fn from_stack(st: &SpecifierStack) -> Result<Rc<dyn Specifier>> {

FILE: src/ssl_peer.rs
  function interpret_pkcs12 (line 17) | pub fn interpret_pkcs12(x: &OsStr) -> ::std::result::Result<Vec<u8>, OsS...
  type TlsConnect (line 35) | pub struct TlsConnect<T: Specifier>(pub T);
  method construct (line 37) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type TlsAccept (line 73) | pub struct TlsAccept<T: Specifier>(pub T);
  method construct (line 75) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  function ssl_connect (line 149) | pub fn ssl_connect(
  function ssl_accept (line 216) | pub fn ssl_accept(inner_peer: Peer, _l2r: L2rUser, progopt: Rc<Options>)...

FILE: src/stdio_peer.rs
  type AsyncStdio (line 28) | pub struct AsyncStdio;
  method construct (line 30) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type OpenAsync (line 85) | pub struct OpenAsync(pub PathBuf);
  method construct (line 87) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type OpenFdAsync (line 113) | pub struct OpenFdAsync(pub i32);
  method construct (line 115) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  function get_stdio_peer_impl (line 138) | fn get_stdio_peer_impl(s: &mut GlobalState) -> Result<Peer> {
  function get_stdio_peer (line 175) | pub fn get_stdio_peer(s: &mut GlobalState) -> BoxedNewPeerFuture {
  type GlobalState (line 181) | pub struct GlobalState {
  method drop (line 187) | fn drop(&mut self) {
  function restore_blocking_status (line 192) | fn restore_blocking_status(s: &GlobalState) {
  type ImplPollEvented (line 206) | type ImplPollEvented = ::tokio_reactor::PollEvented<UnixFile<std::fs::Fi...
  type FileWrapper (line 209) | struct FileWrapper(Rc<RefCell<ImplPollEvented>>);
  method read (line 213) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...
  method shutdown (line 219) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 224) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 227) | fn flush(&mut self) -> IoResult<()> {
  function get_file_peer_impl (line 232) | fn get_file_peer_impl(p: &Path) -> Result<Peer> {
  function get_file_peer (line 245) | pub fn get_file_peer(p: &Path) -> BoxedNewPeerFuture {
  function get_fd_peer_impl (line 250) | fn get_fd_peer_impl(fd: i32) -> Result<Peer> {
  function get_fd_peer (line 259) | pub fn get_fd_peer(fd: i32) -> BoxedNewPeerFuture {

FILE: src/stdio_threaded_peer.rs
  type ThreadedStdio (line 10) | pub struct ThreadedStdio;
  method construct (line 12) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  function get_stdio_peer (line 73) | pub fn get_stdio_peer() -> BoxedNewPeerFuture {

FILE: src/timestamp_peer.rs
  type TimestampPeer (line 15) | pub struct TimestampPeer<T: Specifier>(pub T);
  method construct (line 17) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  function timestamp_peer (line 39) | pub fn timestamp_peer(inner_peer: Peer, monotonic: bool) -> BoxedNewPeer...
  type TimestampWrapper (line 45) | struct TimestampWrapper(Box<dyn AsyncRead>, Option<Instant>);
  method read (line 48) | fn read(&mut self, b: &mut [u8]) -> Result<usize, IoError> {

FILE: src/trivial_peer.rs
  type Literal (line 20) | pub struct Literal(pub Vec<u8>);
    method fmt (line 28) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::result::Result<(), ...
  method construct (line 22) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type Assert (line 51) | pub struct Assert(pub Vec<u8>);
    method fmt (line 59) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::result::Result<(), ...
  method construct (line 53) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type Assert2 (line 80) | pub struct Assert2(pub Vec<u8>);
    method fmt (line 88) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::result::Result<(), ...
  method construct (line 82) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type Clogged (line 109) | pub struct Clogged;
  method construct (line 111) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type LiteralPeer (line 129) | pub struct LiteralPeer {
  function get_literal_peer_now (line 133) | pub fn get_literal_peer_now(b: Vec<u8>) -> LiteralPeer {
  function get_literal_peer (line 139) | pub fn get_literal_peer(b: Vec<u8>) -> BoxedNewPeerFuture {
  function get_assert_peer (line 145) | pub fn get_assert_peer(b: Vec<u8>) -> BoxedNewPeerFuture {
  function get_assert2_peer (line 151) | pub fn get_assert2_peer(b: Vec<u8>) -> BoxedNewPeerFuture {
  function get_clogged_peer (line 158) | pub fn get_clogged_peer() -> BoxedNewPeerFuture {
  method read (line 168) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...
  type DevNull (line 178) | pub struct DevNull;
  method shutdown (line 181) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 186) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 189) | fn flush(&mut self) -> IoResult<()> {
  method read (line 195) | fn read(&mut self, _buf: &mut [u8]) -> std::result::Result<usize, std::i...
  type AssertPeer (line 200) | struct AssertPeer(Vec<u8>, Vec<u8>, bool);
  method shutdown (line 202) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 215) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 219) | fn flush(&mut self) -> IoResult<()> {
  type CloggedPeer (line 224) | pub struct CloggedPeer;
  method shutdown (line 226) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 231) | fn write(&mut self, _buf: &[u8]) -> IoResult<usize> {
  method flush (line 234) | fn flush(&mut self) -> IoResult<()> {
  method read (line 240) | fn read(&mut self, _buf: &mut [u8]) -> std::result::Result<usize, std::i...
  type PrependRead (line 249) | pub struct PrependRead {
  method read (line 258) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...
  type PrependWrite (line 278) | pub struct PrependWrite {
  method shutdown (line 285) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 290) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 304) | fn flush(&mut self) -> IoResult<()> {
  type Log (line 310) | pub struct Log<T: Specifier>(pub T);
  method construct (line 312) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type LogRead (line 341) | pub struct LogRead (pub Box<dyn AsyncRead>);
  function log_buffer (line 343) | fn log_buffer(tag: &'static str, buf: &[u8]) {
  method read (line 356) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...
  type LogWrite (line 370) | pub struct LogWrite(pub Box<dyn AsyncWrite>);
  method shutdown (line 373) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 378) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 391) | fn flush(&mut self) -> IoResult<()> {
  type Random (line 398) | pub struct Random;
  method construct (line 400) | fn construct(&self, _cp: ConstructParams) -> PeerConstructor {
  type RandomReader (line 425) | pub struct RandomReader ();
  method read (line 431) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...
  type ExitOnSpecificByte (line 439) | pub struct ExitOnSpecificByte<T: Specifier>(pub T);
  method construct (line 441) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type ExitOnSpecificByteReader (line 473) | pub struct ExitOnSpecificByteReader {
  method read (line 483) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...
  type DropOnBackpressure (line 503) | pub struct DropOnBackpressure<T: Specifier>(pub T);
  method construct (line 505) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type DropOnBackpressureWriter (line 538) | pub struct DropOnBackpressureWriter {
  method write (line 543) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 554) | fn flush(&mut self) -> IoResult<()> {
  method shutdown (line 567) | fn shutdown(&mut self) -> tokio::prelude::Poll<(), std::io::Error> {

FILE: src/unix_peer.rs
  type UnixConnect (line 27) | pub struct UnixConnect(pub PathBuf);
  method construct (line 29) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type UnixListen (line 58) | pub struct UnixListen(pub PathBuf);
  method construct (line 60) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type UnixDgram (line 111) | pub struct UnixDgram(pub PathBuf, pub PathBuf);
  method construct (line 113) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  function to_abstract (line 153) | fn to_abstract(x: &str) -> PathBuf {
  type AbstractConnect (line 158) | pub struct AbstractConnect(pub String);
  method construct (line 160) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type AbstractListen (line 194) | pub struct AbstractListen(pub String);
  method construct (line 196) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  type AbstractDgram (line 230) | pub struct AbstractDgram(pub String, pub String);
  method construct (line 232) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type MyUnixStream (line 296) | struct MyUnixStream(Rc<UnixStream>, bool);
  method read (line 299) | fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
  method write (line 305) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 309) | fn flush(&mut self) -> IoResult<()> {
  method shutdown (line 317) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method drop (line 324) | fn drop(&mut self) {
  function unix_connect_peer (line 332) | pub fn unix_connect_peer(addr: &Path) -> BoxedNewPeerFuture {
  function unix_listen_peer (line 349) | pub fn unix_listen_peer(addr: &Path, opts: &Rc<Options>) -> BoxedNewPeer...
  type DgramPeer (line 404) | struct DgramPeer {
  type DgramPeerHandle (line 411) | struct DgramPeerHandle(Rc<RefCell<DgramPeer>>);
  function dgram_peer (line 413) | pub fn dgram_peer(bindaddr: &Path, connectaddr: &Path, opts: &Rc<Options...
  function dgram_peer_workaround (line 431) | pub fn dgram_peer_workaround(
  method read (line 511) | fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
  method write (line 518) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 523) | fn flush(&mut self) -> IoResult<()> {
  method shutdown (line 531) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  type HacksForMigratingFromTokioCore (line 536) | trait HacksForMigratingFromTokioCore {
    method recv (line 537) | fn recv(&self, buf: &mut [u8]) -> std::io::Result<usize>;
    method send (line 538) | fn send(&self, buf: &[u8]) -> std::io::Result<usize>;
    method recv (line 542) | fn recv(&self, buf: &mut [u8]) -> std::io::Result<usize> {
    method send (line 549) | fn send(&self, buf: &[u8]) -> std::io::Result<usize> {

FILE: src/unix_seqpacket_peer.rs
  type SeqpacketConnect (line 13) | pub struct SeqpacketConnect(pub PathBuf);
  method construct (line 15) | fn construct(&self, _: ConstructParams) -> PeerConstructor {
  type SeqpacketListen (line 48) | pub struct SeqpacketListen(pub PathBuf);
  method construct (line 50) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  function seqpacket_connect_peer (line 81) | pub fn seqpacket_connect_peer(addr: &Path) -> BoxedNewPeerFuture {
  function seqpacket_listen_peer (line 135) | pub fn seqpacket_listen_peer(addr: &Path, opts: &Rc<Options>) -> BoxedNe...

FILE: src/util.rs
  function wouldblock (line 7) | pub fn wouldblock<T>() -> std::io::Result<T> {
  function brokenpipe (line 10) | pub fn brokenpipe<T>() -> std::io::Result<T> {
  function io_other_error (line 13) | pub fn io_other_error<E: std::error::Error + Send + Sync + 'static>(e: E...
  method map (line 19) | pub fn map<F>(self, func: F) -> Self
  method get_only_first_conn (line 55) | pub fn get_only_first_conn(self, l2r: L2rUser) -> BoxedNewPeerFuture {
  function once (line 78) | pub fn once(x: BoxedNewPeerFuture) -> PeerConstructor {
  function multi (line 81) | pub fn multi(x: BoxedNewPeerStream) -> PeerConstructor {
  function peer_err (line 85) | pub fn peer_err<E: std::error::Error + 'static>(e: E) -> BoxedNewPeerFut...
  function peer_err2 (line 90) | pub fn peer_err2(e: Box<dyn std::error::Error>) -> BoxedNewPeerFuture {
  function peer_err_s (line 95) | pub fn peer_err_s<E: std::error::Error + 'static>(e: E) -> BoxedNewPeerS...
  function peer_err_sb (line 100) | pub fn peer_err_sb(e: Box<dyn std::error::Error + 'static>) -> BoxedNewP...
  function peer_strerr (line 105) | pub fn peer_strerr(e: &str) -> BoxedNewPeerFuture {
  function simple_err (line 109) | pub fn simple_err(e: String) -> std::io::Error {
  function simple_err2 (line 113) | pub fn simple_err2(e: &'static str) -> Box<dyn std::error::Error> {
  function box_up_err (line 117) | pub fn box_up_err<E: std::error::Error + 'static>(e: E) -> Box<dyn std::...
  method new (line 122) | pub fn new<R: AsyncRead + 'static, W: AsyncWrite + 'static>(r: R, w: W, ...

FILE: src/windows_np_peer.rs
  type NamedPipeConnect (line 22) | pub struct NamedPipeConnect(pub PathBuf);
  method construct (line 24) | fn construct(&self, _p: ConstructParams) -> PeerConstructor {
  function named_pipe_connect_peer (line 47) | fn named_pipe_connect_peer(
  type NamedPipeConnectPeer (line 56) | struct NamedPipeConnectPeer(Rc<RefCell<NamedPipe>>);
  method read (line 59) | fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
  method write (line 67) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 73) | fn flush(&mut self) -> IoResult<()> {
  method shutdown (line 83) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {

FILE: src/ws_client_peer.rs
  type WsClient (line 22) | pub struct WsClient(pub Url);
  method construct (line 24) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type WsClientSecure (line 59) | pub struct WsClientSecure(pub Url);
  method construct (line 62) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type WsConnect (line 96) | pub struct WsConnect<T: Specifier>(pub T);
  method construct (line 98) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  function get_ws_client_peer_impl (line 137) | fn get_ws_client_peer_impl<S, F>(uri: &Url, opts: Rc<Options>, f: F) -> ...
  function get_ws_client_peer (line 183) | pub fn get_ws_client_peer(uri: &Url, opts: Rc<Options>) -> BoxedNewPeerF...
  function get_ws_client_peer_wrapped (line 245) | pub fn get_ws_client_peer_wrapped(uri: &Url, inner: Peer, opts: Rc<Optio...

FILE: src/ws_lowlevel_peer.rs
  type WsLlClient (line 19) | pub struct WsLlClient<T: Specifier>(pub T);
  method construct (line 21) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  type WsLlServer (line 48) | pub struct WsLlServer<T: Specifier>(pub T);
  method construct (line 50) | fn construct(&self, p: ConstructParams) -> PeerConstructor {
  function get_ws_lowlevel_peer (line 76) | pub fn get_ws_lowlevel_peer(mode: WsLlContext, mut inner: Peer, opts: Rc...

FILE: src/ws_peer.rs
  type MultiProducerWsSink (line 24) | type MultiProducerWsSink<T> = Rc<
  type WsSource (line 29) | type WsSource<T> = futures::stream::SplitStream<
  type WsSinkWithOneBufferedMessage (line 32) | pub struct WsSinkWithOneBufferedMessage<T> {
  type CompressionMethod (line 39) | pub enum CompressionMethod {
    method uncompress (line 48) | fn uncompress(&self, x: Vec<u8>) -> Vec<u8> {
    method compress (line 91) | fn compress(&self, x: Vec<u8>) -> Vec<u8> {
    method uncompress (line 134) | fn uncompress(&self, x: Vec<u8>) -> Vec<u8> {
    method compress (line 144) | fn compress(&self, x: Vec<u8>) -> Vec<u8> {
  type WsReadWrapper (line 154) | pub struct WsReadWrapper<T: WsStream + 'static> {
  method read (line 174) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...
  type Mode1 (line 324) | pub enum Mode1 {
  type WsWriteWrapper (line 329) | pub struct WsWriteWrapper<T: WsStream + 'static> {
  method shutdown (line 344) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 372) | fn write(&mut self, buf_: &[u8]) -> IoResult<usize> {
  method flush (line 468) | fn flush(&mut self) -> IoResult<()> {
  method drop (line 483) | fn drop(&mut self) {
  type PeerForWs (line 489) | pub struct PeerForWs(pub Peer);
  method read (line 495) | fn read(&mut self, buf: &mut [u8]) -> std::result::Result<usize, std::io...
  method shutdown (line 500) | fn shutdown(&mut self) -> futures::Poll<(), std::io::Error> {
  method write (line 505) | fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
  method flush (line 508) | fn flush(&mut self) -> IoResult<()> {
  type WsPingerState (line 513) | enum WsPingerState {
  type WsPinger (line 520) | pub struct WsPinger<T: WsStream + 'static> {
  function new (line 530) | pub fn new(
  type Item (line 549) | type Item = ();
  type Error (line 550) | type Error = ();
  function poll (line 552) | fn poll(&mut self) -> ::futures::Poll<(), ()> {
  type Duplex (line 633) | pub type Duplex<S> = ::tokio_codec::Framed<S, websocket::r#async::Messag...
  function finish_building_ws_peer (line 635) | pub fn finish_building_ws_peer<S>(opts: &super::Options, duplex: Duplex<...

FILE: src/ws_server_peer.rs
  type WsServer (line 20) | pub struct WsServer<T: Specifier>(pub T);
  method construct (line 22) | fn construct(&self, cp: ConstructParams) -> PeerConstructor {
  function ws_upgrade_peer (line 111) | pub fn ws_upgrade_peer(

FILE: tests/test.rs
  function dflt (line 12) | fn dflt() -> Options {
  function trivial (line 72) | fn trivial() {
  function tcp (line 86) | fn tcp() {
  function ws (line 110) | fn ws() {
  function ws_ll (line 134) | fn ws_ll() {
  function ws_persist (line 159) | fn ws_persist() {
  function unix (line 194) | fn unix() {
  function abstract_ (line 223) | fn abstract_() {