deferred redeclare String frozen;
String when frozen.
boolean dump_simple_p;
YES.
OutputStream dump_simple OutputStream s;
deferred redeclare boolean equal String other;
String with the other String.
deferred boolean equalByteString ByteString other;
String with the other ByteString.
deferred boolean equalCharString CharString other;
String with the other CharString.
deferred boolean equalUniqueString UniqueString other;
String with the other UniqueString.
boolean equalModuloCase String other;
String with the other String, ignoring
case differences.
int compare id other;
String with the other.
(int, int)
rangeOfString String string
range: (int, int) (start, len) = (0, -1);
string in the receiving
string. Return a negative length in case it could not be found. The
optional start and length can be specified to restrict the
searching within the receiving string.
MutableArray
componentsSeparatedBy char c
limit: int limit = -1
excludeEmpty: boolean excl = NO
substringSelector: selector sel = selector (String substring (int, int));
Array of strings, taken from the receiving
string by splitting it at characters with the indicated char value.
Thus, splitting `/usr/tmp' at each `/' returns an array holding the
empty string, `usr', and `tmp'.
The optional argument limit specifies the maximum number of items in
which the caller is interested, or -1 for all items. For example, if
`/usr/foo/bar' is split on `/' in 3 items, the array returned contains
`', `usr', and `foo/bar'.
The optional argument excl, if YES specifies that zero-length
substrings are not to be included in the result. Thus, splitting
`/aap/noot/mies/wim' in 3 items, ignoring empty items, returns an
array containing `aap', `noot', and `mies/wim'.
The optional selector sel specifies the method to be called to
extract the substrings from the receiving string. The default
selector is "r_substring_(ii)". To retrieve mutable substrings, the
selector "r_mutableSubstring_(ii)" could be used.
deferred MutableString mutableSubstring (int, int) (start, len) pre start >= 0 && len >= -1;
MutableString holding the characters from the receiving
String in the (clipped) range (start, len).
deferred String substring (int, int) (start, len) pre start >= 0 && len >= -1;
String holding the characters from the receiving
String in the (clipped) range (start, len).
deferred UniqueString uniqueString;
[UniqueString with my_string]
instead. (This method only creates strings which think they are
unique; the UniqueString class ensures they actually are.)
id downcase;
id upcase;
double (value) doubleValue;
(int, boolean, int) (value, full_range, actual_length)
integerValue (int, int) (start, len)
defaultBase: int base = 10
allowSign: boolean signs = YES
allowCBases: boolean c_bases = YES
baseSeparator: byte base_separator = '_'
decimalBase: boolean decimal_base = YES;
start, running for len bytes (which -1 for unlimited length).
The value returned is a tuple (extracted value, occupied full range, actual length). If the actual length is 0, the extracted number will be 0.
The base defaults to 10, but can be any number. If it is larger
than 10, alpha characters encountered have the value of 11 + the
offset from the alpha character to the start of its range. Thus, `a'
is 10, `z' is 35.
Iff signs, a leading `+' or `-' sign is accepted.
Iff c_bases, C-style base indicators may be used: a number starting
with a `0' denotes an octal number; a number starting with `0x' or
`0X' is a hexadecimal number.
Iff the base_separator is not 0, a number can be prefixed with a
base indication followed by the base separator to specify the base of
the actual number to follow. The base is read using the a decimal
base, unless decimal_base is FALSE, in which case the base is
read in the default base. Thus, `10_10', with `_' as a base
separator, returns base if decimal_base is FALSE, and 10 if it
was TRUE.
int intValue;
integerValue (with default arguments).
int unsignedIntValue;
integerValue, similar to intValue, but not
allowing a negative value. For a negative value entered (due to
integerValue not doing overflow checking), 0 is returned.
boolean isAlpha char c;
c denotes a letter.
boolean isDigit char c;
TRUE iff the character c is a digit.
boolean isLower char c;
TRUE iff the character c is in lower-case.
boolean isPunct char c;
TRUE iff the character c is a punctuation character.
boolean isSpace char c;
TRUE iff the character c is a space character.
boolean isUpper char c;
TRUE iff the character c is in upper-case.
char toLower char c;
char toTitle char c;
char toUpper char c;
int digitValue char c;
int alphaValue char c;
id stringByDecoding String encoding_name;
encoding_name. The default implementation simply
returns self.