Exemple #1
0
  /**
   * Führt die übergebenen Sektionen mit den bestehenden zusammen. Bereits vorhandene
   * werden dabei aktualisiert, neue angelegt.
   *
   * @param initialize zu übernehmende Sektionen
   * @return die aktuelle Instanz mit den zusammgeführten Sektionen
   */
  public synchronized Initialize merge(Initialize initialize) {

    Enumeration enumeration;
    Section section;
    String entry;

    if (initialize == null) return this;

    // die Sektionen werden zusammengefasst oder ggf. neu angelegt
    enumeration = Collections.enumeration(this.entries.keySet());
    while (enumeration.hasMoreElements()) {
      entry = (String) enumeration.nextElement();
      section = initialize.get(entry);
      this.set(entry, section.merge(this.get(entry)));
    }

    return this;
  }
Exemple #2
0
  /**
   * Ermittelt aus dem String die enthaltenen Sektionen. Das Parsen ignoriert ungültige
   * Sektionen, Schlüssel und Werte. Rückgabe die ermittelten Sektionen als Initialize.
   *
   * @param text zu parsender String
   * @param smart automatisches Anlegen nicht existierender Sektionen
   * @return die ermittelten Sektionen als Initialize
   */
  public static Initialize parse(String text, boolean smart) {

    Enumeration enumeration;
    Initialize initialize;
    String line;
    String section;
    StringBuffer buffer;
    StringTokenizer tokenizer;

    String[] strings;

    int index;

    initialize = new Initialize(smart);

    if (text == null) return initialize;

    buffer = null;

    tokenizer = new StringTokenizer(text, "\r\n");
    while (tokenizer.hasMoreTokens()) {

      line = ((String) tokenizer.nextElement()).trim();

      if (line.startsWith("[")) {

        buffer = new StringBuffer();

        // die Zeile wird wie folgt verarbeitet:
        //  - der eindeutige/gueltige Name der Sektion wird ermittelt
        //  - der Kommentarteil wird entfernt
        //  - nachfolgende Sektionen sind nicht zulaessig und werden entfernt
        //  - ggf. existierende Ableitungen werden
        strings =
            line.replaceAll(
                    "^(?i)(?:\\[\\s*([^\\[\\]\\;]+)\\s*\\]\\s*(?:extends\\s+([^\\[\\]\\;]+))*)*.*$",
                    "$1 \00 $2")
                .split("\00");

        // die Sektion wird ggf. dekodiert und optimiert
        section = Initialize.decode(strings[0]);

        // nur gueltige Sektionen werden geladen
        if (section.isEmpty()) continue;

        initialize.entries.put(section, buffer);

        // ggf. existierende Ableitungen werden registriert und geladen
        strings = strings[1].split("\\s+");
        for (index = 0; index < strings.length; index++) {
          section = Initialize.decode(strings[index]);
          if (initialize.entries.containsKey(section))
            buffer.append("\r\n").append(initialize.entries.get(section));
        }

      } else if (buffer != null) {

        // Inhalt wird nur mit gueltiger Sektion verarbeitet
        buffer.append("\r\n").append(line);
      }
    }

    enumeration = Collections.enumeration(initialize.entries.keySet());
    while (enumeration.hasMoreElements()) {
      section = (String) enumeration.nextElement();
      initialize.entries.put(
          section,
          Section.parse(((StringBuffer) initialize.entries.get(section)).toString(), smart));
    }

    return initialize;
  }
Exemple #3
0
 /**
  * Ermittelt aus dem String die enthaltenen Sektionen. Das Parsen ignoriert ung&uuml;ltige
  * Sektionen, Schl&uuml;ssel und Werte. R&uuml;ckgabe die ermittelten Sektionen als Initialize.
  *
  * @param text zu parsende Sektionen
  * @return die ermittelten Sektionen als Initialize
  */
 public static Initialize parse(String text) {
   return Initialize.parse(text, false);
 }