Struct Caveat 

pub struct Caveat<T, K: Kind> { /* 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, K> Caveat<T, K>

where K: Kind,

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

Return the value and any Warnings stored in the Caveat.

Examples found in repository

examples/generate_cdr_from_tariff.rs (line 43)

fn main() {
    const TARIFF_JSON: &str = include_str!(
        "../test_data/v211/real_world/time_and_parking_time_separate_tariff/tariff.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),
        max_energy_battery_kwh: Decimal::from(24),
        max_power_supply_kw: Decimal::from(80),
    };
    let report = cdr::generate_from_tariff(&tariff, config).unwrap();
    let (report, warnings) = report.into_parts();

    print_warnings(&tariff, &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_unknown_version.rs (line 21)

fn main() {
    const CDR_JSON: &str =
        include_str!("../test_data/v211/real_world/time_and_parking_time/cdr.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_source, warnings) = timezone::find_or_infer(&cdr).into_parts();

    let Some(timezone_source) = timezone_source else {
        eprintln!("Unable to infer timezone");
        print_timezone_warnings(&cdr, &warnings);
        return;
    };

    if !warnings.is_empty() {
        print_timezone_warnings(&cdr, &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 =
        cdr::price(&cdr, price::TariffSource::UseCdr, timezone).expect("unable to price CDR JSON");

    // The various fields of the `price::Report` can be examined or converted to JSON.
    let price::Report {
        warnings: _,
        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, K>

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

Trait Implementations

impl<T: Debug, K: Debug + Kind> Debug for Caveat<T, K>

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

Formats the value using the given formatter.

impl<T, K> Deref for Caveat<T, K>

where K: Kind,

A Caveat is simply a value with associated warnings, so providing an impl Deref makes sense for the interface.

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.