Struct Provenance 

#[non_exhaustive]
pub struct Provenance {
    pub tool: String,
    pub tool_version: String,
    pub designation: Option<String>,
    pub source: Option<Source>,
}

Which program wrote a document, and from what.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

tool: String

The program, such as hpr-sim.

tool_version: String

Its version.

designation: Option<String>

The program’s designation in the FusionSpace product system, such as FS · SW · TOOL 005; absent in a document written before hpr-sim 0.1’s first release.

source: Option<Source>

The file the design was read from, if it was read from one.

Implementations

impl Provenance

pub fn hpr(source: Option<Source>) -> Self

This program, at this version, reading source: hpr_core::tool::NAME, hpr_core::tool::VERSION and hpr_core::tool::DESIGNATION.

pub fn rewritten(&self) -> Self

This provenance as a document this program writes again records it: the program fields name this build (Provenance::hpr), and Provenance::source stays exactly as read. A conversion writes a new file, so the program that wrote it is this one; where the design came from doesn’t change.

use hpr_format::{DesignFile, from_json, to_json};

let bytes = include_bytes!("../../../validation/fixtures/ork/loft-demo/demo-stable.ork");
let mut read = DesignFile::from_ork(bytes)?.value;
read.provenance.tool_version = "0.0.1".to_owned();
read.provenance.designation = None;

let rewritten = read.provenance.rewritten();
assert_eq!(rewritten.tool_version, hpr_core::tool::VERSION);
assert_eq!(rewritten.designation.as_deref(), Some(hpr_core::tool::DESIGNATION));
assert_eq!(rewritten.source, read.provenance.source);

Trait Implementations

impl Clone for Provenance

fn clone(&self) -> Provenance

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Provenance

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Provenance

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Provenance

impl JsonSchema for Provenance

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Provenance

fn eq(&self, other: &Provenance) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Provenance

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Provenance