Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## de.jstacs.io
Class XMLParser

    java.lang.Object
      de.jstacs.io.XMLParser

    public class XMLParser

extends Object

Class for parsing standard data types and arrays in and out of an XML `File`. The methods with prefix `append` or `add` are for encoding, while methods with prefix `extract` are for decoding.

Author:
  Jan Grau, Jens Keilwagen

Constructor Summary
`XMLParser()`

Method Summary
`static void` | `addTags(StringBuffer source, String tag)` Frames the `StringBuffer` `source` with equal tags "< `tag`>" and "<`/tag` >".
`static void` | `addTagsAndAttributes(StringBuffer source, String tag, String attributes)` Frames the `StringBuffer` `source` with "< `tag attributes`>" and "<`/tag` >".
`static void` | `appendBoolean2ArrayWithTags(StringBuffer source, boolean[][] i, String tag)` Appends an encoded two dimensional `boolean` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendBoolean2ArrayWithTagsAndAttributes(StringBuffer source, boolean[][] i, String tag, String attributes)` Appends an encoded two dimensional `boolean` array with the tags to the `StringBuffer` `source`.
`static void` | `appendBooleanArrayWithTags(StringBuffer source, boolean[] b, String tag)` Appends an encoded `boolean` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendBooleanArrayWithTagsAndAttributes(StringBuffer source, boolean[] b, String tag, String attributes)` Appends an encoded `boolean` array with the tags to the `StringBuffer` `source`.
`static void` | `appendBooleanWithTags(StringBuffer source, boolean b, String tag)` Appends a `boolean` value with equal tags to the `StringBuffer` `source` in the following way: "< `tag`>`b`<`/tag`>".
`static void` | `appendBooleanWithTagsAndAttributes(StringBuffer source, boolean b, String tag, String attributes)` Appends a `boolean` value with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`b`<`/tag` >".
`static void` | `appendByte2ArrayWithTags(StringBuffer source, byte[][] b, String tag)` Appends an encoded two dimensional `byte` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendByte2ArrayWithTagsAndAttributes(StringBuffer source, byte[][] b, String tag, String attributes)` Appends an encoded two dimensional `byte` array with the tags to the `StringBuffer` `source`.
`static void` | `appendByteArrayWithTags(StringBuffer source, byte[] b, String tag)` Appends an encoded `byte` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendByteArrayWithTagsAndAttributes(StringBuffer source, byte[] b, String tag, String attributes)` Appends an encoded `byte` array with the tags to the `StringBuffer` `source`.
`static void` | `appendByteWithTags(StringBuffer source, byte b, String tag)` Appends a `byte` value with equal tags to the `StringBuffer` `source` in the following way: "< `tag`>`b`<`/tag`>".
`static void` | `appendByteWithTagsAndAttributes(StringBuffer source, byte b, String tag, String attributes)` Appends a `byte` value with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`b`<`/tag` >".
`static void` | `appendDouble2ArrayWithTags(StringBuffer source, double[][] d, String tag)` Appends an encoded two dimensional `double` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendDouble2ArrayWithTagsAndAttributes(StringBuffer source, double[][] d, String tag, String attributes)` Appends an encoded two dimensional `double` array with the tags to the `StringBuffer` `source`.
`static void` | `appendDoubleArrayWithTags(StringBuffer source, double[] d, String tag)` Appends an encoded `double` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendDoubleArrayWithTagsAndAttributes(StringBuffer source, double[] d, String tag, String attributes)` Appends an encoded `double` array with the tags to the `StringBuffer` `source`.
`static void` | `appendDoubleWithTags(StringBuffer source, double d, String tag)` Appends a `double` value with equal tags to the `StringBuffer` `source` in the following way: "< `tag`>`d`<`/tag`>".
`static void` | `appendDoubleWithTagsAndAttributes(StringBuffer source, double d, String tag, String attributes)` Appends a `double` value with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`d`<`/tag` >".
`static
`<T extends Enum<T>> void`
` | `appendEnumWithTags(StringBuffer source, Enum<T> e, String tag)` Appends an `Enum` object with equal tags to the `StringBuffer` `source`.
`static
`<T extends Enum<T>> void`
` | `appendEnumWithTagsAndAttributes(StringBuffer source, Enum<T> e, String tag, String attributes)` Appends an `Enum` object with the tags to the `StringBuffer` `source`.
`static void` | `appendInt2ArrayWithTags(StringBuffer source, int[][] i, String tag)` Appends an encoded two dimensional `int` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendInt2ArrayWithTagsAndAttributes(StringBuffer source, int[][] i, String tag, String attributes)` Appends an encoded two dimensional `int` array with the tags to the `StringBuffer` `source`.
`static void` | `appendIntArrayWithTags(StringBuffer source, int[] i, String tag)` Appends an encoded `int` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendIntArrayWithTagsAndAttributes(StringBuffer source, int[] i, String tag, String attributes)` Appends an encoded `int` array with the tags to the `StringBuffer` `source`.
`static void` | `appendIntWithTags(StringBuffer source, int i, String tag)` Appends an `int` value with equal tags to the `StringBuffer` `source` in the following way: "< `tag`>`i`<`/tag`>"
`static void` | `appendIntWithTagsAndAttributes(StringBuffer source, int i, String tag, String attributes)` Appends an `int` value with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`i`<`/tag` >".
`static void` | `appendLongWithTags(StringBuffer source, long i, String tag)` Appends a `long` value with equal tags to the `StringBuffer` `source` in the following way: "< `tag`>`i`<`/tag`>".
`static void` | `appendLongWithTagsAndAttributes(StringBuffer source, long l, String tag, String attributes)` Appends a `long` value with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`i`<`/tag` >".
`static void` | `appendStorable2ArrayWithTags(StringBuffer source, Storable[][] s, String tag)` Appends an encoded two dimensional `Storable` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendStorable2ArrayWithTagsAndAttributes(StringBuffer source, Storable[][] s, String tag, String attributes)` Appends an encoded two dimensional `Storable` array with the tags to the `StringBuffer` `source`.
`static void` | `appendStorable3ArrayWithTags(StringBuffer source, Storable[][][] s, String tag)` Appends an encoded three dimensional `Storable` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendStorable3ArrayWithTagsAndAttributes(StringBuffer source, Storable[][][] s, String tag, String attributes)` Appends an encoded three dimensional `Storable` array with the tags to the `StringBuffer` `source`.
`static void` | `appendStorableArrayWithTags(StringBuffer source, Storable[] s, String tag)` Appends an encoded `Storable` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendStorableArrayWithTagsAndAttributes(StringBuffer source, Storable[] s, String tag, String attributes)` Appends an encoded `Storable` array with the tags to the `StringBuffer` `source`.
`static void` | `appendStorableWithTags(StringBuffer source, Storable s, String tag)` Appends a `Storable` object or "null" with equal tags to the `StringBuffer` `source`.
`static void` | `appendStorableWithTagsAndAttributes(StringBuffer source, Storable s, String tag, String attributes)` Appends a `Storable` object or "null" with the tags to the `StringBuffer` `source`.
`static void` | `appendString2ArrayWithTags(StringBuffer source, String[][] s, String tag)` Appends an encoded two dimensional `String` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendString2ArrayWithTagsAndAttributes(StringBuffer source, String[][] s, String tag, String attributes)` Appends an encoded two dimensional `String` array with the tags to the `StringBuffer` `source`.
`static void` | `appendStringArrayWithTags(StringBuffer source, String[] s, String tag)` Appends an encoded `String` array with equal tags to the `StringBuffer` `source`.
`static void` | `appendStringArrayWithTagsAndAttributes(StringBuffer source, String[] s, String tag, String attributes)` Appends an encoded `String` array with the tags to the `StringBuffer` `source`.
`static void` | `appendStringWithTags(StringBuffer source, String s, String tag)` Appends a `String` with equal tags to the `StringBuffer` `source` in the following way: "<`tag`> `s`<`/tag` >".
`static void` | `appendStringWithTagsAndAttributes(StringBuffer source, String s, String tag, String attributes)` Appends a `String` with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`s`<`/tag` >".
`static boolean[][]` | `extractBoolean2ArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as two dimensional `boolean` array.
`static boolean[][]` | `extractBoolean2ArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as two dimensional `boolean` array.
`static boolean` | `extractBooleanAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `boolean`.
`static boolean[]` | `extractBooleanArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `boolean` array.
`static boolean[]` | `extractBooleanArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as `boolean` array.
`static boolean` | `extractBooleanForTag(StringBuffer source, String tag)` Returns the value between the tags as `boolean`.
`static byte[][]` | `extractByte2ArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as two dimensional `byte` array.
`static byte[][]` | `extractByte2ArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as two dimensional `byte` array.
`static byte` | `extractByteAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `byte`.
`static byte[]` | `extractByteArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `byte` array.
`static byte[]` | `extractByteArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as `byte` array.
`static byte` | `extractByteForTag(StringBuffer source, String tag)` Returns the value between the tags as `byte`.
`static double[][]` | `extractDouble2ArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as two dimensional `double` array.
`static double[][]` | `extractDouble2ArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as two dimensional `double` array.
`static double` | `extractDoubleAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `double`.
`static double[]` | `extractDoubleArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `double` array.
`static double[]` | `extractDoubleArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as `double` array.
`static double` | `extractDoubleForTag(StringBuffer source, String tag)` Returns the value between the tags as `double` .
`static
`<T extends Enum<T>> T`
` | `extractEnumAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `Enum`.
`static
`<T extends Enum<T>> T`
` | `extractEnumForTag(StringBuffer source, String tag)` Returns the value between the tags as `Enum`.
`static StringBuffer` | `extractForTag(StringBuffer source, String tag)` Extracts the contents of `source` between `tag` start and end tags.
`static StringBuffer` | `extractForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Extracts the contents of `source` between `tag` start and end tags.
`static int[][]` | `extractInt2ArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as two dimensional `int` array.
`static int[][]` | `extractInt2ArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as two dimensional `int` array.
`static int` | `extractIntAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `int`.
`static int[]` | `extractIntArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `int` array.
`static int[]` | `extractIntArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as `int` array.
`static int` | `extractIntForTag(StringBuffer source, String tag)` Returns the value between the tags as `int`.
`static long` | `extractLongAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `long`.
`static long` | `extractLongForTag(StringBuffer source, String tag)` Returns the value between the tags as `long`.
`static Storable[][]` | `extractStorable2ArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as two dimensional `Storable` array.
`static Storable[][]` | `extractStorable2ArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes, Class<? extends Storable> clazz)` Returns the value between the tags as two dimensional `Storable` array.
`static Storable[][]` | `extractStorable2ArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as two dimensional `Storable` array.
`static Storable[][]` | `extractStorable2ArrayForTag(StringBuffer source, String tag, Class<? extends Storable> clazz)` Returns the value between the tags as two dimensional `Storable` array.
`static Storable[][][]` | `extractStorable3ArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as three dimensional `Storable` array.
`static Storable[][][]` | `extractStorable3ArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes, Class<? extends Storable> clazz)` Returns the value between the tags as three dimensional `Storable` array.
`static Storable[][][]` | `extractStorable3ArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as three dimensional `Storable` array.
`static Storable[][][]` | `extractStorable3ArrayForTag(StringBuffer source, String tag, Class<? extends Storable> clazz)` Returns the value between the tags as three dimensional `Storable` array.
`static Storable` | `extractStorableAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `Storable` or `null`.
`static Storable` | `extractStorableAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes, Class<? extends Storable> clazz)` Returns the value between the tags as `Storable` or `null`.
`static Storable[]` | `extractStorableArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `Storable` array.
`static Storable[]` | `extractStorableArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes, Class<? extends Storable> clazz)` Returns the value between the tags as `Storable` array.
`static Storable[]` | `extractStorableArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as `Storable` array.
`static Storable[]` | `extractStorableArrayForTag(StringBuffer source, String tag, Class<? extends Storable> clazz)` Returns the value between the tags as `Storable` array.
`static Storable` | `extractStorableForTag(StringBuffer source, String tag)` Returns the value between the tags as `Storable` or `null`.
`static Storable` | `extractStorableForTag(StringBuffer source, String tag, Class<? extends Storable> clazz)` Returns the value between the tags as `Storable` or `null`.
`static String[][]` | `extractString2ArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as two dimensional `String` array.
`static String[][]` | `extractString2ArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as two dimensional `String` array.
`static String` | `extractStringAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `String`.
`static String[]` | `extractStringArrayAndAttributesForTag(StringBuffer source, String tag, Map<String,String> attributes, Map<String,String> filterAttributes)` Returns the value between the tags as `String` array.
`static String[]` | `extractStringArrayForTag(StringBuffer source, String tag)` Returns the value between the tags as `String` array.
`static String` | `extractStringForTag(StringBuffer source, String tag)` Returns the value between the tags as `String`.
`protected static StringBuffer` | `getBooleanArrayWithTags(boolean[] b)` Encodes a `boolean` array.
`protected static StringBuffer` | `getByteArrayWithTags(byte[] b)` Encodes a `byte` array.
`protected static StringBuffer` | `getDoubleArrayWithTags(double[] d)` Encodes a `double` array.
`protected static StringBuffer` | `getIntArrayWithTags(int[] i)` Encodes an `int` array.
`protected static StringBuffer` | `getStorableArrayWithTags(Storable[] s)` Encodes a `Storable` array.
`protected static StringBuffer` | `getStringArrayWithTags(String[] s)` Encodes a `String` array.

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

Constructor Detail

### XMLParser

    public XMLParser()

Method Detail

### extractForTag

    public static StringBuffer extractForTag(StringBuffer source,
                                             String tag)
                                      throws NonParsableException

  Extracts the contents of `source` between `tag` start and end tags.

  Parameters:
    `source` - the XML-code containing start and end tag
    `tag` - the tag (without angle brackets)
  Returns:
    the contents of start and end tags, without these tags, as a `StringBuffer`
  Throws:
    `NonParsableException` - if start or end tag could not be found

### extractForTag

    public static StringBuffer extractForTag(StringBuffer source,
                                             String tag,
                                             Map<String,String> attributes,
                                             Map<String,String> filterAttributes)
                                      throws NonParsableException

  Extracts the contents of `source` between `tag` start and end tags. If `attributes` is not `null`, the attributes of the start tag are added to this `Map`. If `filterAttributes` is not `null`, the start tag is accepted only if its attributes and associated values contain those defined in `filterAttributed`.

  Parameters:
    `source` - the XML-code containing start and end tag
    `tag` - the tag (without angle brackets)
    `attributes` - a `Map` for attributes and values, or `null` if no attributes should be parsed.
    `filterAttributes` - a `Map` of attributes and associated values, which must be present in the attributes of the start tag, or `null` for no filtering
  Returns:
    the contents of start and end tags, without these tags, as a `StringBuffer`
  Throws:
    `NonParsableException` - if start or end tag could not be found

### extractBooleanForTag

    public static boolean extractBooleanForTag(StringBuffer source,
                                               String tag)
                                        throws NonParsableException

  Returns the value between the tags as `boolean`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as `boolean`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractBooleanAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractBooleanAndAttributesForTag

    public static boolean extractBooleanAndAttributesForTag(StringBuffer source,
                                                            String tag,
                                                            Map<String,String> attributes,
                                                            Map<String,String> filterAttributes)
                                                     throws NonParsableException

  Returns the value between the tags as `boolean`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as `boolean`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`

### extractByteForTag

    public static byte extractByteForTag(StringBuffer source,
                                         String tag)
                                  throws NonParsableException

  Returns the value between the tags as `byte`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as `byte`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractByteAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractByteAndAttributesForTag

    public static byte extractByteAndAttributesForTag(StringBuffer source,
                                                      String tag,
                                                      Map<String,String> attributes,
                                                      Map<String,String> filterAttributes)
                                               throws NonParsableException

  Returns the value between the tags as `byte`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as `byte`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`

### extractEnumForTag

    public static <T extends Enum<T>> T extractEnumForTag(StringBuffer source,
                                                          String tag)
                                               throws NonParsableException

  Returns the value between the tags as `Enum`.

  Type Parameters:
    `T` - the type of the `Enum` objects
  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the enumeration between the tags as `Enum`
  Throws:
    `NonParsableException` - if the enumeration could not be parsed
  See Also:
    `extractEnumAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractEnumAndAttributesForTag

    public static <T extends Enum<T>> T extractEnumAndAttributesForTag(StringBuffer source,
                                                                       String tag,
                                                                       Map<String,String> attributes,
                                                                       Map<String,String> filterAttributes)
                                                            throws NonParsableException

  Returns the value between the tags as `Enum`.

  Type Parameters:
    `T` - the type of the `Enum` objects
  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the enumeration between the tags as `Enum`
  Throws:
    `NonParsableException` - if the enumeration could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`

### extractIntForTag

    public static int extractIntForTag(StringBuffer source,
                                       String tag)
                                throws NonParsableException

  Returns the value between the tags as `int`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as `int`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractIntAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractIntAndAttributesForTag

    public static int extractIntAndAttributesForTag(StringBuffer source,
                                                    String tag,
                                                    Map<String,String> attributes,
                                                    Map<String,String> filterAttributes)
                                             throws NonParsableException

  Returns the value between the tags as `int`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as `int`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`

### extractLongForTag

    public static long extractLongForTag(StringBuffer source,
                                         String tag)
                                  throws NonParsableException

  Returns the value between the tags as `long`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as `long`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractLongAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractLongAndAttributesForTag

    public static long extractLongAndAttributesForTag(StringBuffer source,
                                                      String tag,
                                                      Map<String,String> attributes,
                                                      Map<String,String> filterAttributes)
                                               throws NonParsableException

  Returns the value between the tags as `long`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as `long`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`

### extractDoubleForTag

    public static double extractDoubleForTag(StringBuffer source,
                                             String tag)
                                      throws NonParsableException

  Returns the value between the tags as `double` .

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as `double`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractDoubleAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractDoubleAndAttributesForTag

    public static double extractDoubleAndAttributesForTag(StringBuffer source,
                                                          String tag,
                                                          Map<String,String> attributes,
                                                          Map<String,String> filterAttributes)
                                                   throws NonParsableException

  Returns the value between the tags as `double`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as `double`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`

### extractStorableForTag

    public static Storable extractStorableForTag(StringBuffer source,
                                                 String tag)
                                          throws NonParsableException

  Returns the value between the tags as `Storable` or `null`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as `Storable`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractStorableAndAttributesForTag(StringBuffer, String, Map, Map)`, `extractStorableAndAttributesForTag(StringBuffer, String, Map, Map, Class)`

### extractStorableAndAttributesForTag

    public static Storable extractStorableAndAttributesForTag(StringBuffer source,
                                                              String tag,
                                                              Map<String,String> attributes,
                                                              Map<String,String> filterAttributes)
                                                       throws NonParsableException

  Returns the value between the tags as `Storable` or `null`. The concrete class of the `Storable` is inferred from the XML.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as `Storable`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorableAndAttributesForTag(StringBuffer, String, Map, Map, Class)`

### extractStorableForTag

    public static Storable extractStorableForTag(StringBuffer source,
                                                 String tag,
                                                 Class<? extends Storable> clazz)
                                          throws NonParsableException

  Returns the value between the tags as `Storable` or `null`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `clazz` - the concrete class of the `Storable`, can be `null` then the class is inferred from the XML, otherwise it is tried to create an instance of the class without checking whether it is possible. This might result in an `NonParsableException`
  Returns:
    the value between the tags as `Storable`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorableAndAttributesForTag(StringBuffer, String, Map, Map, Class)`

### extractStorableAndAttributesForTag

    public static Storable extractStorableAndAttributesForTag(StringBuffer source,
                                                              String tag,
                                                              Map<String,String> attributes,
                                                              Map<String,String> filterAttributes,
                                                              Class<? extends Storable> clazz)
                                                       throws NonParsableException

  Returns the value between the tags as `Storable` or `null`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
    `clazz` - the concrete class of the `Storable`, can be `null` then the class is inferred from the XML, otherwise it is tried to create an instance of the class without checking whether it is possible. This might result in an `NonParsableException`
  Returns:
    the value between the tags as `Storable`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`

### extractStringForTag

    public static String extractStringForTag(StringBuffer source,
                                             String tag)
                                      throws NonParsableException

  Returns the value between the tags as `String`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a `String`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractStringAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractStringAndAttributesForTag

    public static String extractStringAndAttributesForTag(StringBuffer source,
                                                          String tag,
                                                          Map<String,String> attributes,
                                                          Map<String,String> filterAttributes)
                                                   throws NonParsableException

  Returns the value between the tags as `String`.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a `String`
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`

### extractBooleanArrayForTag

    public static boolean[] extractBooleanArrayForTag(StringBuffer source,
                                                      String tag)
                                               throws NonParsableException

  Returns the value between the tags as `boolean` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a `boolean` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractBooleanAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractBooleanArrayAndAttributesForTag

    public static boolean[] extractBooleanArrayAndAttributesForTag(StringBuffer source,
                                                                   String tag,
                                                                   Map<String,String> attributes,
                                                                   Map<String,String> filterAttributes)
                                                            throws NonParsableException

  Returns the value between the tags as `boolean` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a `boolean` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractBooleanAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractByteArrayForTag

    public static byte[] extractByteArrayForTag(StringBuffer source,
                                                String tag)
                                         throws NonParsableException

  Returns the value between the tags as `byte` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a `byte` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractByteAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractByteArrayAndAttributesForTag

    public static byte[] extractByteArrayAndAttributesForTag(StringBuffer source,
                                                             String tag,
                                                             Map<String,String> attributes,
                                                             Map<String,String> filterAttributes)
                                                      throws NonParsableException

  Returns the value between the tags as `byte` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a `byte` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractByteAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractIntArrayForTag

    public static int[] extractIntArrayForTag(StringBuffer source,
                                              String tag)
                                       throws NonParsableException

  Returns the value between the tags as `int` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as an `int` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractIntArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractIntArrayAndAttributesForTag

    public static int[] extractIntArrayAndAttributesForTag(StringBuffer source,
                                                           String tag,
                                                           Map<String,String> attributes,
                                                           Map<String,String> filterAttributes)
                                                    throws NonParsableException

  Returns the value between the tags as `int` array.

  Parameters:
    `source` - the source `StringBuffer`
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as an `int` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractIntAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractDoubleArrayForTag

    public static double[] extractDoubleArrayForTag(StringBuffer source,
                                                    String tag)
                                             throws NonParsableException

  Returns the value between the tags as `double` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a `double` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractDoubleArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractDoubleArrayAndAttributesForTag

    public static double[] extractDoubleArrayAndAttributesForTag(StringBuffer source,
                                                                 String tag,
                                                                 Map<String,String> attributes,
                                                                 Map<String,String> filterAttributes)
                                                          throws NonParsableException

  Returns the value between the tags as `double` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a `double` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractDoubleAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractStorableArrayForTag

    public static Storable[] extractStorableArrayForTag(StringBuffer source,
                                                        String tag)
                                                 throws NonParsableException

  Returns the value between the tags as `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractStorableArrayAndAttributesForTag(StringBuffer, String, Map, Map)`, `extractStorableArrayAndAttributesForTag(StringBuffer, String, Map, Map, Class)`, `ArrayHandler.cast(Object...)`

### extractStorableArrayAndAttributesForTag

    public static Storable[] extractStorableArrayAndAttributesForTag(StringBuffer source,
                                                                     String tag,
                                                                     Map<String,String> attributes,
                                                                     Map<String,String> filterAttributes)
                                                              throws NonParsableException

  Returns the value between the tags as `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorableAndAttributesForTag(StringBuffer, String, Map, Map)`, `extractStorableArrayAndAttributesForTag(StringBuffer, String, Map, Map, Class)`, `ArrayHandler.cast(Object...)`

### extractStorableArrayForTag

    public static Storable[] extractStorableArrayForTag(StringBuffer source,
                                                        String tag,
                                                        Class<? extends Storable> clazz)
                                                 throws NonParsableException

  Returns the value between the tags as `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `clazz` - the concrete class of the elements of the array, can be `null` then the class is inferred from the XML, otherwise it is tried to create an instance of the class without checking whether it is possible. This might result in an `NonParsableException`
  Returns:
    the value between the tags as a `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorableAndAttributesForTag(StringBuffer, String, Map, Map)`, `extractStorableArrayAndAttributesForTag(StringBuffer, String, Map, Map, Class)`

### extractStorableArrayAndAttributesForTag

    public static Storable[] extractStorableArrayAndAttributesForTag(StringBuffer source,
                                                                     String tag,
                                                                     Map<String,String> attributes,
                                                                     Map<String,String> filterAttributes,
                                                                     Class<? extends Storable> clazz)
                                                              throws NonParsableException

  Returns the value between the tags as `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
    `clazz` - the concrete class of the elements of the array, can be `null` then the class is inferred from the XML, otherwise it is tried to create an instance of the class without checking whether it is possible. This might result in an `NonParsableException`
  Returns:
    the value between the tags as a `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorableAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractStringArrayForTag

    public static String[] extractStringArrayForTag(StringBuffer source,
                                                    String tag)
                                             throws NonParsableException

  Returns the value between the tags as `String` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a `String` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractStringArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractStringArrayAndAttributesForTag

    public static String[] extractStringArrayAndAttributesForTag(StringBuffer source,
                                                                 String tag,
                                                                 Map<String,String> attributes,
                                                                 Map<String,String> filterAttributes)
                                                          throws NonParsableException

  Returns the value between the tags as `String` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a `String` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStringAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractStorable2ArrayForTag

    public static Storable[][] extractStorable2ArrayForTag(StringBuffer source,
                                                           String tag)
                                                    throws NonParsableException

  Returns the value between the tags as two dimensional `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a two dimensional `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractStorable2ArrayAndAttributesForTag(StringBuffer, String, Map, Map)`, `extractStorable2ArrayAndAttributesForTag(StringBuffer, String, Map, Map, Class)`

### extractStorable2ArrayAndAttributesForTag

    public static Storable[][] extractStorable2ArrayAndAttributesForTag(StringBuffer source,
                                                                        String tag,
                                                                        Map<String,String> attributes,
                                                                        Map<String,String> filterAttributes)
                                                                 throws NonParsableException

  Returns the value between the tags as two dimensional `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a two dimensional `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorableArrayAndAttributesForTag(StringBuffer, String, Map, Map)`, `extractStorable2ArrayAndAttributesForTag(StringBuffer, String, Map, Map, Class)`

### extractStorable2ArrayForTag

    public static Storable[][] extractStorable2ArrayForTag(StringBuffer source,
                                                           String tag,
                                                           Class<? extends Storable> clazz)
                                                    throws NonParsableException

  Returns the value between the tags as two dimensional `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `clazz` - the concrete class of the elements of the array, can be `null` then the class is inferred from the XML, otherwise it is tried to create an instance of the class without checking whether it is possible. This might result in an `NonParsableException`
  Returns:
    the value between the tags as a two dimensional `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorableArrayAndAttributesForTag(StringBuffer, String, Map, Map)`, `extractStorable2ArrayAndAttributesForTag(StringBuffer, String, Map, Map, Class)`

### extractStorable2ArrayAndAttributesForTag

    public static Storable[][] extractStorable2ArrayAndAttributesForTag(StringBuffer source,
                                                                        String tag,
                                                                        Map<String,String> attributes,
                                                                        Map<String,String> filterAttributes,
                                                                        Class<? extends Storable> clazz)
                                                                 throws NonParsableException

  Returns the value between the tags as two dimensional `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
    `clazz` - the concrete class of the elements of the array, can be `null` then the class is inferred from the XML, otherwise it is tried to create an instance of the class without checking whether it is possible. This might result in an `NonParsableException`
  Returns:
    the value between the tags as a two dimensional `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorableArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractStorable3ArrayForTag

    public static Storable[][][] extractStorable3ArrayForTag(StringBuffer source,
                                                             String tag)
                                                      throws NonParsableException

  Returns the value between the tags as three dimensional `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a three dimensional `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractStorable3ArrayAndAttributesForTag(StringBuffer, String, Map, Map)`, `extractStorable3ArrayAndAttributesForTag(StringBuffer, String, Map, Map, Class)`

### extractStorable3ArrayAndAttributesForTag

    public static Storable[][][] extractStorable3ArrayAndAttributesForTag(StringBuffer source,
                                                                          String tag,
                                                                          Map<String,String> attributes,
                                                                          Map<String,String> filterAttributes)
                                                                   throws NonParsableException

  Returns the value between the tags as three dimensional `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a three dimensional `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorable2ArrayAndAttributesForTag(StringBuffer, String, Map, Map)`, `extractStorable3ArrayAndAttributesForTag(StringBuffer, String, Map, Map, Class)`

### extractStorable3ArrayForTag

    public static Storable[][][] extractStorable3ArrayForTag(StringBuffer source,
                                                             String tag,
                                                             Class<? extends Storable> clazz)
                                                      throws NonParsableException

  Returns the value between the tags as three dimensional `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `clazz` - the concrete class of the elements of the array, can be `null` then the class is inferred from the XML, otherwise it is tried to create an instance of the class without checking whether it is possible. This might result in an `NonParsableException`
  Returns:
    the value between the tags as a three dimensional `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorable2ArrayAndAttributesForTag(StringBuffer, String, Map, Map)`, `extractStorable3ArrayAndAttributesForTag(StringBuffer, String, Map, Map, Class)`

### extractStorable3ArrayAndAttributesForTag

    public static Storable[][][] extractStorable3ArrayAndAttributesForTag(StringBuffer source,
                                                                          String tag,
                                                                          Map<String,String> attributes,
                                                                          Map<String,String> filterAttributes,
                                                                          Class<? extends Storable> clazz)
                                                                   throws NonParsableException

  Returns the value between the tags as three dimensional `Storable` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
    `clazz` - the concrete class of the elements of the array, can be `null` then the class is inferred from the XML, otherwise it is tried to create an instance of the class without checking whether it is possible. This might result in an `NonParsableException`
  Returns:
    the value between the tags as a three dimensional `Storable` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStorable2ArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractBoolean2ArrayForTag

    public static boolean[][] extractBoolean2ArrayForTag(StringBuffer source,
                                                         String tag)
                                                  throws NonParsableException

  Returns the value between the tags as two dimensional `boolean` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a two dimensional `boolean` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractBoolean2ArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractBoolean2ArrayAndAttributesForTag

    public static boolean[][] extractBoolean2ArrayAndAttributesForTag(StringBuffer source,
                                                                      String tag,
                                                                      Map<String,String> attributes,
                                                                      Map<String,String> filterAttributes)
                                                               throws NonParsableException

  Returns the value between the tags as two dimensional `boolean` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a two dimensional `boolean` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractBooleanArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractByte2ArrayForTag

    public static byte[][] extractByte2ArrayForTag(StringBuffer source,
                                                   String tag)
                                            throws NonParsableException

  Returns the value between the tags as two dimensional `byte` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a two dimensional `byte` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractByte2ArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractByte2ArrayAndAttributesForTag

    public static byte[][] extractByte2ArrayAndAttributesForTag(StringBuffer source,
                                                                String tag,
                                                                Map<String,String> attributes,
                                                                Map<String,String> filterAttributes)
                                                         throws NonParsableException

  Returns the value between the tags as two dimensional `byte` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a two dimensional `byte` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractByteArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractInt2ArrayForTag

    public static int[][] extractInt2ArrayForTag(StringBuffer source,
                                                 String tag)
                                          throws NonParsableException

  Returns the value between the tags as two dimensional `int` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a two dimensional `int` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractInt2ArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractInt2ArrayAndAttributesForTag

    public static int[][] extractInt2ArrayAndAttributesForTag(StringBuffer source,
                                                              String tag,
                                                              Map<String,String> attributes,
                                                              Map<String,String> filterAttributes)
                                                       throws NonParsableException

  Returns the value between the tags as two dimensional `int` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a two dimensional `int` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractIntArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractDouble2ArrayForTag

    public static double[][] extractDouble2ArrayForTag(StringBuffer source,
                                                       String tag)
                                                throws NonParsableException

  Returns the value between the tags as two dimensional `double` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a two dimensional `double` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractDouble2ArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractDouble2ArrayAndAttributesForTag

    public static double[][] extractDouble2ArrayAndAttributesForTag(StringBuffer source,
                                                                    String tag,
                                                                    Map<String,String> attributes,
                                                                    Map<String,String> filterAttributes)
                                                             throws NonParsableException

  Returns the value between the tags as two dimensional `double` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a two dimensional `double` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractDoubleArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractString2ArrayForTag

    public static String[][] extractString2ArrayForTag(StringBuffer source,
                                                       String tag)
                                                throws NonParsableException

  Returns the value between the tags as two dimensional `String` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
  Returns:
    the value between the tags as a two dimensional `String` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractString2ArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### extractString2ArrayAndAttributesForTag

    public static String[][] extractString2ArrayAndAttributesForTag(StringBuffer source,
                                                                    String tag,
                                                                    Map<String,String> attributes,
                                                                    Map<String,String> filterAttributes)
                                                             throws NonParsableException

  Returns the value between the tags as two dimensional `String` array.

  Parameters:
    `source` - the source `StringBuffer` that should be decoded from XML
    `tag` - the tags between which the value shall be taken
    `attributes` - a `Map` which can be used to obtain the attribute of the tag
    `filterAttributes` - a `Map` which defines a filter for the tags
  Returns:
    the value between the tags as a two dimensional `String` array
  Throws:
    `NonParsableException` - if the value could not be parsed
  See Also:
    `extractForTag(StringBuffer, String, Map, Map)`, `extractStringArrayAndAttributesForTag(StringBuffer, String, Map, Map)`

### addTags

    public static void addTags(StringBuffer source,
                               String tag)

  Frames the `StringBuffer` `source` with equal tags "< `tag`>" and "<`/tag` >".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `tag` - the tags by which the `StringBuffer` should be framed
  See Also:
    `addTagsAndAttributes(StringBuffer, String, String)`

### addTagsAndAttributes

    public static void addTagsAndAttributes(StringBuffer source,
                                            String tag,
                                            String attributes)

  Frames the `StringBuffer` `source` with "< `tag attributes`>" and "<`/tag` >".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `tag` - the tags by which the `StringBuffer` should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```

### appendBooleanWithTags

    public static void appendBooleanWithTags(StringBuffer source,
                                             boolean b,
                                             String tag)

  Appends a `boolean` value with equal tags to the `StringBuffer` `source` in the following way: "< `tag`>`b`<`/tag`>".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `b` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
  See Also:
    `appendBooleanWithTagsAndAttributes(StringBuffer, boolean, String, String)`

### appendBooleanWithTagsAndAttributes

    public static void appendBooleanWithTagsAndAttributes(StringBuffer source,
                                                          boolean b,
                                                          String tag,
                                                          String attributes)

  Appends a `boolean` value with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`b`<`/tag` >".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `b` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```

### appendByteWithTags

    public static void appendByteWithTags(StringBuffer source,
                                          byte b,
                                          String tag)

  Appends a `byte` value with equal tags to the `StringBuffer` `source` in the following way: "< `tag`>`b`<`/tag`>".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `b` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
  See Also:
    `appendByteWithTagsAndAttributes(StringBuffer, byte, String, String)`

### appendByteWithTagsAndAttributes

    public static void appendByteWithTagsAndAttributes(StringBuffer source,
                                                       byte b,
                                                       String tag,
                                                       String attributes)

  Appends a `byte` value with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`b`<`/tag` >".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `b` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```

### appendEnumWithTags

    public static <T extends Enum<T>> void appendEnumWithTags(StringBuffer source,
                                                              Enum<T> e,
                                                              String tag)

  Appends an `Enum` object with equal tags to the `StringBuffer` `source`.

  Type Parameters:
    `T` - the type of the `Enum` objects
  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `e` - the enumeration that should be framed by the tags and appended to the source
    `tag` - the tags by which the enumeration should be framed
  See Also:
    `appendEnumWithTagsAndAttributes(StringBuffer, Enum, String, String)`

### appendEnumWithTagsAndAttributes

    public static <T extends Enum<T>> void appendEnumWithTagsAndAttributes(StringBuffer source,
                                                                           Enum<T> e,
                                                                           String tag,
                                                                           String attributes)

  Appends an `Enum` object with the tags to the `StringBuffer` `source`.

  Type Parameters:
    `T` - the type of the `Enum` objects
  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `e` - the enumeration that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendStringWithTagsAndAttributes(StringBuffer, String, String, String)`

### appendIntWithTags

    public static void appendIntWithTags(StringBuffer source,
                                         int i,
                                         String tag)

  Appends an `int` value with equal tags to the `StringBuffer` `source` in the following way: "< `tag`>`i`<`/tag`>"

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `i` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
  See Also:
    `appendIntWithTagsAndAttributes(StringBuffer, int, String, String)`

### appendIntWithTagsAndAttributes

    public static void appendIntWithTagsAndAttributes(StringBuffer source,
                                                      int i,
                                                      String tag,
                                                      String attributes)

  Appends an `int` value with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`i`<`/tag` >".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `i` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```

### appendLongWithTags

    public static void appendLongWithTags(StringBuffer source,
                                          long i,
                                          String tag)

  Appends a `long` value with equal tags to the `StringBuffer` `source` in the following way: "< `tag`>`i`<`/tag`>".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `i` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
  See Also:
    `appendLongWithTagsAndAttributes(StringBuffer, long, String, String)`

### appendLongWithTagsAndAttributes

    public static void appendLongWithTagsAndAttributes(StringBuffer source,
                                                       long l,
                                                       String tag,
                                                       String attributes)

  Appends a `long` value with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`i`<`/tag` >".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `l` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```

### appendDoubleWithTags

    public static void appendDoubleWithTags(StringBuffer source,
                                            double d,
                                            String tag)

  Appends a `double` value with equal tags to the `StringBuffer` `source` in the following way: "< `tag`>`d`<`/tag`>".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `d` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
  See Also:
    `appendDoubleWithTagsAndAttributes(StringBuffer, double, String, String)`

### appendDoubleWithTagsAndAttributes

    public static void appendDoubleWithTagsAndAttributes(StringBuffer source,
                                                         double d,
                                                         String tag,
                                                         String attributes)

  Appends a `double` value with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`d`<`/tag` >".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `d` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```

### appendStorableWithTags

    public static void appendStorableWithTags(StringBuffer source,
                                              Storable s,
                                              String tag)

  Appends a `Storable` object or "null" with equal tags to the `StringBuffer` `source`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the object that should be framed by the tags and appended to the source, if `null` then "null" framed by the tags is appended to the source
    `tag` - the tags by which the value should be framed
  See Also:
    `appendStorableWithTagsAndAttributes(StringBuffer, Storable, String, String)`

### appendStorableWithTagsAndAttributes

    public static void appendStorableWithTagsAndAttributes(StringBuffer source,
                                                           Storable s,
                                                           String tag,
                                                           String attributes)

  Appends a `Storable` object or "null" with the tags to the `StringBuffer` `source`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the object that should be framed by the tags and appended to the source, if `null` then "null" framed by the tags is appended to the source
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```

### appendStringWithTags

    public static void appendStringWithTags(StringBuffer source,
                                            String s,
                                            String tag)

  Appends a `String` with equal tags to the `StringBuffer` `source` in the following way: "<`tag`> `s`<`/tag` >".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the `String` that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
  See Also:
    `appendStringWithTagsAndAttributes(StringBuffer, String, String, String)`

### appendStringWithTagsAndAttributes

    public static void appendStringWithTagsAndAttributes(StringBuffer source,
                                                         String s,
                                                         String tag,
                                                         String attributes)

  Appends a `String` with the tags to the `StringBuffer` `source` in the following way: "< `tag attributes`>`s`<`/tag` >".

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the value that should be framed by the tags and appended to the source
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```

### getByteArrayWithTags

    protected static StringBuffer getByteArrayWithTags(byte[] b)

  Encodes a `byte` array. The encoding is the following way:
  <length>b.length</length>
  <pos val="0">b[0]</pos>
  <pos val="1">b[1]</pos>
  ...
  It is necessary to include such an encoded array in tags or another array.

  Parameters:
    `b` - the array that should be encoded
  Returns:
    a `StringBuffer` representing the encoded array
  See Also:
    `appendByteWithTagsAndAttributes(StringBuffer, byte, String, String)`

### getIntArrayWithTags

    protected static StringBuffer getIntArrayWithTags(int[] i)

  Encodes an `int` array. The encoding is like in `getByteArrayWithTags(byte[])`.

  Parameters:
    `i` - the array that should be encoded
  Returns:
    a `StringBuffer` representing the encoded array
  See Also:
    `getByteArrayWithTags(byte[])`, `appendIntWithTagsAndAttributes(StringBuffer, int, String, String)`

### getDoubleArrayWithTags

    protected static StringBuffer getDoubleArrayWithTags(double[] d)

  Encodes a `double` array. The encoding is like in `getByteArrayWithTags(byte[])`.

  Parameters:
    `d` - the array that should be encoded
  Returns:
    a `StringBuffer` representing the encoded array
  See Also:
    `getByteArrayWithTags(byte[])`, `appendDoubleWithTagsAndAttributes(StringBuffer, double, String, String)`

### getBooleanArrayWithTags

    protected static StringBuffer getBooleanArrayWithTags(boolean[] b)

  Encodes a `boolean` array. The encoding is like in `getByteArrayWithTags(byte[])`.

  Parameters:
    `b` - the array that should be encoded
  Returns:
    a `StringBuffer` representing the encoded array
  See Also:
    `getByteArrayWithTags(byte[])`, `appendBooleanWithTagsAndAttributes(StringBuffer, boolean, String, String)`

### getStringArrayWithTags

    protected static StringBuffer getStringArrayWithTags(String[] s)

  Encodes a `String` array. The encoding is like in `getByteArrayWithTags(byte[])`.

  Parameters:
    `s` - the array that should be encoded
  Returns:
    a `StringBuffer` representing the encoded array
  See Also:
    `getByteArrayWithTags(byte[])`, `appendStringWithTagsAndAttributes(StringBuffer, String, String, String)`

### getStorableArrayWithTags

    protected static StringBuffer getStorableArrayWithTags(Storable[] s)

  Encodes a `Storable` array. The encoding is like in `getByteArrayWithTags(byte[])`.

  Parameters:
    `s` - the `Storable` object that should be encoded
  Returns:
    a `StringBuffer` representing the encoded `Storable` object
  See Also:
    `getByteArrayWithTags(byte[])`, `appendStorableWithTagsAndAttributes(StringBuffer, Storable, String, String)`

### appendBooleanArrayWithTags

    public static void appendBooleanArrayWithTags(StringBuffer source,
                                                  boolean[] b,
                                                  String tag)

  Appends an encoded `boolean` array with equal tags to the `StringBuffer` `source`. The encoding is like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `b` - the array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
  See Also:
    `appendBooleanArrayWithTagsAndAttributes(StringBuffer, boolean[], String, String)`

### appendBooleanArrayWithTagsAndAttributes

    public static void appendBooleanArrayWithTagsAndAttributes(StringBuffer source,
                                                               boolean[] b,
                                                               String tag,
                                                               String attributes)

  Appends an encoded `boolean` array with the tags to the `StringBuffer` `source`. The encoding is like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `b` - the array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`, `getBooleanArrayWithTags(boolean[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendByteArrayWithTags

    public static void appendByteArrayWithTags(StringBuffer source,
                                               byte[] b,
                                               String tag)

  Appends an encoded `byte` array with equal tags to the `StringBuffer` `source`. The encoding is like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `b` - the array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
  See Also:
    `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`

### appendByteArrayWithTagsAndAttributes

    public static void appendByteArrayWithTagsAndAttributes(StringBuffer source,
                                                            byte[] b,
                                                            String tag,
                                                            String attributes)

  Appends an encoded `byte` array with the tags to the `StringBuffer` `source`. The encoding is this way:
  <`tag attributes`> <length>b.length</length>
  <pos val="0">b[0]</pos>
  <pos val="1">b[1]</pos>
  ...
  <`/tag`>.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `b` - the array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `getByteArrayWithTags(byte[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendIntArrayWithTags

    public static void appendIntArrayWithTags(StringBuffer source,
                                              int[] i,
                                              String tag)

  Appends an encoded `int` array with equal tags to the `StringBuffer` `source`. The encoding is like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `i` - the array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the encoded array should be framed
  See Also:
    `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`, `appendIntArrayWithTagsAndAttributes(StringBuffer, int[], String, String)`

### appendIntArrayWithTagsAndAttributes

    public static void appendIntArrayWithTagsAndAttributes(StringBuffer source,
                                                           int[] i,
                                                           String tag,
                                                           String attributes)

  Appends an encoded `int` array with the tags to the `StringBuffer` `source`. The encoding is like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `i` - the array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`, `getIntArrayWithTags(int[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendDoubleArrayWithTags

    public static void appendDoubleArrayWithTags(StringBuffer source,
                                                 double[] d,
                                                 String tag)

  Appends an encoded `double` array with equal tags to the `StringBuffer` `source`. The encoding is like in like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `d` - the array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the encoded array should be framed
  See Also:
    `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`, `appendDoubleArrayWithTagsAndAttributes(StringBuffer, double[], String, String)`

### appendDoubleArrayWithTagsAndAttributes

    public static void appendDoubleArrayWithTagsAndAttributes(StringBuffer source,
                                                              double[] d,
                                                              String tag,
                                                              String attributes)

  Appends an encoded `double` array with the tags to the `StringBuffer` `source`. The encoding is like in like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `d` - the array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`, `getDoubleArrayWithTags(double[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendStorableArrayWithTags

    public static void appendStorableArrayWithTags(StringBuffer source,
                                                   Storable[] s,
                                                   String tag)

  Appends an encoded `Storable` array with equal tags to the `StringBuffer` `source`. The encoding is like in like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the `Storable` array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the encoded `Storable` array should be framed
  See Also:
    `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`, `appendStorableArrayWithTagsAndAttributes(StringBuffer, Storable[], String, String)`

### appendStorableArrayWithTagsAndAttributes

    public static void appendStorableArrayWithTagsAndAttributes(StringBuffer source,
                                                                Storable[] s,
                                                                String tag,
                                                                String attributes)

  Appends an encoded `Storable` array with the tags to the `StringBuffer` `source`. The encoding is like in like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the `Storable` array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`, `getStorableArrayWithTags(Storable[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendStringArrayWithTags

    public static void appendStringArrayWithTags(StringBuffer source,
                                                 String[] s,
                                                 String tag)

  Appends an encoded `String` array with equal tags to the `StringBuffer` `source`. The encoding is like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the encoded array should be framed
  See Also:
    `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`, `appendStringArrayWithTagsAndAttributes(StringBuffer, String[], String, String)`

### appendStringArrayWithTagsAndAttributes

    public static void appendStringArrayWithTagsAndAttributes(StringBuffer source,
                                                              String[] s,
                                                              String tag,
                                                              String attributes)

  Appends an encoded `String` array with the tags to the `StringBuffer` `source`. The encoding is like in `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendByteArrayWithTagsAndAttributes(StringBuffer, byte[], String, String)`, `getStringArrayWithTags(String[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendBoolean2ArrayWithTags

    public static void appendBoolean2ArrayWithTags(StringBuffer source,
                                                   boolean[][] i,
                                                   String tag)

  Appends an encoded two dimensional `boolean` array with equal tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)` .

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `i` - the two dimensional array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the encoded two dimensional array should be framed
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`, `appendBoolean2ArrayWithTagsAndAttributes(StringBuffer, boolean[][], String, String)`

### appendBoolean2ArrayWithTagsAndAttributes

    public static void appendBoolean2ArrayWithTagsAndAttributes(StringBuffer source,
                                                                boolean[][] i,
                                                                String tag,
                                                                String attributes)

  Appends an encoded two dimensional `boolean` array with the tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)` .

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `i` - the two dimensional array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`, `appendBooleanWithTags(StringBuffer, boolean, String)`, `getBooleanArrayWithTags(boolean[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendByte2ArrayWithTags

    public static void appendByte2ArrayWithTags(StringBuffer source,
                                                byte[][] b,
                                                String tag)

  Appends an encoded two dimensional `byte` array with equal tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)` .

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `b` - the two dimensional array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`

### appendByte2ArrayWithTagsAndAttributes

    public static void appendByte2ArrayWithTagsAndAttributes(StringBuffer source,
                                                             byte[][] b,
                                                             String tag,
                                                             String attributes)

  Appends an encoded two dimensional `byte` array with the tags to the `StringBuffer` `source`. The encoding is the following way:
  <tag attributes> <length>b.length</length>
  <pos val="0"> <length>b[0].length</length>
  <pos val="0">b[0][0]</pos>
  <pos val="1">bi[0][1]</pos>
  ...
  </pos>
  <pos val="1"> <length>b[1].length</length>
  ...
  </pos>
  ...
  </tag>.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `b` - the two dimensional array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendIntWithTags(StringBuffer, int, String)`, `getByteArrayWithTags(byte[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendInt2ArrayWithTags

    public static void appendInt2ArrayWithTags(StringBuffer source,
                                               int[][] i,
                                               String tag)

  Appends an encoded two dimensional `int` array with equal tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)` .

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `i` - the two dimensional array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`, `appendInt2ArrayWithTagsAndAttributes(StringBuffer, int[][], String, String)`

### appendInt2ArrayWithTagsAndAttributes

    public static void appendInt2ArrayWithTagsAndAttributes(StringBuffer source,
                                                            int[][] i,
                                                            String tag,
                                                            String attributes)

  Appends an encoded two dimensional `int` array with the tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)` .

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `i` - the two dimensional array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`, `appendIntWithTags(StringBuffer, int, String)`, `getIntArrayWithTags(int[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendDouble2ArrayWithTags

    public static void appendDouble2ArrayWithTags(StringBuffer source,
                                                  double[][] d,
                                                  String tag)

  Appends an encoded two dimensional `double` array with equal tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)` .

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `d` - the two dimensional array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`, `appendDouble2ArrayWithTagsAndAttributes(StringBuffer, double[][], String, String)`

### appendDouble2ArrayWithTagsAndAttributes

    public static void appendDouble2ArrayWithTagsAndAttributes(StringBuffer source,
                                                               double[][] d,
                                                               String tag,
                                                               String attributes)

  Appends an encoded two dimensional `double` array with the tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)` .

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `d` - the two dimensional array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`, `appendIntWithTags(StringBuffer, int, String)`, `getDoubleArrayWithTags(double[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendStorable2ArrayWithTags

    public static void appendStorable2ArrayWithTags(StringBuffer source,
                                                    Storable[][] s,
                                                    String tag)

  Appends an encoded two dimensional `Storable` array with equal tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the two dimensional `Storable` array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`, `appendStorable2ArrayWithTagsAndAttributes(StringBuffer, Storable[][], String, String)`

### appendStorable2ArrayWithTagsAndAttributes

    public static void appendStorable2ArrayWithTagsAndAttributes(StringBuffer source,
                                                                 Storable[][] s,
                                                                 String tag,
                                                                 String attributes)

  Appends an encoded two dimensional `Storable` array with the tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the two dimensional `Storable` array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`, `appendIntWithTags(StringBuffer, int, String)`, `getStorableArrayWithTags(Storable[])`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendStorable3ArrayWithTags

    public static void appendStorable3ArrayWithTags(StringBuffer source,
                                                    Storable[][][] s,
                                                    String tag)

  Appends an encoded three dimensional `Storable` array with equal tags to the `StringBuffer` `source`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the three dimensional `Storable` array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
  See Also:
    `appendStorable3ArrayWithTagsAndAttributes(StringBuffer, Storable[][][], String, String)`

### appendStorable3ArrayWithTagsAndAttributes

    public static void appendStorable3ArrayWithTagsAndAttributes(StringBuffer source,
                                                                 Storable[][][] s,
                                                                 String tag,
                                                                 String attributes)

  Appends an encoded three dimensional `Storable` array with the tags to the `StringBuffer` `source`.

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the three dimensional `Storable` array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendIntWithTags(StringBuffer, int, String)`, `appendStorable2ArrayWithTagsAndAttributes(StringBuffer, Storable[][], String, String)`, `addTagsAndAttributes(StringBuffer, String, String)`

### appendString2ArrayWithTags

    public static void appendString2ArrayWithTags(StringBuffer source,
                                                  String[][] s,
                                                  String tag)

  Appends an encoded two dimensional `String` array with equal tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)` .

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the two dimensional array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`, `appendString2ArrayWithTagsAndAttributes(StringBuffer, String[][], String, String)`

### appendString2ArrayWithTagsAndAttributes

    public static void appendString2ArrayWithTagsAndAttributes(StringBuffer source,
                                                               String[][] s,
                                                               String tag,
                                                               String attributes)

  Appends an encoded two dimensional `String` array with the tags to the `StringBuffer` `source`. The encoding is like in `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)` .

  Parameters:
    `source` - the source `StringBuffer` that should be encoded in XML
    `s` - the two dimensional array that should be encoded and appended to the source framed by the tags
    `tag` - the tags by which the value should be framed
    `attributes` - `null`or some attributes, i.e. `value="100" confidence="0"```
  See Also:
    `appendByte2ArrayWithTagsAndAttributes(StringBuffer, byte[][], String, String)`, `appendIntWithTags(StringBuffer, int, String)`, `getStringArrayWithTags(String[])`, `addTagsAndAttributes(StringBuffer, String, String)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD