Struct Array 

pub struct Array<Identifier = String> {
    pub name: String,
    pub contents: Vec<Literal<Identifier>>,
    pub ann: Vec<Annotation<Identifier>>,
    pub defined: bool,
    pub introduced: bool,
}

A definition of a named array literal in FlatZinc

FlatZinc Arrays are a simple (one-dimensional) sequence of Literals. These values are stored as the Array::contents member. Additional information, in the form of Annotations, from the MiniZinc model is stored in Array::ann when present. When Array::defined is set to true, then

Fields

name: String

The optional public name of the array literal.

This is None for arrays inlined within constraints.

contents: Vec<Literal<Identifier>>

The values stored within the array literal

ann: Vec<Annotation<Identifier>>

List of annotations

defined: bool

This field is set to true when there is a constraint that has been marked as defining this array.

introduced: bool

This field is set to true when the array has been introduced by the MiniZinc compiler, rather than being explicitly defined at the top-level of the MiniZinc model.

Implementations

impl<Identifier> Array<Identifier>

pub fn cloned_key(self: &Arc<Self>) -> ArcKey<Self>

Clones this array reference into an ArcKey.

This is useful when storing arrays in collections such as HashMap, HashSet, and BTreeMap, where the key should identify the specific parsed array object rather than its contents or name.

This method clones the Arc reference count and keeps the original array reference usable by the caller.

The resulting key uses the allocation / pointer identity of this Arc. Two arrays with the same name and equal contents will therefore compare as different keys if they are stored in different allocations.

During FlatZinc parsing and deserialization, this crate guarantees that identical top-level arrays are allocated only once. In those cases, ArcKey is a good fit for keying collections by the canonical parsed array object.

Trait Implementations

impl<Identifier: Clone> Clone for Array<Identifier>

fn clone(&self) -> Array<Identifier>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Identifier: Debug> Debug for Array<Identifier>

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

Formats the value using the given formatter.

impl<Identifier: PartialEq> PartialEq for Array<Identifier>

fn eq(&self, other: &Array<Identifier>) -> 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<Identifier> Serialize for Array<Identifier>

where Identifier: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Identifier> StructuralPartialEq for Array<Identifier>