use std::borrow::Cow;
use std::collections::{HashMap, HashSet};
use std::fmt;
use std::ops::Range;
use super::lexer::{Span, Token, TokenKind};
use super::string::decode_string;
use crate::error::Result;
pub struct Exchange<'a> {
src: &'a [u8],
tokens: Vec<Token>,
header: Range<usize>,
header_text: Span,
sections: Vec<DataSection>,
instances: Vec<Instance>,
index: HashMap<u64, usize>,
extra: Vec<ExtraSection>,
external: HashSet<u64>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ExtraKind {
Anchor,
Reference,
Signature,
}
#[derive(Debug, Clone)]
pub(crate) struct ExtraSection {
pub(crate) kind: ExtraKind,
pub(crate) span: Span,
pub(crate) entries: Vec<(Span, Range<usize>)>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Anchor<'e> {
pub name: &'e str,
pub target: Option<u64>,
pub text: &'e [u8],
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ExternalReference<'e> {
pub name: ReferenceName<'e>,
pub uri: &'e str,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ReferenceName<'e> {
Instance(u64),
Constant(&'e str),
Value(&'e str),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Instance {
pub id: u64,
pub span: Span,
pub(crate) tokens: Range<usize>,
pub(crate) complex: bool,
}
impl Instance {
pub fn is_complex(&self) -> bool {
self.complex
}
}
#[derive(Debug, Clone)]
pub(crate) struct DataSection {
pub(crate) params: Range<usize>,
pub(crate) instances: Range<usize>,
}
#[derive(Debug, Clone)]
pub struct Section<'e> {
pub params: Params<'e>,
pub instances: &'e [Instance],
}
impl<'a> Exchange<'a> {
pub(crate) fn new(
src: &'a [u8],
tokens: Vec<Token>,
header: Range<usize>,
header_text: Span,
sections: Vec<DataSection>,
instances: Vec<Instance>,
index: HashMap<u64, usize>,
) -> Self {
Self {
src,
tokens,
header,
header_text,
sections,
instances,
index,
extra: Vec::new(),
external: HashSet::new(),
}
}
pub(crate) fn with_extra_sections(mut self, sections: Vec<ExtraSection>) -> Self {
self.external = sections
.iter()
.filter(|section| section.kind == ExtraKind::Reference)
.flat_map(|section| section.entries.iter())
.filter_map(|(_, tokens)| match self.tokens.get(tokens.start)?.kind {
TokenKind::InstanceName(id) => Some(id),
_ => None,
})
.collect();
self.extra = sections;
self
}
pub fn anchors(&self) -> Vec<Anchor<'_>> {
self.extra_entries(ExtraKind::Anchor)
.filter_map(|(span, tokens)| {
let name = tokens.first().filter(|t| t.kind == TokenKind::Resource)?;
let target = match tokens.get(2..) {
Some(
[
Token {
kind: TokenKind::InstanceName(id),
..
},
],
) => Some(*id),
_ => None,
};
Some(Anchor {
name: inner(name.span.slice(self.src), 1, 1),
target,
text: span.slice(self.src),
})
})
.collect()
}
pub fn external_references(&self) -> Vec<ExternalReference<'_>> {
self.extra_entries(ExtraKind::Reference)
.filter_map(|(_, tokens)| {
let [lhs, equals, uri] = tokens else {
return None;
};
if equals.kind != TokenKind::Equals || uri.kind != TokenKind::Resource {
return None;
}
let text = lhs.span.slice(self.src);
let name = match lhs.kind {
TokenKind::InstanceName(id) => ReferenceName::Instance(id),
TokenKind::ConstantName => ReferenceName::Constant(inner(text, 1, 0)),
TokenKind::ValueName => ReferenceName::Value(inner(text, 1, 0)),
_ => return None,
};
Some(ExternalReference {
name,
uri: inner(uri.span.slice(self.src), 1, 1),
})
})
.collect()
}
pub fn is_external(&self, id: u64) -> bool {
self.external.contains(&id)
}
pub(crate) fn extra_sections(&self) -> &[ExtraSection] {
&self.extra
}
pub(crate) fn tokens_in(&self, range: Range<usize>) -> &[Token] {
self.tokens.get(range).unwrap_or_default()
}
fn extra_entries(&self, kind: ExtraKind) -> impl Iterator<Item = (Span, &[Token])> {
self.extra
.iter()
.filter(move |section| section.kind == kind)
.flat_map(|section| section.entries.iter())
.map(|(span, tokens)| (*span, self.tokens.get(tokens.clone()).unwrap_or_default()))
}
pub fn source(&self) -> &'a [u8] {
self.src
}
pub fn header(&self) -> Records<'_> {
Records {
src: self.src,
tokens: self.tokens.get(self.header.clone()).unwrap_or_default(),
}
}
pub fn header_entity(&self, name: &str) -> Option<Record<'_>> {
self.header().find(|record| record.is(name))
}
pub fn sections(&self) -> impl ExactSizeIterator<Item = Section<'_>> {
self.sections.iter().map(|section| {
let tokens = &self.tokens[section.params.clone()];
Section {
params: Params {
src: self.src,
tokens: tokens
.get(1..tokens.len().saturating_sub(1))
.unwrap_or_default(),
},
instances: &self.instances[section.instances.clone()],
}
})
}
pub fn instances(&self) -> &[Instance] {
&self.instances
}
pub fn instances_of<'e>(&'e self, name: &'e str) -> impl Iterator<Item = usize> {
self.instances
.iter()
.enumerate()
.filter(move |(_, instance)| self.records(instance).any(|record| record.is(name)))
.map(|(position, _)| position)
}
pub fn get(&self, id: u64) -> Option<&Instance> {
self.position(id).map(|i| &self.instances[i])
}
pub fn position(&self, id: u64) -> Option<usize> {
self.index.get(&id).copied()
}
pub fn text(&self, instance: &Instance) -> &'a [u8] {
instance.span.slice(self.src)
}
pub fn records(&self, instance: &Instance) -> Records<'_> {
let tokens = self.instance_tokens(instance);
let tokens = if instance.complex {
tokens
.get(1..tokens.len().saturating_sub(1))
.unwrap_or_default()
} else {
tokens
};
Records {
src: self.src,
tokens,
}
}
pub fn references(&self, instance: &Instance) -> References<'_> {
References {
tokens: self.instance_tokens(instance).iter(),
}
}
pub(crate) fn instance_tokens(&self, instance: &Instance) -> &[Token] {
self.tokens.get(instance.tokens.clone()).unwrap_or_default()
}
pub(crate) fn header_text(&self) -> &'a [u8] {
self.header_text.slice(self.src)
}
pub(crate) fn header_span(&self) -> Span {
self.header_text
}
pub(crate) fn header_tokens(&self) -> &[Token] {
self.tokens.get(self.header.clone()).unwrap_or_default()
}
pub(crate) fn data_sections(&self) -> impl Iterator<Item = (&'a [u8], Range<usize>)> {
self.sections.iter().map(|section| {
let tokens = &self.tokens[section.params.clone()];
let params: &'a [u8] = match (tokens.first(), tokens.last()) {
(Some(first), Some(last)) => &self.src[first.span.start..last.span.end],
_ => &[],
};
(params, section.instances.clone())
})
}
}
fn inner(text: &[u8], front: usize, back: usize) -> &str {
text.get(front..text.len().saturating_sub(back))
.and_then(|bytes| std::str::from_utf8(bytes).ok())
.unwrap_or_default()
}
impl fmt::Debug for Exchange<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Exchange")
.field("bytes", &self.src.len())
.field("sections", &self.sections.len())
.field("instances", &self.instances.len())
.finish_non_exhaustive()
}
}
#[derive(Debug, Clone)]
pub struct References<'e> {
tokens: std::slice::Iter<'e, Token>,
}
impl Iterator for References<'_> {
type Item = u64;
fn next(&mut self) -> Option<u64> {
self.tokens.find_map(|token| match token.kind {
TokenKind::InstanceName(id) => Some(id),
_ => None,
})
}
}
#[derive(Debug, Clone)]
pub struct Records<'e> {
src: &'e [u8],
tokens: &'e [Token],
}
impl<'e> Iterator for Records<'e> {
type Item = Record<'e>;
fn next(&mut self) -> Option<Record<'e>> {
let (&name, rest) = self.tokens.split_first()?;
let close = matching(rest);
let params = rest.get(1..close).unwrap_or_default();
self.tokens = rest.get(close + 1..).unwrap_or_default();
Some(Record {
src: self.src,
name,
params,
})
}
}
#[derive(Debug, Clone, Copy)]
pub struct Record<'e> {
src: &'e [u8],
name: Token,
params: &'e [Token],
}
impl<'e> Record<'e> {
pub fn name(self) -> &'e [u8] {
self.name.span.slice(self.src)
}
pub fn is(self, name: &str) -> bool {
self.name().eq_ignore_ascii_case(name.as_bytes())
}
pub fn params(self) -> Params<'e> {
Params {
src: self.src,
tokens: self.params,
}
}
pub fn param(self, index: usize) -> Option<Param<'e>> {
self.params().nth(index)
}
}
#[derive(Debug, Clone)]
pub struct Params<'e> {
src: &'e [u8],
tokens: &'e [Token],
}
impl<'e> Iterator for Params<'e> {
type Item = Param<'e>;
fn next(&mut self) -> Option<Param<'e>> {
loop {
let (&token, rest) = self.tokens.split_first()?;
let literal = Literal {
src: self.src,
token,
};
let param = match token.kind {
TokenKind::Comma
| TokenKind::RightParen
| TokenKind::Semicolon
| TokenKind::Equals => {
self.tokens = rest;
continue;
}
TokenKind::LeftParen => {
let close = matching(self.tokens);
let inner = self.tokens.get(1..close).unwrap_or_default();
self.tokens = self.tokens.get(close + 1..).unwrap_or_default();
return Some(Param::List(Params {
src: self.src,
tokens: inner,
}));
}
TokenKind::Keyword | TokenKind::UserKeyword => {
let close = matching(rest);
let params = rest.get(1..close).unwrap_or_default();
self.tokens = rest.get(close + 1..).unwrap_or_default();
return Some(Param::Typed(Record {
src: self.src,
name: token,
params,
}));
}
TokenKind::Dollar => Param::Unset,
TokenKind::Asterisk => Param::Derived,
TokenKind::Integer => Param::Integer(literal),
TokenKind::Real => Param::Real(literal),
TokenKind::String => Param::String(literal),
TokenKind::Enumeration => Param::Enumeration(literal),
TokenKind::Binary => Param::Binary(literal),
TokenKind::InstanceName(id) => Param::Reference(id),
TokenKind::ConstantName => Param::ConstantReference(literal),
TokenKind::ValueName => Param::ValueReference(literal),
TokenKind::Resource => Param::Resource(literal),
};
self.tokens = rest;
return Some(param);
}
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum Param<'e> {
Unset,
Derived,
Integer(Literal<'e>),
Real(Literal<'e>),
String(Literal<'e>),
Enumeration(Literal<'e>),
Binary(Literal<'e>),
Reference(u64),
ConstantReference(Literal<'e>),
ValueReference(Literal<'e>),
Resource(Literal<'e>),
List(Params<'e>),
Typed(Record<'e>),
}
impl<'e> Param<'e> {
pub fn reference(&self) -> Option<u64> {
match self {
Self::Reference(id) => Some(*id),
_ => None,
}
}
pub fn list(&self) -> Option<Params<'e>> {
match self {
Self::List(items) => Some(items.clone()),
_ => None,
}
}
pub fn typed(&self) -> Option<Record<'e>> {
match self {
Self::Typed(record) => Some(*record),
_ => None,
}
}
pub fn literal(&self) -> Option<Literal<'e>> {
match self {
Self::Integer(literal)
| Self::Real(literal)
| Self::String(literal)
| Self::Enumeration(literal)
| Self::Binary(literal)
| Self::ConstantReference(literal)
| Self::ValueReference(literal)
| Self::Resource(literal) => Some(*literal),
Self::Unset | Self::Derived | Self::Reference(_) | Self::List(_) | Self::Typed(_) => {
None
}
}
}
pub fn is_unset(&self) -> bool {
matches!(self, Self::Unset)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Literal<'e> {
src: &'e [u8],
token: Token,
}
impl<'e> Literal<'e> {
pub fn text(self) -> &'e [u8] {
self.token.span.slice(self.src)
}
pub fn span(self) -> Span {
self.token.span
}
pub fn decode(self) -> Result<Cow<'e, str>> {
decode_string(self.src, self.token.span)
}
pub fn to_i64(self) -> Option<i64> {
if self.token.kind != TokenKind::Integer {
return None;
}
std::str::from_utf8(self.text()).ok()?.parse().ok()
}
pub fn to_f64(self) -> Option<f64> {
if !matches!(self.token.kind, TokenKind::Integer | TokenKind::Real) {
return None;
}
std::str::from_utf8(self.text()).ok()?.parse().ok()
}
pub fn enumeration(self) -> Option<&'e str> {
if self.token.kind != TokenKind::Enumeration {
return None;
}
let text = self.text();
std::str::from_utf8(text.get(1..text.len().saturating_sub(1))?).ok()
}
}
fn matching(tokens: &[Token]) -> usize {
let mut depth = 0usize;
for (i, token) in tokens.iter().enumerate() {
match token.kind {
TokenKind::LeftParen => depth += 1,
TokenKind::RightParen => {
depth = depth.saturating_sub(1);
if depth == 0 {
return i;
}
}
_ => {}
}
}
tokens.len()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::p21::parse;
#[test]
fn query_helpers() {
let src = b"ISO-10303-21;HEADER;FILE_NAME('part');FILE_SCHEMA(('AP242'));ENDSEC;DATA;\
#1=PRODUCT('p1','bracket','',(#2));\
#2=PRODUCT_CONTEXT('',$,'mechanical');\
#3=(NAMED_UNIT(*)PRODUCT());\
#4=product('p2','plate','',(#2));\
ENDSEC;END-ISO-10303-21;";
let exchange = parse(src).unwrap();
assert_eq!(
exchange.instances_of("PRODUCT").collect::<Vec<_>>(),
[0, 2, 3]
);
assert_eq!(exchange.instances_of("NOTHING").count(), 0);
let schema = exchange.header_entity("file_schema").unwrap();
let schemas = schema.param(0).and_then(|p| p.list()).unwrap();
let names: Vec<String> = schemas
.filter_map(|p| p.literal()?.decode().ok().map(Cow::into_owned))
.collect();
assert_eq!(names, ["AP242"]);
let product = exchange.records(&exchange.instances()[0]).next().unwrap();
let name = product.param(1).and_then(|p| p.literal()).unwrap();
assert_eq!(name.decode().unwrap(), "bracket");
let contexts = product.param(3).and_then(|p| p.list()).unwrap();
assert_eq!(
contexts.filter_map(|p| p.reference()).collect::<Vec<_>>(),
[2]
);
assert!(product.param(4).is_none());
let context = exchange.records(&exchange.instances()[1]).next().unwrap();
assert!(context.param(1).unwrap().is_unset());
assert!(context.param(1).unwrap().literal().is_none());
}
}