Struct ValidTimeSupport 

pub struct ValidTimeSupport<T: Ord + Clone> { /* private fields */ }

Deterministic canonical valid-time support for one fact.

ValidTimeSupport<T> stores half-open intervals in canonical lexicographic order. Overlapping or directly adjacent intervals are coalesced, so user-visible support never contains redundant fragments. Support can then be queried for overlap with one interval or restricted to one interval window without losing deterministic canonical order.

This is the interval support attached to one stored fact. It is distinct from the exact support of a relation, which forgets time and keeps only which facts are present.

Examples

use relmath::temporal::{Interval, ValidTimeSupport};

let support = ValidTimeSupport::from_intervals([
    Interval::new(3, 5).expect("expected valid interval"),
    Interval::new(1, 3).expect("expected valid interval"),
    Interval::new(6, 7).expect("expected valid interval"),
    Interval::new(4, 6).expect("expected valid interval"),
]);

assert_eq!(
    support.to_vec(),
    vec![Interval::new(1, 7).expect("expected valid interval")]
);
assert!(support.contains(&4));
assert!(!support.contains(&7));

Implementations

impl<T: Ord + Clone> ValidTimeSupport<T>

pub fn new() -> Self

Creates empty valid-time support.

A ValidTimeRelation does not store empty support for a fact, so absent facts return None rather than an empty support value. This constructor is still useful for standalone inspection and testing.

Examples

use relmath::temporal::ValidTimeSupport;

let empty = ValidTimeSupport::<i32>::new();

assert!(empty.is_empty());
assert_eq!(empty.len(), 0);

pub fn from_intervals<I>(intervals: I) -> Self

where I: IntoIterator<Item = Interval<T>>,

Creates canonical valid-time support from intervals.

The resulting support is sorted and coalesced deterministically.

Examples

use relmath::temporal::{Interval, ValidTimeSupport};

let support = ValidTimeSupport::from_intervals([
    Interval::new(2, 4).expect("expected valid interval"),
    Interval::new(1, 2).expect("expected valid interval"),
]);

assert_eq!(
    support.to_vec(),
    vec![Interval::new(1, 4).expect("expected valid interval")]
);

pub fn len(&self) -> usize

Returns the number of canonical support intervals.

For one stored fact, this counts canonical support fragments rather than time points or inserted raw intervals.

pub fn is_empty(&self) -> bool

Returns true when the support contains no intervals.

pub fn contains(&self, point: &T) -> bool

Returns true when point is covered by some support interval.

Examples

use relmath::temporal::{Interval, ValidTimeSupport};

let support =
    ValidTimeSupport::from_intervals([Interval::new(2, 4).expect("expected valid interval")]);

assert!(support.contains(&2));
assert!(support.contains(&3));
assert!(!support.contains(&4));

pub fn overlaps(&self, constraint: &Interval<T>) -> bool

Returns true when some support interval overlaps constraint.

Direct boundary-only contact does not count as overlap under half-open semantics.

Examples

use relmath::temporal::{Interval, ValidTimeSupport};

let support = ValidTimeSupport::from_intervals([
    Interval::new(1, 3).expect("expected valid interval"),
    Interval::new(5, 7).expect("expected valid interval"),
]);

assert!(support.overlaps(&Interval::new(2, 6).expect("expected valid interval")));
assert!(!support.overlaps(&Interval::new(3, 5).expect("expected valid interval")));

pub fn restrict_to(&self, constraint: &Interval<T>) -> Self

Restricts this support to the overlap with constraint.

The returned support remains canonical: overlapping or directly adjacent fragments are coalesced deterministically. When no interval overlaps the constraint, this returns empty support.

Examples

use relmath::temporal::{Interval, ValidTimeSupport};

let support = ValidTimeSupport::from_intervals([
    Interval::new(1, 3).expect("expected valid interval"),
    Interval::new(5, 7).expect("expected valid interval"),
]);

assert_eq!(
    support
        .restrict_to(&Interval::new(2, 6).expect("expected valid interval"))
        .to_vec(),
    vec![
        Interval::new(2, 3).expect("expected valid interval"),
        Interval::new(5, 6).expect("expected valid interval"),
    ]
);
assert!(
    support
        .restrict_to(&Interval::new(3, 5).expect("expected valid interval"))
        .is_empty()
);

pub fn iter(&self) -> impl Iterator<Item = &Interval<T>>

Returns an iterator over canonical support intervals.

Examples

use relmath::temporal::{Interval, ValidTimeSupport};

let support = ValidTimeSupport::from_intervals([
    Interval::new(4, 6).expect("expected valid interval"),
    Interval::new(1, 3).expect("expected valid interval"),
]);

assert_eq!(
    support.iter().cloned().collect::<Vec<_>>(),
    vec![
        Interval::new(1, 3).expect("expected valid interval"),
        Interval::new(4, 6).expect("expected valid interval"),
    ]
);

pub fn to_vec(&self) -> Vec<Interval<T>>

Returns the canonical interval list as a vector.

Examples found in repository

examples/capability_boundaries.rs (line 68)

fn main() {
    let evidence = ProvenanceRelation::from_facts([
        (("alice", "review"), "directory"),
        (("bob", "approve"), "policy"),
    ]);
    let permissions = AnnotatedRelation::from_facts([
        (("alice", "review"), BooleanSemiring::TRUE),
        (("bob", "approve"), BooleanSemiring::TRUE),
    ]);
    let schedule = ValidTimeRelation::from_facts([
        (
            ("alice", "review"),
            Interval::new(1, 3).expect("expected valid interval"),
        ),
        (
            ("bob", "approve"),
            Interval::new(2, 4).expect("expected valid interval"),
        ),
    ]);

    let exact_evidence = exact_pairs(&evidence);
    let exact_permissions = exact_pairs(&permissions);
    let exact_schedule = exact_pairs(&schedule);

    assert_eq!(
        exact_evidence.to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(exact_permissions.to_vec(), exact_evidence.to_vec());
    assert_eq!(exact_schedule.to_vec(), exact_evidence.to_vec());

    assert_eq!(
        evidence
            .why(&("alice", "review"))
            .expect("expected witness")
            .to_vec(),
        vec!["directory"]
    );
    assert_eq!(
        permissions.annotation_of(&("alice", "review")),
        Some(&BooleanSemiring::TRUE)
    );
    assert_eq!(
        schedule
            .valid_time_of(&("alice", "review"))
            .expect("expected interval support")
            .to_vec(),
        vec![Interval::new(1, 3).expect("expected valid interval")]
    );

    println!(
        "witness={:?}, annotation={:?}, interval_support={:?}, exact_support={:?}",
        evidence
            .why(&("alice", "review"))
            .expect("expected witness")
            .to_vec(),
        permissions.annotation_of(&("alice", "review")),
        schedule
            .valid_time_of(&("alice", "review"))
            .expect("expected interval support")
            .to_vec(),
        exact_schedule.to_vec()
    );
}

examples/valid_time.rs (line 35)

fn main() {
    let assignments = ValidTimeRelation::from_facts([
        (
            ("alice", "review"),
            Interval::new(1, 3).expect("expected valid interval"),
        ),
        (
            ("alice", "review"),
            Interval::new(3, 5).expect("expected valid interval"),
        ),
        (
            ("bob", "approve"),
            Interval::new(2, 4).expect("expected valid interval"),
        ),
    ]);

    let alice = UnaryRelation::singleton("alice");
    let fact_support = assignments.support();
    let exact_support = assignments.to_binary_relation();
    let audit_window = Interval::new(2, 4).expect("expected valid interval");
    let active_at_three = assignments.snapshot_at(&3);
    let audit_assignments = assignments.restrict_to(&audit_window);

    assert_eq!(
        assignments
            .valid_time_of(&("alice", "review"))
            .expect("expected support")
            .to_vec(),
        vec![Interval::new(1, 5).expect("expected valid interval")]
    );
    assert!(assignments.is_active_at(&("alice", "review"), &4));
    assert!(!assignments.is_active_at(&("alice", "review"), &5));
    assert_eq!(
        active_at_three.to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(
        fact_support.to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(
        audit_assignments
            .valid_time_of(&("alice", "review"))
            .expect("expected support")
            .to_vec(),
        vec![Interval::new(2, 4).expect("expected valid interval")]
    );
    assert_eq!(
        audit_assignments.to_binary_relation().to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(exact_support.image(&alice).to_vec(), vec!["review"]);

    println!(
        "fact support: {:?}; active at t=3: {:?}; audit restriction: {:?}",
        fact_support.to_vec(),
        active_at_three.to_vec(),
        audit_assignments
            .valid_time_of(&("alice", "review"))
            .expect("expected support")
            .to_vec()
    );
}

Trait Implementations

impl<T: Clone + Ord + Clone> Clone for ValidTimeSupport<T>

fn clone(&self) -> ValidTimeSupport<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Ord + Clone> Debug for ValidTimeSupport<T>

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

Formats the value using the given formatter.

impl<T: Ord + Clone> Default for ValidTimeSupport<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Ord + Clone> Extend<Interval<T>> for ValidTimeSupport<T>

fn extend<I: IntoIterator<Item = Interval<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: Ord + Clone> FromIterator<Interval<T>> for ValidTimeSupport<T>

fn from_iter<I: IntoIterator<Item = Interval<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: PartialEq + Ord + Clone> PartialEq for ValidTimeSupport<T>

fn eq(&self, other: &ValidTimeSupport<T>) -> 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<T: Eq + Ord + Clone> Eq for ValidTimeSupport<T>

impl<T: Ord + Clone> StructuralPartialEq for ValidTimeSupport<T>