XmlJzCfgAnalyzer

java.lang.Object
- org.vishia.xmlReader.XmlJzCfgAnalyzer

```
public class XmlJzCfgAnalyzer
extends java.lang.Object
```
This class reads any XML file and writes its structure to a XmlCfg format or also can be used to create the Java classes for storing the XmlJzReader parse results.
- It has a main operation to call from command line. See description on https://vishia.org/Java/html/RWTrans/XmlJzReader.html or see documentation on XmlJzCfgAnalyzer.CmdArgs.
- How does the analysing of XML files work: See description on

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`XmlJzCfgAnalyzer.AttribRead`
`private static class`	`XmlJzCfgAnalyzer.CmdArgs`
`(package private) static class`	`XmlJzCfgAnalyzer.XmlStructureData`
`(package private) static class`	`XmlJzCfgAnalyzer.XmlStructureNode` This class is one node for one element to store the structure of a XML file via `XmlJzReader`.

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) java.util.TreeMap<java.lang.String,XmlJzCfgAnalyzer.XmlStructureData.CfgSubtreeType>`	`allElementTypes` Contains one element for each tag name or node type.
`(package private) XmlCfg`	`cfgData`
`(package private) XmlCfg`	`cfgGiven`
`(package private) XmlCfg`	`cfgGiven1`
`private XmlJzCfgAnalyzer.CmdArgs`	`cmdArgs`
`(package private) int`	`debugStopLineXmlInp`
`(package private) java.io.File`	`dirDbg`
`(package private) LogMessage`	`log`
`static java.lang.String`	`version` Version, License and History: 2025-12-15 Hartmut: bugfix of new stuff.
`(package private) XmlJzCfgAnalyzer.XmlStructureData`	`xmlStructData` The common structure data of the read XML file.
`(package private) XmlJzCfgAnalyzer.XmlStructureNode`	`xmlStructTree` Contains for each tag as key all occurrences of nodes with this tag.

Constructor Summary

Constructors
Constructor and Description

XmlJzCfgAnalyzer()

Constructors
Constructor and Description
`XmlJzCfgAnalyzer()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`addWrNode(XmlNode wrCfgXmlNode, XmlJzCfgAnalyzer.XmlStructureNode structNode, int recursion)` Adds the node and recursively all sub nodes from `XmlJzCfgAnalyzer.XmlStructureNode` It is invoked after a XML file war read with `XmlCfg#newCfgReadStruct()`
`static int`	`amain(XmlJzCfgAnalyzer.CmdArgs args)` Reads a XML file and writes its structure as cfg.xml to help creating a config for the XmlJzReader
`(package private) void`	`analyzeXml(XmlJzCfgAnalyzer.CmdArgs args)` Reads given XML file(s) and writes its structure as cfg.xml or cfg.txt to help creating a config for the XmlJzReader.
`XmlCfg`	`analyzeXmlFile(java.util.List<FileFunctions.FilePathnameExt> fIn)` Reads any XML file and stores the structure in the returned `XmlCfg`.
`XmlCfg`	`analyzeXmlStruct(java.io.File fXmlIn)` Reads and analyses any XML file and stores the structure in the `#XmlCfg`.
`private void`	`checkStructTree()` Checks the read XML structure tree.
`private void`	`fillNodesGivenForCheckSubtree(XmlCfg.XmlCfgNode node, java.util.Map<java.lang.String,XmlCfg.XmlCfgNode> idxNodesGiven, int recursion)`
`static void`	`main(java.lang.String[] sArgs)`
`void`	`mergeNode(XmlCfg.XmlCfgNode ndDst, XmlJzCfgAnalyzer.XmlStructureNode ndSrc)`
`static XmlCfg`	`newCfgReadStruct()` Creates the configuration to read any xml file to store its structure especially in `XmlJzCfgAnalyzer.XmlStructureNode`.
`XmlCfg`	`readXmlStruct(java.io.File fXmlIn)` Compatible form
`XmlCfg`	`readXmlStructZip(java.io.File fIn, java.lang.String sPathInZip)` Reads any XML file and stores the structure in the `#XmlCfg`.
`private void`	`resetCtNodesInStructTree()`
`private void`	`resetCtNodesInStructTree(XmlJzCfgAnalyzer.XmlStructureNode node, int recursion)`
`void`	`setDebugStop(int line)` Only for internal debug.
`void`	`setDirDebug(java.io.File dir)`
`static int`	`smain(java.lang.String[] sArgs, java.lang.Appendable logHelp, java.lang.Appendable logError)` main gets the arguments as String, but does not catch unexpected exceptions and does not System.exit(...), use it to execute in a Java environment.
`private void`	`storeCfgNode(XmlCfg.XmlCfgNode dst, XmlJzCfgAnalyzer.XmlStructureNode src, boolean bRoot, int recursion)` Copy or add the content of the read `XmlJzCfgAnalyzer.XmlStructureData` 'srx' to the XmlCfg 'dst'.
`private void`	`storeInCfg(XmlJzReader xmlReader)`
`void`	`writeCfgTemplate(java.io.File wrCfg)` Writes the config file for the XmlJzReader with config file.
`void`	`writeCfgText(java.io.File fout)` Writes the config file for the XmlJzReader with config file.
`void`	`writeData(java.io.File fout)`
`private void`	`writeJavaClasses()`
`private void`	`wrSetAddContentAttrib(XmlJzCfgAnalyzer.XmlStructureNode structNode, XmlNode wrCfgXmlNode)`

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

- Field Detail
  - version
```
public static final java.lang.String version
```
    Version, License and History:
    - 2025-12-15 Hartmut: bugfix of new stuff. New: XmlStructureNode#finishElement(XmlStructureNode), set the XmlJzCfgAnalyzer.XmlStructureNode.ctTextInNode =0 on new call of XmlJzCfgAnalyzer.XmlStructureNode.addElement(String) Now the XmlJzCfgAnalyzer.XmlStructureNode.ctText, 'TEXT-LIST' detection is correct.
    - 2025-12-11 Hartmut: enhancement: Supports re-read XML files with given XmlCfg from before and supplements the configuration with the new elements in the read XML files:
      checkStructTree() recognises given subtrees in cfgGiven.
      ~ also offers all nodes from all trees to check whether the nodes are twice, should build a subtree.
    - 2024-05-25 Hartmut: #XXXreadNode(BufferedReader, String) etc. seems to be unnecessary.
    - 2024-05-25 Hartmut: Criteria to build a SUBTREE: Not if all have the same parent tag. This is only closed sensible, if all parent node occurrences or its parents have the same SUBTREE. But this should be regarded if given XmlCfg is really used.
    - 2024-05-25 Hartmut: Now do no more deal with the "!accessPath", this is only for the XML form of XmlCfg
    - 2024-05-21 Hartmut: Reads a given XmlCfg, uses Arguments for XmlJzCfgAnalyzer.CmdArgs now. Not ready for all.
    - 2022-06-06 Hartmut: produces the "xmlinput:finish" entry, see XmlCfg.
    - 2022-06-06 Hartmut: regards all namespace entries
    - 2019-08-18 improvements with namespace and usage for GenXmlCfgJavaData.
    - 2018-09-10 writes cfg attributes.
    - 2018-08-15 created.
    Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:
    1. You can use this source without any restriction for any desired purpose.
    2. You can redistribute copies of this source to everybody.
    3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
    4. But the LPGL is not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
    5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.
    If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.
    See Also:
    
    Constant Field Values
  - cmdArgs
```
private XmlJzCfgAnalyzer.CmdArgs cmdArgs
```
  - dirDbg
```
java.io.File dirDbg
```
  - debugStopLineXmlInp
```
int debugStopLineXmlInp
```
  - log
```
LogMessage log
```
  - xmlStructData
```
final XmlJzCfgAnalyzer.XmlStructureData xmlStructData
```
    The common structure data of the read XML file.
  - xmlStructTree
```
XmlJzCfgAnalyzer.XmlStructureNode xmlStructTree
```
    Contains for each tag as key all occurrences of nodes with this tag. An element is added to this root node and then to all current nodes in XmlJzCfgAnalyzer.XmlStructureNode.addElement(String).
  - allElementTypes
```
java.util.TreeMap<java.lang.String,XmlJzCfgAnalyzer.XmlStructureData.CfgSubtreeType> allElementTypes
```
    Contains one element for each tag name or node type. The XmlJzCfgAnalyzer.XmlStructureData.CfgSubtreeType.occurrence of the element contains only one instance of XmlJzCfgAnalyzer.XmlStructureNode if the node with this tag is only found in one constellation, but maybe more as one time in the same parent.
    If the node with this tag name is found in different constellations (with different parent nodes) then each constellation occurrence of XmlJzCfgAnalyzer.XmlStructureNode ia stored in XmlJzCfgAnalyzer.XmlStructureData.CfgSubtreeType.occurrence.
    
    checkStructTree() checks, if the occurrences are substantial equal, (yet always), then a 'SUBTREE' is created to prevent effort in the configuration, respectively allow recursively using of a node type.
  - cfgData
```
XmlCfg cfgData
```
  - cfgGiven
```
XmlCfg cfgGiven
```
  - cfgGiven1
```
XmlCfg cfgGiven1
```
- Constructor Detail
  - XmlJzCfgAnalyzer
```
public XmlJzCfgAnalyzer()
```
- Method Detail
  - main
```
public static void main(java.lang.String[] sArgs)
```
  - smain
```
public static int smain(java.lang.String[] sArgs,
                        java.lang.Appendable logHelp,
                        java.lang.Appendable logError)
                 throws java.io.IOException
```
    main gets the arguments as String, but does not catch unexpected exceptions and does not System.exit(...), use it to execute in a Java environment.
    
    Parameters:
    
    sArgs -
    
    Returns:
    
    0 if all is ok
    
    Throws:
    
    java.io.IOException
    
    java.lang.Exception - if unexpected.
  - amain
```
public static int amain(XmlJzCfgAnalyzer.CmdArgs args)
```
    Reads a XML file and writes its structure as cfg.xml to help creating a config for the XmlJzReader
    
    Parameters:
    
    args - pathfileIn.xml pathfileOutcfg.xml
  - newCfgReadStruct
```
public static XmlCfg newCfgReadStruct()
```
    Creates the configuration to read any xml file to store its structure especially in XmlJzCfgAnalyzer.XmlStructureNode.
    
    Returns:
    
    instance of XmlCfg to do so.
  - setDirDebug
```
public void setDirDebug(java.io.File dir)
```
  - setDebugStop
```
public void setDebugStop(int line)
```
    Only for internal debug. See implementation. There is a possibility to set a break point if the parser reaches the line.
    
    Parameters:
    
    line -
  - analyzeXml
```
void analyzeXml(XmlJzCfgAnalyzer.CmdArgs args)
         throws java.io.IOException
```
    Reads given XML file(s) and writes its structure as cfg.xml or cfg.txt to help creating a config for the XmlJzReader.
    - For explanation of the analyse algorithm see the called analyzeXmlFile(List).
    - Write the XML config is done if XmlJzCfgAnalyzer.CmdArgs.fxOut is given, it calls writeCfgTemplate(File).
    - The textual configuration is written on given XmlJzCfgAnalyzer.CmdArgs.fWriteXmlConfigText with the capability in XmlCfg: XmlCfg.writeToText(File, LogMessage).
    Parameters:
    args - from main invocation, also from any other Java call with this args as super class.
    
    uses XmlJzCfgAnalyzer.CmdArgs.listfIn either zip with xml or xml file, more as one possible.
    uses XmlJzCfgAnalyzer.CmdArgs.fdOut to write with writeData(File) currently not used and tested.
    uses XmlJzCfgAnalyzer.CmdArgs.fWriteXmlConfigText to write the content of analysed configuration to a config.txt file usable for XmlCfg.readCfgFile(File, LogMessage) later for parsing.
    uses XmlJzCfgAnalyzer.CmdArgs.fxOut to write the content of analysed configuration to a config.xml file. This is meanwhile (2025-12) no more recommended, use the textual config presentation. It is usable for XmlJzReader#se later for parsing.
    pathfileIn.xml pathfileOutcfg.xml
    Throws:
    
    java.io.IOException
  - analyzeXmlFile
```
public XmlCfg analyzeXmlFile(java.util.List<FileFunctions.FilePathnameExt> fIn)
                      throws java.io.IOException
```
    Reads any XML file and stores the structure in the returned XmlCfg. The found configuration should be writtem out after them with XmlCfg.writeToText(File, LogMessage) to use it to configure the XmlJzReader.setCfg(XmlCfg) with a proper configuration, which reads the here created textual configuration file via XmlCfg.readCfgFile(File, LogMessage) or XmlCfg.readFromJar(Class, String, LogMessage). Whereby, for further usage, the configuration file and also the possible created Java classes can be manual adapted before further usage.
    It calls the following operations per node and attribute in the read XML file, set a breakpoint there to see what's happen. This operations are called inside XmlJzReader.readXml(File, Object) due to the set config with newCfgReadStruct().
    - XmlJzCfgAnalyzer.XmlStructureNode.addElement(String) on a new node on 'XmlJzCfgAnalyzer.XmlStructureNode.setAttribute(String) on a attribute
    - XmlJzCfgAnalyzer.XmlStructureNode.addNamespace(String, String) on a 'xmlns:...' attribute
    - XmlJzCfgAnalyzer.XmlStructureNode.setTextOccurrence() on a text.
    This operations accumulate the occurrence of the given tags and attributes in
    - xmlStructData: Note: renamed from readXmlStructZip(...)
    Parameters:
    
    fXmlIn - The file, immediately the XML file or a zip file containing the XML file.
    
    pathInZip - null for reading immediately XML, else the path in the zip file to the XML file to read.
    
    Returns:
    
    Throws:
    
    java.io.IOException
  - writeCfgTemplate
```
public void writeCfgTemplate(java.io.File wrCfg)
```
    Writes the config file for the XmlJzReader with config file.
    
    Parameters:
    
    wrCfg - the output file.
  - writeCfgText
```
public void writeCfgText(java.io.File fout)
```
    Writes the config file for the XmlJzReader with config file.
    
    Parameters:
    
    wrCfg - the output file.
  - resetCtNodesInStructTree
```
private void resetCtNodesInStructTree()
```
  - resetCtNodesInStructTree
```
private void resetCtNodesInStructTree(XmlJzCfgAnalyzer.XmlStructureNode node,
                                      int recursion)
```
  - writeJavaClasses
```
private void writeJavaClasses()
                       throws java.nio.charset.IllegalCharsetNameException,
                              java.nio.charset.UnsupportedCharsetException
```
    Throws:
    
    java.nio.charset.IllegalCharsetNameException
    
    java.nio.charset.UnsupportedCharsetException
  - wrSetAddContentAttrib
```
private void wrSetAddContentAttrib(XmlJzCfgAnalyzer.XmlStructureNode structNode,
                                   XmlNode wrCfgXmlNode)
                            throws XmlException
```
    Throws:
    
    XmlException
  - addWrNode
```
private void addWrNode(XmlNode wrCfgXmlNode,
                       XmlJzCfgAnalyzer.XmlStructureNode structNode,
                       int recursion)
                throws XmlException
```
    Adds the node and recursively all sub nodes from XmlJzCfgAnalyzer.XmlStructureNode It is invoked after a XML file war read with XmlCfg#newCfgReadStruct()
    
    Parameters:
    
    wrCfgXmlNode - The xml node for output to add.
    
    structNode - The node from the structure of the read XML file,
    
    recursion - decremented, exception on <=0
    
    Throws:
    
    XmlException - on XML error, IllegalArgumentException on recursion error.
  - analyzeXmlStruct
```
public XmlCfg analyzeXmlStruct(java.io.File fXmlIn)
                        throws java.io.IOException
```
    Reads and analyses any XML file and stores the structure in the #XmlCfg. Description see #analyzeXmlStructZip(File, String) Note: compatible form calls analyzeXmlFile(List)
    
    Parameters:
    
    fXmlIn -
    
    Throws:
    
    java.io.IOException
  - readXmlStruct
```
public XmlCfg readXmlStruct(java.io.File fXmlIn)
                     throws java.io.IOException
```
    Compatible form
    
    Parameters:
    
    fXmlIn -
    
    Returns:
    
    Throws:
    
    java.io.IOException
  - readXmlStructZip
```
public XmlCfg readXmlStructZip(java.io.File fIn,
                               java.lang.String sPathInZip)
                        throws java.io.IOException
```
    Reads any XML file and stores the structure in the #XmlCfg. Description see #analyzeXmlStructZip(File, String) Note: compatible form calls analyzeXmlFile(List)
    
    Parameters:
    
    fIn - zip file
    
    sPathInZip - null then fIn should be an XML file, else path of the XML file in the zip
    
    Throws:
    
    java.io.IOException
  - checkStructTree
```
private void checkStructTree()
```
    Checks the read XML structure tree. All the occurrences of nodes with the same tag are stored in allElementTypes. That entries knows all XmlStructNode occurrences. If a XmlStructNode is used in several constellations (more as one time found, different parent), then an entry in cfgData XmlCfg.subtrees will be created to mark, it is an candidate for SUBTREE. The SUBTREE in cfgData is then filled in storeInCfg(XmlJzReader).
  - fillNodesGivenForCheckSubtree
```
private final void fillNodesGivenForCheckSubtree(XmlCfg.XmlCfgNode node,
                                                 java.util.Map<java.lang.String,XmlCfg.XmlCfgNode> idxNodesGiven,
                                                 int recursion)
```
  - storeInCfg
```
private void storeInCfg(XmlJzReader xmlReader)
```
  - storeCfgNode
```
private void storeCfgNode(XmlCfg.XmlCfgNode dst,
                          XmlJzCfgAnalyzer.XmlStructureNode src,
                          boolean bRoot,
                          int recursion)
                   throws java.text.ParseException
```
    Copy or add the content of the read XmlJzCfgAnalyzer.XmlStructureData 'srx' to the XmlCfg 'dst'. This can be a simple inner child node which is created with 'dst' in its parent, or it can be also the first node of a XmlCfg.subtrees
    
    Parameters:
    
    dst - the destination where info from 'src' are stored
    
    src - read data from evaluated XML
    
    bRoot - true then ignore XmlJzCfgAnalyzer.XmlStructureNode.sSubtreenode because it is the name of the subtree itself, and not the reference to a subtree.
    
    recursion - called recursively for all sub nodes
    
    Throws:
    
    java.text.ParseException
  - mergeNode
```
public void mergeNode(XmlCfg.XmlCfgNode ndDst,
                      XmlJzCfgAnalyzer.XmlStructureNode ndSrc)
```
  - writeData
```
public void writeData(java.io.File fout)
               throws java.io.IOException
```
    Throws:
    
    java.io.IOException

Class XmlJzCfgAnalyzer

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

version

cmdArgs

dirDbg

debugStopLineXmlInp

log

xmlStructData

xmlStructTree

allElementTypes

cfgData

cfgGiven

cfgGiven1

Constructor Detail

XmlJzCfgAnalyzer

Method Detail

main

smain

amain

newCfgReadStruct

setDirDebug

setDebugStop

analyzeXml

analyzeXmlFile

writeCfgTemplate

writeCfgText

resetCtNodesInStructTree

resetCtNodesInStructTree

writeJavaClasses

wrSetAddContentAttrib

addWrNode

analyzeXmlStruct

readXmlStruct

readXmlStructZip

checkStructTree

fillNodesGivenForCheckSubtree

storeInCfg

storeCfgNode

mergeNode

writeData