Enum horned_owl::model::ClassExpression

pub enum ClassExpression<A> {
    Class(Class<A>),
    ObjectIntersectionOf(Vec<ClassExpression<A>>),
    ObjectUnionOf(Vec<ClassExpression<A>>),
    ObjectComplementOf(Box<ClassExpression<A>>),
    ObjectOneOf(Vec<Individual<A>>),
    ObjectSomeValuesFrom {
        ope: ObjectPropertyExpression<A>,
        bce: Box<ClassExpression<A>>,
    },
    ObjectAllValuesFrom {
        ope: ObjectPropertyExpression<A>,
        bce: Box<ClassExpression<A>>,
    },
    ObjectHasValue {
        ope: ObjectPropertyExpression<A>,
        i: Individual<A>,
    },
    ObjectHasSelf(ObjectPropertyExpression<A>),
    ObjectMinCardinality {
        n: u32,
        ope: ObjectPropertyExpression<A>,
        bce: Box<ClassExpression<A>>,
    },
    ObjectMaxCardinality {
        n: u32,
        ope: ObjectPropertyExpression<A>,
        bce: Box<ClassExpression<A>>,
    },
    ObjectExactCardinality {
        n: u32,
        ope: ObjectPropertyExpression<A>,
        bce: Box<ClassExpression<A>>,
    },
    DataSomeValuesFrom {
        dp: DataProperty<A>,
        dr: DataRange<A>,
    },
    DataAllValuesFrom {
        dp: DataProperty<A>,
        dr: DataRange<A>,
    },
    DataHasValue {
        dp: DataProperty<A>,
        l: Literal<A>,
    },
    DataMinCardinality {
        n: u32,
        dp: DataProperty<A>,
        dr: DataRange<A>,
    },
    DataMaxCardinality {
        n: u32,
        dp: DataProperty<A>,
        dr: DataRange<A>,
    },
    DataExactCardinality {
        n: u32,
        dp: DataProperty<A>,
        dr: DataRange<A>,
    },
}

A class expression

As well as a named class, it is possible to define classes of individuals based on these class constructors.

Variants

Class(Class<A>)

A named class

ObjectIntersectionOf(Vec<ClassExpression<A>>)

The boolean and

The class of individuals which are individuals of all these classes.

ObjectUnionOf(Vec<ClassExpression<A>>)

The boolean or

The class of individuals which are individuals of any of these classes.

ObjectComplementOf(Box<ClassExpression<A>>)

The boolean not

The class of individuals which are not individuals of any of these classes.

ObjectOneOf(Vec<Individual<A>>)

An enumeration of individuals

This is the class containing exactly the given set of individuals.

ObjectSomeValuesFrom

An existential relationship

This is the anonymous class of individuals i, which have the relationship o to a class expression ce. Every individual in i must have this relationship to one individual in ce.

Fields

ope: ObjectPropertyExpression<A>

bce: Box<ClassExpression<A>>

ObjectAllValuesFrom

A universal relationship

This is the anonymous class of individuals i where all individuals which are related by o are instances of ce. This does not imply that the i necessarily has any relation r.

Fields

ope: ObjectPropertyExpression<A>

bce: Box<ClassExpression<A>>

ObjectHasValue

An existential relationship to an individual

This is the class of individuals c which have the relationship o to another individual i. Every individual in c must have this relationship to the individual i

Fields

ope: ObjectPropertyExpression<A>

i: Individual<A>

ObjectHasSelf(ObjectPropertyExpression<A>)

The class of individuals which have a relation to themselves

Given a object property r, this class defines all the individuals where i r i.

ObjectMinCardinality

A min cardinality relationship between individuals

Given an object property o and a class ce, this describes the class of individuals which have the o relationship to at least n other individuals.

Fields

n: u32

ope: ObjectPropertyExpression<A>

bce: Box<ClassExpression<A>>

ObjectMaxCardinality

A max cardinality relationship between individuals

Given an object property o and a class ce, this describes the class of individuals which have the o relationship to at most n other individuals.

Fields

n: u32

ope: ObjectPropertyExpression<A>

bce: Box<ClassExpression<A>>

ObjectExactCardinality

An exact cardinality relationship between individuals

Given an object property o and a class ce, this describes the class of individuals which have the o relationship to exactly n other individuals.

Fields

n: u32

ope: ObjectPropertyExpression<A>

bce: Box<ClassExpression<A>>

DataSomeValuesFrom

An existential relationship.

This is the anonymous class of individuals i which have the relationship dp to the data range, dr. Every individual i must have this relationship to data constrained by dr.

See also: Existential Quantification

Fields

dp: DataProperty<A>

dr: DataRange<A>

DataAllValuesFrom

A universal relationship.

This is the anonymous class of individuals i which if they have a relationship dp to some data, then that must be of type dr.

See also Universal Quantification

Fields

dp: DataProperty<A>

dr: DataRange<A>

DataHasValue

A has-value relationship. This is the class of individuals, i, which have the relationship dp to exactly the literal l. See also Value Restriction

Fields

dp: DataProperty<A>

l: Literal<A>

DataMinCardinality

A minimum cardinality restriction The class of individuals have at least n relationships of the kind dp to a given data range dr. See also Min Cardinality

Fields

n: u32

dp: DataProperty<A>

dr: DataRange<A>

DataMaxCardinality

A max cardinality restriction The class of individuals have at most n relationships of the kind dp to a given data range dr. See also Max Cardinality

Fields

n: u32

dp: DataProperty<A>

dr: DataRange<A>

DataExactCardinality

An exact cardinality restriction The class of individuals have exactly n relationships of the kind dp to a given data range dr. See also Exactly Cardinality

Fields

n: u32

dp: DataProperty<A>

dr: DataRange<A>

Trait Implementations

impl<A: ForIRI> AsFunctional<A> for ClassExpression<A>

fn as_functional(&self) -> Functional<'_, Self, A>

Get a handle for displaying the element in functional syntax.

fn as_functional_with_prefixes<'t>( &'t self, prefix: &'t PrefixMapping ) -> Functional<'t, Self, A>

Get a handle for displaying the element, using the given context.

impl<A: Clone> Clone for ClassExpression<A>

fn clone(&self) -> ClassExpression<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for ClassExpression<A>

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

Formats the value using the given formatter.

impl<'a, A: ForIRI> From<&'a Class<A>> for ClassExpression<A>

fn from(c: &'a Class<A>) -> ClassExpression<A>

Converts to this type from the input type.

impl<A: ForIRI> From<Class<A>> for Box<ClassExpression<A>>

fn from(c: Class<A>) -> Box<ClassExpression<A>>

Converts to this type from the input type.

impl<A: ForIRI> From<Class<A>> for ClassExpression<A>

fn from(c: Class<A>) -> ClassExpression<A>

Converts to this type from the input type.

impl<A: Hash> Hash for ClassExpression<A>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A: Ord> Ord for ClassExpression<A>

fn cmp(&self, other: &ClassExpression<A>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<A: PartialEq> PartialEq for ClassExpression<A>

fn eq(&self, other: &ClassExpression<A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<A: PartialOrd> PartialOrd for ClassExpression<A>

fn partial_cmp(&self, other: &ClassExpression<A>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<A: Eq> Eq for ClassExpression<A>

impl<A> StructuralPartialEq for ClassExpression<A>