Tasks (BandM metatools API doc)

java.lang.Object
- eu.bandm.tools.d2d2.base.Tasks

```
public class Tasks
extends Object
```
Collection of static methods which realize the different d2d conversion tasks. These are the currently supported PIPELINES (implemented mostly here and in partly in Main):
```
 textfile ---> udom ----------------> sax ----> xml textfile         (1)
                                           \
                                             -> tdom                 (2)

 textfile ---> udom --sax--[xslt]---> sax --> textfile (xml/no-xml)  (3) 
                             ^              \
                             |                -> tdom                (4)
                             \________________________________
                                                              \
                                                       -->Txsl Code (=own implementation,
                                                     /              ( formerly: JAXP translet
 modulereg ---> xslt-d2d-source                     / 
                xslt-d2d-source--------> udom --> sax --> xml xslt source (5)
                   \         (text2xml parser)            
                    \        (  in xslt mode )                           
                     \----------------------------------> d2d xslt source (5)

 (MODULE.{ddf,umod,dtd, etc.}
    \
     V
    modulereg ------------------------------------------> MODULE.dtd       (6)
          \ 
           \ -------------------------------------------> FILENAME.ddf     (7)
            \ 
             \ -------------------> d2d_documentation_[MODULE]_user_[LANG] (8) 
              \ 
               \ ---------------------------------------> FILENAME.html    (9)
                \ 
                 \ -------------------------------------> FILENAME.xml     (10)

 
 MODULE.dtd --------------------------------------------> MODULE.ddf       (11)
 
```
Legend:
(1) Main use case: produce an XML output file from a d2d input text file in "one-to-one" discipline.
Initiated from commandline by "Main --task text2xml".
Initiated programmatically by calling #text2texts(MessageReceiver, ModuleRegistry, Text2Udom.ErrorStrategy, File, ContentHandler, Map, String, NamespaceName2String)

(2) Main use case: produce a TDOM model from a d2d text in "one-to-one" discipline.
Initiated programmatically by calling (File, ModuleRegistry, Class, TypedDTD, MessageReceiver, Text2Udom.ErrorStrategy, int)

(3) Derived use case: produce output file (xml/non-xml) by first translating a d2d text file to xml, as in (1), and then applying xslt transformations into specified target formats. The transformation code is given with the module definitions.
Initiated from commandline by "Main --task text2texts".
Initiated programmatically by calling #text2texts(MessageReceiver, ModuleRegistry, Text2Udom.ErrorStrategy, File, ContentHandler, Map, String, NamespaceName2String)

(4) Derived use case: produce a TDOM model from a d2d udom (=intermediate parse result of a d2d text), after applying xslt transformations as in (3). (The first parsing step in the graphic above is NOT contained!)
Implemented by udom2xslt2document(MessageReceiver,ModuleRegistry,Udom,String,String,Class,TypedDTD,URIResolver,NamespaceName2String,boolean).

(5) Auxiliary use case: write out the xslt transformation for a given module and a given target format.
Initiated from commandline by "Main --task ddf2xslt"; implemented in Main#ddf2xslt(String).

(6) Auxiliary use case: translate the ddf definition of a given module into a DTD.
Initiated from commandline by "Main --task ddf2dtd"; implemented in Def2Dtd#convert(MessageReceiver, ModuleRegistry, XMLDocumentIdentifier, boolean).

(7) Auxiliary use case: pretty-print the ddf definition of a given module.
Initiated from commandline by "Main --task ddf2format"; implemented by the format rules in the umod definition.

(8) Auxiliary use case: generate HTML formatted user documentation for a given module in a given state (raw or instantiated) in a given human language.
Initiated from commandline by "Main --task ddf2doc"; implemented in Def2Doc.

(9) Auxiliary use case: translate the ddf definition of a given module into a html formular with labels and input fields.
Initiated from commandline by "Main --task ddf2htmlform"; (currently not supported, old implementation in OLD ../../d2d/base/Def2HtmlForm.)

(10) Auxiliary use case: write out a given module in umod tsoap xml format.
Initiated from commandline by "Main --task ddf2tsoap";

(11) Auxiliary use case: write out the ddf equivalent of a dtd
Initiated from commandline by "Main --task dtd2ddf";
Implemented in Dtd2Def, which is also called by Modulereg, when a dtd is used as ddf. But the use case is slightly different from (7), since more errors must be signalled explicitly and more diagnosis is required.

Constructor Summary

Constructors
Constructor and Description

Tasks()

Constructors
Constructor and Description
`Tasks()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`ddf2doc3(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, ModuleRegistry moduleReg, String modulename, String language, String outputname, String gencomment, NamespaceName2String stylesheetParams, Iterable<String> additionalSources, int lineWidth)` Generate the html doc for a given module, ie.
`static void`	`ddf2dtd(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, ModuleRegistry moduleReg, String modulename, String docuLanguage, String fileOutputName, int lineWidth)` Convert a module to a dtd.
`static void`	`ddf2xslt(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, ModuleRegistry moduleReg, String modulename, String targetModule, @Opt String targetTopTag, String outputname, Text2Udom.ErrorStrategy errorStrategy, String genString, int lineWidth)` Extracts all xslt rules for the given module and target into a d2d definition and exports this to a d2d source file.
`static void`	`dtd2ddf(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> extmsg, ModuleRegistry moduleReg, String inputname, String fileOutputName, int lineWidth)` Convert a dtd to a module.
`protected static void`	`e_error(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, Exception ex, String s, Object... args)` Adapter to treat parse formatting of Strings to MuLiMessageReceiver, and simulate it locally for normal MessageReceiver. (This must be treated differently, because MuLiMessageReceiver FIRST translates BEFORE formatting !-)
`protected static void`	`e_error(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, String s)`
`protected static void`	`e_log(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, String s)`
`protected static void`	`e_log(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, String s, Object... args)`
`protected static void`	`e_logEnd(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, String s)`
`protected static void`	`e_logStart(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, String s)`
`protected static void`	`execXsltUsingXalan(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> e_msg, MessageReceiver<SimpleMessage<Object>> msgNOLOC, ResultingStructure res, Templates templates, NamespaceName2String e_stylesheetParams, boolean errorsInSourceFound, @Opt String stylesheetErrorFlag, File resfile, @Opt Map<String,String> inputNamespaces)`
`static <T extends TypedDocument,D extends TypedDTD> T`	`string2tdom(String sourcetext, ModuleRegistry modreg, Class<T> documentClass, D dtdInstance, MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msgr, Text2Udom.ErrorStrategy errorStrategy, int debug)` Convert a d2d source text (GIVEN AS STRING) into a tdom model.
`static <T extends TypedDocument,D extends TypedDTD> T`	`text2tdom(File infile, ModuleRegistry modreg, Class<T> documentClass, D dtdInstance, MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msgr, Text2Udom.ErrorStrategy errorStrategy, int debug)` Convert a d2d input file into a tdom model.
`static void`	`text2texts(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> e_msg, ModuleRegistry e_moduleReg, Text2Udom.ErrorStrategy errorStrategy, File e_sourcefile, @Opt String generationComment, @Opt ContentHandler contentHandler, Map<String,File> e_formats, String stylesheetErrorFlag, NamespaceName2String e_stylesheetParams)` Convert directly a d2d encoded input text file into output files in different output formats, using xslt.
`static <T extends TypedDocument,D extends TypedDTD> T`	`udom2xslt2document(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msgr, ModuleRegistry modreg, Udom input, String xsltTargetModuleSelect, String xsltTargetToptagSelect, Class<T> documentClass, D dtdInstance, URIResolver uriResolver, NamespaceName2String stylesheetparams, boolean debug)` Convert a d2d untyped model (result of a d2d parsing process) via the xslt rules coming with the d2d module definition directly into a tdom model.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- Tasks
```
public Tasks()
```

Method Detail

e_log

protected static void e_log(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
                            String s)

e_log

protected static void e_log(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
                            String s,
                            Object... args)

e_logStart

protected static void e_logStart(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
                                 String s)

e_logEnd

protected static void e_logEnd(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
                               String s)

e_error

protected static void e_error(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
                              String s)

e_error

protected static void e_error(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
                              Exception ex,
                              String s,
                              Object... args)

Adapter to treat parse formatting of Strings to MuLiMessageReceiver, and simulate it locally for normal MessageReceiver.
(This must be treated differently, because MuLiMessageReceiver FIRST translates BEFORE formatting !-)

ddf2dtd

public static void ddf2dtd(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
                           ModuleRegistry moduleReg,
                           String modulename,
                           String docuLanguage,
                           String fileOutputName,
                           int lineWidth)

Convert a module to a dtd. (Currently called by base.Main AND gui.Webstart)

dtd2ddf

public static void dtd2ddf(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> extmsg,
                           ModuleRegistry moduleReg,
                           String inputname,
                           String fileOutputName,
                           int lineWidth)

Convert a dtd to a module. (Currently called by base.Main AND gui.Webstart)

ddf2xslt
```
public static void ddf2xslt(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
                            ModuleRegistry moduleReg,
                            String modulename,
                            String targetModule,
                            @Opt
                            @Opt String targetTopTag,
                            String outputname,
                            Text2Udom.ErrorStrategy errorStrategy,
                            String genString,
                            int lineWidth)
```
Extracts all xslt rules for the given module and target into a d2d definition and exports this to a d2d source file. Then the d2d source is immediately parsed into an xml/xslt file. The "outfile" parameter gives the directory where to store these results; the name of the files are derived from the module name and the target format as defined in #filename_template_xslt_d2d and , #filename_template_xslt_xml, like
"[module.module]_to_[xhtml_1_0].xslt.d2d"
or
"[module.module]_to_[xhtml_1_0].xslt"

The d2d source will start with the indication of the target element and all namespaces involved:
```
      #d2d 2.0 xslt text producing [MODULE:ELEMENT]
         from  [PREF] = [NS_URI]
         from  [PREF] = [NS_URI]
 
```
Collects into the header all namespaces which appear in the tags of the source module (or module*S*, incl d2d-meta, etc).
The Text2Udom xslt parsing mode delivers these in a dedicated map.
This is necessary because the namespace-prefices appearing in xpath-constants only cannot be declared "in-place", since they exist only as XML attribute values. In template match="a:b" the prefix "a:" must be declared somewhere!
The (immutable) map can be read with Text2Udom.getXsltInputNamespaces().
Parameters:

targetTopTag - is only needed for to find the reachable elements, for the xslt parsing. It may be ==null, indicating pure text.

ddf2doc3

public static void ddf2doc3(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
                            ModuleRegistry moduleReg,
                            String modulename,
                            String language,
                            String outputname,
                            String gencomment,
                            NamespaceName2String stylesheetParams,
                            Iterable<String> additionalSources,
                            int lineWidth)

Generate the html doc for a given module, ie. collect explicit doc texts in the selected language, and create "Wirth"-Graphs for the content models. New version, works only on expanded modules and covers only reachable definitions.

Parameters:: additionalSources - source files which only add further documentation text to definitions contained in a loaded module.; outputname - the path of the directory in which to create the generated documentation directory.

text2texts

public static void text2texts(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> e_msg,
                              ModuleRegistry e_moduleReg,
                              Text2Udom.ErrorStrategy errorStrategy,
                              File e_sourcefile,
                              @Opt
                              @Opt String generationComment,
                              @Opt
                              @Opt ContentHandler contentHandler,
                              Map<String,File> e_formats,
                              String stylesheetErrorFlag,
                              NamespaceName2String e_stylesheetParams)

Convert directly a d2d encoded input text file into output files in different output formats, using xslt.

parse text and create an untyped xml model Udom.
write out to an xml file and/or a SAX ContentHandler, if requested.
for every selected back-end format do:
1. load xslt transformer for the given source and target in moduleReg
2. convert the udom into sax events and apply the transformation
3. write out the transformer output (sax events) to outfile

Currently called by wiki/D2dAdapter.java and by the command line method in Main.main(String[]).

execXsltUsingXalan

protected static void execXsltUsingXalan(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> e_msg,
                                         MessageReceiver<SimpleMessage<Object>> msgNOLOC,
                                         ResultingStructure res,
                                         Templates templates,
                                         NamespaceName2String e_stylesheetParams,
                                         boolean errorsInSourceFound,
                                         @Opt
                                         @Opt String stylesheetErrorFlag,
                                         File resfile,
                                         @Opt
                                         @Opt Map<String,String> inputNamespaces)

udom2xslt2document

@Opt
public static <T extends TypedDocument,D extends TypedDTD> T udom2xslt2document(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msgr,
                                                                                     ModuleRegistry modreg,
                                                                                     Udom input,
                                                                                     String xsltTargetModuleSelect,
                                                                                     String xsltTargetToptagSelect,
                                                                                     Class<T> documentClass,
                                                                                     D dtdInstance,
                                                                                     URIResolver uriResolver,
                                                                                     NamespaceName2String stylesheetparams,
                                                                                     boolean debug)

Convert a d2d untyped model (result of a d2d parsing process) via the xslt rules coming with the d2d module definition directly into a tdom model.
Currently uses the "JAXP" interface (which normally means "Xalan").
Global, externally callable construction method.
cf xantlrtdom/TdomReader.java
Currently only called by "Def2Doc" for rendering the users' docu texts, which have the format of (restricted) "rich" d2d_gp text.

Returns:: null in case of load error

text2tdom

@Opt
public static <T extends TypedDocument,D extends TypedDTD> T text2tdom(File infile,
                                                                            ModuleRegistry modreg,
                                                                            Class<T> documentClass,
                                                                            D dtdInstance,
                                                                            MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msgr,
                                                                            Text2Udom.ErrorStrategy errorStrategy,
                                                                            int debug)

Convert a d2d input file into a tdom model. Ubiquituously callable for constructing a tdom model from a d2d input.
cf xantlrtdom/TdomReader.java Currently only USED in bandm.eu/bpm/book2/base/Main.java and in applics/src/eu/bandm/tools/jul/compiler/Model2Swing.java
(20190524) Additionally Meta2Pi is inserted, to store d2d error messages transparently in a tdom model.

Returns:: null in case of load error

string2tdom

public static <T extends TypedDocument,D extends TypedDTD> T string2tdom(String sourcetext,
                                                                         ModuleRegistry modreg,
                                                                         Class<T> documentClass,
                                                                         D dtdInstance,
                                                                         MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msgr,
                                                                         Text2Udom.ErrorStrategy errorStrategy,
                                                                         int debug)

Convert a d2d source text (GIVEN AS STRING) into a tdom model. FIXME needed by "na-meeli-server-demo". MUST BE UNIFIED WITH "text2tdom".

Class Tasks

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Tasks

Method Detail

e_log

e_log

e_logStart

e_logEnd

e_error

e_error

ddf2dtd

dtd2ddf

ddf2xslt

ddf2doc3

text2texts

execXsltUsingXalan

udom2xslt2document

text2tdom

string2tdom