net.sansa_stack.owl.common.parsing
ManchesterParsing
Related Doc:
package parsing
Since the specs (https://www.w3.org/TR/owl2-manchester-syntax/#annotationPropertyFrame) say an annotation property frame should look like this
Since the specs (https://www.w3.org/TR/owl2-manchester-syntax/#annotationPropertyFrame) say an annotation property frame should look like this
annotationPropertyFrame ::= 'AnnotationProperty:' annotationPropertyIRI { 'Annotations:' annotationAnnotatedList } | 'Domain:' IRIAnnotatedList | 'Range:' IRIAnnotatedList | 'SubPropertyOf:' annotationPropertyIRIAnnotatedList
(which means either annotations, or one domain, or one range, or one subproperty of part) but give an example that violates this rule:
AnnotationProperty: creator Annotations: ... Domain: Person ,... Range: integer ,... SubPropertyOf: initialCreator ,...
I assume spec should be
annotationPropertyFrame ::= 'AnnotationProperty:' annotationPropertyIRI { 'Annotations:' annotationAnnotatedList | 'Domain:' IRIAnnotatedList | 'Range:' IRIAnnotatedList | 'SubPropertyOf:' annotationPropertyIRIAnnotatedList }
('e' | 'E') ['+' | '-'] digits
[ iuserinfo "@" ] ihost [ ":" port ]
[ iuserinfo "@" ] ihost [ ":" port ]
@ (U+40) followed a nonempty sequence of characters matching the langtag production from [BCP 47]
a finite sequence of characters matching the PNAME_NS production of [SPARQL] and not matching any of the keyword terminals of the syntax
a finite sequence of characters in which " (U+22) and \ (U+5C) occur only in pairs of the form \" (U+5C, U+22) and \\ (U+5C, U+5C), enclosed in a pair of " (U+22) characters
(Changed in version 2.9.0) The p0 call-by-name arguments is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
For cases where there is a comma-separated list with an arbitrary number of items, but we're only interested in the items.
For cases where there is a comma-separated list with an arbitrary number of items, but we're only interested in the items. Converts a parsed sequence like
, item1 , item2 , item3
(with optional white space around the commas) to a Scala list appended to the accumulator list given as first argument.
Determines the kind of items that are considered, e.g. OWLLiteral, IRI, ...
Accumulator list
Parsed results that follow the pattern
{ whiteSpace.? ~ comma ~ whiteSpace.? ~ value }.*
A Scala list containing just the parsed items (without commas)
Does the same like unravel but considering optional annotations.
Does the same like unravel but considering optional annotations. The pattern is
<U>AnnotatedList ::= [annotations] <U> { ',' [annotations] <U> }
What kind of OWL entity is considered here; e.g. OWLClass, OWLIndividual etc
A list of pairs of U's and corresponding (possibly empty) annotation lists
The first parsed, optional annotations block
The first parsed U entry
Everything parsed after the first annotation block and first U entry
The filled resultList
Converts parser results of a list of annotations which themselves can be annotated into a list of OWLAnnotation instances.
Converts parser results of a list of annotations which themselves can be annotated into a list of OWLAnnotation instances. The pattern looks like this:
AnnotationAnnotatedList ::= [annotations] annotation { ',' [annotations] annotation }
The result list containing OWLAnnotation objects
The left-most (optional) annotation block
The annotation property of the left-most annotation
The annotation value of the left-most annotation
The parser results coming after the left-most annotation block
annotationsResultList
Converts a parsed, 'and'-separated sequence of class expressions with optional 'not' determining an expression's complement.
Converts a parsed, 'and'-separated sequence of class expressions with optional 'not' determining an expression's complement. The pattern looks like this:
[ 'not' ] expression { 'and' [ 'not' ] expression }
The list containing the parsed OWLClassExpressions
Holds everything after the first optional 'not' and the first class expression
The resultList
For cases where there is a comma-separated list with an arbitrary number of item pairs, but we're only interested in the item pairs.
For cases where there is a comma-separated list with an arbitrary number of item pairs, but we're only interested in the item pairs. Converts a parsed sequence like
, item1_1 item1_2 , item2_1 item2_2 , item3_1 item3_2
to a Scala list of pairs, appended to the accumulator list given as first argument.
Determines the kind of items that are considered, e.g. OWLLiteral, IRI, ...
Determines the kind of items that are considered, e.g. OWLLiteral, IRI, ...
Accumulator list
Parsed results that follow the pattern { comma ~ value ~ value }.*
A Scala list containing just the parsed items (without commas)
Converts parser results of a token separated sequence (with whitespaces around the token) into a list.
Converts parser results of a token separated sequence (with whitespaces around the token) into a list. The pattern looks like this:
<U> token <U> { token <U> }