lingo 1.8.0

data/lib/lingo/attendee/variator.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+
+#--
+# LINGO ist ein Indexierungssystem mit Grundformreduktion, Kompositumzerlegung,
+# Mehrworterkennung und Relationierung.
+#
+# Copyright (C) 2005-2007 John Vorhauer
+# Copyright (C) 2007-2011 John Vorhauer, Jens Wille
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
+#
+# For more information visit http://www.lex-lingo.de or contact me at
+# welcomeATlex-lingoDOTde near 50°55'N+6°55'E.
+#
+# Lex Lingo rules from here on
+#++
+
+class Lingo
+
+  # Der Variator ermöglicht bei nicht erkannten Wörtern den listenbasierten
+  # Austausch einzelner Wortteile einchließlich erneuter Wörterbuchsuche zur
+  # Verbesserung der Worterkennungsquote.
+  #
+  # Ursprünglich wurde der Variator entwickelt, um die mangelnde Qualität bei der
+  # OCR-Erkennung altdeutscher 's'-Konsonanten zu optimieren. Er kann ebenso bei
+  # alternativen Umlautschreibweisen z.B. zur Wandlung von 'Koeln' in 'Köln' dienen.
+  #
+  # === Mögliche Verlinkung
+  # Erwartet:: Daten vom Typ *Word* (andere werden einfach durchgereicht) z.B. von Wordsearcher
+  # Erzeugt:: Daten vom Typ *Word* zur Weiterleitung z.B. an Synonymer, Decomposer, Multiworder, Sequencer, Noneword_filter oder Vector_filter
+  #
+  # === Parameter
+  # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
+  # Alle anderen Parameter müssen zwingend angegeben werden.
+  # <b>in</b>:: siehe allgemeine Beschreibung des Attendee
+  # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
+  # <b>source</b>:: siehe allgemeine Beschreibung des Dictionary
+  # <b><i>mode</i></b>:: (Standard: all) siehe allgemeine Beschreibung des Dictionary
+  # <b><i>^check</i></b>:: (Standard: WA_UNKNOWN) Gebrenzt die zu variierenden Worttypen
+  # <b><i>marker</i></b>:: (Standard: '*') Kennzeichnung durch Variation erkannter Wörter
+  # <b><i>max-var</i></b>:: (Standard: '10000') Begrenzung der maximal zu prüfenden Permutationen bei der vollständigen Kombination aller auf ein Wort anzuwendenen aufgelisteten Wortteile.
+  #
+  # === Beispiele
+  # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
+  #   meeting:
+  #     attendees:
+  #       - textreader:   { out: lines, files: '$(files)' }
+  #       - tokenizer:    { in: lines, out: token }
+  #       - wordsearcher: { in: abbrev, out: words, source: 'sys-dic' }
+  #       - variator:     { in: words, out: varios, source: 'sys-dic' }
+  #       - debugger:     { in: varios, prompt: 'out>' }
+  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+  #   out> *FILE('test.txt')
+  #   out> <*Dies = [(dies/w)]>
+  #   out> <*ist = [(ist/t)]>
+  #   out> <ein = [(ein/t)]>
+  #   out> <*Tisch = [(tisch/s)]>
+  #   out> :./PUNC:
+  #   out> *EOL('test.txt')
+  #   out> *EOF('test.txt')
+
+  class Attendee::Variator < Attendee
+
+    protected
+
+    def init
+      # Parameter verarbeiten
+      @marker  = get_key('marker', '*')
+      @max_var = get_key('max-var', '10000').to_i
+      filter = get_array('check', WA_UNKNOWN)
+
+      src = get_array('source')
+      mod = get_key('mode', 'all')
+
+      # Daten verarbeiten
+      @var_strings = get_key('variations')
+      forward(STR_CMD_ERR, 'Ocr-variator: Konfiguration <ocr-variator> ist leer') if @var_strings.size==0
+
+      # Initialisierungen
+      @check = Hash.new(false)
+      filter.each { |s| @check[s.upcase] = true }
+
+      # Wörterbuchzugriff
+      @dic = Dictionary.new({'source'=>src, 'mode'=>mod}, @lingo)
+      @gra = Grammar.new({'source'=>src, 'mode'=>mod}, @lingo)
+
+      # Optimierungen
+      if @max_var == 0
+        forward( STR_CMD_WARN, 'Ocr-variator: max-var ist 0, setze es auf 10.000' )
+        @max_var = 10000
+      end
+    end
+
+    def control(cmd, par)
+      # Status wird abgefragt
+      if cmd == STR_CMD_STATUS
+        # Eigenen Status um Status von Dictionary und Grammer erweitern
+        @dic.report.each_pair { | k, v | set( k, v ) }
+        @gra.report.each_pair { | k, v | set( k, v ) }
+      end
+    end
+
+    def process(obj)
+      # Zu prüfende Wörter filtern
+      if obj.is_a?(Word) && @check[obj.attr]
+        # Statistik für Report
+        inc('Anzahl gesuchter Wörter')
+
+        # Erzeuge Variationen einer Wortform
+        variations = [obj.form]
+        @var_strings.each do |switch|
+          from, to = switch
+          variations = variate(variations, from, to)
+        end
+
+        # Prüfe Variation auf bekanntes Wort
+        variations[0...@max_var].each do |var|
+          # Variiertes Wort im Wörterbuch suchen
+          word = @dic.find_word(var)
+          word = @gra.find_compositum(var) if word.attr == WA_UNKNOWN
+          next if word.attr == WA_UNKNOWN || (
+            word.attr == WA_KOMPOSITUM && word.lexicals.any? { |lex|
+              lex.attr[0..0] == LA_TAKEITASIS
+            }
+          )
+
+          # Das erste erkannte Wort beendet die Suche
+          inc('Anzahl gefundener Wörter')
+          word.form = @marker + var
+          forward(word)
+          return
+        end
+      end
+
+      forward(obj)
+    end
+
+    private
+
+    # Variiere die Bestandteile eines Arrays gemäß den Austauschvorgaben.
+    #
+    # variate( 'Tiieh', 'ieh', 'sch' ) => ['Tiieh', 'Tisch']
+    def variate(variation_list, from, to)
+      # neue Varianten sammeln
+      add_variations = []
+      from_re = Regexp.new(from)
+
+      # alle Wörter in der variation_list permutieren
+      variation_list.each do |wordform|
+
+        # Wortform in Teile zerlegen und anschließend Dimension feststellen
+        wordpart = " #{wordform} ".split( from_re )
+        n = wordpart.size - 1
+
+        # Austauschketten in Matrix hinterlegen
+        change = [from, to]
+
+        # Austauschketten auf alle Teile anwenden
+        (1..(2**n-1)).each do |i|
+          variation = wordpart[0]
+          # i[x] = Wert des x.ten Bit von Integer i
+          (1..n).each { |j| variation += change[i[j-1]] + wordpart[j]  }
+
+          add_variations << variation.strip
+        end
+      end
+
+      variation_list + add_variations
+    end
+
+  end
+
+end

data/lib/lingo/attendee/vector_filter.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+
+#--
+# LINGO ist ein Indexierungssystem mit Grundformreduktion, Kompositumzerlegung,
+# Mehrworterkennung und Relationierung.
+#
+# Copyright (C) 2005-2007 John Vorhauer
+# Copyright (C) 2007-2011 John Vorhauer, Jens Wille
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
+#
+# For more information visit http://www.lex-lingo.de or contact me at
+# welcomeATlex-lingoDOTde near 50°55'N+6°55'E.
+#
+# Lex Lingo rules from here on
+#++
+
+class Lingo
+
+  # Die Hauptaufgabe des Vector_filter ist die Erstellung eines Dokumenten-Index-Vektor.
+  # Dabei werden die durch die anderen Attendees ermittelten Grundformen eines Wortes
+  # gespeichert und bei einem Datei- oder Record-Wechsel weitergeleitet. Der Vector_filter
+  # kann bestimmte Wortklassen filtern und die Ergebnisse in verschiedenen Arten aufbereiten.
+  # Dabei werden Funktionen wie das einfache Zählen der Häufigkeit innerhalb eines Dokuments,
+  # aber auch die Term-Frequenz und unterschiedliche Ausgabeformate unterstützt.
+  #
+  # === Mögliche Verlinkung
+  # Erwartet:: Daten vom Typ *Word*, z.B. von Abbreviator, Wordsearcher, Decomposer, Synonymer, Multiworder, Sequencer
+  # Erzeugt:: Daten vom Typ *String*, z.B. für Textwriter
+  #
+  # === Parameter
+  # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
+  # Alle anderen Parameter müssen zwingend angegeben werden.
+  # <b>in</b>:: siehe allgemeine Beschreibung des Attendee
+  # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
+  # <b><i>lexicals</i></b>:: (Standard: '[sy]' => die Wortklassen Substantiv und Synonyme werden gefiltert)
+  #                          Es können in eckige Klammern beliebige Wortklassen angegeben werden (siehe lib/strings.rb).
+  #                          Der Parameter wird als regulärer Ausdruck ausgewertet.
+  # <b><i>sort</i></b>:: (Standard: 'normal')
+  #                      Der Parameter +sort+ beeinflußt Verarbeitung und Ausgabeformat des Vector_filters.
+  #                      normal:: Jedes gefilterte Wort wird einmalig (keine Doppelnennungen!) in
+  #                               alphabetischer Reihenfolge in der Form "wort" ausgegeben.
+  #                      term_abs:: Jedes gefilterte Wort wird einmalig in absteigender Häufigkeit mit Angabe
+  #                                 der absoluten Häufigkeit im Dokument in der Form "12 wort" ausgegeben.
+  #                      term_rel:: Jedes gefilterte Wort wird einmalig in absteigender Häufigkeit mit Angabe
+  #                                 der relativen Häufigkeit im Dokument in der Form "0.1234 wort" ausgegeben.
+  #                      sto_abs:: Jedes gefilterte Wort wird einmalig in absteigender Häufigkeit mit Angabe
+  #                                der absoluten Häufigkeit im Dokument in der Form "wort {12}" ausgegeben.
+  #                      sto_rel:: Jedes gefilterte Wort wird einmalig in absteigender Häufigkeit mit Angabe
+  #                                der relativen Häufigkeit im Dokument in der Form "wort {0.1234}" ausgegeben.
+  # <b><i>skip</i></b>:: (Standard: TA_PUNCTUATION und TA_OTHER) Hiermit wird angegeben, welche Objekte nicht
+  #                      verarbeitet werden sollen. Die +skip+-Angabe bezieht sich auf das Attribut +attr+ von
+  #                      Token oder Word-Objekten.
+  #
+  # === Beispiele
+  # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
+  #   meeting:
+  #     attendees:
+  #       - textreader:   { out: lines, files: '$(files)' }
+  #       - tokenizer:    { in: lines, out: token }
+  #       - wordsearcher: { in: token, out: words, source: 'sys-dic' }
+  #       - vector_filter: { in: words, out: filtr, sort: 'term_rel' }
+  #       - debugger:     { in: filtr, prompt: 'out>' }
+  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+  #   out> *FILE('test.txt')
+  #   out> "0.28571 indexierung"
+  #   out> *EOF('test.txt')
+
+  class Attendee::Vector_filter < Attendee
+
+    protected
+
+    def init
+      @lexis = Regexp.new(get_key('lexicals', '[sy]').downcase)
+      @sort = get_key('sort', 'normal').downcase
+      @skip = get_array('skip', TA_PUNCTUATION+','+TA_OTHER).collect {|s| s.upcase }
+      @vectors = Array.new
+      @word_count = 0
+
+      if @debug = get_key('debug', false)
+        @prompt = get_key('prompt', 'lex:) ')
+      end
+    end
+
+    def control(cmd, par)
+      case cmd
+        when STR_CMD_EOL
+          deleteCmd
+        when STR_CMD_FILE, STR_CMD_RECORD, STR_CMD_EOF
+          @debug ? @vectors.each { |str| forward(str) } : sendVector
+          @vectors.clear
+      end
+    end
+
+    def process(obj)
+      if @debug
+        @vectors << "#{@prompt} #{obj.inspect}" if eval(@debug)
+      elsif obj.is_a?(Word)
+        @word_count += 1 if @skip.index(obj.attr).nil?
+        unless obj.lexicals.nil?
+          lexis = obj.get_class(@lexis) #lexicals.collect { |lex| (lex.attr =~ @lexis) ? lex : nil }.compact # get_class(@lexis)
+          lexis.each { |lex| @vectors << lex.form.downcase }
+          add('Anzahl von Vektor-Wörtern', lexis.size)
+        end
+      end
+    end
+
+    private
+
+    def sendVector
+      return if @vectors.size==0
+
+      add('Objekte gefiltert', @vectors.size)
+
+      # Array der Vector-Wörter zählen und nach Häufigkeit sortieren
+      if @sort=='normal'
+        @vectors = @vectors.compact.sort.uniq
+      else
+        cnt = Hash.new(0)
+        @vectors.compact.each { |e| cnt[e]+=1 }
+        @vectors = cnt.to_a.sort { |x,y|
+          if (y[1]<=>x[1])==0
+            x[0]<=>y[0]
+          else
+            y[1]<=>x[1]
+          end
+        }
+      end
+
+      # Vectoren je nach Parameter formatiert weiterleiten
+      @vectors.collect { |vec|
+        case @sort
+        when 'term_abs' then sprintf "%d %s", vec[1], vec[0]
+        when 'term_rel' then sprintf "%6.5f %s", vec[1].to_f/@word_count, vec[0]
+        when 'sto_abs'  then sprintf "%s {%d}", vec[0], vec[1]
+        when 'sto_rel'  then sprintf "%s {%6.5f}", vec[0], vec[1].to_f/@word_count
+        else sprintf "%s", vec
+        end
+      }.each { |str| forward(str) }
+
+      @word_count = 0 if @sort == 'sto_rel'
+    end
+
+  end
+
+end

data/lib/lingo/attendee/wordsearcher.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+#--
+# LINGO ist ein Indexierungssystem mit Grundformreduktion, Kompositumzerlegung,
+# Mehrworterkennung und Relationierung.
+#
+# Copyright (C) 2005-2007 John Vorhauer
+# Copyright (C) 2007-2011 John Vorhauer, Jens Wille
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
+#
+# For more information visit http://www.lex-lingo.de or contact me at
+# welcomeATlex-lingoDOTde near 50°55'N+6°55'E.
+#
+# Lex Lingo rules from here on
+#++
+
+class Lingo
+
+  # Der Wordsearcher ist das Herzstück von Lingo. Er macht die Hauptarbeit und versucht
+  # alle Token die nach einem sinnvollen Wort aussehen, in den ihm angegebenen
+  # Wörterbüchern zu finden und aufzulösen. Dabei werden die im Wörterbuch gefundenen
+  # Grundformen inkl. Wortklassen an das Word-Objekt angehängt.
+  #
+  # === Mögliche Verlinkung
+  # Erwartet:: Daten vom Typ *Token* (andere werden einfach durchgereicht) z.B. von Tokenizer, Abbreviator
+  # Erzeugt:: Daten vom Typ *Word* für erkannte Wörter z.B. für Synonymer, Decomposer, Ocr_variator, Multiworder, Sequencer, Noneword_filter, Vector_filter
+  #
+  # === Parameter
+  # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
+  # Alle anderen Parameter müssen zwingend angegeben werden.
+  # <b>in</b>:: siehe allgemeine Beschreibung des Attendee
+  # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
+  # <b>source</b>:: siehe allgemeine Beschreibung des Dictionary
+  # <b><i>mode</i></b>:: (Standard: all) siehe allgemeine Beschreibung des Dictionary
+  #
+  # === Beispiele
+  # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
+  #   meeting:
+  #     attendees:
+  #       - textreader:   { out: lines, files: '$(files)' }
+  #       - tokenizer:    { in: lines, out: token }
+  #       - abbreviator:  { in: token, out: abbrev, source: 'sys-abk' }
+  #       - wordsearcher: { in: abbrev, out: words, source: 'sys-dic' }
+  #       - debugger:     { in: words, prompt: 'out>' }
+  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+  #   out> *FILE('test.txt')
+  #   out> <Dies = [(dies/w)]>
+  #   out> <ist = [(sein/v)]>
+  #   out> <ggf. = [(gegebenenfalls/w)]>
+  #   out> <eine = [(einen/v), (ein/w)]>
+  #   out> <Abk³rzung = [(abk³rzung/s)]>
+  #   out> :./PUNC:
+  #   out> *EOL('test.txt')
+  #   out> *EOF('test.txt')
+
+  class Attendee::Wordsearcher < Attendee
+
+    def init
+      # Wörterbuch bereitstellen
+      src = get_array('source')
+      mod = get_key('mode', 'all')
+      @dic = Dictionary.new({'source'=>src, 'mode'=>mod}, @lingo)
+    end
+
+    def control(cmd, par)
+      @dic.report.each_pair { |key, value|
+        set(key, value)
+      } if cmd == STR_CMD_STATUS
+    end
+
+    def process(obj)
+      if obj.is_a?(Token) && obj.attr == TA_WORD
+        inc('Anzahl gesuchter Wörter')
+        word = @dic.find_word(obj.form)
+        inc('Anzahl gefundener Wörter') unless word.attr == WA_UNKNOWN
+        obj = word
+      end
+      forward(obj)
+    end
+
+  end
+
+end

data/lib/lingo/attendees.rb

@@ -0,0 +1,289 @@
+# encoding: utf-8
+
+#--
+# LINGO ist ein Indexierungssystem mit Grundformreduktion, Kompositumzerlegung,
+# Mehrworterkennung und Relationierung.
+#
+# Copyright (C) 2005-2007 John Vorhauer
+# Copyright (C) 2007-2011 John Vorhauer, Jens Wille
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
+#
+# For more information visit http://www.lex-lingo.de or contact me at
+# welcomeATlex-lingoDOTde near 50°55'N+6°55'E.
+#
+# Lex Lingo rules from here on
+#++
+
+require_relative 'modules'
+require_relative 'language'
+require_relative 'const'
+require_relative 'types'
+
+class Lingo
+
+  # Lingo ist als universelles Indexierungssystem entworfen worden. Seine Stärke liegt in der einfachen Konfigurierbarkeit für
+  # spezifische Aufgaben und in der schnelle Entwicklung weiterer Funktionen durch systematischen Kapselung der Komplexität auf
+  # kleine Verarbeitungseinheiten. Die kleinste Verarbeitungseinheit wird Attendee genannt. Um ein gewünschtes Verarbeitungsergebnis
+  # zu bekommen, werden die benötigten Attendees einfach in einer Reihe hinter einander geschaltet. Ein einfaches Beispiel hierfür ist
+  # eine direkte Verbindung zwischen einem Textreader, einem Tokenizer und einem Textwriter. Alle drei Klassen sind von der Klasse
+  # Attendee abgeleitet.
+  #
+  # Der Textreader liest beispielsweise Zeilen aus einer Textdatei und leitet sie weiter an den Tokenizer. Der Tokenizer zerlegt eine
+  # Textzeile in einzelne Wörter und gibt diese weiter an den Textwriter, der diese in eine (andere) Datei schreibt. Über vielfältige
+  # Konfigurationsmöglichkeiten kann das Verhalten der Attendees an die eigenen Bedürfnisse angepasst werden.
+  #
+  # Die Verkettung einzelner Attendees findet über die Schnittstellen +listen+ und +talk+ statt. An +listen+ können beliebige Objekte
+  # zur Ver- und Bearbeitung übergeben werden. Nach der Verarbeitung werden sie mittels +talk+ an die verketteten Attendees weiter
+  # gegeben. Objekte der Klasse AgendaItem dienen dabei der Steuerung der Verarbeitung und sind nicht Bestandteil der normalen
+  # Verarbeitung. Beispiele für AgendaItems sind die Kommandos TALK (Aufforderung zum Start der Verarbeitung), WARN (zur Ausgabe von
+  # Warnungen eines Attendees) und EOL (End of Line, Ende einer Textzeile nach Zerlegung in einzelne Wörter). Eine vollständige
+  # Übersicht benutzer AgendaItems (oder auf Stream Commands) steht in lib/const.rb mit dem Prefix STR_CMD_.
+  #
+  # Um die Entwicklung von neuen Attendees zu beschleunigen, wird durch die Vererbung sind bei wird die gesammte sind in der Regel nur
+  # drei abstrakte Methoden zu implementieren: +init+, +control+ und +process+. Die Methode +init+ wird bei der Instanziierung eines
+  # Objektes einmalig aufgerufen. Sie dient der Vorbereitung der Verarbeitung, z.B. durch das Öffnen und Bereitstellen von
+  # Wörterbüchern zur linguistischen Analyse. An die Methode +control+ werden alle eingehenden AgendaItems weitergeleitet. Dort erfolgt
+  # die Verarbeitungssteuerung, also z.B. bei STR_CMD_FILE das Öffnen einer Datei und bei STR_CMD_EOF respektive das Schließen. Die
+  # echte Verarbeitung von Daten findet daher durch die Methode +process+ statt.
+  #
+  # was macht attendee
+  # - verkettung der attendees anhand von konfigurationsinformationen
+  # - bereitstellung von globalen und spezifischen konfigurationsinformationen
+  # - behandlung von bestimmten übergreifenden Kommandos, z.B. STR_CMD_TALK, STR_CMD_STATUS, STR_CMD_WARN, STR_CMD_ERR
+  # - separierung und routing von kommando bzw. datenobjekten
+  #
+  # was macht die abgeleitet klasse
+  # - verarbeitet und/oder transformiert datenobjekte
+  # - wird gesteuert durch kommandos
+  # - schreibt verarbeitungsstatistiken
+
+  class Attendee
+
+    include Reportable
+
+    def initialize(config, lingo)
+      @lingo = lingo
+
+      init_reportable
+
+      begin
+        lingo.dictionary_config
+      rescue
+        raise "Fehler in der .lang-Datei bei 'language/dictionary'"
+      end
+
+      @config, @subscriber = config, []
+
+      init if self.class.method_defined?(:init)
+
+      @attendee_can_control = self.class.method_defined?(:control)
+      @attendee_can_process = self.class.method_defined?(:process)
+
+      @skip_this_command, @start_of_processing = false, nil
+    end
+
+    def add_subscriber(subscriber)
+      @subscriber.concat(subscriber)
+    end
+
+    def listen(obj)
+      unless obj.is_a?(AgendaItem)
+        if @attendee_can_process
+          inc(STA_NUM_OBJECTS)
+
+          unless @lingo.report_time
+            process(obj)
+          else
+            @start_of_processing = Time.new
+            process(obj)
+            add(STA_TIM_OBJECTS, Time.new - @start_of_processing)
+          end
+        else
+          forward(obj)
+        end
+      else
+        # Neuen TOP verarbeiten
+        if @attendee_can_control
+          inc(STA_NUM_COMMANDS)
+
+          unless @lingo.report_time
+            control(obj.cmd, obj.param)
+          else
+            @start_of_processing = Time.new
+            control(obj.cmd, obj.param)
+            add(STA_TIM_COMMANDS, Time.new - @start_of_processing)
+          end
+        end
+
+        # Spezialbehandlung für einige TOPs nach Verarbeitung
+        case obj.cmd
+          when STR_CMD_TALK
+            # keine weitere Behandlung oder Weiterleitung
+            nil
+          when STR_CMD_STATUS
+            # Standardprotokollinformationen ausgeben
+
+            if @lingo.report_time
+              @lingo.config.stderr.puts 'Perf: %-15s => %7d commands in %s (%s/cmd),  %8d objects in %s (%s/obj)' % [
+                @config['name'],
+                get(STA_NUM_COMMANDS),
+                seconds_to_str(get(STA_TIM_COMMANDS)),
+                seconds_to_str((get(STA_NUM_COMMANDS)==0) ? 0.0 : get(STA_TIM_COMMANDS) / get(STA_NUM_COMMANDS).to_f),
+                get(STA_NUM_OBJECTS),
+                seconds_to_str(get(STA_TIM_OBJECTS)),
+                seconds_to_str((get(STA_NUM_OBJECTS)==0) ? 0.0 : get(STA_TIM_OBJECTS) / get(STA_NUM_OBJECTS).to_f)
+              ]
+            end
+
+            if @lingo.report_status
+              @lingo.config.stderr.puts "Attendee <%s> was connected from '%s' to '%s' reporting...\n" % @config.values_at(*%w[name in out]),
+                report.sort.map { |info| " #{info[0]} = #{info[1]}" }, nil
+            end
+
+            forward(obj.cmd, obj.param)
+          else
+            if @skip_this_command
+              @skip_this_command = false
+            else
+              forward(obj.cmd, obj.param)
+            end
+        end
+      end
+    end
+
+    def talk(obj)
+      time_for_sub = Time.new if @lingo.report_time
+      @subscriber.each { |attendee| attendee.listen(obj) }
+      @start_of_processing += (Time.new - time_for_sub) if @lingo.report_time
+    end
+
+    private
+
+    # ---------------------------------------------------
+    # Create intelligent output of performance times
+    # measured with command line option -p
+    # ---------------------------------------------------
+
+    def seconds_to_str(float)
+      if float < 0.001
+        "%9.3f µs" % [float * 1000000.0]
+      elsif float < 1.0
+        "%9.3f ms" % [float * 1000.0]
+      elsif float < 60.0
+        "%9.3f s " % [float]
+      elsif float < 3600.0
+        "%9.3f m " % [float / 60.0]
+      else
+        "%9.3f h " % [float / 3600.0]
+      end
+    end
+
+    def deleteCmd
+      @skip_this_command = true
+    end
+
+    def forward(obj, param=nil)
+      if param.nil?
+        # Information weiterreichen
+        talk(obj)
+      else
+        # TOP weiterreichen (wenn keine Warnung oder Fehler)
+        case obj
+          when STR_CMD_WARN  then printf "+%s\n|   %s: %s\n+%s\n", '-'*60, @config['name'], param, '-'*60
+          when STR_CMD_ERR  then printf "%s\n=   %s: %s\n%s\n", '='*61, @config['name'], param, '='*61;  exit( 1 )
+          else
+            talk(AgendaItem.new(obj, param))
+        end
+      end
+    end
+
+    # ---------------------------------------------------
+    # Konfigurationshilfsmethoden
+    # ---------------------------------------------------
+    def has_key?(key)
+      !@config.nil? && @config.has_key?(key)
+    end
+
+    def get_key(key, default=nil)
+      forward(STR_CMD_ERR, "Attribut #{key} nicht gesetzt") if default.nil? && !has_key?(key)
+      @config.fetch(key, default)
+    end
+
+    def get_array(key, default=nil)
+      get_key(key, default).split(STRING_SEPERATOR_PATTERN)
+    end
+
+    # ---------------------------------------------------
+    # Abstrakte Methoden
+    #
+    # init
+    # control(cmd, param)
+    # process(obj)
+    # ---------------------------------------------------
+
+  end
+
+  class BufferedAttendee < Attendee
+
+    BufferInsert = Struct.new(:position, :object)
+
+    def initialize(config, lingo)
+      # In den Buffer werden alle Objekte geschrieben, bis process_buffer? == true ist
+      @buffer = []
+
+      # deferred_inserts beeinflussen nicht die Buffer-Größe, sondern werden an einer
+      # bestimmten Stelle in den Datenstrom eingefügt
+      @deferred_inserts = []
+
+      super
+    end
+
+    protected
+
+    def process(obj)
+      @buffer.push(obj)
+      process_buffer if process_buffer?
+    end
+
+    private
+
+    def forward_buffer
+      # Aufgeschobene Einfügungen in Buffer kopieren
+      @deferred_inserts.sort_by { |ins| ins.position }.each { |ins|
+        @buffer.insert(ins.position, ins.object)
+      }
+      @deferred_inserts.clear
+
+      # Buffer weiterleiten
+      @buffer.each { |obj| forward(obj) }
+      @buffer.clear
+    end
+
+    def process_buffer?
+      true
+    end
+
+    def process_buffer
+      # to be defined by child class
+    end
+
+    def deferred_insert(pos, obj)
+      @deferred_inserts << BufferInsert.new(pos, obj)
+    end
+
+  end
+
+end