Enum AssertionPattern 

pub enum AssertionPattern {
    Isa {
        binding: BindingId,
        include_subtypes: bool,
        type_id: TypeId,
    },
    Has {
        attribute: BindingId,
        attribute_id: AttributeId,
        owner: BindingId,
    },
    Links {
        players: Vec<AssertionRolePlayer>,
        relation: BindingId,
        relation_id: TypeId,
    },
    Value {
        comparator: ValueComparator,
        left: ValueOperand,
        right: ValueOperand,
    },
    Not {
        patterns: Vec<AssertionPattern>,
    },
}

Minimal closed typed pattern algebra used by migration assertions.

Variants

Isa

Constrain a binding to one schema type, optionally including subtypes.

Fields

binding: BindingId

The binding the type constraint applies to.

include_subtypes: bool

Whether subtypes of the named type also satisfy the constraint.

type_id: TypeId

The schema type the binding must instantiate.

Has

Bind an owned attribute through an effective ownership.

Fields

attribute: BindingId

The binding that receives the owned attribute instance.

attribute_id: AttributeId

The schema attribute type being read.

owner: BindingId

The binding that owns the attribute.

Links

Bind a relation and role-qualified players.

Fields

players: Vec<AssertionRolePlayer>

The role-qualified players the relation must link.

relation: BindingId

The binding that receives the relation instance.

relation_id: TypeId

The schema relation type being matched.

Value

Compare two exact typed scalar operands.

Fields

comparator: ValueComparator

The comparison operator.

left: ValueOperand

The left operand.

right: ValueOperand

The right operand.

Not

Negate a closed nested conjunction.

Fields

patterns: Vec<AssertionPattern>

The conjunction that must not match.

Trait Implementations

impl Clone for AssertionPattern

fn clone(&self) -> AssertionPattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AssertionPattern

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

Formats the value using the given formatter.

impl Eq for AssertionPattern

impl PartialEq for AssertionPattern

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for AssertionPattern

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 AssertionPattern