|
La classe BString n'est pas "thread safe". Vous ne pouvez accéder au même objet BString depuis deux threads différents au même moment.
|
|
Actuellement,la classe BString supporte seulement l'assignation et la récupération de chaînes qui contiennent des caractères sur un octet unique. Si vous voulez utiliser un objet BString pour stocker une chaîne qui contient des caractères encodés sur plusieurs octets (UTF8) , vous devez plaquer la chaîne vous—même et ajuster l'argument du nombre de caratères en conséquence.
|
|
Constructeur et Destructeur
BString()
|
|
|
BString(void)
|
BString(const char *string)
|
BString(const char *string, int32 maxLength)
|
BString(const BString &string)
| |
Crée, un nouvel objet BString et alloue assez d'espace mémoire pour contenir string (ou string->String(), ou jusqu'à maxLength octets), ensuite copie la chaîne dans l'espace alloué. Sans argument, le nouvel objet BString est vide. Vous pouvez aussi mettre des données dans un BString en utilisant SetTo(), Adopt(), ou l'opérateur =.
~BString()
Libère la mèmoire allouée pour un objet BString, puis détruit celui—ci.
Fonctions Membres
Append()
,
Prepend()
,
Insert()
|
|
|
inline BString &Append(const BString &source)
|
BString &Append(const BString &source, int32 charCount)
|
inline BString &Append(const char *source)
|
BString &Append(const char *source, int32 charCount)
|
BString &Append(char c, int32 charCount)
|
BString &Prepend(const BString &source)
|
BString &Prepend(const BString &source, int32 charCount)
|
BString &Prepend(const char *source)
|
BString &Prepend(const char *source, int32 charCount)
|
BString &Prepend(char c, int32 charCount)
|
BString &Insert(const BString &source, int32 insertAt)
|
BString &Insert(const BString &source, int32 charCount, int32 insertAt)
|
BString &Insert(const BString &source, int32 sourceOffset, int32 charCount, int32 insertAt)
|
BString &Insert(const char *source, int32 insertAt)
|
BString &Insert(const char *source, int32 charCount, int32 insertAt)
|
BString &Insert(const char *source, int32 sourceOffset, int32 charCount, int32 insertAt)
|
BString &Insert(char c, int32 charCount, int32 insertAt)
| |
Ces fonctions ajoutent des caractères à la fin (append), au début (prepend), ou au milieu (insert) de la chaîne d'un objet BString. Dans chaque cas, le BString réalloue automatiquement la mémoire pour contenir les nouvelles données. Toutes ces fonctions retournent *this.
Append() copie charCount caractères depuis source et les ajoute à la fin du BString. Si l'argument charCount n'est pas spécifié, la chaîne entière est copiée; ceci est identique pour l'opérateur +=. La version à un caratère de Append() ajoute count copie du caractère c à la fin de l'objet.
Prepend() est identique à Append(), sauf qu'elle ajoute les caractères au début du BString, délant les données existantes "vers la droite" pour faire de la place.
Insert() ajoute les caractères désignés à la position insertAt (indexée sur zéro) dans le BString. Les données existantes du BString (à la position insertAt et plus) sont décalées vers la droite pour libérer de la place pour les nouvelles données. L'argument sourceOffset est un décalage (indexé de zéro) dans la chaîne source.
CharacterEscape()
,
CharacterDeescape()
|
|
|
BString &CharacterEscape(const char *original, const char *setOfCharsToEscape,
char escapeWithChar)
|
BString &CharacterEscape(const char *setOfCharsToEscape,
char escapeWithChar)
|
BString &CharacterDeescape(const char *original,
char escapeWithChar)
|
BString &CharacterDeescape(char escapeWithChar)
| |
CharacterEscape() scanne une chaîne pour trouver les occurences individuelles des caractères de la chaîne setOfCharsToEscape et insère dans la chaîne l'octet indiqué par escapeWithChar devant chacune des occurrences. La première forme copie la chaîne original dans le BString; la seconde forme opère sur un BString existant.
CharacterDeescape() annule cette opération en scannant la chaîne et en enlevant toutes les occurences de l'octet escapeWithChar. La première forme copie la chaîne original dans le BString; la seconde forme opère sur un BString existant.
Compare()
,
ICompare()
|
|
|
int Compare(const BString &string) const
|
int Compare(const BString &string, int32 range) const
|
int Compare(const char *string) const
|
int Compare(const char *string, int32 range) const
|
int Compare(const BString &astring, const BString &bstring) global
|
int Compare(const BString *astring, const BString *bstring) global
|
int ICompare(const BString &string) const
|
int ICompare(const BString &string, int32 range) const
|
int ICompare(const char *string) const
|
int ICompare(const char *string, int32 range) const
|
int ICompare(const BString &astring, const BString &bstring) global
|
int ICompare(const BString *astring, const BString *bstring) global
| |
Ces fonctions comparent le BString avec la chaîne passée en argument (Compare() est sensible à la casse, ICompare() est insensible à la casse); Elles retournent 0 si les deux chaînes sont dientiques, 1 si le BString est "plus grand que" l'argument, et -1 si l'argument est "plus grand que" ce BString. Les deux chaînes sont comparées par rapport à la valeur ASCII ou UTF-8 de leurs caractères respectifs. Une chaîne longue est plus grande qu'une chaîne courte (et inversement) —"abcdef" est plus grand que "abcde".
En donnant un argument range, la fonction compare uniquement les range premiers caractères.
Les fonctions globales retournent 0 si les arguments sont égaux, 1 si astring est plus grande que bstring, et -1 si bstring est plus grande que astring.
Vous pouvez aussi comparer deux chaînes à l'aide des opérateurs ==, !=, <, <=, >, et =>.
CopyInto()
,
MoveInto()
|
|
|
BString &CopyInto(BString &destination, int32 sourceOffset,
int32 charCount) const
|
void CopyInto(char *destination, int32 sourceOffset, int32 charCount) const
|
BString &MoveInto(BString &destination, int32 sourceOffset, int32 charCount)
|
void MoveInto(char *destination, int32 sourceOffset, int32 charCount)
| |
CopyInto() copie une sous—chaîne de l'objet BString dans destination. MoveInto() est identique, mais supprime la sous—chaîne originale (dans le BString). Si destination est un objet BString, l'espace mémoire pour la sous—chaîne est automatiquement alloué; si la destination est une char *, l'appellant est responsable de l'allocationn d'un espace mémoire suffisant.
La sous—chaîne comprend charCount caractères débutant au sourceOffset—ième caratère (indexé de zéro). Après que la sous—chaîne soit effacée, les caractères restant sont décalés vers la gauche pour combler le vide (MoveInto() seulement). Par exemple:
BString source, destination;
source.SetTo("abcdefg");
source.MoveInto(&destination, 2, 3);
/* source.String() == "abfg" */
/* destination.String() == "cde" */
Les fonctions retournent destination (ou void).
CountChars()
,
Length()
|
|
|
int32 CountChars(void) const
|
inline int32 Length(void) const
| |
CountChars() retourne la longueur de la chaîne d'un objet BString mesurée en caractères; Length() retourne la longueur mesurée en octets.
FindFirst()
,
IFindFirst()
,
FindLast()
,
IFindLast()
|
|
|
int32 FindFirst(const BString &string) const
|
int32 FindFirst(const BString &string, int32 offset) const
|
int32 FindFirst(const char *string) const
|
int32 FindFirst(const char *string, int32 offset) const
|
int32 FindFirst(char c) const
|
int32 FindFirst(char c, int32 offset) const
|
int32 FindLast(const BString &string) const
|
int32 FindLast(const BString &string, int32 offset) const
|
int32 FindLast(const char *string) const
|
int32 FindLast(const char *string, int32 offset) const
|
int32 FindLast(char c) const
|
int32 FindLast(char c, int32 offset) const
|
int32 IFindFirst(const BString &string) const
|
int32 IFindFirst(const BString &string, int32 offset) const
|
int32 IFindFirst(const char *string) const
|
int32 IFindFirst(const char *string, int32 offset) const
|
int32 IFindLast(const BString &string) const
|
int32 IFindLast(const BString &string, int32 offset) const
|
int32 IFindLast(const char *string) const
|
int32 IFindLast(const char *string, int32 offset) const
| |
Ces fonctions retournent l'index de la première ou de la dernière occurence ( dans l'objet BString) d'une sous—chaîne ou d'un caractère. FindFirst() et FindLast() sont sensibles à la casse; IFindFirst() et IFindLast() sont insensibles à la casse. Les fonctions retournent B_ERROR si le caractère ou la sous—chaîne n'ont pas été trouvés.
Les versions avec l'argument offset regardent uniquement dans la portion du BString qui commence au caractère offset (pour [I]FindFirst()), ou se termine au caractère offset (pour [I]FindLast()). Par exemple, dans cet exemple...
BString astring("AbcAbcAbc");
astring.FindLast("Abc", 7);
... l'appel à FindLast() retourne 3, l'index de la dernière instance complète de "Abc" apparaissant avant le caractère 7.
LockBuffer()
,
UnlockBuffer()
|
|
|
char *LockBuffer(int32 maxLength)
|
BString &UnlockBuffer(int32 length = -1)
| |
LockBuffer() retourne un pointeur sur la chaîne de l'objet; vous pouvez manipuler ce pointeur directement. L'argument maxLength permet de demander à l'objet d'allouer del'espace mémoire à la fin de la chaîne avant de retourner le pointeur. Si maxLength est inférieur à la longueur de la chaîne courante, l'argument est ignoré (donner 0 si vous voulez vérrouiller le buffer sans allouer de mémoire supplémentaire).
UnlockBuffer() prévient l'objet que vous avez fini de manipuler le pointeur de la chaîne. length est la nouvelle longueur de la chaîne; si vous donnez -1, l'objet BString récupère la longueur en appellant la fonction strlen() sur la chaîne. La fonction retourne *this.
A chaque LockBuffer() doit être correspondre un UnlockBuffer(). Entre ces deux appels, vous ne pouvez appelere aucunes fonctions d'un objet BString. Beaucoup de fonctions d'un BString déclenreront une erreur si elles sont pendant que le buffer est vérrouillé.
Voir "Accés Direct aux Données" pour un exemple.
Remove()
,
RemoveFirst()
,
RemoveLast()
,
RemoveAll()
,
RemoveSet()
|
|
|
BString &Remove(int32 startingAt, int32 charCount)
|
BString &RemoveFirst(const BString &string)
|
BString &RemoveFirst(const char *string)
|
BString &RemoveLast(const BString &string)
|
BString &RemoveLast(const char *string)
|
BString &RemoveAll(const BString &string)
|
BString &RemoveAll(const char *string)
|
BString &RemoveSet(const char *charSet)
| |
Ces fonctions suppriment des caractères dans l'objet BString et réalloue l'espace mémoire de l'objet pour qu'il contienne les nouvelles données (plus petites). Ces fonctions retournent *this.
Remove() supprime charCount caractères, commençant au caractère startingAt (indexé de zéro).
RemoveFirst(), RemoveLast(), et RemoveAll() suppriment, respectivement, la première, la dernière et chaque occurrence de string dans l'objet.
RemoveSet() supprime toutes les occurrences de chaque caractère dans la chaîne charSet. Par exemple:
BString string("ab abc abcd");
string.RemoveSet("db");
/* 'string' contient maintenant "a ac ac" */
Replace()
,
ReplaceFirst()
,
ReplaceLast()
,
ReplaceSet()
,
IReplace()
,
IReplaceFirst()
,
IReplaceLast()
|
|
|
BString &Replace(const char *old, const char *new, int32 count, int32 offset = 0)
|
BString &Replace(char old, char new, int32 count, int32 offset = 0)
|
BString &ReplaceFirst(const char *old, const char *new)
|
BString &ReplaceFirst(char old, char new)
|
BString &ReplaceLast(const char *old, const char *new)
|
BString &ReplaceLast(char old, char new)
|
BString &ReplaceAll(const char *old, const char *new, int32 offset = 0)
|
BString &ReplaceAll(char old, char new, int32 offset = 0)
|
BString &ReplaceSet(const char *oldSet, const char *new)
|
BString &ReplaceSet(const char *oldSet, char new)
|
BString &IReplace(const char *old, const char *new, int32 count, int32 offset = 0)
|
BString &IReplace(char old, char new, int32 count, int32 offset = 0)
|
BString &IReplaceFirst(const char *old, const char *new)
|
BString &IReplaceFirst(char old, char new)
|
BString &IReplaceLast(const char *old, const char *new)
|
BString &IReplaceLast(char old, char new)
|
BString &IReplaceAll(const char *old, const char *new, int32 offset = 0)
|
BString &IReplaceAll(char old, char new, int32 offset = 0)
| |
Ces fonctions cherchent les occurrences de old dans l'objet BString, et les remplacent par new. Dans les fonctions Replace...(), la recherche de old est sensible à la casse; dans les fonctions IReplace...(), la recherche est insensible à la casse. Ces fonctions retournent *this.
[I]Replace() remplacent les count premières occurrences qui débutent au ou après le caractère offset.
[I]ReplaceFirst() et [I]ReplaceLast() remplacent uniquement la première et la dernière occurence (respectivement).
[I]ReplaceAll() remplace toutes les occurrences qui commencent au ou après le caractère à l'index offset.
[I]ReplaceSet() est légèrement différente des autres: elle remplace chaque occurrence de tous les caractères dans oldSet avec les caractères ou la chaîne donnée dans new. Par exemple:
BString astring("a-b-c");
astring.ReplaceSet("abc", "ABC");
/* astring est maintenant "ABC-ABC-ABC" */
SetTo()
,
Adopt()
|
|
|
inline BString &SetTo(const char *source)
|
BString &SetTo(const char *source, int32 charCount)
|
BString &SetTo(const BString &source)
|
BString &SetTo(const BString &source, int32 charCount)
|
BString &SetTo(char c, int32 charCount)
|
BString &Adopt(BString &source)
|
BString &Adopt(BString &source, int32 charCount)
| |
Ces fonctions initialisent les données d'un chaîne d'un objet BString. L'espace mémoire pour les données est automatiquement alloué par les fonctions. Les données courantes de l'objet sont intégralement remplacées par les nouvelles. Les fonctions retournent *this.
SetTo() copie charCount caractères depuis source dans l'objet. Si charCount n'est pas renseigné, la chaîne entière est copiée; cette forme est équivalente à l'opérateur =. La version pour un caractère deSetTo() positionne les données de l'objet à une chaîne de longueur charCount composée entièrement du caractère c.
Adopt() déplace charCount caractères depuis source dans l'objet, et réinitialise le pointeur de données de source. Notez que source sera vide quand vous l'appelerez après Adopt(), même si charCount est inférieur à la longueur complète de source.
String()
,
ByteAt()
|
|
|
inline const char *String() const
|
inline char ByteAt(int32 index) const
| |
String() retourne un pointeur sur la chaîne de l'objet, terminée par NULL( caractère '\0') . Vous ne pouvez modifier ou libérer le pointeur. Si l'objet BString est effacé, le pointeur devient invalide.
ByteAt() retourne le index—ième caractère dans la chaîne. Si index est hors limite, la fonction retourne 0. Mise à part la vérification des bornes, cette fonction est identique à l'opérateur [].
ToLower()
,
ToUpper()
,
Capitalize()
,
CapitalizeEachWord()
|
|
|
BString &ToLower(void)
|
BString &ToUpper(void)
|
BString &Capitalize(void)
|
BString &CapitalizeEachWord(void)
| |
ToLower() convertie chaque caractère dans la chaîne en minuscule; ToUpper() les convertie en masjucule. Les caractères Non-alphabétiques ne sont pas affectés.
Capitalize() convertie le premiercaractère alphabétique dans le mot en masjuscule, et le reste en minuscule. CapitalizeEachWord() convertie le premiercaractère alphabétique de chaque "mot" en masjuscule, et le reste en minuscule. Un mot est un groupe de caractères alphabétiques délimités par des caractères non-alphabétiques.
Ces fonctions retournent *this.
Truncate()
|
|
|
BString &Truncate(int32 charCount, bool lazy = true)
| |
Truncate() raccourcie la chaîne de l'objet pour qu'elle ne contienne que charCount caractères. Cette fonction n'allonge pas la chaîne: Si charCount est égal ou supérieur au nombre de caractères de la chaîne, la fonction ne fait rien.
Si lazy est à false, la chaîne est immédiatement réallouée pour s'ajuster à la nouvelle taille (et l'excédent est immédiatement libéré). Si lazy est à true, la chaîne est positionné à la nouvelle taille, mais l'excédent ne sera libéré qu'au prochain appel d'une fonction manipulant l'espace mémoire. C'est légérement plus efficace d'avoir lazy à true; sinon, les deux formes de la fonction sont identiques.
Cette fonction retourne *this.
Operators
=
(assignation)
|
|
|
BString& operator=(const BString &string)
|
BString& operator=(const char *string)
|
BString& operator=(const char character)
| |
Positionne le contenu de l'objet BString à string ou character, et retourne *this .
+=
(concaténation)
|
|
|
inline BString& operator+=(const BString &string)
|
BString& operator+=(const char *string)
|
BString& operator+=(const char character)
| |
Concatène string ou character à l'objet BString, et retourne *this.
<<
(concaténation formaté)
|
|
|
BString &operator<<(const char *string)
|
BString &operator<<(const BString &string)
|
BString &operator<<(char c)
|
BString &operator<<(uint32 val)
|
BString &operator<<(int32 val)
|
BString &operator<<(uint64 val)
|
BString &operator<<(int64 val)
|
BString &operator<<(float val)
| |
Convertie l'opérande de droite en une chaîne (si nécessaire), et la concatène à l'opérande de gauche. Les nombre à virgule sont toujours écrits avec deux décimales:
BString astring("The result is: "), bstring(" bps");
float result = 12.5;
astring << result << bstring;
Ici, astring devient "The result is: 12.50 bps".
Les concaténations multiples sont évaluées de la gauche vers la droite, ainsi seul l'opérande la plus à gauche est modifiée. Par exemple:
BString astring("a"), bstring("b"), cstring("c");
astring << bstring << cstring;
Ici, bstring est concaténé à astring, et ensuite cstring est concaténé au résultat; ainsi, astring vaut "abc", et bstring vaut toujours "b".
[]
(indexation)
|
|
|
char operator[](int32 index) const
|
inline char &operator[](int32 index)
| |
Retourne le caractère à la position index dans la chaîne. Aucune vérification de bornes n'est faite—— c'est à l'appelant de s'assurer que index soit dans les bornes.
==
,
!=
,
<
,
>
,
<=
,
>=
(comparaison)
|
|
|
inline bool operator==(const BString &string) const
|
bool operator==(const char *string) const
|
inline bool operator==(const char *string, const BString &string) const global
|
inline bool operator!=(const BString &string) const
|
inline bool operator!=(const char *string) const
|
inline bool operator!=(const char *string, const BString &string) const global
|
inline bool operator<(const BString &string) const
|
bool operator<(const char *string) const
|
inline bool operator<(const char *string, const BString &string) const global
|
inline bool operator<=(const BString &string) const
|
bool operator<=(const char *string) const
|
inline bool operator<=(const char *string, const BString &string) const global
|
inline bool operator>(const BString &string) const
|
bool operator>(const char *string) const
|
inline bool operator>(const char *string, const BString &string) const global
|
inline bool operator>=(const BString &string) const
|
bool operator>=(const char *string) const
|
inline bool operator>=(const char *string, const BString &string) const global
| |
Comparaison sensible à la casse de deux chaînes. Les deux chaînes sont comparées en comparant les valeurs ASCII ou UTF-8 de leurs caractères respectifs. Une chaîne longue est plus grande qu'une courte (et inversement)—"abcdef" est plus grande que "abcde".
Les versions globales de ces opérateurs sont fournis pour que vous ne vous souciez pas de l'ordre des opérandes; par exemple:
if (astring == "Okay")
/* ...est équivalent à... */
if ("Okay" == astring) |