Struct sozu_lib::https_rustls::session::Session[−][src]

pub struct Session {
    pub frontend_token: Token,
    pub backend: Option<Rc<RefCell<Backend>>>,
    pub back_connected: BackendConnectionStatus,
    pub public_address: SocketAddr,
    pub metrics: SessionMetrics,
    pub app_id: Option<String>,
    pub listen_token: Token,
    pub connection_attempt: u8,
    // some fields omitted
}

Fields

frontend_token: Tokenbackend: Option<Rc<RefCell<Backend>>>back_connected: BackendConnectionStatuspublic_address: SocketAddrmetrics: SessionMetricsapp_id: Option<String>listen_token: Tokenconnection_attempt: u8

Implementations

`impl Session`[src]

`pub fn new( ssl: ServerSession, sock: TcpStream, token: Token, pool: Weak<RefCell<Pool>>, public_address: SocketAddr, expect_proxy: bool, sticky_name: String, timeout: Timeout, answers: Rc<RefCell<HttpAnswers>>, listen_token: Token, delay: Duration ) -> Session`[src]

`pub fn http(&self) -> Option<&Http<FrontRustls>>`[src]

`pub fn http_mut(&mut self) -> Option<&mut Http<FrontRustls>>`[src]

`pub fn set_answer(&mut self, answer: DefaultAnswerStatus, buf: Rc<Vec<u8>>)`[src]

`pub fn upgrade(&mut self) -> bool`[src]

`pub fn log_context(&self) -> String`[src]

`pub fn front_socket(&self) -> &TcpStream`[src]

`pub fn back_socket(&self) -> Option<&TcpStream>`[src]

`pub fn back_token(&self) -> Option<Token>`[src]

`pub fn set_back_socket(&mut self, sock: TcpStream)`[src]

`pub fn set_back_token(&mut self, token: Token)`[src]

`pub fn front_readiness(&mut self) -> &mut Readiness`[src]

`pub fn back_readiness(&mut self) -> Option<&mut Readiness>`[src]

Trait Implementations

`impl ProxyConfiguration<Session> for Proxy`[src]

`fn accept(&mut self, token: ListenToken) -> Result<TcpStream, AcceptError>`[src]

`fn create_session( &mut self, frontend_sock: TcpStream, token: ListenToken, poll: &mut Poll, session_token: Token, timeout: Timeout, delay: Duration ) -> Result<(Rc<RefCell<Session>>, bool), AcceptError>`[src]

`fn connect_to_backend( &mut self, poll: &mut Poll, session: &mut Session, back_token: Token ) -> Result<BackendConnectAction, ConnectionError>`[src]

`fn notify( &mut self, event_loop: &mut Poll, message: ProxyRequest ) -> ProxyResponse`[src]

`fn listen_port_state(&self, port: &u16) -> ListenPortState`[src]

`impl ProxySession for Session`[src]

`fn close(&mut self, poll: &mut Poll) -> CloseResult`[src]

`fn timeout( &mut self, token: Token, timer: &mut Timer<Token>, front_timeout: &Duration ) -> SessionResult`[src]

`fn cancel_timeouts(&self, timer: &mut Timer<Token>)`[src]

`fn close_backend(&mut self, _: Token, poll: &mut Poll)`[src]

`fn protocol(&self) -> Protocol`[src]

`fn process_events(&mut self, token: Token, events: Ready)`[src]

`fn ready(&mut self) -> SessionResult`[src]

`fn shutting_down(&mut self) -> SessionResult`[src]

`fn last_event(&self) -> Instant`[src]

`fn print_state(&self)`[src]

`fn tokens(&self) -> Vec<Token>`[src]

`impl ProxySessionCast for Session`[src]

`fn as_http(&mut self) -> &mut Session`[src]

`fn as_tcp(&mut self) -> &mut Session`[src]

`fn as_https_rustls(&mut self) -> &mut Session`[src]

Auto Trait Implementations

`impl !RefUnwindSafe for Session`

`impl !Send for Session`

`impl !Sync for Session`

`impl Unpin for Session`

`impl !UnwindSafe for Session`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> FmtForward for T`

`pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> Pipe for T where T: ?Sized,`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_ref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self) -> R ) -> R where R: 'a,`

`pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where Self: Borrow, R: 'a, B: 'a + ?Sized,`

`pub fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R where Self: BorrowMut, R: 'a, B: 'a + ?Sized,`

`pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where Self: AsRef, R: 'a, U: 'a + ?Sized,`

`pub fn pipe_as_mut<'a, U, R>( &'a mut self, func: impl FnOnce(&'a mut U) -> R ) -> R where Self: AsMut, R: 'a, U: 'a + ?Sized,`

`pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Deref<Target = T>, R: 'a, T: 'a + ?Sized,`

`pub fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: DerefMut<Target = T> + Deref, R: 'a, T: 'a + ?Sized,`

`impl<T> Pipe for T`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, R: 'a, T: 'a,`

`pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: AsMut<T>, R: 'a, T: 'a,`

`impl<T> PipeBorrow for T`

`pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Borrow<T>, R: 'a, T: 'a,`

`pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: BorrowMut<T>, R: 'a, T: 'a,`

`impl<T> PipeDeref for T`

`pub fn pipe_deref<'a, R>( &'a self, func: impl FnOnce(&'a Self::Target) -> R ) -> R where Self: Deref, R: 'a,`

`pub fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R ) -> R where Self: DerefMut, R: 'a,`

`impl<T> PipeRef for T`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,`

`impl<T> Same<T> for T`

`type Output = T`

Should always be Self

`impl<T> Tap for T`

`pub fn tap(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow(self, func: impl FnOnce(&B)) -> Self where Self: Borrow, B: ?Sized,`

`pub fn tap_borrow_mut(self, func: impl FnOnce(&mut B)) -> Self where Self: BorrowMut, B: ?Sized,`

`pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where Self: AsRef<R>, R: ?Sized,`

`pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where Self: AsMut<R>, R: ?Sized,`

`pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where Self: Deref<Target = T>, T: ?Sized,`

`pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized,`

`pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow_dbg(self, func: impl FnOnce(&B)) -> Self where Self: Borrow, B: ?Sized,`

`pub fn tap_borrow_mut_dbg(self, func: impl FnOnce(&mut B)) -> Self where Self: BorrowMut, B: ?Sized,`

`pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where Self: AsRef<R>, R: ?Sized,`

`pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where Self: AsMut<R>, R: ?Sized,`

`pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where Self: Deref<Target = T>, T: ?Sized,`

`pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized,`

`impl<T> Tap for T`

`pub fn tap<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`impl<T, U> TapAsRef for T where U: ?Sized,`

`pub fn tap_ref<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,`

`pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,`

`pub fn tap_ref_mut<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,`

`pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,`

`impl<T, U> TapBorrow for T where U: ?Sized,`

`pub fn tap_borrow<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,`

`pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,`

`pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,`

`pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,`

`impl<T> TapDeref for T`

`pub fn tap_deref<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,`

`pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,`

`pub fn tap_deref_mut<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,`

`pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,`

`impl<T> TryConv for T`

`pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T> TryConv for T`

`pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, >::Error>`[src]

`impl<V, T> VZip<V> for T where V: MultiLane<T>,`

`pub fn vzip(self) -> V`

Struct sozu_lib::https_rustls::session::Session⎘[−][src]

Fields

Implementations

impl Session[src]

pub fn new( ssl: ServerSession, sock: TcpStream, token: Token, pool: Weak<RefCell<Pool>>, public_address: SocketAddr, expect_proxy: bool, sticky_name: String, timeout: Timeout, answers: Rc<RefCell<HttpAnswers>>, listen_token: Token, delay: Duration) -> Session[src]

pub fn http(&self) -> Option<&Http<FrontRustls>>[src]

pub fn http_mut(&mut self) -> Option<&mut Http<FrontRustls>>[src]

pub fn set_answer(&mut self, answer: DefaultAnswerStatus, buf: Rc<Vec<u8>>)[src]

pub fn upgrade(&mut self) -> bool[src]

pub fn log_context(&self) -> String[src]

pub fn front_socket(&self) -> &TcpStream[src]

pub fn back_socket(&self) -> Option<&TcpStream>[src]

pub fn back_token(&self) -> Option<Token>[src]

pub fn set_back_socket(&mut self, sock: TcpStream)[src]

pub fn set_back_token(&mut self, token: Token)[src]

pub fn front_readiness(&mut self) -> &mut Readiness[src]

pub fn back_readiness(&mut self) -> Option<&mut Readiness>[src]

Trait Implementations

impl ProxyConfiguration<Session> for Proxy[src]

fn accept(&mut self, token: ListenToken) -> Result<TcpStream, AcceptError>[src]

fn create_session( &mut self, frontend_sock: TcpStream, token: ListenToken, poll: &mut Poll, session_token: Token, timeout: Timeout, delay: Duration) -> Result<(Rc<RefCell<Session>>, bool), AcceptError>[src]

fn connect_to_backend( &mut self, poll: &mut Poll, session: &mut Session, back_token: Token) -> Result<BackendConnectAction, ConnectionError>[src]

fn notify( &mut self, event_loop: &mut Poll, message: ProxyRequest) -> ProxyResponse[src]

fn listen_port_state(&self, port: &u16) -> ListenPortState[src]

impl ProxySession for Session[src]

fn close(&mut self, poll: &mut Poll) -> CloseResult[src]

fn timeout( &mut self, token: Token, timer: &mut Timer<Token>, front_timeout: &Duration) -> SessionResult[src]

fn cancel_timeouts(&self, timer: &mut Timer<Token>)[src]

fn close_backend(&mut self, _: Token, poll: &mut Poll)[src]

fn protocol(&self) -> Protocol[src]

fn process_events(&mut self, token: Token, events: Ready)[src]

fn ready(&mut self) -> SessionResult[src]

fn shutting_down(&mut self) -> SessionResult[src]

fn last_event(&self) -> Instant[src]

fn print_state(&self)[src]

fn tokens(&self) -> Vec<Token>[src]

impl ProxySessionCast for Session[src]

fn as_http(&mut self) -> &mut Session[src]

fn as_tcp(&mut self) -> &mut Session[src]

fn as_https_rustls(&mut self) -> &mut Session[src]

Auto Trait Implementations

impl !RefUnwindSafe for Session

impl !Send for Session

impl !Sync for Session

impl Unpin for Session

impl !UnwindSafe for Session

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

impl<T> Conv for T

pub fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Conv for T

pub fn conv<T>(self) -> T where Self: Into<T>,

impl<T> FmtForward for T

pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

pub fn into(self) -> U[src]

impl<T> Pipe for T where T: ?Sized,

pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R

pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,

pub fn pipe_ref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,

pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where Self: Borrow<B>, R: 'a, B: 'a + ?Sized,

pub fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R) -> R where Self: BorrowMut<B>, R: 'a, B: 'a + ?Sized,

pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where Self: AsRef<U>, R: 'a, U: 'a + ?Sized,

pub fn pipe_as_mut<'a, U, R>( &'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where Self: AsMut<U>, R: 'a, U: 'a + ?Sized,

pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Deref<Target = T>, R: 'a, T: 'a + ?Sized,

pub fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where Self: DerefMut<Target = T> + Deref, R: 'a, T: 'a + ?Sized,

Struct sozu_lib::https_rustls::session::Session[−][src]

`impl Session`[src]

`pub fn new( ssl: ServerSession, sock: TcpStream, token: Token, pool: Weak<RefCell<Pool>>, public_address: SocketAddr, expect_proxy: bool, sticky_name: String, timeout: Timeout, answers: Rc<RefCell<HttpAnswers>>, listen_token: Token, delay: Duration ) -> Session`[src]

`pub fn http(&self) -> Option<&Http<FrontRustls>>`[src]

`pub fn http_mut(&mut self) -> Option<&mut Http<FrontRustls>>`[src]

`pub fn set_answer(&mut self, answer: DefaultAnswerStatus, buf: Rc<Vec<u8>>)`[src]

`pub fn upgrade(&mut self) -> bool`[src]

`pub fn log_context(&self) -> String`[src]

`pub fn front_socket(&self) -> &TcpStream`[src]

`pub fn back_socket(&self) -> Option<&TcpStream>`[src]

`pub fn back_token(&self) -> Option<Token>`[src]

`pub fn set_back_socket(&mut self, sock: TcpStream)`[src]

`pub fn set_back_token(&mut self, token: Token)`[src]

`pub fn front_readiness(&mut self) -> &mut Readiness`[src]

`pub fn back_readiness(&mut self) -> Option<&mut Readiness>`[src]

`impl ProxyConfiguration<Session> for Proxy`[src]

`fn accept(&mut self, token: ListenToken) -> Result<TcpStream, AcceptError>`[src]

`fn create_session( &mut self, frontend_sock: TcpStream, token: ListenToken, poll: &mut Poll, session_token: Token, timeout: Timeout, delay: Duration ) -> Result<(Rc<RefCell<Session>>, bool), AcceptError>`[src]

`fn connect_to_backend( &mut self, poll: &mut Poll, session: &mut Session, back_token: Token ) -> Result<BackendConnectAction, ConnectionError>`[src]

`fn notify( &mut self, event_loop: &mut Poll, message: ProxyRequest ) -> ProxyResponse`[src]

`fn listen_port_state(&self, port: &u16) -> ListenPortState`[src]

`impl ProxySession for Session`[src]

`fn close(&mut self, poll: &mut Poll) -> CloseResult`[src]

`fn timeout( &mut self, token: Token, timer: &mut Timer<Token>, front_timeout: &Duration ) -> SessionResult`[src]

`fn cancel_timeouts(&self, timer: &mut Timer<Token>)`[src]

`fn close_backend(&mut self, _: Token, poll: &mut Poll)`[src]

`fn protocol(&self) -> Protocol`[src]

`fn process_events(&mut self, token: Token, events: Ready)`[src]

`fn ready(&mut self) -> SessionResult`[src]

`fn shutting_down(&mut self) -> SessionResult`[src]

`fn last_event(&self) -> Instant`[src]

`fn print_state(&self)`[src]

`fn tokens(&self) -> Vec<Token>`[src]

`impl ProxySessionCast for Session`[src]

`fn as_http(&mut self) -> &mut Session`[src]

`fn as_tcp(&mut self) -> &mut Session`[src]

`fn as_https_rustls(&mut self) -> &mut Session`[src]

`impl !RefUnwindSafe for Session`

`impl !Send for Session`

`impl !Sync for Session`

`impl Unpin for Session`

`impl !UnwindSafe for Session`

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> FmtForward for T`

`pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> Pipe for T where T: ?Sized,`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_ref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self) -> R ) -> R where R: 'a,`

`pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where Self: Borrow<B>, R: 'a, B: 'a + ?Sized,`

`pub fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R where Self: BorrowMut<B>, R: 'a, B: 'a + ?Sized,`

`pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where Self: AsRef<U>, R: 'a, U: 'a + ?Sized,`

`pub fn pipe_as_mut<'a, U, R>( &'a mut self, func: impl FnOnce(&'a mut U) -> R ) -> R where Self: AsMut<U>, R: 'a, U: 'a + ?Sized,`

`pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Deref<Target = T>, R: 'a, T: 'a + ?Sized,`

`pub fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: DerefMut<Target = T> + Deref, R: 'a, T: 'a + ?Sized,`

`impl<T> Pipe for T`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, R: 'a, T: 'a,`

`pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: AsMut<T>, R: 'a, T: 'a,`