Format-Strings für DataSets

[SubData]

Hi zusammen,

da ich seit langem mal wieder in meinen Delphi-Units gegraben habe, ist mir eine alte
Unit in die Hände gefallen, die ich mal gebaut habe, um DataSets einfach via Format-Strings
ausgeben zu können.

Ich erlaube mir einfach mal den Kopf der Unit zu zitieren und diese anzuhängen.

Damals entwickelt für Delphi 7, ob sie auf neueren Umgebungen läuft, weiß ich nicht.
Da ich den Code aber sehr lange Zeit verwendet habe und er immer wieder viel Arbeit erspart hat,
hier für alle.

Delphi-Quellcode:

(* ************************************************************************* *)
(*  unit      : dbformat
(*  version   : 0.03.20090825
(* ------------------------------------------------------------------------- *)
(*  lizenz    :
(*
(*    dbformat - unit for generating formated strings with datasets as source
(*
(*    Copyright (C) 2006 - 2010   SubData
(*
(*    This program is free software; you can redistribute it and/or modify it
(*    under the terms of the GNU 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 General Public License for more details.
(*
(*    You should have received a copy of the GNU General Public License
(*    along with this program; if not, see <http://www.gnu.org/licenses/>.
(* ------------------------------------------------------------------------- *)
(*  vorwort   :
(*
(*    Diese Unit stellt einige Funktionen zur Verfügung, um DataSets mit
(*    Hilfe von Formatstrings zu formatieren und als String bzw. Array
(*    zurückzuliefern. Das DataSet selbst wird dabei nicht verändert.
(*
(*    Der Grundgedanke dieser Unit war es, auf einfachem und schnellem
(*    Wege Informationen aus einer Datenbank in Dokumente und Listen
(*    einzufügen oder die Daten an Schnittstellen zu übergeben.
(* ------------------------------------------------------------------------- *)
(*  proc      :
(*
(*    CompileFmtStr(FormatString): TFormatRecord;
(*
(*      Zerlegt den Formatstring in ein Array, welches hinterher an die
(*      Format-Routinen übergeben wird, um die eigentlich gewünschte
(*      Rückgabe, nämlich den formatierten String, zu erhalten.
(*
(*    FormatDataSet(TFormatRecord, TDataSet): String;
(*    FormatDataSet(PFormatRecord, TDataSet): String;
(*    FormatDataSet(FormatString, TDataSet): String;
(*
(*      Formatiert das DataSet nach den übergebenen Parametern.
(*      Sofern diese Formatierung einmalig durchgeführt wird, kann der
(*      Formatstring direkt übergeben werden, bei Schleifen bzw.
(*      größeren Datenmengen empfiehlt es sich, vorher ein TFormatRecord
(*      via CompileFmtStr zu erstellen.
(*
(*    FormatDataSetRows(TFormatRecord, TDataSet): TStringDynArray;
(*    FormatDataSetRows(FormatString, TDataSet): TStringDynArray;
(*
(*      Liefert statt einen String mit dem aktuell selectierten Datensatz
(*      alle Datensätze bis EOF in einem Array zurück.
(* ------------------------------------------------------------------------- *)
(*  format    :
(*
(*    Nehmen wir folgendes DataSet als Beispiel
(*    --------------------------------------------------------------------------
(*    |  id | name       | gebdatum   | verheiratet | notiz         | gehalt   |
(*    --------------------------------------------------------------------------
(*    |  42 | max muster | 01.04.1980 |       false |               |  5000.00 |
(*    --------------------------------------------------------------------------
(*
(*    Ein normaler Formatstring zur Ausgabe der Felder könnte dann
(*    folgendermaßen aussehen:
(*      "Der Mitarbeiter $name$ wurde am $gebdatum$ geboren und hat ID $id$"
(*    Das Ergebnis:
(*      "Der Mitarbeiter max muster wurde am 01.04.1980 geboren und hat ID 42"
(*
(*    Ergänzend zu den normalen Formatangaben können die angesprochenen
(*    Felder mit Parametern formatiert bzw. an externe Prozeduren
(*    übergeben werden.
(*
(*    Eine Formatangabe mit Parameter sieht immer folgendermaßen aus
(*      "$[befehl][parameter]:[feldname]$"
(*    Sofern mehrere Parameter eingegeben werden können, werden diese
(*    durch Kommas voneinander getrennt. Nach dem Befehl wird kein
(*    Trennzeichen angegeben, sondern direkt mit dem Parameter fortgefahren
(*
(*    Es stehen folgende Befehle zur Verfügung:
(*      %, b, c, d, e, f, h, i, l, p, r und v
(*
(*    % - Übergabe an Format
(*      Eingabe:  "Name: $%20s:name$"
(*      Ausgabe:  "Name: max muster          "
(*
(*    b - Übergabe an FormatBcd (bisher ungetestet)
(*
(*    c - Übergabe an FormatCurr (Feld wird mit asCurrency gelesen)
(*      Eingabe:  "Gehalt: $c#,##0.00:gehalt$"
(*      Ausgabe:  "Gehalt: 5.000,00"
(*
(*    d - Übergabe an FormatDateTime
(*      Eingabe:  "Geburtsdatum: $dyyyy-mm-dd:gebdatum$";
(*      Ausgabe:  "Geburtsdatum: 1980-04-01"
(*
(*    e - Extrahieren eines Teilstrings
(*      Der erste Parameter bezeichnet den Index, der zweite die Anzahl
(*      Eingabe:  "$e3,3:name$"
(*      Ausgabe:  "x m"
(*
(*    f - Übergabe an FormatFloat (Feld wird mit asFloat gelesen)
(*      siehe FormatCurr
(*
(*    h - Feldinhalt hexadezimal ausgeben
(*      Hier besteht die Möglichkeit das Feld als String oder Integer
(*      zu behandeln. Sofern kein Parameter angegeben wird, wird das
(*      Feld als String behandelt.
(*      Eingabe:  "Die ganze Wahrheit: $hi:id$"
(*      Ausgabe:  "Die ganze Wahrheit: 2A"      # Entspricht der Zahl 42
(*      Eingabe:  "Die ganze Wahrheit: $h:id$"
(*      Ausgabe:  "Die ganze Wahrheit: 2220"    # Entspricht dem String "42"
(*
(*    i - Feld über den Index ansprechen
(*      Hierbei kann der Feldname weggelassen werden, der Doppelpunkt
(*      muss allerdings trotzdem angegeben werden!
(*      Eingabe:  "Index 1: $i1:$"
(*      Ausgabe:  "Index 1: max muster"
(*
(*    l - Feld als logischen Wert (Boolean) behandeln
(*      Es können dabei die Werte für True, False und Null (Sofern das Feld
(*      keinen Wert beinhaltet) festgelegt werden.
(*      Eingabe:  "Ehe: $lJa,Nein,Unbekannt:verheiratet$"
(*      Ausgabe:  "Ehe: Nein"
(*
(*    p - Übergabe an eine eigene Prozedur
(*      Erlaubt die Übergabe von 2 Pointern, einen für die Prozedur, die
(*      dem Format TFormatProcedure entsprechen muss und einem zusätzlichen
(*      Pointer auf eine ggf. benötigte Datenmenge.
(*      Auf diese Weise kann zum Beispiel ein individueller Zähler
(*      realisiert werden, der jeden Aufruf mit ausgibt.
(*      Beispielcode:
(*
(*        function DataSetWithCount(const xSet: TDataSet): String;
(*        var
(*          sFmt  : String;
(*          iLoop : Integer;
(*
(*          function _Loop(const re: TFormatRecordEntry; const xSet: TDataSet): String;
(*          begin
(*            Result := IntToStr(Integer(re.pData^))
(*          end;
(*
(*        begin
(*          Result := '';
(*          sFmt := 'Count: $p' + IntToStr(Integer(@_Loop)) + ',' + IntToStr(Integer(@iLoop)) + ':$ => $name$';
(*          while not xSet.Eof do
(*          begin
(*            Result := Result + FormatDataSet(sFmt, xSet) + #13#10;
(*            Inc(iLoop);
(*            xSet.Next;
(*          end;
(*        end;
(*
(*    r - Reguläre Ausdrück
(*      TODO
(*
(*    v - Alternativwert wenn das Feld leer ist. (isNull)
(*      Eingabe:  "Notiz: $vNicht vorhanden:notiz$"
(*      Ausgabe:  "Notiz: Nicht vorhanden"
(*
(* ************************************************************************* *)