Skip to main content

FmdAdm

fmd_adm

Struct FmdAdm 

Source 
pub struct FmdAdm { /* private fields */ }
Expand description

A handle to the Fault Management Daemon administrative interface.

Implementations§

Source§

impl FmdAdm

Source

pub fn open() -> Result<Self, Error>

Open a connection to the local fault management daemon.

Examples found in repository?
examples/case_detail.rs (line 26)
25fn main() {
26    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
27    let cases = adm.cases(None).expect("failed to list cases");
28
29    if let Some(c) = cases.first() {
30        println!("Case {} ({})\n", c.uuid, c.code);
31        if let Some(event) = &c.event {
32            print_nvlist(event, 0);
33        } else {
34            println!("  (no event data)");
35        }
36    } else {
37        println!("No cases found.");
38    }
39}
More examples
Hide additional examples
examples/list_modules.rs (line 4)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    println!("=== FMD Modules ===");
7    let modules = adm.modules().expect("failed to list modules");
8    for m in &modules {
9        println!(
10            "  {} v{} - {}{}",
11            m.name,
12            m.version,
13            m.description,
14            if m.failed { " [FAILED]" } else { "" },
15        );
16    }
17    println!("({} modules total)", modules.len());
18
19    println!("\n=== Faulty Resources ===");
20    let resources = adm.resources(true).expect("failed to list resources");
21    if resources.is_empty() {
22        println!("  (none)");
23    } else {
24        for r in &resources {
25            println!("  {} (case {})", r.fmri, r.uuid);
26        }
27    }
28
29    println!("\n=== Cases ===");
30    let cases = adm.cases(None).expect("failed to list cases");
31    if cases.is_empty() {
32        println!("  (none)");
33    } else {
34        for c in &cases {
35            let severity = c
36                .event
37                .as_ref()
38                .and_then(|e| e.lookup("severity"))
39                .and_then(|v| match v {
40                    NvValue::String(s) => Some(s.as_str()),
41                    _ => None,
42                })
43                .unwrap_or("unknown");
44            println!("  {} - {} (severity: {})", c.uuid, c.code, severity);
45        }
46    }
47}
examples/stats.rs (line 4)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(
16        resources.len(),
17        count as usize,
18        "resource count mismatch!"
19    );
20
21    // Transports
22    println!("\n=== Transports ===");
23    let xprts = adm.transports().expect("failed to list transports");
24    if xprts.is_empty() {
25        println!("  (none)");
26    } else {
27        for id in &xprts {
28            println!("  transport {id}");
29        }
30    }
31
32    // SERD engines for each module
33    println!("\n=== SERD Engines ===");
34    let modules = adm.modules().expect("failed to list modules");
35    let mut total = 0;
36    for m in &modules {
37        let engines =
38            adm.serd_engines(&m.name).expect("failed to list serd engines");
39        if !engines.is_empty() {
40            println!("  {} ({} engines):", m.name, engines.len());
41            for e in &engines {
42                println!(
43                    "    {} - count={}, n={}, fired={}",
44                    e.name, e.count, e.n, e.fired,
45                );
46            }
47            total += engines.len();
48        }
49    }
50    if total == 0 {
51        println!("  (none)");
52    }
53
54    // Global stats
55    println!("\n=== Global Stats ===");
56    let stats = adm.stats(None).expect("failed to read stats");
57    for s in &stats {
58        println!("  {}: {} ({})", s.name, s.value, s.description);
59    }
60
61    // Per-module stats for the first module
62    if let Some(m) = modules.first() {
63        println!("\n=== Stats for {} ===", m.name);
64        let mstats =
65            adm.stats(Some(&m.name)).expect("failed to read module stats");
66        for s in &mstats {
67            println!("  {}: {} ({})", s.name, s.value, s.description);
68        }
69    }
70}
Source

pub fn modules(&self) -> Result<Vec<ModuleInfo>, Error>

Iterate over loaded FMD modules.

Examples found in repository?
examples/list_modules.rs (line 7)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    println!("=== FMD Modules ===");
7    let modules = adm.modules().expect("failed to list modules");
8    for m in &modules {
9        println!(
10            "  {} v{} - {}{}",
11            m.name,
12            m.version,
13            m.description,
14            if m.failed { " [FAILED]" } else { "" },
15        );
16    }
17    println!("({} modules total)", modules.len());
18
19    println!("\n=== Faulty Resources ===");
20    let resources = adm.resources(true).expect("failed to list resources");
21    if resources.is_empty() {
22        println!("  (none)");
23    } else {
24        for r in &resources {
25            println!("  {} (case {})", r.fmri, r.uuid);
26        }
27    }
28
29    println!("\n=== Cases ===");
30    let cases = adm.cases(None).expect("failed to list cases");
31    if cases.is_empty() {
32        println!("  (none)");
33    } else {
34        for c in &cases {
35            let severity = c
36                .event
37                .as_ref()
38                .and_then(|e| e.lookup("severity"))
39                .and_then(|v| match v {
40                    NvValue::String(s) => Some(s.as_str()),
41                    _ => None,
42                })
43                .unwrap_or("unknown");
44            println!("  {} - {} (severity: {})", c.uuid, c.code, severity);
45        }
46    }
47}
More examples
Hide additional examples
examples/stats.rs (line 34)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(
16        resources.len(),
17        count as usize,
18        "resource count mismatch!"
19    );
20
21    // Transports
22    println!("\n=== Transports ===");
23    let xprts = adm.transports().expect("failed to list transports");
24    if xprts.is_empty() {
25        println!("  (none)");
26    } else {
27        for id in &xprts {
28            println!("  transport {id}");
29        }
30    }
31
32    // SERD engines for each module
33    println!("\n=== SERD Engines ===");
34    let modules = adm.modules().expect("failed to list modules");
35    let mut total = 0;
36    for m in &modules {
37        let engines =
38            adm.serd_engines(&m.name).expect("failed to list serd engines");
39        if !engines.is_empty() {
40            println!("  {} ({} engines):", m.name, engines.len());
41            for e in &engines {
42                println!(
43                    "    {} - count={}, n={}, fired={}",
44                    e.name, e.count, e.n, e.fired,
45                );
46            }
47            total += engines.len();
48        }
49    }
50    if total == 0 {
51        println!("  (none)");
52    }
53
54    // Global stats
55    println!("\n=== Global Stats ===");
56    let stats = adm.stats(None).expect("failed to read stats");
57    for s in &stats {
58        println!("  {}: {} ({})", s.name, s.value, s.description);
59    }
60
61    // Per-module stats for the first module
62    if let Some(m) = modules.first() {
63        println!("\n=== Stats for {} ===", m.name);
64        let mstats =
65            adm.stats(Some(&m.name)).expect("failed to read module stats");
66        for s in &mstats {
67            println!("  {}: {} ({})", s.name, s.value, s.description);
68        }
69    }
70}
Source

pub fn module_load(&self, path: &str) -> Result<(), Error>

Load an FMD module by path.

Source

pub fn module_unload(&self, name: &str) -> Result<(), Error>

Unload an FMD module by name.

Source

pub fn module_reset(&self, name: &str) -> Result<(), Error>

Reset an FMD module by name.

Source

pub fn module_gc(&self, name: &str) -> Result<(), Error>

Garbage-collect an FMD module by name.

Source

pub fn resources(&self, all: bool) -> Result<Vec<ResourceInfo>, Error>

Iterate over faulty resources.

If all is true, includes resources that are not directly visible.

Examples found in repository?
examples/list_modules.rs (line 20)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    println!("=== FMD Modules ===");
7    let modules = adm.modules().expect("failed to list modules");
8    for m in &modules {
9        println!(
10            "  {} v{} - {}{}",
11            m.name,
12            m.version,
13            m.description,
14            if m.failed { " [FAILED]" } else { "" },
15        );
16    }
17    println!("({} modules total)", modules.len());
18
19    println!("\n=== Faulty Resources ===");
20    let resources = adm.resources(true).expect("failed to list resources");
21    if resources.is_empty() {
22        println!("  (none)");
23    } else {
24        for r in &resources {
25            println!("  {} (case {})", r.fmri, r.uuid);
26        }
27    }
28
29    println!("\n=== Cases ===");
30    let cases = adm.cases(None).expect("failed to list cases");
31    if cases.is_empty() {
32        println!("  (none)");
33    } else {
34        for c in &cases {
35            let severity = c
36                .event
37                .as_ref()
38                .and_then(|e| e.lookup("severity"))
39                .and_then(|v| match v {
40                    NvValue::String(s) => Some(s.as_str()),
41                    _ => None,
42                })
43                .unwrap_or("unknown");
44            println!("  {} - {} (severity: {})", c.uuid, c.code, severity);
45        }
46    }
47}
More examples
Hide additional examples
examples/stats.rs (line 7)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(
16        resources.len(),
17        count as usize,
18        "resource count mismatch!"
19    );
20
21    // Transports
22    println!("\n=== Transports ===");
23    let xprts = adm.transports().expect("failed to list transports");
24    if xprts.is_empty() {
25        println!("  (none)");
26    } else {
27        for id in &xprts {
28            println!("  transport {id}");
29        }
30    }
31
32    // SERD engines for each module
33    println!("\n=== SERD Engines ===");
34    let modules = adm.modules().expect("failed to list modules");
35    let mut total = 0;
36    for m in &modules {
37        let engines =
38            adm.serd_engines(&m.name).expect("failed to list serd engines");
39        if !engines.is_empty() {
40            println!("  {} ({} engines):", m.name, engines.len());
41            for e in &engines {
42                println!(
43                    "    {} - count={}, n={}, fired={}",
44                    e.name, e.count, e.n, e.fired,
45                );
46            }
47            total += engines.len();
48        }
49    }
50    if total == 0 {
51        println!("  (none)");
52    }
53
54    // Global stats
55    println!("\n=== Global Stats ===");
56    let stats = adm.stats(None).expect("failed to read stats");
57    for s in &stats {
58        println!("  {}: {} ({})", s.name, s.value, s.description);
59    }
60
61    // Per-module stats for the first module
62    if let Some(m) = modules.first() {
63        println!("\n=== Stats for {} ===", m.name);
64        let mstats =
65            adm.stats(Some(&m.name)).expect("failed to read module stats");
66        for s in &mstats {
67            println!("  {}: {} ({})", s.name, s.value, s.description);
68        }
69    }
70}
Source

pub fn resource_count(&self, all: bool) -> Result<u32, Error>

Get the count of faulty resources.

Examples found in repository?
examples/stats.rs (line 8)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(
16        resources.len(),
17        count as usize,
18        "resource count mismatch!"
19    );
20
21    // Transports
22    println!("\n=== Transports ===");
23    let xprts = adm.transports().expect("failed to list transports");
24    if xprts.is_empty() {
25        println!("  (none)");
26    } else {
27        for id in &xprts {
28            println!("  transport {id}");
29        }
30    }
31
32    // SERD engines for each module
33    println!("\n=== SERD Engines ===");
34    let modules = adm.modules().expect("failed to list modules");
35    let mut total = 0;
36    for m in &modules {
37        let engines =
38            adm.serd_engines(&m.name).expect("failed to list serd engines");
39        if !engines.is_empty() {
40            println!("  {} ({} engines):", m.name, engines.len());
41            for e in &engines {
42                println!(
43                    "    {} - count={}, n={}, fired={}",
44                    e.name, e.count, e.n, e.fired,
45                );
46            }
47            total += engines.len();
48        }
49    }
50    if total == 0 {
51        println!("  (none)");
52    }
53
54    // Global stats
55    println!("\n=== Global Stats ===");
56    let stats = adm.stats(None).expect("failed to read stats");
57    for s in &stats {
58        println!("  {}: {} ({})", s.name, s.value, s.description);
59    }
60
61    // Per-module stats for the first module
62    if let Some(m) = modules.first() {
63        println!("\n=== Stats for {} ===", m.name);
64        let mstats =
65            adm.stats(Some(&m.name)).expect("failed to read module stats");
66        for s in &mstats {
67            println!("  {}: {} ({})", s.name, s.value, s.description);
68        }
69    }
70}
Source

pub fn resource_repaired(&self, fmri: &str) -> Result<(), Error>

Mark a resource (by FMRI) as repaired.

Source

pub fn resource_replaced(&self, fmri: &str) -> Result<(), Error>

Mark a resource (by FMRI) as replaced.

Source

pub fn resource_acquit( &self, fmri: &str, case_uuid: Option<&Uuid>, ) -> Result<(), Error>

Acquit a resource (by FMRI), optionally specifying a case UUID.

If case_uuid is None, the resource is acquitted across all cases.

Source

pub fn resource_flush(&self, fmri: &str) -> Result<(), Error>

Flush cached state for a resource (by FMRI).

Source

pub fn cases(&self, url: Option<&str>) -> Result<Vec<CaseInfo>, Error>

Iterate over cases, optionally filtered by URL.

Examples found in repository?
examples/case_detail.rs (line 27)
25fn main() {
26    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
27    let cases = adm.cases(None).expect("failed to list cases");
28
29    if let Some(c) = cases.first() {
30        println!("Case {} ({})\n", c.uuid, c.code);
31        if let Some(event) = &c.event {
32            print_nvlist(event, 0);
33        } else {
34            println!("  (no event data)");
35        }
36    } else {
37        println!("No cases found.");
38    }
39}
More examples
Hide additional examples
examples/list_modules.rs (line 30)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    println!("=== FMD Modules ===");
7    let modules = adm.modules().expect("failed to list modules");
8    for m in &modules {
9        println!(
10            "  {} v{} - {}{}",
11            m.name,
12            m.version,
13            m.description,
14            if m.failed { " [FAILED]" } else { "" },
15        );
16    }
17    println!("({} modules total)", modules.len());
18
19    println!("\n=== Faulty Resources ===");
20    let resources = adm.resources(true).expect("failed to list resources");
21    if resources.is_empty() {
22        println!("  (none)");
23    } else {
24        for r in &resources {
25            println!("  {} (case {})", r.fmri, r.uuid);
26        }
27    }
28
29    println!("\n=== Cases ===");
30    let cases = adm.cases(None).expect("failed to list cases");
31    if cases.is_empty() {
32        println!("  (none)");
33    } else {
34        for c in &cases {
35            let severity = c
36                .event
37                .as_ref()
38                .and_then(|e| e.lookup("severity"))
39                .and_then(|v| match v {
40                    NvValue::String(s) => Some(s.as_str()),
41                    _ => None,
42                })
43                .unwrap_or("unknown");
44            println!("  {} - {} (severity: {})", c.uuid, c.code, severity);
45        }
46    }
47}
Source

pub fn case_repair(&self, uuid: &Uuid) -> Result<(), Error>

Repair a case by UUID.

Source

pub fn case_acquit(&self, uuid: &Uuid) -> Result<(), Error>

Acquit a case by UUID.

Source

pub fn serd_engines(&self, module: &str) -> Result<Vec<SerdInfo>, Error>

Iterate over SERD engines for a module.

Examples found in repository?
examples/stats.rs (line 38)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(
16        resources.len(),
17        count as usize,
18        "resource count mismatch!"
19    );
20
21    // Transports
22    println!("\n=== Transports ===");
23    let xprts = adm.transports().expect("failed to list transports");
24    if xprts.is_empty() {
25        println!("  (none)");
26    } else {
27        for id in &xprts {
28            println!("  transport {id}");
29        }
30    }
31
32    // SERD engines for each module
33    println!("\n=== SERD Engines ===");
34    let modules = adm.modules().expect("failed to list modules");
35    let mut total = 0;
36    for m in &modules {
37        let engines =
38            adm.serd_engines(&m.name).expect("failed to list serd engines");
39        if !engines.is_empty() {
40            println!("  {} ({} engines):", m.name, engines.len());
41            for e in &engines {
42                println!(
43                    "    {} - count={}, n={}, fired={}",
44                    e.name, e.count, e.n, e.fired,
45                );
46            }
47            total += engines.len();
48        }
49    }
50    if total == 0 {
51        println!("  (none)");
52    }
53
54    // Global stats
55    println!("\n=== Global Stats ===");
56    let stats = adm.stats(None).expect("failed to read stats");
57    for s in &stats {
58        println!("  {}: {} ({})", s.name, s.value, s.description);
59    }
60
61    // Per-module stats for the first module
62    if let Some(m) = modules.first() {
63        println!("\n=== Stats for {} ===", m.name);
64        let mstats =
65            adm.stats(Some(&m.name)).expect("failed to read module stats");
66        for s in &mstats {
67            println!("  {}: {} ({})", s.name, s.value, s.description);
68        }
69    }
70}
Source

pub fn serd_reset(&self, module: &str, name: &str) -> Result<(), Error>

Reset a SERD engine.

Source

pub fn transports(&self) -> Result<Vec<TransportId>, Error>

Iterate over transports.

Examples found in repository?
examples/stats.rs (line 23)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(
16        resources.len(),
17        count as usize,
18        "resource count mismatch!"
19    );
20
21    // Transports
22    println!("\n=== Transports ===");
23    let xprts = adm.transports().expect("failed to list transports");
24    if xprts.is_empty() {
25        println!("  (none)");
26    } else {
27        for id in &xprts {
28            println!("  transport {id}");
29        }
30    }
31
32    // SERD engines for each module
33    println!("\n=== SERD Engines ===");
34    let modules = adm.modules().expect("failed to list modules");
35    let mut total = 0;
36    for m in &modules {
37        let engines =
38            adm.serd_engines(&m.name).expect("failed to list serd engines");
39        if !engines.is_empty() {
40            println!("  {} ({} engines):", m.name, engines.len());
41            for e in &engines {
42                println!(
43                    "    {} - count={}, n={}, fired={}",
44                    e.name, e.count, e.n, e.fired,
45                );
46            }
47            total += engines.len();
48        }
49    }
50    if total == 0 {
51        println!("  (none)");
52    }
53
54    // Global stats
55    println!("\n=== Global Stats ===");
56    let stats = adm.stats(None).expect("failed to read stats");
57    for s in &stats {
58        println!("  {}: {} ({})", s.name, s.value, s.description);
59    }
60
61    // Per-module stats for the first module
62    if let Some(m) = modules.first() {
63        println!("\n=== Stats for {} ===", m.name);
64        let mstats =
65            adm.stats(Some(&m.name)).expect("failed to read module stats");
66        for s in &mstats {
67            println!("  {}: {} ({})", s.name, s.value, s.description);
68        }
69    }
70}
Source

pub fn stats(&self, module: Option<&str>) -> Result<Vec<Stat>, Error>

Read statistics, optionally for a specific module.

Examples found in repository?
examples/stats.rs (line 56)
3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(
16        resources.len(),
17        count as usize,
18        "resource count mismatch!"
19    );
20
21    // Transports
22    println!("\n=== Transports ===");
23    let xprts = adm.transports().expect("failed to list transports");
24    if xprts.is_empty() {
25        println!("  (none)");
26    } else {
27        for id in &xprts {
28            println!("  transport {id}");
29        }
30    }
31
32    // SERD engines for each module
33    println!("\n=== SERD Engines ===");
34    let modules = adm.modules().expect("failed to list modules");
35    let mut total = 0;
36    for m in &modules {
37        let engines =
38            adm.serd_engines(&m.name).expect("failed to list serd engines");
39        if !engines.is_empty() {
40            println!("  {} ({} engines):", m.name, engines.len());
41            for e in &engines {
42                println!(
43                    "    {} - count={}, n={}, fired={}",
44                    e.name, e.count, e.n, e.fired,
45                );
46            }
47            total += engines.len();
48        }
49    }
50    if total == 0 {
51        println!("  (none)");
52    }
53
54    // Global stats
55    println!("\n=== Global Stats ===");
56    let stats = adm.stats(None).expect("failed to read stats");
57    for s in &stats {
58        println!("  {}: {} ({})", s.name, s.value, s.description);
59    }
60
61    // Per-module stats for the first module
62    if let Some(m) = modules.first() {
63        println!("\n=== Stats for {} ===", m.name);
64        let mstats =
65            adm.stats(Some(&m.name)).expect("failed to read module stats");
66        for s in &mstats {
67            println!("  {}: {} ({})", s.name, s.value, s.description);
68        }
69    }
70}
Source

pub fn log_rotate(&self, log: &str) -> Result<(), Error>

Rotate a log file.

Trait Implementations§

Source§

impl Drop for FmdAdm

Source§

fn drop(&mut self)

Executes the destructor for this type. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.