[dsdl-discuss] Re: Part 10 Scenario

Erik

Thanks for your neat XPL example

Let me start by trying to answer some of the questions you raised in your
submission:

1. a) What is expected of the output of validators?
    A validated input stream should be passed to the next operation(s) in
the Validation Management chain

    b) Is the flow supposed to be interrupted when a validation error
occurs?
    An invalid input stream should generate one or more error messages. The
Validation Management instructions should determine whether or not the input
stream generating the message should or should not be passed to subsequent
operations. For example, Schematron may only generate warning messages,
without the need to stop further processing.

[At CSW we can use Schematron to generate messages asking doctors to obtain
further information when they next see a patient, without invalidating the
medical record being processed.]

2) For simplicity, I assumed that the NVDL processor here would produce
outputs with those
    particular names. This would be possible only if the NVDL processor
could be configured to
    map those output names to namespaces. Practically, this processor could
either:

          a) Have predefined output names, like document-1, document-2, etc.
          b) Produce a single XML document with all the streams aggregated

    I do not know NVDL well enough to see what would be natural here.

The NVDL model talks of a 5 stage process:
   Stage 1: Creating element and attribute sections
   Stage 2: Constructing interpretations
   Stage 3: Combining sections
   Stage 4: Filtering the combined sections
   Stage 5: Validation
I have presumed in my test scenario that the filtered combined sections
generated at Stage 4 can be seperately passed on for subsequent processing.
(I may not be right in this assumption, but it seems to me to be a
reasonable one for users to expect.) In the test scenario I have presumed
that the processing streams for HTML, SVG, MathML and Docbook embedded
fragments need to be handled in different workflows and then recombined at a
later stage. I was presuming that some mechanism in the Validation
Management specification would allow different combined sections to be
assigned unique identifiers that could be referenced at a later point (as
you do with XPL). How this recombination can be affected is at present
beyond my comprehension, but somehow the streams have to be reaggregated
after different transformations and validations have been applied to
different parts of the stream.

3) I have used a single validation processor that supports W3C XML Schema,
Relax NG,
    Schematron, and DTDs (here DTDs would either have to be encaspulated
into a root element,
    or referred externally). You could of course propose one processor per
schema type. The
    PresentationServer validation processor currently supports transparently
W3C Schema and
    Relax NG.

Personally I would prefer one processor per schema type so that users could
select which processor they prefer. (There could be cases where a specific
processor is required to support a specific schema. We know from bitter
experience that not all processors correctly support all functionality of
W3C schemas.)

4) I proposed using XSLT to recombine the final document in the end.
I was hoping you would say that, and then explain how XSLT could be used to
generate the correct sequence of processed subcomponents. You seem, however,
to have presume that the NVDL output produces sequential sets of data. This
may not be the case. For example, Stage 3 of NVDL could combine segments
from different points in the input stream prior to NVDL validation and
subsequent processing. We need to undo this combination to create separate
segments, and then use the Stage 1 segmentation of the NVDL elements and
attributes to reconstruct the document.

5) Otherwise, the pipeline is very simple. Nothing is against parallel
execution on XPL.
    Without exception support, the processing would just stop if there is a
validation error.
    With exception support, it could resume, locally (per branch) if needed,
or just propose a
    global fallback. Everything that is possible with exceptions.

Can include examples of exception handling in the sample code? For example,
if Schematron issued a warning that the SVG contained options that would not
be supported by all devices this should not stop the user-generated SVG from
being integrated with the program-generated SVG output of the MathML data in
the final document.

Otherwise a good start.

Murata-san: What are your feelings about the best way to identify the
components parts of the NVDL stream so that they can be used to manage the
correct ordering of processed fragments?

Martin Bryan

--
DSDL members discussion list
To unsubscribe, please send a message with the
command  "unsubscribe" to dsdl-discuss-request@dsdl.org
(mailto:dsdl-discuss-request@dsdl.org?Subject=unsubscribe)