Struct Selection 

pub struct Selection<'a> { /* private fields */ }

Implementations

impl<'a> Selection<'a>

pub fn input(&self) -> &'a Input

pub fn items(&self) -> &[SelectedItem<'a>]

Examples found in repository

examples/grow-wedding.rs (line 90)

fn grow(bytes: Vec<u8>, factor: usize) -> Result<Vec<u8>> {
    if !(1..=MAX_FACTOR).contains(&factor) {
        return Err(format!("FACTOR must be in 1..={MAX_FACTOR}"));
    }
    if bytes.len() > MAX_INPUT {
        return Err("input exceeds 1 MiB".into());
    }
    let input = Input::parse_named(bytes, FileMode::Data, "wedding.dzn")
        .map_err(|error| format!("invalid data: {error:?}"))?;
    if input
        .syntax()
        .tokens()
        .len()
        .checked_mul(factor)
        .is_none_or(|n| n > MAX_TOKENS)
    {
        return Err("grown input exceeds the 200,000-token allowance".into());
    }
    // This example understands these eight assignments, not arbitrary dependencies.
    let QueryResult::Selection(items) = Query::parse("items", Limits::default())
        .map_err(|error| error.message)?
        .evaluate(&input, Limits::default())
        .map_err(|error| error.message)?
    else {
        unreachable!()
    };
    let mut names = BTreeSet::new();
    for item in items.items() {
        if item.kind != ItemKind::Assignment
            || !item
                .name
                .is_some_and(|name| ASSIGNMENTS.contains(&name) && names.insert(name))
        {
            return Err("expected only the eight distinct wedding data assignments".into());
        }
    }
    if names.len() != ASSIGNMENTS.len() {
        return Err("all eight wedding data assignments are required".into());
    }
    // Refuse formatter directives: copying their text could change directive scopes.
    for (index, token) in input.syntax().tokens().iter().enumerate() {
        if matches!(token.kind, TokenKind::LineComment | TokenKind::BlockComment)
            && input
                .token_bytes(index)
                .windows(b"zincite-fmt:".len())
                .any(|w| w == b"zincite-fmt:")
        {
            return Err("comments containing zincite directives are unsupported".into());
        }
    }
    let topics = literal(&input, "Topics")?;
    let guests = literal(&input, "Guests")?;
    let records = literal(&input, "guests")?;
    let same = literal(&input, "same_table")?;
    let different = literal(&input, "different_tables")?;
    let capacities = literal(&input, "table_capacities")?;
    let imbalance = literal(&input, "max_gender_imbalance_per_table")?;
    let topic_members = members(&topics)?;
    let guest_members = members(&guests)?;
    if topic_members.is_empty() || guest_members.is_empty() {
        return Err("Topics and Guests must be nonempty literal member sets".into());
    }
    let topic_names: BTreeSet<_> = topic_members.iter().map(|(name, _)| *name).collect();
    let guest_names: BTreeSet<_> = guest_members.iter().map(|(name, _)| *name).collect();
    if !topic_names.is_disjoint(&guest_names)
        || topic_names
            .iter()
            .chain(guest_names.iter())
            .any(|name| ASSIGNMENTS.contains(name) || ["Man", "Woman", "NA", "T"].contains(name))
    {
        return Err("enum members collide with the wedding model's identifiers".into());
    }
    validate_records(&records, &guest_names, topic_members.len())?;
    let same_members = group_members(&same, &guest_names)?;
    let different_members = group_members(&different, &guest_names)?;
    let table_item = items
        .items()
        .iter()
        .find(|item| item.name == Some("Tables"))
        .unwrap();
    let (table_count, table_range) = table_constructor(&input, &table_item.range)?;
    let capacity_values = positional(&capacities)?;
    if capacity_values.len() != table_count
        || capacity_values
            .iter()
            .any(|value| !matches!(value.kind, LiteralKind::Integer))
        || !matches!(imbalance.kind, LiteralKind::Integer)
    {
        return Err("table_capacities must contain one literal integer per table; imbalance must be a literal integer".into());
    }
    let grown_tables = table_count
        .checked_mul(factor)
        .filter(|count| i64::try_from(*count).is_ok())
        .ok_or("table count overflow")?;
    if factor == 1 {
        return Ok(input.source_bytes().to_vec());
    }
    let mut occupied: BTreeSet<String> = input
        .syntax()
        .tokens()
        .iter()
        .enumerate()
        .filter(|(_, token)| {
            matches!(
                token.kind,
                TokenKind::Identifier | TokenKind::QuotedIdentifier
            )
        })
        .map(|(index, _)| {
            String::from_utf8_lossy(input.token_bytes(index))
                .trim_matches('\'')
                .to_owned()
        })
        .collect();
    let mut mappings = Vec::new();
    for copy in 1..factor {
        let mut mapping = BTreeMap::new();
        for (index, (name, _)) in guest_members.iter().enumerate() {
            let generated = format!("GrownGuest_{copy}_{}", index + 1);
            if !occupied.insert(generated.clone()) {
                return Err(format!("generated guest identifier collides: {generated}"));
            }
            mapping.insert(*name, generated);
        }
        mappings.push(mapping);
    }
    let LiteralKind::Array { entries, .. } = &records.kind else {
        unreachable!()
    };
    let record_keys: Vec<_> = entries
        .iter()
        .map(|entry| {
            let key = entry.key.as_ref().unwrap();
            let LiteralKind::Member(name) = key.kind else {
                unreachable!()
            };
            (name, key.range.clone())
        })
        .collect();
    let mut edits = Vec::new();
    for (value, replacements) in [
        (&guests, guest_members),
        (&records, record_keys),
        (&same, same_members),
        (&different, different_members),
        (&capacities, Vec::new()),
    ] {
        edits.push(copy_collection(&input, value, &replacements, &mappings)?);
    }
    edits.push(TextEdit {
        range: table_range,
        replacement: vec![EditPart::Text(grown_tables.to_string())],
    });
    // Charge the exact final byte count before the public edit API allocates it.
    let mut output_len = input.source_bytes().len();
    for edit in &edits {
        output_len -= edit.range.len();
        for part in &edit.replacement {
            let len = match part {
                EditPart::Text(text) => text.len(),
                EditPart::Original(range) => range.len(),
            };
            output_len = output_len
                .checked_add(len)
                .filter(|n| *n <= MAX_OUTPUT)
                .ok_or("candidate exceeds 16 MiB")?;
        }
    }
    let snapshot = SourceSnapshot::new("wedding.dzn", input.source_bytes());
    let candidate = prepare_text_edits(&snapshot, input.source_bytes(), &edits)
        .map_err(|error| error.to_string())?;
    Input::parse_named(candidate.clone(), FileMode::Data, "grown-wedding.dzn")
        .map_err(|error| format!("invalid candidate: {error:?}"))?;
    Ok(candidate)
}

pub fn is_document(&self) -> bool

Only the untouched initial selection or items emits the whole document.

Trait Implementations

impl<'a> Debug for Selection<'a>

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

Formats the value using the given formatter.