Package org.kapott.hbci.protocol

## Class SyntaxElement

- java.lang.Object
- - org.kapott.hbci.protocol.SyntaxElement

Direct Known Subclasses:
  `DE`, `DEG`, `MSG`, `SEG`, `SF`

    public abstract class SyntaxElement
    extends java.lang.Object

### Field Summary

Fields
`static boolean` `ALLOW_OVERWRITE`
`static boolean` `DONT_ALLOW_OVERWRITE`
`static boolean` `DONT_TRY_TO_CREATE`
`static boolean` `TRY_TO_CREATE`

### Constructor Summary

Constructors

`protected`

`SyntaxElement​(java.lang.String type, java.lang.String name, java.lang.String path, char predelim, int idx, java.lang.StringBuffer res, int fullResLen, org.w3c.dom.Document syntax, java.util.Hashtable<java.lang.String,​java.lang.String> predefs, java.util.Hashtable<java.lang.String,​java.lang.String> valids)`

beim parsen: initialisiert ein neues syntaxelement mit der id 'name'; in 'path' wird der pfad bis zu dieser stelle uebergeben 'predelim' gibt das delimiter-zeichen an, das beim parsen vor diesem syntax- element stehen muesste 'idx' ist die nummer des syntaxelementes innerhalb der uebergeordneten liste (die liste repraesentiert das evtl.

`protected`

`SyntaxElement​(java.lang.String type, java.lang.String name, java.lang.String path, int idx, org.w3c.dom.Document syntax)`

es wird ein syntaxelement mit der id 'name' initialisiert; der pfad bis zu diesem element wird in 'path' uebergeben; 'idx' ist die nummer dieses elementes innerhalb der syntaxelementliste fuer dieses element (falls ein bestimmtes syntaxelement mehr als einmal auftreten kann)

### Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
`protected void` `addChildContainer​(MultipleSyntaxElements x)`
`int` `checkSegSeq​(int value)`
`protected MultipleSyntaxElements` `createAndAppendNewChildContainer​(org.w3c.dom.Node ref, org.w3c.dom.Document syntax)`
`protected abstract MultipleSyntaxElements` `createNewChildContainer​(org.w3c.dom.Node ref, org.w3c.dom.Document syntax)` erzeugt einen neuen Child-Container, welcher durch den xml-knoten 'ref' identifiziert wird; wird beim erzeugen von elementen benutzt
`protected void` `destroy()`
`int` `enumerateSegs​(int startValue, boolean allowOverwrite)` loop through all child-elements; the segments found there will be sequentially enumerated starting with num startValue; if startValue is zero, the segments will not be enumerated, but all given the number 0
`void` `extractValues​(java.util.Hashtable<java.lang.String,​java.lang.String> values)` fuellt die hashtable 'values' mit den werten der de-syntaxelemente; dazu wird in allen anderen typen von syntaxelementen die liste der child-elemente durchlaufen und deren 'fillValues' methode aufgerufen
`java.util.List<MultipleSyntaxElements>` `getChildContainers()`
`SyntaxElement` `getElement​(java.lang.String path)`
`void` `getElementPaths​(java.util.Properties p, int[] segref, int[] degref, int[] deref)`
`protected abstract java.lang.String` `getElementTypeName()` gibt einen string mit den typnamen (msg,seg,deg,de,...) des elementes zurueck
`protected abstract char` `getInDelim()` liefert das delimiter-zeichen zurueck, dass innerhalb dieses syntaxelementes benutzt wird, um die einzelnen child-elemente voneinander zu trennen
`java.lang.String` `getName()`
`MultipleSyntaxElements` `getParent()`
`java.lang.String` `getPath()`
`int` `getPosInMsg()`
`protected char` `getPreDelim()`
`org.w3c.dom.Node` `getSyntaxDef​(java.lang.String type, org.w3c.dom.Document syntax)`
`java.lang.String` `getType()`
`java.lang.String` `getValueOfDE​(java.lang.String path)`
`java.lang.String` `getValueOfDE​(java.lang.String path, int zero)`
`protected void` `init​(java.lang.String type, java.lang.String name, java.lang.String path, char predelim, int idx, java.lang.StringBuffer res, int fullResLen, org.w3c.dom.Document syntax, java.util.Hashtable<java.lang.String,​java.lang.String> predefs, java.util.Hashtable<java.lang.String,​java.lang.String> valids)`
`protected void` `init​(java.lang.String type, java.lang.String name, java.lang.String path, int idx, org.w3c.dom.Document syntax)`
`boolean` `isValid()`
`protected MultipleSyntaxElements` `parseAndAppendNewChildContainer​(org.w3c.dom.Node ref, char predelim0, char predelim1, java.lang.StringBuffer res, int fullResLen, org.w3c.dom.Document syntax, java.util.Hashtable<java.lang.String,​java.lang.String> predefs, java.util.Hashtable<java.lang.String,​java.lang.String> valids)`
`protected abstract MultipleSyntaxElements` `parseNewChildContainer​(org.w3c.dom.Node ref, char predelim0, char predelim1, java.lang.StringBuffer res, int fullResLen, org.w3c.dom.Document syntax, java.util.Hashtable<java.lang.String,​java.lang.String> predefs, java.util.Hashtable<java.lang.String,​java.lang.String> valids)` beim parsen: haengt an die 'childElements' ein neues Element an.

`boolean`

`propagateValue​(java.lang.String destPath, java.lang.String value, boolean tryToCreate, boolean allowOverwrite)`

setzt den wert eines de; in allen syntaxelementen ausser DE wird dazu die liste der child-elemente durchlaufen; jedem dieser child-elemente wird der wert zum setzen uebergeben; genau _eines_ dieser elemente wird sich dafuer zustaendig fuehlen (das DE mit 'path'='destPath') und den wert uebernehmen

`protected void` `setName​(java.lang.String name)`
`void` `setParent​(MultipleSyntaxElements parent)`
`protected void` `setPath​(java.lang.String path)`
`protected void` `setType​(java.lang.String type)`
`protected void` `setValid​(boolean valid)`
`protected boolean` `storeValidValueInDE​(java.lang.String destPath, java.lang.String value)`
`java.lang.String` `toString​(int zero)` diese toString() methode wird benutzt, um den wert eines de-syntaxelementes in human-readable-form zurueckzugeben.
`void` `validate()` ueberpreuft, ob das syntaxelement alle restriktionen einhaelt; ist das nicht der fall, so wird eine Exception ausgeloest.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### TRY_TO_CREATE

    public static final boolean TRY_TO_CREATE

See Also:
  Constant Field Values

#### DONT_TRY_TO_CREATE

    public static final boolean DONT_TRY_TO_CREATE

See Also:
  Constant Field Values

#### ALLOW_OVERWRITE

    public static final boolean ALLOW_OVERWRITE

See Also:
  Constant Field Values

#### DONT_ALLOW_OVERWRITE

    public static final boolean DONT_ALLOW_OVERWRITE

See Also:
  Constant Field Values

### Constructor Detail

#### SyntaxElement

    protected SyntaxElement​(java.lang.String type,
                            java.lang.String name,
                            java.lang.String path,
                            int idx,
                            org.w3c.dom.Document syntax)

es wird ein syntaxelement mit der id 'name' initialisiert; der pfad bis zu diesem element wird in 'path' uebergeben; 'idx' ist die nummer dieses elementes innerhalb der syntaxelementliste fuer dieses element (falls ein bestimmtes syntaxelement mehr als einmal auftreten kann)

#### SyntaxElement

    protected SyntaxElement​(java.lang.String type,
                            java.lang.String name,
                            java.lang.String path,
                            char predelim,
                            int idx,
                            java.lang.StringBuffer res,
                            int fullResLen,
                            org.w3c.dom.Document syntax,
                            java.util.Hashtable<java.lang.String,​java.lang.String> predefs,
                            java.util.Hashtable<java.lang.String,​java.lang.String> valids)

beim parsen: initialisiert ein neues syntaxelement mit der id 'name'; in 'path' wird der pfad bis zu dieser stelle uebergeben 'predelim' gibt das delimiter-zeichen an, das beim parsen vor diesem syntax- element stehen muesste 'idx' ist die nummer des syntaxelementes innerhalb der uebergeordneten liste (die liste repraesentiert das evtl. mehrmalige auftreten eines syntaxelementes, siehe class syntaxelementlist) 'res' ist der zu parsende String 'predefs' soll eine menge von pfad-wert-paaren enthalten, die fuer einige syntaxelemente den wert angeben, den diese elemente zwingend haben muessen (z.b. ein bestimmter segmentcode o.ae.)

### Method Detail

#### getElementTypeName

    protected abstract java.lang.String getElementTypeName()

gibt einen string mit den typnamen (msg,seg,deg,de,...) des elementes zurueck

#### getInDelim

    protected abstract char getInDelim()

liefert das delimiter-zeichen zurueck, dass innerhalb dieses syntaxelementes benutzt wird, um die einzelnen child-elemente voneinander zu trennen

#### createNewChildContainer

    protected abstract MultipleSyntaxElements createNewChildContainer​(org.w3c.dom.Node ref,
                                                                      org.w3c.dom.Document syntax)

erzeugt einen neuen Child-Container, welcher durch den xml-knoten 'ref' identifiziert wird; wird beim erzeugen von elementen benutzt

#### parseNewChildContainer

    protected abstract MultipleSyntaxElements parseNewChildContainer​(org.w3c.dom.Node ref,
                                                                     char predelim0,
                                                                     char predelim1,
                                                                     java.lang.StringBuffer res,
                                                                     int fullResLen,
                                                                     org.w3c.dom.Document syntax,
                                                                     java.util.Hashtable<java.lang.String,​java.lang.String> predefs,
                                                                     java.util.Hashtable<java.lang.String,​java.lang.String> valids)

beim parsen: haengt an die 'childElements' ein neues Element an. der xml-knoten 'ref' gibt an, um welches element es sich dabei handelt; aus 'res' (der zu parsende String) wird der wert fuer das element ermittelt (falls es sich um ein de handelt); in 'predefined' ist der wert des elementes zu finden, der laut syntaxdefinition ('syntax') an dieser stelle auftauchen mueste (optional; z.b. fuer segmentcodes); 'predelim*' geben die delimiter an, die direkt vor dem zu erzeugenden syntaxelement auftauchen muessten

#### init

    protected void init​(java.lang.String type,
                        java.lang.String name,
                        java.lang.String path,
                        int idx,
                        org.w3c.dom.Document syntax)

#### createAndAppendNewChildContainer

    protected MultipleSyntaxElements createAndAppendNewChildContainer​(org.w3c.dom.Node ref,
                                                                      org.w3c.dom.Document syntax)

#### storeValidValueInDE

    protected boolean storeValidValueInDE​(java.lang.String destPath,
                                          java.lang.String value)

#### enumerateSegs

    public int enumerateSegs​(int startValue,
                             boolean allowOverwrite)

loop through all child-elements; the segments found there will be sequentially enumerated starting with num startValue; if startValue is zero, the segments will not be enumerated, but all given the number 0

Parameters:
  `startValue` - value to be used for the first segment found
Returns:
  next sequence number usable for enumeration

#### init

    protected void init​(java.lang.String type,
                        java.lang.String name,
                        java.lang.String path,
                        char predelim,
                        int idx,
                        java.lang.StringBuffer res,
                        int fullResLen,
                        org.w3c.dom.Document syntax,
                        java.util.Hashtable<java.lang.String,​java.lang.String> predefs,
                        java.util.Hashtable<java.lang.String,​java.lang.String> valids)

#### parseAndAppendNewChildContainer

    protected MultipleSyntaxElements parseAndAppendNewChildContainer​(org.w3c.dom.Node ref,
                                                                     char predelim0,
                                                                     char predelim1,
                                                                     java.lang.StringBuffer res,
                                                                     int fullResLen,
                                                                     org.w3c.dom.Document syntax,
                                                                     java.util.Hashtable<java.lang.String,​java.lang.String> predefs,
                                                                     java.util.Hashtable<java.lang.String,​java.lang.String> valids)

#### extractValues

    public void extractValues​(java.util.Hashtable<java.lang.String,​java.lang.String> values)

fuellt die hashtable 'values' mit den werten der de-syntaxelemente; dazu wird in allen anderen typen von syntaxelementen die liste der child-elemente durchlaufen und deren 'fillValues' methode aufgerufen

#### addChildContainer

    protected void addChildContainer​(MultipleSyntaxElements x)

#### getChildContainers

    public java.util.List<MultipleSyntaxElements> getChildContainers()

Returns:
  the ArrayList containing all child-elements (the elements of the ArrayList are instances of the SyntaxElementArray class

#### propagateValue

    public boolean propagateValue​(java.lang.String destPath,
                                  java.lang.String value,
                                  boolean tryToCreate,
                                  boolean allowOverwrite)

setzt den wert eines de; in allen syntaxelementen ausser DE wird dazu die liste der child-elemente durchlaufen; jedem dieser child-elemente wird der wert zum setzen uebergeben; genau _eines_ dieser elemente wird sich dafuer zustaendig fuehlen (das DE mit 'path'='destPath') und den wert uebernehmen

#### getValueOfDE

    public java.lang.String getValueOfDE​(java.lang.String path)

Returns:
  den wert eines bestimmten DE; funktioniert analog zu 'propagateValue'

#### getValueOfDE

    public java.lang.String getValueOfDE​(java.lang.String path,
                                         int zero)

#### getElement

    public SyntaxElement getElement​(java.lang.String path)

Parameters:
  `path` - path to the element to be returned
Returns:
  the element identified by path

#### setPath

    protected void setPath​(java.lang.String path)

#### getPath

    public final java.lang.String getPath()

Returns:
  the path to this element

#### setName

    protected void setName​(java.lang.String name)

#### getName

    public java.lang.String getName()

Returns:
  the name of this element (i.e. the last component of path)

#### setType

    protected void setType​(java.lang.String type)

#### getType

    public java.lang.String getType()

#### getPreDelim

    protected char getPreDelim()

Returns:
  the delimiter that must be in front of this element

#### getSyntaxDef

    public final org.w3c.dom.Node getSyntaxDef​(java.lang.String type,
                                               org.w3c.dom.Document syntax)

Parameters:
  `type` - the name of the syntaxelement to be returned
  `syntax` - the structure containing the current syntaxdefinition
Returns:
  a XML-node with the definition of the requested syntaxelement

#### toString

    public java.lang.String toString​(int zero)

diese toString() methode wird benutzt, um den wert eines de-syntaxelementes in human-readable-form zurueckzugeben. innerhalb eines de-elementes wird der wert in der hbci-form gespeichert

#### setValid

    protected final void setValid​(boolean valid)

#### isValid

    public boolean isValid()

#### checkSegSeq

    public int checkSegSeq​(int value)

#### validate

    public void validate()

ueberpreuft, ob das syntaxelement alle restriktionen einhaelt; ist das nicht der fall, so wird eine Exception ausgeloest. die meisten syntaxelemente koennen sich nicht selbst ueberpruefen, sondern rufen statt dessen die validate-funktion der child-elemente auf

#### getElementPaths

    public void getElementPaths​(java.util.Properties p,
                                int[] segref,
                                int[] degref,
                                int[] deref)

#### setParent

    public void setParent​(MultipleSyntaxElements parent)

#### getParent

    public MultipleSyntaxElements getParent()

#### getPosInMsg

    public int getPosInMsg()

#### destroy

    protected void destroy()