Ada Tour - Dokumentation

zurück

vor

11.1.3.3 Zeichenkettenbehandlung bei fester Zeichenkettenlänge

Das Paket Ada.Strings.Fixed bietet Unterprogramme zur Zeichenkettenbehandlung von Zeichenketten mit fester Länge, also Zeichenketten vom Typ Standard.String.

1) Unterprogramme zum Kopieren und Vervielfätigen

procedure Move (Source : in String;
                Target : out String;
                Drop    : in Truncation := Error;
                Justify : in Alignment := Left;
                Pad     : in Character := Space);

Die Prozedur Move dient zum Kopieren von Zeichenketten, wobei die Zeichenketten auch unterschiedliche Längen haben können. Wenn die Zeichenketten die gleiche Länge haben, werden die Zeichen einfach nur von "Source" nach "Target" kopiert. Wenn "Source" kürzer als "Target" ist, werden die Zeichen entsprechend dem in "Justify" angegebenen Wert ausgerichtet und der Rest mit dem in "Pad" angegebenen Zeichen aufgefüllt. Wenn "Source" länger als "Target" ist, wird entsprechende dem in "Drop" angegebenen Wert, links oder rechts abgeschnitten oder die Ausnahme Length_Error ausgelöst.

function "*" (Left : in Natural; Right : in Character) return String;
function "*" (Left : in Natural; Right : in String) return String;

Die Funktion "*" liefert eine Zeichenkette, die "Left" mal das Zeichen oder die Zeichenkette aus "Right" enthält. Wenn "Left" 0 ist, wird eine leere Zeichenkette zurückgegeben.

2) Unterprogramme zum Suchen

function Index (Source : in String; Pattern : in String;
                Going   : in Direction := Forward;
                Mapping : in Maps.Character_Mapping := Maps.Identity) return Natural;

function Index (Source : in String; Pattern : in String;
                Going : in Direction := Forward;
                Mapping : in Maps.Character_Mapping_Function) return Natural;

Die Funktion Index sucht in der Zeichenkette "Source" nach der Zeichenkette "Pattern" und liefert die Position des ersten Zeichens von "Pattern" in "Source" zurück. Abhängig von "Going" wird von vorne (forward) oder von hinten (backward) angefangen zu suchen, somit kann das erste oder letzte Auftreten von "Pattern" ermittelt werden. Vor dem Vergleich werden beide Zeichenketten entsprechend der in "Mapping" angegebenen Zeichen-auf- Zeichen-Abbildung umgewandelt. Wenn "Pattern" nicht gefunden wird, liefert die Funktion 0 zurück. Wenn "Pattern" eine leere Zeichenkette ist ,wird die Ausnahme Pattern_Error ausgelöst.

function Index (Source : in String;
                Set    : in Maps.Character_Set;
                Test   : in Membership := Inside;
                Going : in Direction := Forward) return Natural;

Die Funktion Index sucht in der Zeichenkette "Source" abhängig von "Test" nach dem ersten Auftreten eines Zeichens aus dem Zeichensatz "Set" oder nach dem ersten Auftreten eines Zeichens, das nicht im Zeichensatz "Set" enthalten ist und liefert dessen Position zurück. Auch hier kann mit der Suche von vorne oder von hinten begonnen werden (Parameter "Going"). Wenn kein Zeichen gefunden wird, wird 0 zurückgegeben.

function Index_Non_Blank (Source : in String;
Going : in Direction := Forward) return Natural;
return Natural;

Die Funktion Index_Non_Blank liefert die Position des ersten Zeichens in der Zeichenkette "Source", das kein Leerzeichen ist. Es kann nach dem ersten oder nach dem letzten Zeichen gesucht werden (Parameter "Going"). Wenn die Zeichenkette nur Leerzeichen enthält oder eine leere Zeichenkette ist, wird 0 zurückgeliefert.

function Count (Source : in String;
                Pattern : in String;
                Mapping : in Maps.Character_Mapping := Maps.Identity) return Natural;

function Count (Source : in String;
                Pattern : in String;
                Mapping : in Maps.Character_Mapping_Function) return Natural;

Liefert die Anzahl nichtüberlappender Vorkommen von "Pattern" in der Zeichenkette "Source". Beide Zeichenketten werden vorher mit "Mapping" abgebildet. Wenn "Pattern" die Länge 0 hat wird die Ausnahme Pattern_Error ausgelöst.

function Count (Source : in String; Set : in Maps.Character_Set) return Natural;

Liefert die Anzahl der Zeichen aus "Source", die im Zeichensatz "Set" enthalten sind.

procedure Find_Token (Source : in String;
                      Set    : in Maps.Character_Set;
                      Test   : in Membership;
                      First : out Positive;
                      Last   : out Natural);

Liefert in "First" und "Last" die erste und letzte Position des ersten Bereichs in "Source", der nur Zeichen aus dem Zeichensatz "Set" enthält (wenn "Test" Inside ist) und dessen Nachbarzeichen nicht im Zeichensatz enthalten sind. Wenn "Test" Outside ist, genau andersherum. Wenn kein solcher Bereich existiert wird für "First" Source'First zurückgegeben, für "Last" 0.

3) Unterprogramme zum Übersetzen

function Translate (Source : in String;
Mapping : in Maps.Character_Mapping) return String;

function Translate (Source : in String;
Mapping : in Maps.Character_Mapping_Function) return String;

Gibt eine Zeichenkette zurück, in der alle Zeichen aus der Zeichenkette "Source" entsprechend der Abbildungsmaske bzw. der Abbildungsfunktion in "Mapping" übersetzt wurden.

procedure Translate (Source : in out String;
Mapping : in Maps.Character_Mapping);

procedure Translate (Source : in out String;
Mapping : in Maps.Character_Mapping_Function);

Übersetzt in der Zeichenkette "Source" jedes Zeichen entsprechend der in "Mapping" angegebenen Abbildungsmaske bzw. Abbildungsfunktion.

4) Unterprogramme zum Umformen

function Replace_Slice (Source : in String;
                        Low    : in Positive;
                        High   : in Natural;
                      By     : in String) return String;

Die Funktion Replace_Slice ersetzt in der Zeichenkette "Source" den Bereich von "Low" bis "High" durch die Zeichenkette "By" und liefert diese zurück. Wenn "Low" größer als Source'Last+1 oder "High" kleiner als Source'First-1 ist, wird die Ausnahme Index_Error ausgelöst. Wenn "High" kleiner als "Low" ist, wird die Zeichenkette "By" vor der Position "Low" in die Zeichenkette "Source" eingefügt.

procedure Replace_Slice (Source : in out String;
                         Low    : in Positive;
                         High    : in Natural;
                       By      : in String;
                         Drop    : in Truncation := Error;
                         Justify : in Alignment := Left;
                         Pad     : in Character := Space);

Ersetzt in der Zeichenkette "Source" den Bereich von "Low" bis "High" durch die Zeichenkette "By". Wird die Zeichenkette zu lang, wird sie entsprechend "Drop" abgeschnitten oder die Ausnahme Length_Error ausgelöst. Wird die Zeichenkette zu kurz, wird sie entsprechend "Justify" ausgerichtet und der freie Bereich mit dem Zeichen in "Pad" aufgefüllt.

function Insert (Source   : in String;
                 Before   : in Positive;
                 New_Item : in String) return String;

Liefert die Zeichenkette "Source", bei der vor der Position "Before" die Zeichenkette "New_Item" eingefügt wurde. Ist "Before" kleiner als Source'First oder größer als Source'Last+1 wird die Ausnahme Index_Error ausgelöst.

procedure Insert (Source   : in out String;
                  Before   : in Positive;
                  New_Item : in String; Drop : in Truncation := Error);

Fügt die Zeichenkette "New_Item" an der Position "Before" der Zeichenkette "Source" ein. Die Zeichenkette "Source" wird dann entsprechend dem Parameter "Drop" links oder rechts abgeschnitten oder es wird die Ausnahme Length_Error ausgelöst.

function Overwrite (Source : in String;
Position : in Positive;
New_Item : in String) return String;

Liefert die Zeichenkette "Source", wobei die Zeichen ab "Position" mit "New_Item"
überschrieben werden. Wenn "New_Item" länger ist als der ab "Position" noch vorhandene Platz in "Source", so wird der Rest von "New_Item" an die Zeichenkette angehängt. Wenn "Position" kleiner als Source'First oder größer als Source'Last+1 ist, wird die Ausnahme Index_Error ausgelöst.

procedure Overwrite (Source   : in out String;
                     Position : in Positive;
                     New_Item : in String;
                     Drop     : in Truncation := Right);

Überschreibt in "Source" die Zeichen ab "Position" mit den Zeichen aus "New_Item". Wird die Zeichenkette dadurch zu lang, wird sie entsprechen "Drop" links oder rechts abgeschnitten oder die Ausnahme Length_Error ausgelöst.

function Delete (Source : in String;
From : in Positive;
Through : in Natural) return String;

Gibt die Zeichenkette "Source" zurück, bei der die Zeichen von Position "From" bis "Through" gelöscht wurden. Ist "From" größer als "Through" wird "Source" zurückgegeben.

procedure Delete (Source : in out String;
                  From    : in Positive;
                  Through : in Natural;
                  Justify : in Alignment := Left;
                  Pad     : in Character := Space);

Löscht in "Source" die Zeichen von Position "From" bis "Through". Der Ergebnisstring wird entsprechend "Justify" in "Source" ausgerichtet und der Rest mit dem Zeichen aus "Pad" aufgefüllt.

5) Unterprogramme zur Auswahl

function Trim (Source : in String; Side : in Trim_End) return String;

Liefert, abhängig von "Side", die Zeichenkette "Source" ohne die führenden, die folgenden oder die führenden und die folgenden Leerzeichen.

procedure Trim (Source : in out String;
                Side    : in Trim_End;
                Justify : in Alignment := Left;
                Pad     : in Character := Space);

Entfernt, abhängig von "Side", aus der Zeichenkette "Source" die führenden, die folgenden oder die führenden und die folgenden Leerzeichen und richtet diese Zeichenkette entsprechend "Justify" in "Source" aus. Der Rest der Zeichenkette wird mit dem Zeichen aus "Pad" aufgefüllt.

function Trim (Source : in String;
Left : in Maps.Character_Set;
Right : in Maps.Character_Set) return String;

Liefert die Zeichenkette "Source", bei der von der linken Seite alle Zeichen aus "Left" und von der rechten Seite alle Zeichen aus "Right" abgeschnitten werden.

procedure Trim (Source : in out String;
                Left    : in Maps.Character_Set;
                Right   : in Maps.Character_Set;
                Justify : in Alignment := Strings.Left;
                Pad : in Character := Space);

Schneidet von der Zeichenfolge "Source" auf der linken Seite alle Zeichen aus "Left" und auf der rechten Seite alle Zeichen aus "Right" ab. Die Zeichenkette wird entsprechen "Justify" in "Source" zentriert und der Rest mit dem Zeichen aus "Pad" gefüllt.

function Head (Source : in String;
Count : in Natural;
Pad : in Character := Space) return String;

Liefert eine Zeichenkette der Länge "Count". Ist "Count" kleiner als die Länge von "Source",
enthält die Ergebniszeichenkette die ersten "Count" Zeichen aus "Source", ansonsten wird die Ergebniszeichenkette bis zur Länge "Count" mit dem Zeichen aus "Pad" aufgefüllt.

procedure Head (Source : in out String;
                Count   : in Natural;
                Justify : in Alignment := Left;
                Pad     : in Character := Space);

Liefert die ersten "Count" Zeichen aus "Source" und richtet diese Zeichenkette entsprechend "Justify" in "Source" aus. Der Rest wird mit dem Zeichen aus "Pad" gefüllt.

function Tail (Source : in String;
Count : in Natural;
Pad : in Character := Space) return String;

Liefert eine Zeichenkette der Länge "Count". Ist "Count" kleiner als die Länge von "Source", enthält die Ergebniszeichenkette die letzten "Count" Zeichen aus "Source", ansonsten wird die Ergebniszeichenkette solange links mit dem Zeichen aus "Pad" aufgefüllt bis die Länge
"Count" erreicht ist.

procedure Tail (Source : in out String;
                Count   : in Natural;
                Justify : in Alignment := Left;
                Pad     : in Character := Space);

Liefert die letzten "Count" Zeichen aus "Source" und richtet diese Zeichenkette entsprechend "Justify" in "Source" aus. Der Rest wird mit dem Zeichen aus "Pad" gefüllt.

Spezifikation des Paketes "Ada.Strings.Fixed"

zurück

vor

Index

nach oben