XmlSequWriter

java.lang.Object
- org.vishia.xmlSimple.XmlSequWriter

```
public class XmlSequWriter
extends java.lang.Object
```
This is a XML writer which does not store anything. It writes only. The usage is seen in the test files, #testWritetree2(File, StringBuilder) etc with following template:
```
    open(file, "US-ASCII", out);
    writeElement("root");
      writeText("contentRoot", true);
    writeElement("child1");
      writeAttribute("attr", "value");
      writeText("contentChild <???> special chars", false);
      writeElementEnd();
    writeElement("child2");
      writeAttribute("attr2", "text ? special chars");
    close();
 
```
The output for that is:
```
<?xml version="1.0" encoding="US-ASCII"?>
<root>
  contentRoot
  <child1 attr="value">contentChild &lt;&#xc4;&#xdc;&#xd6;&gt; special chars</child1>
  <child2 attr2="text &#x20ac; special chars"/>
</root>
 
```
Note: The source contains the transcription for Javadoc. See the original. Javadoc presents correctly.
Features:
- Supported encodings are all UTF-, US-ASCII and ISO-8859-1 yet. Other ISO-8859-x can be enhanced (needs a special solution, see CodeCharset
- Parallel to the file an Appendable can be written, for debug or Java-internal String usage of XML output.
- Namespaces should be written manually as attributes and as "ns:tag"
- Beatification on output: default 2 spaces for indent on any element, indent on text content is able to parametrize

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private static class XmlSequWriter.ElementInfo

Nested Classes
Modifier and Type	Class and Description
`private static class`	`XmlSequWriter.ElementInfo`

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) boolean`	`bElementStart`
`(package private) boolean`	`bFullEncoding` true then no reason to output transcription characters.
`boolean`	`bTreeComment`
`(package private) XmlSequWriter.ElementInfo`	`elementCurr` Info of the current element.
`(package private) java.util.Stack<XmlSequWriter.ElementInfo>`	`elementsParent` Store all parent elements, necessary for close etc.
`private java.nio.charset.Charset`	`encodingFile` The used encoding for File output and also the encoding to convert Java internal UTF-16 to the file's enconding.
`private CodeCharset`	`encodingJava2File` The encoding to convert Java internal UTF-16 to the file's encoding.
`private java.nio.file.FileSystem`	`fileSystem` Used for zip files.
`private java.io.OutputStream`	`fwrFile`
`(package private) int`	`indent`
`(package private) int`	`nColumn`
`(package private) int`	`nColumnMax`
`private java.lang.String`	`replaceBasics`
`(package private) java.lang.String`	`sEncoding`
`private static java.lang.String`	`sIndent`
`private static java.lang.String[]`	`stdReplacement`
`private java.lang.Appendable`	`twr`
`static java.lang.String`	`version` Version, License and History: 2024-07-05 uses a temporary `wsb` to see what was written in debug.
`private java.io.Writer`	`wrFile`
`private java.lang.StringBuilder`	`wsb` This is for debugging, see what was written at last.
`private static int`	`zWsb`

Constructor Summary

Constructors
Constructor and Description

XmlSequWriter()

Constructors
Constructor and Description
`XmlSequWriter()`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`close()` Writes closing elementsParent if necessary, then close the files.
`java.lang.String`	`elementCurrTag()`
`void`	`fileclose()`
`java.lang.String`	`open(java.io.File file, java.lang.String encodingArg, java.lang.Appendable buffer)` Opens for writing in a file, closes an opened file if any is open.
`void`	`replaceNewline(boolean bReplace)` Switch the mode for replacing a \n in texts or attribute values.
`void`	`setDebugTextOut(java.lang.Appendable out)` Sets an output for text output of the created XML.
`void`	`setEncoding(java.lang.String sEncoding)`
`java.lang.String`	`toString()`
`void`	`writeAttribute(java.lang.String name, java.lang.String value)`
`void`	`writeComment()`
`void`	`writeElement(java.lang.String sTag)` Writes a new Element with its tag in a new line with incremented indentation.
`void`	`writeElementEnd()` Writes a simple end "" or "/>" depending on invocation of `#writeElementHeadEnd()` before
`private void`	`writeElementEnd(boolean bNewline)` Writes a simple end "" or "/>" depending on invocation of `#writeElementHeadEnd()` before
`void`	`writeElementEnd(java.lang.String sTag)` Writes the or .../> in the same line as the opened tag or in a new line, depending on written child elements.
`private void`	`writeElementEnd(java.lang.String sTag, boolean bNewline)` Writes the or .../> but checks whether this is the correct tag.
`void`	`writeElementEndInline(java.lang.String sTag)` Writes the or .../> anyway without newline, independent of the tree situation.
`void`	`writeElementHeadEnd(boolean bNewline)` Writes a simple end ">" because child nodes may be added to the element.
`void`	`writeElementInline(java.lang.String sTag)` Writes a new Element with its tag in the line without line break and change or indentation.
`private void`	`writeHead()`
`void`	`writeText(java.lang.CharSequence txt, boolean bNewline)`
`private void`	`wrNewline()`
`private void`	`wrTxtBuffered(java.lang.CharSequence txt)` Writes the text immediately as given to the debug buffer file, but {@link #wrTxtToFile(CharSequence) changes non writeable UTF-16 characters to the file encoding.
`private void`	`wrTxtByteEncoding(java.lang.String txt)` Simple writes the ASCII 8 bit code- Text to `fwrFile`
`private void`	`wrTxtToFile(java.lang.CharSequence txt)` Write as given, without replacement of "<" etc, it is for the immediately output.
`private void`	`wrTxtWithReplacements(java.lang.CharSequence txt)` Writes text with all replacements.
`void`	`XXXflush()`
`java.lang.String`	`XXXopenZip(java.io.File file, java.lang.String sPathInZip, java.lang.String encoding, java.lang.Appendable buffer)` Deprecated.

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

- Field Detail
  - version
```
public static final java.lang.String version
```
    Version, License and History:
    - 2024-07-05 uses a temporary wsb to see what was written in debug. The wrTxtToFile(CharSequence) does yet the conversion to special character for non UTF-8 encoding.
    - 2024-06-30 new writeElementEndInline(String) necessary for LibreOffice because this tool interprets a newline before </text:p> as a space in the paragraph. It was obvious if a paragraph does only contain an image, because then no writeElementInline(String) was called which also forces <:text:p> on end of line.
    - 2024-05-28 new writeElementInline(String) to write contigous content in one line.
    - 2024-05-28 writeElementEnd(String) important first to check correctness, second also for documentation which kind of element is closed.
    - 2024-05-28 #openZip(File, String, String, Appendable) Now also to write zips.
    - 2020-10-05 check encoding stuff, some better documented and changed. Hint: Introducing namespace processing is faulty here. The namespace can be written as normal attribute name string or tag, as given. Handling of namespaces should be done in the application. This class is in documentation yet. See https://vishia.org/Java/html/RWTrans/XmlSeqWriter.html
    - 2019-12-24 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
  - fileSystem
```
private java.nio.file.FileSystem fileSystem
```
    Used for zip files.
  - wrFile
```
private java.io.Writer wrFile
```
  - fwrFile
```
private java.io.OutputStream fwrFile
```
  - twr
```
private java.lang.Appendable twr
```
  - wsb
```
private java.lang.StringBuilder wsb
```
    This is for debugging, see what was written at last. If the StringBuilder is filled more than 1500, the first 1000 are written to file, and shift.
  - zWsb
```
private static int zWsb
```
  - sEncoding
```
java.lang.String sEncoding
```
  - encodingFile
```
private java.nio.charset.Charset encodingFile
```
    The used encoding for File output and also the encoding to convert Java internal UTF-16 to the file's enconding.
  - encodingJava2File
```
private CodeCharset encodingJava2File
```
    The encoding to convert Java internal UTF-16 to the file's encoding. it is the same as encoding, or it is null for UTF encoding
  - bFullEncoding
```
boolean bFullEncoding
```
    true then no reason to output transcription characters.
  - bElementStart
```
boolean bElementStart
```
  - nColumn
```
int nColumn
```
  - nColumnMax
```
int nColumnMax
```
  - elementCurr
```
XmlSequWriter.ElementInfo elementCurr
```
    Info of the current element.
  - elementsParent
```
java.util.Stack<XmlSequWriter.ElementInfo> elementsParent
```
    Store all parent elements, necessary for close etc. and also for parent namespaces.
  - indent
```
int indent
```
  - replaceBasics
```
private java.lang.String replaceBasics
```
  - stdReplacement
```
private static java.lang.String[] stdReplacement
```
  - bTreeComment
```
public boolean bTreeComment
```
  - sIndent
```
private static java.lang.String sIndent
```
- Constructor Detail
  - XmlSequWriter
```
public XmlSequWriter()
```
- Method Detail
  - setEncoding
```
public void setEncoding(java.lang.String sEncoding)
                 throws java.nio.charset.IllegalCharsetNameException
```
    Throws:
    
    java.nio.charset.IllegalCharsetNameException
  - open
```
public java.lang.String open(java.io.File file,
                             java.lang.String encodingArg,
                             java.lang.Appendable buffer)
                      throws java.io.IOException
```
    Opens for writing in a file, closes an opened file if any is open.
    
    Parameters:
    
    file - can be null, then only the buffer is written.
    
    encodingArg - can be null, then the last used or given setEncoding(String) is valid. Default is "UTF-8". If given the setEncoding(String) is called here.
    If the encoding is "ISO-8859-x" or "US-ASCII" then non map able characters are written as 샞
    On other encodings non mapable character are faulty written as defined by Writer(... Charset).
    
    buffer - can be null, if given, the output is written there, the same as in setDebugTextOut(Appendable) The buffer is written with replaced characters by 샞 as in file.
    
    Returns:
    
    null on success, the error on error. It is either "Encoding ..." on unsupportedCharset or "File not able to create: ..." with the absolute path of the file.
    
    Throws:
    
    java.io.IOException - only on closing an opened file. Not expected.
  - XXXopenZip
```
@Deprecated
public java.lang.String XXXopenZip(java.io.File file,
                                                java.lang.String sPathInZip,
                                                java.lang.String encoding,
                                                java.lang.Appendable buffer)
                                         throws java.io.IOException
```
    Deprecated.
    
    Opens for writing in a file, closes an opened file if any is open. This is used once, but seems not be correct.
    
    Parameters:
    
    file - can be null, then only the buffer is written.
    
    encoding - can be null, then the last used or given setEncoding(String) is valid. Default is "UTF-8". If given the setEncoding(String) is called here.
    If the encoding is "ISO-8859-x" or "US-ASCII" then non map able characters are written as 샞
    On other encodings non mapable character are faulty written as defined by Writer(... Charset).
    
    buffer - can be null, if given, the output is written there, the same as in setDebugTextOut(Appendable) The buffer is written with replaced characters by 샞 as in file.
    
    Returns:
    
    null on success, the error on error. It is either "Encoding ..." on unsupportedCharset or "File not able to create: ..." with the absolute path of the file.
    
    Throws:
    
    java.io.IOException - only on closing an opened file. Not expected.
  - close
```
public void close()
           throws java.io.IOException
```
    Writes closing elementsParent if necessary, then close the files.
    
    Throws:
    
    java.io.IOException
  - XXXflush
```
public void XXXflush()
              throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - fileclose
```
public void fileclose()
```
  - setDebugTextOut
```
public void setDebugTextOut(java.lang.Appendable out)
```
    Sets an output for text output of the created XML. If #open(File, String) is not used respectively close() is called before, the XML output is written only to this Appendable. If #open(File, String) is used too, the XML output is written twice, to this Appendable too. The Appendable instance can used outside of this XML write operations in any kind, it can be delete etc. Hence it may be used as debug check.
    
    Parameters:
    
    out - if null then this output is disabled.
  - replaceNewline
```
public void replaceNewline(boolean bReplace)
```
    Switch the mode for replacing a \n in texts or attribute values.
    
    Parameters:
    
    bReplace - true, then do not output a \n (line break), instead output false then break the line with \n if it occurs in texts and attribute values.
  - writeHead
```
private void writeHead()
                throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writeComment
```
public void writeComment()
```
  - writeElement
```
public void writeElement(java.lang.String sTag)
                  throws java.io.IOException
```
    Writes a new Element with its tag in a new line with incremented indentation. The element is not closed with >, because attributes should be written. See also writeElementInline(String). It is a child node of a non closed writeElement(String) before. After this call firstly writeAttribute(String, String) can be written, then writeElement(String) for child nodes or #writeText()
    
    Parameters:
    
    sTag -
    
    Throws:
    
    java.io.IOException
  - writeElementInline
```
public void writeElementInline(java.lang.String sTag)
                        throws java.io.IOException
```
    Writes a new Element with its tag in the line without line break and change or indentation. The element is not closed with >, because attributes should be written. It is a child node of a non closed writeElement(String) before. After this call firstly writeAttribute(String, String) can be written, then writeElement(String) for child nodes or #writeText()
    
    Writing an element in the line, without newline, is sometimes necessary for systems which reads the text inside the elements. In XML it seems to be not absolute clear, when a newline has a meaning for text content or not. Usual between elements, if no text is there, only the line feed and indentation, this is ignored by reading the XML content. But it seems to be some programs does not so, (Libre Office odt content.xml?) They seems to interpret an new line as a space. That's why all stuff from one text paragraph is written in one line. Line breaks are only introduced between the paragraphs. This is a seen, not explained behavior. This operation helps to build one line for a defined XML content.
    
    Parameters:
    
    sTag -
    
    Throws:
    
    java.io.IOException
  - wrNewline
```
private void wrNewline()
                throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writeElementHeadEnd
```
public void writeElementHeadEnd(boolean bNewline)
                         throws java.io.IOException
```
    Writes a simple end ">" because child nodes may be added to the element.
    
    Throws:
    
    java.io.IOException
  - writeElementEnd
```
public void writeElementEnd(java.lang.String sTag)
                     throws java.io.IOException
```
    Writes the or .../> in the same line as the opened tag or in a new line, depending on written child elements.
    
    Parameters:
    
    sTag - should correspond with the open tag.
    
    Throws:
    
    java.io.IOException
    
    java.lang.IllegalStateException - on tag mismatch.
  - writeElementEnd
```
private void writeElementEnd(java.lang.String sTag,
                             boolean bNewline)
                      throws java.io.IOException
```
    Writes the or .../> but checks whether this is the correct tag.
    
    Parameters:
    
    sTag - should correspond with the open tag.
    
    bNewline - true then writes the in a newline, but not if the element was created with writeElementInline(String).
    
    Throws:
    
    java.io.IOException
    
    java.lang.IllegalStateException - on tag mismatch.
  - writeElementEndInline
```
public void writeElementEndInline(java.lang.String sTag)
                           throws java.io.IOException
```
    Writes the or .../> anyway without newline, independent of the tree situation. This can be used for special cases to prevent interpretation of a newline from the evaluation of the XML.
    
    Parameters:
    
    sTag - should correspond with the open tag.
    
    Throws:
    
    java.io.IOException
    
    java.lang.IllegalStateException - on tag mismatch.
  - writeElementEnd
```
public void writeElementEnd()
                     throws java.io.IOException
```
    Writes a simple end "" or "/>" depending on invocation of #writeElementHeadEnd() before
    
    Throws:
    
    java.io.IOException
  - writeElementEnd
```
private void writeElementEnd(boolean bNewline)
                      throws java.io.IOException
```
    Writes a simple end "" or "/>" depending on invocation of #writeElementHeadEnd() before
    
    Throws:
    
    java.io.IOException
  - writeAttribute
```
public void writeAttribute(java.lang.String name,
                           java.lang.String value)
                    throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writeText
```
public void writeText(java.lang.CharSequence txt,
                      boolean bNewline)
               throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - wrTxtWithReplacements
```
private void wrTxtWithReplacements(java.lang.CharSequence txt)
                            throws java.io.IOException
```
    Writes text with all replacements.
    
    Parameters:
    
    txt -
    
    Throws:
    
    java.io.IOException
  - wrTxtBuffered
```
private void wrTxtBuffered(java.lang.CharSequence txt)
                    throws java.io.IOException
```
    Writes the text immediately as given to the debug buffer file, but {@link #wrTxtToFile(CharSequence) changes non writeable UTF-16 characters to the file encoding.
    
    Parameters:
    
    txt - as Java internal UTF-16 text stored in wsb. If wsb would be overflow, the half content is written to file
    
    Throws:
    
    java.io.IOException
  - wrTxtToFile
```
private void wrTxtToFile(java.lang.CharSequence txt)
                  throws java.io.IOException
```
    Write as given, without replacement of "<" etc, it is for the immediately output. It is called from wrTxtBuffered(CharSequence). But due to the file encoding non writable character are transformed to "ģ" in its UTF-16 value.
    
    Parameters:
    
    txt -
    
    Throws:
    
    java.io.IOException
  - wrTxtByteEncoding
```
private void wrTxtByteEncoding(java.lang.String txt)
                        throws java.io.IOException
```
    Simple writes the ASCII 8 bit code- Text to fwrFile
    
    Parameters:
    
    txt -
    
    Throws:
    
    java.io.IOException
  - elementCurrTag
```
public java.lang.String elementCurrTag()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class XmlSequWriter

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

version

fileSystem

wrFile

fwrFile

twr

wsb

zWsb

sEncoding

encodingFile

encodingJava2File

bFullEncoding

bElementStart

nColumn

nColumnMax

elementCurr

elementsParent

indent

replaceBasics

stdReplacement

bTreeComment

sIndent

Constructor Detail

XmlSequWriter

Method Detail

setEncoding

open

XXXopenZip

close

XXXflush

fileclose

setDebugTextOut

replaceNewline

writeHead

writeComment

writeElement

writeElementInline

wrNewline

writeElementHeadEnd

writeElementEnd

writeElementEnd

writeElementEndInline

writeElementEnd

writeElementEnd

writeAttribute

writeText

wrTxtWithReplacements

wrTxtBuffered

wrTxtToFile

wrTxtByteEncoding

elementCurrTag

toString