15950552464

Committed 29 Jun 2025 02:20AM UTC coverage: 94.619% (-0.6%) from 95.201%

Build # 15950552464

Build Type

Pull #1472

github

Committed by

web-flow

Commit Message

Merge 253df1f85 into 8cf854cc4

Pull Request Pull Request #1472: Fix Clippy Lints for Rust 1.88

Coverage Stats

39 of 50 new or added lines in 16 files covered. (78.0%)

72 existing lines in 19 files now uncovered.

17760 of 18770 relevant lines covered (94.62%)

1551273.73 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

38.89

/rustworkx-core/src/err.rs

// Licensed under the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.

//! This module contains common error types and trait impls.

use std::error::Error;
use std::fmt::{Debug, Display, Formatter};

#[derive(Debug)]
pub enum ContractError {
    DAGWouldCycle,
}

impl Display for ContractError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            ContractError::DAGWouldCycle => fmt_dag_would_cycle(f),
        }
    }
}

impl Error for ContractError {}

#[derive(Debug)]
pub enum ContractSimpleError<E: Error> {
    DAGWouldCycle,
    MergeError(E),
}

impl<E: Error> Display for ContractSimpleError<E> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            ContractSimpleError::DAGWouldCycle => fmt_dag_would_cycle(f),
            ContractSimpleError::MergeError(ref e) => fmt_merge_error(f, e),
        }
    }
}

impl<E: Error> Error for ContractSimpleError<E> {}

fn fmt_dag_would_cycle(f: &mut Formatter<'_>) -> std::fmt::Result {
    write!(f, "The operation would introduce a cycle.")
}

fn fmt_merge_error<E: Error>(f: &mut Formatter<'_>, inner: &E) -> std::fmt::Result {
    write!(f, "The merge callback failed with: {inner:?}")
}

/// Error returned by Layers function when an index is not part of the graph.
#[derive(Debug, PartialEq, Eq)]
pub struct LayersError(pub String);

impl Error for LayersError {}

impl Display for LayersError {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

1	// Licensed under the Apache License, Version 2.0 (the "License"); you may
2	// not use this file except in compliance with the License. You may obtain
3	// a copy of the License at
4	//
5	// http://www.apache.org/licenses/LICENSE-2.0
6	//
7	// Unless required by applicable law or agreed to in writing, software
8	// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
9	// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
10	// License for the specific language governing permissions and limitations
11	// under the License.
12
13	//! This module contains common error types and trait impls.
14
15	use std::error::Error;
16	use std::fmt::{Debug, Display, Formatter};
17
18	#[derive(Debug)]
19	pub enum ContractError {
20	DAGWouldCycle,
21	}
22
23	impl Display for ContractError {
24	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {	10✔
25	match self {	10✔
26	ContractError::DAGWouldCycle => fmt_dag_would_cycle(f),	10✔
27	}
28	}	10✔
29	}
30
31	impl Error for ContractError {}
32
33	#[derive(Debug)]
34	pub enum ContractSimpleError<E: Error> {
35	DAGWouldCycle,
36	MergeError(E),
37	}
38
39	impl<E: Error> Display for ContractSimpleError<E> {
40	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {	×
41	match self {	×
42	ContractSimpleError::DAGWouldCycle => fmt_dag_would_cycle(f),	×
43	ContractSimpleError::MergeError(ref e) => fmt_merge_error(f, e),	×
44	}
45	}	×
46	}
47
48	impl<E: Error> Error for ContractSimpleError<E> {}
49
50	fn fmt_dag_would_cycle(f: &mut Formatter<'_>) -> std::fmt::Result {	10✔
51	write!(f, "The operation would introduce a cycle.")	10✔
52	}	10✔
53
54	fn fmt_merge_error<E: Error>(f: &mut Formatter<'_>, inner: &E) -> std::fmt::Result {	×
NEW 55	write!(f, "The merge callback failed with: {inner:?}")	×
56	}	×
57
58	/// Error returned by Layers function when an index is not part of the graph.
59	#[derive(Debug, PartialEq, Eq)]
60	pub struct LayersError(pub String);
61
62	impl Error for LayersError {}
63
64	impl Display for LayersError {
65	fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {	×
66	write!(f, "{}", self.0)	×
67	}	×
68	}

Qiskit / rustworkx / 15950552464

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous