Struct Caveat 

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

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

impl<T, W> Caveat<T, W>

where W: Warning,

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

Return the value and any Warnings stored in the Caveat.

Examples found in repository

examples/generate_cdr_from_tariff.rs (line 49)

fn main() {
    const TARIFF_JSON: &str = include_str!("data/tariff_time_and_parking_time_separate.json");

    let report = tariff::parse_and_report(TARIFF_JSON).unwrap();
    let guess::Report {
        unexpected_fields,
        version,
    } = report;

    if !unexpected_fields.is_empty() {
        eprintln!("Strange... there are fields in the tariff that are not defined in the spec.");

        for path in &unexpected_fields {
            eprintln!("  * {path}");
        }

        eprintln!();
    }

    let tariff = version.certain_or(Version::V221);

    let config = generate::Config {
        timezone: chrono_tz::Europe::Amsterdam,
        start_date_time: DateTime::<Utc>::from_str("2025-06-12 18:22:33+00:00").unwrap(),
        end_date_time: DateTime::<Utc>::from_str("2025-06-12 22:33:44+00:00").unwrap(),
        max_current_supply_amp: Decimal::from(4),
        requested_kwh: Decimal::from(24),
        max_power_supply_kw: Decimal::from(80),
    };
    let report = match cdr::generate_from_tariff(&tariff, &config) {
        Ok(r) => r,
        Err(set) => {
            let (error, warnings) = set.into_parts();
            print_error(&error);
            print_warnings(&warnings);
            return;
        }
    };
    let (report, warnings) = report.into_parts();

    print_warnings(&warnings);

    let generate::Report {
        tariff_id,
        tariff_currency_code,
        partial_cdr,
    } = report;

    println!("CDR genereated for tariff with id: `{tariff_id}` and currency code: `{tariff_currency_code}`");
    println!("{partial_cdr:#?}");
}

examples/price_cdr_with_known_version.rs (line 36)

fn main() {
    const CDR_JSON: &str = include_str!("data/cdr_time_and_parking_time.json");

    // If you know the version and timezone of a CDR you simply pass them into the `cdr::parse_with_version` fn.
    let report = cdr::parse_with_version(CDR_JSON, Version::V211).expect("unable to parse CDR");
    let cdr::ParseReport {
        cdr,
        unexpected_fields,
    } = report;

    if !unexpected_fields.is_empty() {
        eprintln!("Strange... there are fields in the CDR that are not defined in the spec.");

        for path in &unexpected_fields {
            eprintln!("{path}");
        }
    }

    let report = match cdr::price(&cdr, price::TariffSource::UseCdr, Tz::Europe__Amsterdam) {
        Ok(r) => r,
        Err(set) => {
            let (error, warnings) = set.into_parts();
            print_pricing_error(&error);
            print_pricing_warnings(&warnings);
            return;
        }
    };

    let (report, warnings) = report.into_parts();
    print_pricing_warnings(&warnings);

    // The various fields of the `price::Report` can be examined or converted to JSON.
    let price::Report {
        periods: _,
        tariff_used: _,
        tariff_reports: _,
        timezone: _,
        billed_energy: _,
        billed_parking_time: _,
        total_charging_time: _,
        billed_charging_time: _,
        total_cost: _,
        total_fixed_cost: _,
        total_time: _,
        total_time_cost: _,
        total_energy: _,
        total_energy_cost: _,
        total_parking_time: _,
        total_parking_cost: _,
        total_reservation_cost: _,
    } = report;
}

examples/price_cdr_with_unknown_version.rs (line 30)

fn main() {
    const CDR_JSON: &str = include_str!("data/cdr_time_and_parking_time.json");

    // First the raw JSON should be parsed into a `cdr::Versioned` object.
    // The `cdr::Report` returned from calling `cdr::parse` contains a `cdr::Versioned` object
    // and a potential list of unexpected fields based on the OCPI v221 spec.
    let cdr = cdr::parse(CDR_JSON).expect("Unable to parse CDR JSON");

    // The guessed Version can be either certain or uncertain.
    // In this case we discard the CDR object and try to convert it into a version.
    // If the version is uncertain then fallback to presuming the CDR is v211.
    let cdr = cdr.certain_or(Version::V211);

    // The timezone can be inferred or found in the CDR, but a versioned CDR is required.
    let timezone = match timezone::find_or_infer(&cdr) {
        Ok(tz) => tz,
        Err(err_set) => {
            let (error, warnings) = err_set.into_parts();
            eprintln!("Unable to infer timezone");
            print_timezone_error(&error);
            print_timezone_warnings(&warnings);
            return;
        }
    };
    let (timezone_source, warnings) = timezone.into_parts();

    if !warnings.is_empty() {
        print_timezone_warnings(&warnings);
    }

    // We don't care whether the timezone was found or inferred.
    let timezone = timezone_source.into_timezone();
    let report = cdr::parse_with_version(CDR_JSON, Version::V211).expect("Unable to parse CDR");
    let cdr::ParseReport {
        cdr,
        unexpected_fields,
    } = report;

    if !unexpected_fields.is_empty() {
        eprintln!("Strange... there are fields in the CDR that are not defined in the spec.");

        for path in &unexpected_fields {
            eprintln!("{path}");
        }
    }

    let report = match cdr::price(&cdr, price::TariffSource::UseCdr, timezone) {
        Ok(r) => r,
        Err(set) => {
            let (error, warnings) = set.into_parts();
            print_pricing_error(&error);
            print_pricing_warnings(&warnings);
            return;
        }
    };

    let (report, warnings) = report.into_parts();

    print_pricing_warnings(&warnings);

    // The various fields of the `price::Report` can be examined or converted to JSON.
    let price::Report {
        periods: _,
        tariff_used: _,
        tariff_reports: _,
        timezone: _,
        billed_energy: _,
        billed_parking_time: _,
        total_charging_time: _,
        billed_charging_time: _,
        total_cost: _,
        total_fixed_cost: _,
        total_time: _,
        total_time_cost: _,
        total_energy: _,
        total_energy_cost: _,
        total_parking_time: _,
        total_parking_cost: _,
        total_reservation_cost: _,
    } = report;
}

pub fn ignore_warnings(self) -> T

Return the value and drop any warnings contained within.

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

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

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

Formats the value using the given formatter.

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:

1. a value of the type transparently behaves like a value of the target type;
2. the implementation of the deref function is cheap; and
3. 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

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.