Struct Caveat

Source

pub struct Caveat<T, W: Warning> { /* private fields */ }

Expand description

A value that may have associated Warnings.

Even though the value has been created there may be certain caveats you should be aware of before using it.

Implementations§

Source §

impl<T, W> Caveat<T, W>
where W: Warning,

Source

pub fn warnings(&self) -> &Set<W>

Return a ref to the warning Set.

Source

pub fn into_parts(self) -> (T, Set<W>)

Return the value and any Warnings stored in the Caveat.

Examples found in repository ?

examples/lint_tariff.rs (line 12)

6fn main() {
7    const TARIFF_JSON: &str = include_str!("data/tariff_misspelled_field.json");
8
9    // Parse the raw JSON and validate it against the `v2.2.1` tariff schema. Any unexpected,
10    // misspelled, missing, or wrongly typed fields are reported as schema warnings.
11    let doc = json::parse_object(TARIFF_JSON).unwrap();
12    let (tariff, warnings) = tariff::build(doc, Version::V221).into_parts();
13
14    print_schema_warnings(&warnings);
15
16    let report = tariff::lint(&tariff);
17
18    print_lint_warnings(&report.warnings);
19}

More examples

Hide additional examples

examples/price_cdr_with_known_version.rs (line 13)

7fn main() {
8    const CDR_JSON: &str = include_str!("data/cdr_time_and_parking_time.json");
9
10    // If you know the version of a CDR you can parse it into a `json::Document` and validate it
11    // against the schema for that version.
12    let doc = json::parse_object(CDR_JSON).expect("unable to parse CDR");
13    let (cdr, warnings) = cdr::build(doc, Version::V211).into_parts();
14
15    if !warnings.is_empty() {
16        eprintln!("The CDR has `{}` schema warnings.", warnings.len_warnings());
17    }
18
19    let report = match cdr::price(&cdr, price::TariffSource::UseCdr, Tz::Europe__Amsterdam) {
20        Ok(r) => r,
21        Err(set) => {
22            let (error, warnings) = set.into_parts();
23            print_pricing_error(&error);
24            print_pricing_warnings(&warnings);
25            return;
26        }
27    };
28
29    let (report, warnings) = report.into_parts();
30    print_pricing_warnings(&warnings);
31
32    // The various fields of the `price::Report` can be examined or converted to JSON.
33    let price::Report {
34        periods: _,
35        tariff_used: _,
36        tariff_reports: _,
37        timezone: _,
38        billed_energy: _,
39        billed_idle_time: _,
40        total_charging_time: _,
41        billed_charging_time: _,
42        total_cost: _,
43        total_fixed_cost: _,
44        total_time: _,
45        total_charging_time_cost: _,
46        total_energy: _,
47        total_energy_cost: _,
48        total_idle_time: _,
49        total_idle_cost: _,
50    } = report;
51}

examples/generate_cdr_from_tariff.rs (line 37)

11fn main() {
12    const TARIFF_JSON: &str = include_str!("data/tariff_time_and_parking_time_separate.json");
13
14    // Parse the raw JSON into a `json::Document` and guess the OCPI version of the tariff, falling
15    // back to `v2.2.1` when the version is uncertain.
16    let doc = json::parse_object(TARIFF_JSON).unwrap();
17    let tariff = tariff::infer_version(doc).certain_or(Version::V221);
18    let tariff = tariff::build_versioned(tariff).ignore_warnings();
19
20    let config = generate::Config {
21        timezone: chrono_tz::Europe::Amsterdam,
22        start_date_time: DateTime::<Utc>::from_str("2025-06-12 18:22:33+00:00").unwrap(),
23        end_date_time: DateTime::<Utc>::from_str("2025-06-12 22:33:44+00:00").unwrap(),
24        max_current_supply_amp: Decimal::from(4),
25        requested_kwh: Decimal::from(24),
26        max_power_supply_kw: Decimal::from(80),
27    };
28    let report = match cdr::generate_from_tariff(&tariff, &config) {
29        Ok(r) => r,
30        Err(set) => {
31            let (error, warnings) = set.into_parts();
32            print_error(&error);
33            print_warnings(&warnings);
34            return;
35        }
36    };
37    let (report, warnings) = report.into_parts();
38
39    print_warnings(&warnings);
40
41    let generate::Report {
42        tariff_id,
43        tariff_currency_code,
44        partial_cdr,
45    } = report;
46
47    println!("CDR generated for tariff with id: `{tariff_id}` and currency code: `{tariff_currency_code}`");
48    println!("{partial_cdr:#?}");
49}

examples/price_cdr_with_unknown_version.rs (line 31)

6fn main() {
7    const CDR_JSON: &str = include_str!("data/cdr_time_and_parking_time.json");
8
9    // First the raw JSON is parsed into a `json::Document` and the OCPI version of the CDR is
10    // guessed. The `guess::CdrVersion` returned from calling `cdr::infer_version` is either certain
11    // or uncertain about the version of the contained `cdr::Versioned` object.
12    let cdr = json::parse_object(CDR_JSON).expect("Unable to parse CDR JSON");
13    let cdr = cdr::infer_version(cdr);
14
15    // The guessed Version can be either certain or uncertain.
16    // If the version is uncertain then fallback to presuming the CDR is v211.
17    let cdr = cdr.certain_or(Version::V211);
18    let cdr = cdr::build_versioned(cdr).ignore_warnings();
19
20    // The timezone can be inferred or found in the CDR, but a versioned CDR is required.
21    let timezone = match timezone::find_or_infer(&cdr) {
22        Ok(tz) => tz,
23        Err(err_set) => {
24            let (error, warnings) = err_set.into_parts();
25            eprintln!("Unable to infer timezone");
26            print_timezone_error(&error);
27            print_timezone_warnings(&warnings);
28            return;
29        }
30    };
31    let (timezone_source, warnings) = timezone.into_parts();
32
33    if !warnings.is_empty() {
34        print_timezone_warnings(&warnings);
35    }
36
37    // We don't care whether the timezone was found or inferred.
38    let timezone = timezone_source.into_timezone();
39
40    let report = match cdr::price(&cdr, price::TariffSource::UseCdr, timezone) {
41        Ok(r) => r,
42        Err(set) => {
43            let (error, warnings) = set.into_parts();
44            print_pricing_error(&error);
45            print_pricing_warnings(&warnings);
46            return;
47        }
48    };
49
50    let (report, warnings) = report.into_parts();
51
52    print_pricing_warnings(&warnings);
53
54    // The various fields of the `price::Report` can be examined or converted to JSON.
55    let price::Report {
56        periods: _,
57        tariff_used: _,
58        tariff_reports: _,
59        timezone: _,
60        billed_energy: _,
61        billed_idle_time: _,
62        total_charging_time: _,
63        billed_charging_time: _,
64        total_cost: _,
65        total_fixed_cost: _,
66        total_time: _,
67        total_charging_time_cost: _,
68        total_energy: _,
69        total_energy_cost: _,
70        total_idle_time: _,
71        total_idle_cost: _,
72    } = report;
73}

Source

pub fn ignore_warnings(self) -> T

Return the value and drop any warnings contained within.

Examples found in repository ?

examples/generate_cdr_from_tariff.rs (line 18)

11fn main() {
12    const TARIFF_JSON: &str = include_str!("data/tariff_time_and_parking_time_separate.json");
13
14    // Parse the raw JSON into a `json::Document` and guess the OCPI version of the tariff, falling
15    // back to `v2.2.1` when the version is uncertain.
16    let doc = json::parse_object(TARIFF_JSON).unwrap();
17    let tariff = tariff::infer_version(doc).certain_or(Version::V221);
18    let tariff = tariff::build_versioned(tariff).ignore_warnings();
19
20    let config = generate::Config {
21        timezone: chrono_tz::Europe::Amsterdam,
22        start_date_time: DateTime::<Utc>::from_str("2025-06-12 18:22:33+00:00").unwrap(),
23        end_date_time: DateTime::<Utc>::from_str("2025-06-12 22:33:44+00:00").unwrap(),
24        max_current_supply_amp: Decimal::from(4),
25        requested_kwh: Decimal::from(24),
26        max_power_supply_kw: Decimal::from(80),
27    };
28    let report = match cdr::generate_from_tariff(&tariff, &config) {
29        Ok(r) => r,
30        Err(set) => {
31            let (error, warnings) = set.into_parts();
32            print_error(&error);
33            print_warnings(&warnings);
34            return;
35        }
36    };
37    let (report, warnings) = report.into_parts();
38
39    print_warnings(&warnings);
40
41    let generate::Report {
42        tariff_id,
43        tariff_currency_code,
44        partial_cdr,
45    } = report;
46
47    println!("CDR generated for tariff with id: `{tariff_id}` and currency code: `{tariff_currency_code}`");
48    println!("{partial_cdr:#?}");
49}

More examples

Hide additional examples

examples/price_cdr_with_unknown_version.rs (line 18)

6fn main() {
7    const CDR_JSON: &str = include_str!("data/cdr_time_and_parking_time.json");
8
9    // First the raw JSON is parsed into a `json::Document` and the OCPI version of the CDR is
10    // guessed. The `guess::CdrVersion` returned from calling `cdr::infer_version` is either certain
11    // or uncertain about the version of the contained `cdr::Versioned` object.
12    let cdr = json::parse_object(CDR_JSON).expect("Unable to parse CDR JSON");
13    let cdr = cdr::infer_version(cdr);
14
15    // The guessed Version can be either certain or uncertain.
16    // If the version is uncertain then fallback to presuming the CDR is v211.
17    let cdr = cdr.certain_or(Version::V211);
18    let cdr = cdr::build_versioned(cdr).ignore_warnings();
19
20    // The timezone can be inferred or found in the CDR, but a versioned CDR is required.
21    let timezone = match timezone::find_or_infer(&cdr) {
22        Ok(tz) => tz,
23        Err(err_set) => {
24            let (error, warnings) = err_set.into_parts();
25            eprintln!("Unable to infer timezone");
26            print_timezone_error(&error);
27            print_timezone_warnings(&warnings);
28            return;
29        }
30    };
31    let (timezone_source, warnings) = timezone.into_parts();
32
33    if !warnings.is_empty() {
34        print_timezone_warnings(&warnings);
35    }
36
37    // We don't care whether the timezone was found or inferred.
38    let timezone = timezone_source.into_timezone();
39
40    let report = match cdr::price(&cdr, price::TariffSource::UseCdr, timezone) {
41        Ok(r) => r,
42        Err(set) => {
43            let (error, warnings) = set.into_parts();
44            print_pricing_error(&error);
45            print_pricing_warnings(&warnings);
46            return;
47        }
48    };
49
50    let (report, warnings) = report.into_parts();
51
52    print_pricing_warnings(&warnings);
53
54    // The various fields of the `price::Report` can be examined or converted to JSON.
55    let price::Report {
56        periods: _,
57        tariff_used: _,
58        tariff_reports: _,
59        timezone: _,
60        billed_energy: _,
61        billed_idle_time: _,
62        total_charging_time: _,
63        billed_charging_time: _,
64        total_cost: _,
65        total_fixed_cost: _,
66        total_time: _,
67        total_charging_time_cost: _,
68        total_energy: _,
69        total_energy_cost: _,
70        total_idle_time: _,
71        total_idle_cost: _,
72    } = report;
73}

Source

pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Caveat<U, W>

Map the value to another target type while retaining the warnings about the source type.

Trait Implementations§

Source §

impl<T: Debug, W: Debug + Warning> Debug for Caveat<T, W>

Source §

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

Formats the value using the given formatter. Read more

Source §

impl<T, W> Deref for Caveat<T, W>
where W: Warning,

A Caveat is simply a value with associated warnings. Providing an impl Deref makes sense for given that it’s an annotated value.

The same advice applies to both deref traits. In general, deref traits should be implemented if:

a value of the type transparently behaves like a value of the target type;

the implementation of the deref function is cheap; and

users of the type will not be surprised by any deref coercion behavior.

See: https://doc.rust-lang.org/std/ops/trait.Deref.html#when-to-implement-deref-or-derefmut.

Source §