Enum Version 

pub enum Version<V, U>
where
    V: Versioned,
    U: Debug,
{
    Certain(V),
    Uncertain(U),
}

The guessed version for the CDR or tariff objects.

Variants

Certain(V)

If the Version of the object is certain, the Versioned object is stored here.

Uncertain(U)

The version can’t be determined with certainty. The object with an uncertain version is stored here.

Implementations

impl<V, U> Version<V, U>

where V: Versioned, U: Unversioned<Versioned = V>,

pub fn into_version(self) -> Version<Version, ()>

Convert Versioned object with it’s Version.

pub fn as_version(&self) -> Version<Version, ()>

Convert Versioned object with it’s Version.

pub fn certain_or(self, fallback: Version) -> V

Convert Versioned object with it’s Version.

Examples found in repository

examples/lint_tariff.rs (line 23)

fn main() {
    const TARIFF_JSON: &str =
        include_str!("../test_data/v221/real_world/misspelled_field/tariff.json");

    let report = tariff::parse_and_report(TARIFF_JSON).unwrap();
    let (tariff, unexpected_fields) = report.into_parts();

    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 = tariff.certain_or(Version::V221);
    let report = tariff::lint(&tariff).unwrap();

    print_lint_warnings(&tariff, &report.into_warning_report());
}

examples/price_cdr_with_unknown_version.rs (line 18)

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 convert it into a version.
    // If the version is uncertain then fallback to presuming the CDR is v221.
    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.into_report());
        return;
    };

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

    // We don't care whether the timezone was found or inferred.
    let timezone = timezone_source.into_timezone();

    let report = cdr::price(
        CDR_JSON,
        price::TariffSource::UseCdr,
        timezone,
        Version::V211,
    )
    .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_index: _,
        tariff_id: _,
        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: _,
        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}");
        }
    }
}

pub fn unwrap_certain(self) -> Option<V>

Discard the object if the version is uncertain.

Trait Implementations

impl<V, U> Debug for Version<V, U>

where V: Versioned + Debug, U: Debug + Debug,

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

Formats the value using the given formatter.