pub fn early_data(&mut self) -> Option<WriteEarlyData> {
        if self.data.early_data.is_enabled() {
            Some(WriteEarlyData::new(self))
        } else {
            None
        }
    }
/// Returns an `io::Write` implementer you can write bytes to
/// to send TLS1.3 early data (a.k.a. "0-RTT data") to the server.
///
/// This returns None in many circumstances when the capability to
/// send early data is not available, including but not limited to:
///
/// - The server hasn't been talked to previously.
/// - The server does not support resumption.
/// - The server does not support early data.
/// - The resumption data for the server has expired.
///
/// The server specifies a maximum amount of early data.  You can
/// learn this limit through the returned object, and writes through
/// it will process only this many bytes.
///
/// The server can choose not to accept any sent early data --
/// in this case the data is lost but the connection continues.  You
/// can tell this happened using `is_early_data_accepted`.
Returns an `io::Write` implementer you can write bytes to
to send TLS1.3 early data (a.k.a. "0-RTT data") to the server.

This returns None in many circumstances when the capability to
send early data is not available, including but not limited to.

The server hasn't been talked to previously.
The server does not support resumption.
The server does not support early data.
The resumption data for the server has expired.

The server specifies a maximum amount of early data.  You can
learn this limit through the returned object, and writes through
it will process only this many bytes.

The server can choose not to accept any sent early data
in this case the data is lost but the connection continues.  You
can tell this happened using `is_early_data_accepted`.
Returns an ` io :: Write ` implementer you can write bytes to to send TLS1 . 3 early data ( a . k . a . " 0 - RTT data " ) to the server . This returns None in many circumstances when the capability to send early data is not available including but not limited to . The server hasn ' t been talked to previously . The server does not support resumption . The server does not support early data . The resumption data for the server has expired . The server specifies a maximum amount of early data . You can learn this limit through the returned object and writes through it will process only this many bytes . The server can choose not to accept any sent early data in this case the data is lost but the connection continues . You can tell this happened using ` is_early_data_accepted ` .
pub fn early_data(&mut self) -> Option<WriteEarlyData> {
        if self.data.early_data.is_enabled() {
            Some(WriteEarlyData::new(self))
        } else {
            None
        }
    }
pub fn early_data ( & mut self ) -> Option < WriteEarlyData > { if self . data . early_data . is_enabled ( ) { Some ( WriteEarlyData :: new ( self ) ) } else { None } }
Returns an `io::Write` implementer you can write bytes to
to send TLS1.3 early data (a.k.a.
Returns an ` io :: Write ` implementer you can write bytes to to send TLS1 . 3 early data ( a . k . a .
&mut self