rama::crypto::dep::x509_parser::prelude::asn1_rs::nom::lib::std::fmt

Trait Debug

1.0.0 · Source

pub trait Debug {
    // Required method
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}

Expand description

? formatting.

Debug should format the output in a programmer-facing, debugging context.

Generally speaking, you should just derive a Debug implementation.

When used with the alternate format specifier #?, the output is pretty-printed.

For more information on formatters, see the module-level documentation.

This trait can be used with #[derive] if all fields implement Debug. When derived for structs, it will use the name of the struct, then {, then a comma-separated list of each field’s name and Debug value, then }. For enums, it will use the name of the variant and, if applicable, (, then the Debug values of the fields, then ).

§Stability

Derived Debug formats are not stable, and so may change with future Rust versions. Additionally, Debug implementations of types provided by the standard library (std, core, alloc, etc.) are not stable, and may also change with future Rust versions.

§Examples

Deriving an implementation:

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

let origin = Point { x: 0, y: 0 };

assert_eq!(
    format!("The origin is: {origin:?}"),
    "The origin is: Point { x: 0, y: 0 }",
);

Manually implementing:

use std::fmt;

struct Point {
    x: i32,
    y: i32,
}

impl fmt::Debug for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Point")
         .field("x", &self.x)
         .field("y", &self.y)
         .finish()
    }
}

let origin = Point { x: 0, y: 0 };

assert_eq!(
    format!("The origin is: {origin:?}"),
    "The origin is: Point { x: 0, y: 0 }",
);

There are a number of helper methods on the Formatter struct to help you with manual implementations, such as debug_struct.

Types that do not wish to use the standard suite of debug representations provided by the Formatter trait (debug_struct, debug_tuple, debug_list, debug_set, debug_map) can do something totally custom by manually writing an arbitrary representation to the Formatter.

impl fmt::Debug for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Point [{} {}]", self.x, self.y)
    }
}

Debug implementations using either derive or the debug builder API on Formatter support pretty-printing using the alternate flag: {:#?}.

Pretty-printing with #?:

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

let origin = Point { x: 0, y: 0 };

let expected = "The origin is: Point {
    x: 0,
    y: 0,
}";
assert_eq!(format!("The origin is: {origin:#?}"), expected);

Source §

impl Debug for untrusted::reader::EndOfInput

Source §

impl Debug for untrusted::reader::Reader<'_>

Avoids writing the value or position to avoid creating a side channel, though Reader can’t avoid leaking the position via timing.

Source §

impl Debug for untrusted::EndOfInput

Source §

impl Debug for ByteString

1.0.0 · Source§

impl Debug for CString

impl Debug for CStr

The string printed can be readily parsed via the parse method on str.

§Example

use chrono::NaiveDate;

assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(2015, 9, 5).unwrap()), "2015-09-05");
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(0, 1, 1).unwrap()), "0000-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(9999, 12, 31).unwrap()), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(-1, 1, 1).unwrap()), "-0001-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(10000, 12, 31).unwrap()), "+10000-12-31");

Source §

impl Debug for NaiveDateDaysIterator

Source §

impl Debug for NaiveDateWeeksIterator

Source §

impl Debug for NaiveDateTime

The Debug output of the naive date and time dt is the same as dt.format("%Y-%m-%dT%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn’t matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

§Example

use chrono::NaiveDate;

let dt = NaiveDate::from_ymd_opt(2016, 11, 15).unwrap().and_hms_opt(7, 39, 24).unwrap();
assert_eq!(format!("{:?}", dt), "2016-11-15T07:39:24");

Leap seconds may also be used.

let dt =
    NaiveDate::from_ymd_opt(2015, 6, 30).unwrap().and_hms_milli_opt(23, 59, 59, 1_500).unwrap();
assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60.500");

Source §

impl Debug for IsoWeek

The Debug output of the ISO week w is the same as d.format("%G-W%V") where d is any NaiveDate value in that week.

§Example

use chrono::{Datelike, NaiveDate};

assert_eq!(
    format!("{:?}", NaiveDate::from_ymd_opt(2015, 9, 5).unwrap().iso_week()),
    "2015-W36"
);
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(0, 1, 3).unwrap().iso_week()), "0000-W01");
assert_eq!(
    format!("{:?}", NaiveDate::from_ymd_opt(9999, 12, 31).unwrap().iso_week()),
    "9999-W52"
);

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(0, 1, 2).unwrap().iso_week()), "-0001-W52");
assert_eq!(
    format!("{:?}", NaiveDate::from_ymd_opt(10000, 12, 31).unwrap().iso_week()),
    "+10000-W52"
);

Source §

impl Debug for Days

Source §

impl Debug for NaiveWeek

Source §

impl Debug for NaiveTime

The Debug output of the naive time t is the same as t.format("%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn’t matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

§Example

use chrono::NaiveTime;

assert_eq!(format!("{:?}", NaiveTime::from_hms_opt(23, 56, 4).unwrap()), "23:56:04");
assert_eq!(
    format!("{:?}", NaiveTime::from_hms_milli_opt(23, 56, 4, 12).unwrap()),
    "23:56:04.012"
);
assert_eq!(
    format!("{:?}", NaiveTime::from_hms_micro_opt(23, 56, 4, 1234).unwrap()),
    "23:56:04.001234"
);
assert_eq!(
    format!("{:?}", NaiveTime::from_hms_nano_opt(23, 56, 4, 123456).unwrap()),
    "23:56:04.000123456"
);

Leap seconds may also be used.

assert_eq!(
    format!("{:?}", NaiveTime::from_hms_milli_opt(6, 59, 59, 1_500).unwrap()),
    "06:59:60.500"
);

Print the underlying bitmask, padded to 7 bits.

§Example

use chrono::Weekday::*;
assert_eq!(format!("{:?}", WeekdaySet::single(Mon)), "WeekdaySet(0000001)");
assert_eq!(format!("{:?}", WeekdaySet::single(Tue)), "WeekdaySet(0000010)");
assert_eq!(format!("{:?}", WeekdaySet::ALL), "WeekdaySet(1111111)");

Debug the serialization of this URL.

Debug implementation does not leak internal state

impl<T> Debug for (T₁, T₂, …, Tₙ)
where T: Debug,

This trait is implemented for tuples up to twelve items long.

Trait DebugCopy item path

§Stability

§Examples

Required Methods§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

§Errors

§Examples

Implementors§

impl Debug for ForwardKind

impl Debug for LookupIpStrategy

impl Debug for ResolveHosts

impl Debug for ServerOrderingStrategy

impl Debug for rama::futures::io::ErrorKind

impl Debug for SeekFrom

impl Debug for PollNext

impl Debug for EmptyLineHandling

impl Debug for HttpProxyError

impl Debug for UserError

impl Debug for rama::http::headers::encoding::Encoding

impl Debug for After

impl Debug for ClientHint

impl Debug for Extension

impl Debug for PerMessageDeflateIdentifier

impl Debug for GrpcCode

impl Debug for GrpcFailureClass

impl Debug for ServerErrorsFailureClass

impl Debug for StatusInRangeFailureClass

impl Debug for rama::http::layer::compression::CompressionLevel

impl Debug for Action

impl Debug for rama::http::layer::har::spec::ContentEncoding

impl Debug for HttpVersion

impl Debug for BidirectionalMessage

impl Debug for WriterMode

impl Debug for rama::http::matcher::uri::dep::regex::Error

impl Debug for PseudoHeader

impl Debug for EarlyFrame

impl Debug for rama::http::proto::h2::frame::Error

impl Debug for rama::http::proto::h2::frame::Kind

impl Debug for PushPromiseHeaderError

impl Debug for SettingId

impl Debug for DecoderError

impl Debug for NeedMore

impl Debug for DirectoryServeMode

impl Debug for CsvRejection

impl Debug for FormRejection

impl Debug for JsonRejection

impl Debug for TextRejection

impl Debug for PathRejection

impl Debug for TypedHeaderRejectionReason

impl Debug for ElementPatchMode

impl Debug for EventType

impl Debug for CrossOriginKind

impl Debug for rama::http::sse::datastar::execute_script::ReferrerPolicy

impl Debug for ScriptAttribute

impl Debug for ScriptType

impl Debug for HeaderValueErr

impl Debug for rama::http::ws::Message

impl Debug for rama::http::ws::ProtocolError

impl Debug for rama::http::ws::handshake::client::HandshakeError

impl Debug for ResponseValidateError

impl Debug for RequestValidateError

impl Debug for Role

impl Debug for CloseCode

impl Debug for rama::http::ws::protocol::frame::coding::OpCode

impl Debug for OpCodeControl

impl Debug for OpCodeData

impl Debug for rama::net::address::Host

impl Debug for ReuseStrategy

impl Debug for Ja3ComputeError

impl Debug for Ja4ComputeError

impl Debug for Ja4HComputeError

impl Debug for PeetComputeError

impl Debug for ConnectIpMode

impl Debug for DnsResolveIpMode

impl Debug for InterfaceIndexOrAddress

impl Debug for Interface

impl Debug for rama::net::socket::opts::Domain

impl Debug for rama::net::socket::opts::Protocol

impl Debug for rama::net::socket::opts::Type

impl Debug for IpAddrRange

Trait Debug