Smalltalk/X Webserver

Documentation of class 'CharacterArray':

Class: CharacterArray

Inheritance
Description
Class protocol
Instance protocol

Inheritance:

   Object
   |
   +--Collection
      |
      +--SequenceableCollection
         |
         +--ArrayedCollection
            |
            +--UninterpretedBytes
               |
               +--CharacterArray
                  |
                  +--FourByteString
                  |
                  +--String
                  |
                  +--Text
                  |
                  +--TwoByteString

Package:: stx:libbasic

Category:: Collections-Text

Version:: rev: 1.1005 date: 2024/04/23 08:34:05; user: stefan; file: CharacterArray.st directory: libbasic; module: stx stc-classLibrary: libbasic

Description:

CharacterArray is a superclass for all kinds of Strings (i.e.
(singleByte-)Strings, TwoByteStrings, UnicodeStrings
and whatever may come in the future.

This class is abstract, meaning that there are no instances of it;
concrete subclasses define how the characters are stored (i.e. either as
single byte, two-byte or four byte strings).

All this class does is provide common protocol for concrete subclasses.

Notice:
    internally, ST/X uses a unicode encoding for ALL characters - both
    for individual character entities and for strings of characters.
    When reading/writing files in different encodings, the conversion is
    done at read/write time by use of a CharacterEncoder instance.
    These know how to convert to a wide range of encodings.

Also notice:
    UTF8 and UTF16 are external encodings of a Unicode string; they are never
    used internally. When interacting with a UTF8 interface (OS-API or files),
    you should convert UTF8 into the internal full Unicode right at the interface.
    Do not keep UTF8 around internally as String instances.
    The reason is that UTF8 makes it harder to manipulate strings (for example
    to insert/extract substrings or to get its size. Such operations would
    require a scan of the UTF8, which would complicate them).
    Of course, there may be rare exceptions to this, for example if a file's contents
    is treated as raw data, and the strings have to be copied/shuffled around only,
    without any real processing on it.

[about hashing:]
    the ST/X VM uses the fnv1 hash (*) to quickly retrieve symbols,
    This has only 1 collision in my current systm with 66k symbols.

    To try, evaluate:
        ((Symbol allInstances collect:#hash_fnv1a as:Bag)
            valuesAndCountsSelect:[:h :cnt | cnt > 1]) size
    in contrast, java hash is much worse (18 collisions):
        ((Symbol allInstances collect:#hash_java as:Bag)
            valuesAndCountsSelect:[:h :cnt | cnt > 1]) size
    and hash_sdbm hash is even better (0 collisions),
    but slightly slower:
        ((Symbol allInstances collect:#hash_sdbm as:Bag)
            valuesAndCountsSelect:[:h :cnt | cnt > 1]) size
    we could use CRC32 (also with 0 collisions), 
    but that is slower on machines without CRC instruction:
        ((Symbol allInstances collect:[:s | CRC32Stream hashValueOf:s] as:Bag)
            valuesAndCountsSelect:[:h :cnt | cnt > 1]) size

    (*) slightly modified to return a 31bit positive number, eg. a SmallInt in 32bit systems.

copyrightCOPYRIGHT (c) 1994 by Claus Gittinger
             All Rights Reserved

This software is furnished under a license and may be used
only in accordance with the terms of that license and with the
inclusion of the above copyright notice.   This software may not
be provided or otherwise made available to, or used by, any
other person.  No title to or ownership of the software is
hereby transferred.

Class protocol:

Compatibility-VW

fromIntegerArray: anArray

Answer a new instance of the receiver that is created from the argument, anArray.

Usage example(s):

     String fromIntegerArray: #[8 127]

Signal constants

decodingFailedSignal: return the signal, raised when decoding of a string is not possible
due to invalid characters contained in the source.
This may happen for example, if a non EUC coded 8-bit string
is attempted to be decoded into a JIS string.
encodingFailedSignal: return the (query-) signal, raised when encoding of a string is not possible
due to invalid characters contained in the source.

cleanup

lowSpaceCleanup

cleanup in low-memory situations

Usage example(s):

     CharacterArray lowSpaceCleanup

encoding & decoding

deadKeyLanguage: aLanguage

deadKeyMap

returns a 2-stage map from ch2 -> ch1 -> mappedChar
for deadkey processing (i.e. for making combining chars regular ones).
Caveat:
possibly incomplete: only COMBINING_DIACRITICAL_MARKS are cared for.
Does not care for COMBINING_DIACRITICAL_MARKS_EXTENDED
and COMBINING_DIACRITICAL_MARKS_SUPPLEMENT.
However; those are used for German dialectology, ancient Greek and other similar
exotic uses. Probably noone will ever even notice that they are missing...

Usage example(s):

     self deadKeyMap

deadKeyMapForLanguage: lang

returns a subset of the full dead key map, useful when editing a specific language texts
(it is disrupting, to get dead-keys for every possible character;
using one of these maps limits the processing to those characters, which are actually
used in the language)

Usage example(s):

     self deadKeyMapForLanguage:#de
     self deadKeyMapForLanguage:#fr

deadKeyMapsPerLanguage

decodeFromUTF8: aStringOrByteCollection

given a string or bytes in UTF8 encoding,
return a new string containing the same characters, in Unicode encoding.
Returns either a normal String, a Unicode16String or a Unicode32String instance.
This is only useful, when reading from external sources or communicating with
other systems
(ST/X never uses utf8 internally, but always uses strings of fully decoded unicode characters).
This only handles up-to 30bit characters.

Usage example(s):

     CharacterArray decodeFromUTF8:#[ 16r41 16r42 ]
     CharacterArray decodeFromUTF8:#[ 16rC6 16r8F ]
     CharacterArray decodeFromUTF8:#[ 16rEF 16rBF 16rBF ]

   rfc3629 examples:
     CharacterArray decodeFromUTF8:#[ 16r41 16rE2 16r89 16rA2 16rCE 16r91 16r2E ]
     CharacterArray decodeFromUTF8:#[ 16rED 16r95 16r9C 16rEA 16rB5 16rAD 16rEC 16r96 16rB4 ]
     CharacterArray decodeFromUTF8:#[ 16rE6 16r97 16rA5 16rE6 16r9C 16rAC 16rE8 16rAA 16r9E ]

   invalid:
     CharacterArray decodeFromUTF8:#[ 16rC0 16r80 ]
     CharacterArray decodeFromUTF8:#[ 16rE0 16r80 16r80 ]
     CharacterArray decodeFromUTF8:#[ 16rE0 16r81 16r02 ]

setupNormalizationAndDeadKeyMaps

returns a 2-stage map from ch2 -> ch1 -> mappedChar.
for unicode normalization and deadKey translation
(i.e. for replacing combining char-sequences with regular characters).
ch2 is the combining charCode (eg. 0x0308), ch1 is the previous character (eg. $A),
mappedChar is the result (eg. $Ä).
Caveat:
possibly incomplete: only COMBINING_DIACRITICAL_MARKS are cared for.
Does not care for COMBINING_DIACRITICAL_MARKS_EXTENDED
and COMBINING_DIACRITICAL_MARKS_SUPPLEMENT.
However; those are used for German dialectology, ancient Greek and other similar
exotic uses. Probably noone will ever even notice that they are missing...

Usage example(s):

     self setupNormalizationAndDeadKeyMaps

unicodeDenormalizationMap

returns a 2-stage map from ch2 -> ch1 -> mappedChar
for unicode normalization (i.e. for making combining chars regular ones).
Caveat:
possibly incomplete: only COMBINING_DIACRITICAL_MARKS are cared for.
Does not care for COMBINING_DIACRITICAL_MARKS_EXTENDED
and COMBINING_DIACRITICAL_MARKS_SUPPLEMENT.
However; those are used for German dialectology, ancient Greek and other similar
exotic uses. Probably noone will ever even notice that they are missing...

Usage example(s):

     self unicodeDenormalizationMap

unicodeNormalizationMap

Usage example(s):

     self unicodeNormalizationMap

initialization

initialize: CharacterArray initialize

instance creation

basicNew

return a new empty string

fromBytes: aByteCollection

return an instance of the receiver class,
taking untranslated bytes from the argument, aByteCollection
in most-significant first order.
Only useful, when reading twoByteStrings from external sources.

Usage example(s):

     Unicode16String fromBytes:#[16r02 16r20]
     Unicode16String fromBytes:#[16r02 16r20] MSB:true
     Unicode16String fromBytes:#[16r02 16r20] MSB:false

fromBytes: aByteCollection MSB: msb

return an instance of the receiver class,
taking untranslated bytes from the argument, aByteCollection
in the given byte order.
Only useful, when reading twoByteStrings from external sources.

Usage example(s):

     Unicode16String fromBytes:#[16r02 16r20]

fromString: aString

return a copy of the argument, aString

Usage example(s):

        Unicode16String fromString:'hello'
        String fromString:'hello' asUnicode16String
        Unicode16String fromString:'hello' asUnicode16String

fromStringCollection: aCollectionOfStrings

return a new string formed by concatenating each in aCollectionOfStrings

Usage example(s):

     String fromStringCollection:#('hello' 'world' 'how' 'about' 'this')

fromStringCollection: aCollectionOfStrings separatedBy: aSeparatorString

return a new string formed by concatenating each in aCollectionOfStrings
separating them by aSeparatorString

Usage example(s):

     String fromStringCollection:#('hello' 'world' 'how' 'about' 'this') separatedBy:' '
     String fromStringCollection:#('hello' 'world' 'how' 'about' 'this') separatedBy:'Ƞ'
     Text fromStringCollection:{'hello'. 'world'. 'how' allBold. 'about'. 'this'. 'äöü'} separatedBy:'Ƞ'

fromUTF8Bytes: aByteCollection

Modified (comment): / 07-02-2017 / 17:32:38 / stefan

** This is an obsolete interface - do not use it (it may vanish in future versions) **

new

return a new empty string

readSmalltalkStringFrom: aStreamOrString keepCRs: keepCRs onError: exceptionBlock

read & return the next String from the (character-)stream aStream;
skipping all whitespace first; return the value of exceptionBlock,
if no string can be read. The sequence of characters as read from the
stream must be one as stored via storeOn: or storeString.
If keepCRs is true, CRLF is kept as is.
A variant of this code is also found in the Scanner class (libcomp);
however, libcomp is optional, whereas this is always present,
and string reading is needed for resource file and config file parsing (sigh)

Usage example(s):

     String readSmalltalkStringFrom:('''hello world''' readStream) onError:[self halt]
     String readSmalltalkStringFrom:('''hello '''' world''' readStream) onError:[self halt]
     String readSmalltalkStringFrom:('1 ''hello'' ' readStream) onError:[self halt]
     String readSmalltalkStringFrom:('1 ''hello'' ' readStream) onError:['foobar']
     String readSmalltalkStringFrom:('''hello\nworld''' readStream) onError:[self halt. 'foobar'] 

     String readSmalltalkStringFrom:('''hello\nworld''' readStream) keepCRs:false onError:[self halt. 'foobar']   
     String readSmalltalkStringFrom:('c''hello\nworld''' readStream) keepCRs:false onError:[self halt. 'foobar']

readSmalltalkStringFrom: aStreamOrString onError: exceptionBlock

Usage example(s):

     String readSmalltalkStringFrom:('''hello world''' readStream) onError:[self halt]
     String readSmalltalkStringFrom:('''hello '''' world''' readStream) onError:[self halt]
     String readSmalltalkStringFrom:('1 ''hello'' ' readStream) onError:[self halt]
     String readSmalltalkStringFrom:('1 ''hello'' ' readStream) onError:['foobar']

readSmalltalkStringWithCRsFrom: aStreamOrString onError: exceptionBlock

Usage example(s):

     String readSmalltalkStringWithCRsFrom:('''hello world''' readStream) onError:[self halt]  
     String readSmalltalkStringWithCRsFrom:('''hello '''' world''' readStream) onError:[self halt]
     String readSmalltalkStringWithCRsFrom:('1 ''hello'' ' readStream) onError:[self halt]
     String readSmalltalkStringWithCRsFrom:('1 ''hello'' ' readStream) onError:['foobar']

writeStreamClass

the type of stream used in writeStream.
Here, we return CharacterWriteStream, which automatically changes
the underlying collection to a multiByte string (i.e. UnicodeString).
So you can stream wide characters into it.

pattern matching

matchEscapeCharacter

return the character used to escape a matchCharacter
(i.e. make it a regular character in a matchPattern)

matchScan: matchScanArray from: matchStart to: matchStop with: aString from: start to: stop caseSensitive: caseSensitive

helper for match; return true if the characters from start to stop in
aString are matching the scan in matchScan from matchStart to matchStop.
The matchScan is as created by asMatchScanArray.

This algorithm is not at all the most efficient;
for heavy duty pattern matching, an interface (primitive) to the regex
pattern matching package should be added.

Usage example(s):

     |scanArray s|

     scanArray := self matchScanArrayFrom:'*hello'.
     s := 'foo bar hello world'.
     CharacterArray
         matchScan:scanArray
         from:1
         to:scanArray size
         with:s
         from:1
         to:s size
         caseSensitive:true

Usage example(s):

     |scanArray s|

     scanArray := self matchScanArrayFrom:'*hello*'.
     s := 'foo bar hello world'.
     CharacterArray
         matchScan:scanArray
         from:1
         to:scanArray size
         with:s
         from:1
         to:s size
         caseSensitive:true

matchScan: matchScanArray from: matchStart to: matchStop with: aString from: start to: stop ignoreCase: ignoreCase

matchScanArrayFrom: aString

scan a pattern string and decompose it into a scanArray.
This is processed faster (especially with character ranges), and
can also be reused later. (if the same pattern is to be searched again).
Returns nil for invalid patterns

Usage example(s):

     String matchScanArrayFrom:'*ute*'
     String matchScanArrayFrom:'**ute**'
     String matchScanArrayFrom:'*uter'
     String matchScanArrayFrom:'\*uter'
     String matchScanArrayFrom:'[cC]#mpute[rR]'
     String matchScanArrayFrom:'[abcd]*'
     String matchScanArrayFrom:'[a-k]*'
     String matchScanArrayFrom:'*some*compl*ern*'
     String matchScanArrayFrom:'[a-'
     String matchScanArrayFrom:'[a-zA-Z]'
     String matchScanArrayFrom:'[a-z01234A-Z]'

matchScanArrayFrom: aString escapeCharacter: escape

Usage example(s):

     String matchScanArrayFrom:'*ute*'  
     String matchScanArrayFrom:'**ute**'
     String matchScanArrayFrom:'*uter'
     String matchScanArrayFrom:'\*uter'
     String matchScanArrayFrom:'[cC]#mpute[rR]'
     String matchScanArrayFrom:'[abcd]*'
     String matchScanArrayFrom:'[abcdŴĂĂ]*'
     String matchScanArrayFrom:'[a-k]*'
     String matchScanArrayFrom:'*some*compl*ern*'
     String matchScanArrayFrom:'[a-'
     String matchScanArrayFrom:'[a-zA-Z]'
     String matchScanArrayFrom:'[a-z01234A-Z]'
     String matchScanArrayFrom:'[A-Z$_][A-Za-z0-9$\[\]]*'
     String matchScanArrayFrom:'[A-Z$\[\]]*'
     String matchScanArrayFrom:'[A-Z$_\[][A-Za-z0-9$\-\] ]*'

     String matchScanArrayFrom:'abc#'    
     String matchScanArrayFrom:'*#*'    
     String matchScanArrayFrom:'\[a-' escapeCharacter:$\
     .

queries

isAbstract: Return if this class is an abstract class.
True is returned for CharacterArray here; false for subclasses.
Abstract subclasses must redefine this again.
speciesForCharacterSize: characterSize: answer the class, that is able to hold characters of size characterSize

utilities

through: aCharacter in: inStream

read all characters through aCharacter and return a
dense strings for it (i.e. String/TwoByteString, if possible).
This helper is present because when reading from a unicode32 stream,
dense strings are preferred.
If inStream is known to return single byte characters,
you should better use inStream through:aCharacter

throughAny: aCollection in: inStream

read all characters through any in aCollection and return a
dense strings for it (i.e. String/TwoByteString, if possible).
This helper is present because when reading from a unicode32 stream,
dense strings are preferred.
If inStream is known to return single byte characters,
you should better use inStream throughAny:aCollection

withoutAmpersandEscapes: label

remove single ampersands;
replace double ampersands by single ones.
This is used to unescape menu-labels
(which use the ampersand as shortKey marker)

Usage example(s):

     String withoutAmpersandEscapes:''
     String withoutAmpersandEscapes:'a'
     String withoutAmpersandEscapes:'abcd'
     String withoutAmpersandEscapes:'&abcd'
     String withoutAmpersandEscapes:'&abcd&'
     String withoutAmpersandEscapes:'&a&b&c&d'
     String withoutAmpersandEscapes:'&a&b&c&d&'
     String withoutAmpersandEscapes:'&&a&&b&&c&&d&&'
     String withoutAmpersandEscapes:'&&a&&b&&c&&d&'
     String withoutAmpersandEscapes:'&a&&b&&c&&d&'
     String withoutAmpersandEscapes:'a&&b&&c&&d'

Instance protocol:

Compatibility-ANSI

addLineDelimiters: Ansi compatibility - same as withCRs

Compatibility-Dolphin

copyExpanding: expandTable
( an extension from the stx:libcompat package )

return a copy of myself, with translations from the expandTable sliced in.
The argument is supposed to map from characters to either characters or strings.
Added for Dolphin compatibility

Usage example(s):

     'hello' copyExpanding:(Dictionary withKeys:{$h . $e . $o} andValues:{'HH' . 'EE' . $O })

formatWith: aString
( an extension from the stx:libcompat package )

Compatibility method - do not use in new code.
same as #bindWith: for Dolphin compatibility

Usage example(s):

     'hello%1world' formatWith:'123'

formatWith: arg1 with: arg2
( an extension from the stx:libcompat package )

Compatibility method - do not use in new code.
same as #bindWith: for Dolphin compatibility

Usage example(s):

     'hello%1 %2world' formatWith:'123' with:234

formatWith: arg1 with: arg2 with: arg3
( an extension from the stx:libcompat package )

Compatibility method - do not use in new code.
same as #bindWith: for Dolphin compatibility

Usage example(s):

     'hello%1 %2 %3world' formatWith:'123' with:234 with:345

lines
( an extension from the stx:libcompat package )

return the receiver as a collection of lines.
Added for Dolphin compatibility

Usage example(s):

     'hello world' lines  

     'foo
bar
baz' lines

substrings: separatorCharacterOrString
( an extension from the stx:libcompat package )

return a collection consisting of all words contained in the receiver.
Words are separated by separatorCharacter.
This is similar to split: (squeak), asCollectionOfSubstringsSeparatedBy: (st/x)
and the same as subStrings: (with UC 'S' in V'age)
and has been added for Dolphin compatibility.

Usage example(s):

     'foo:bar:baz:smalltalk' substrings:$:
     'foo:bar:baz:smalltalk' substrings:':'
     'foo.bar,baz-smalltalk' substrings:'.,-'

truncateTo: smallSize
( an extension from the stx:libcompat package )

return myself or a copy shortened to smallSize. 1/18/96 sw

Usage example(s):

     'hello world' truncateTo:5  
     'hello' truncateTo:10     

     'hello world' copyTo:5
     'hello' copyTo:10

Compatibility-GNU

% anArrayOfOperands

Usage example(s):

     'do you prefer %1 or rather %2 (not talking about %3) ?'
        % #('smalltalk' 'c++' 'c')

     'do you %(what) ?'
        % (Dictionary new at:#'what' put:'understand'; yourself)

Compatibility-ST/V

asArrayOfSubstrings

return an array of substrings from the receiver, interpreting
separators (i.e. spaces & newlines) as word-delimiters.
This has been added for ST/V compatibility
- the actual work is done in asCollectionOfWords.
(sigh: it is called #'subStrings' in V'Age, #'substrings' in Squeak
and #'asCollectionOfWords' in ST/X)

Usage example(s):

     '1 one two three four 5 five' asArrayOfSubstrings
     '1
one
        two three four 5 five' asArrayOfSubstrings

equalsIgnoreCase: aString
( an extension from the stx:libcompat package )

This is an ST/V compatibility method and an alias for sameAs:.

Usage example(s):

     'abc' equalsIgnoreCase: 'aBC'

replChar: oldChar with: newChar
( an extension from the stx:libcompat package )

return a copy of the receiver, with all oldChars replaced by newChar.
This is an ST/V compatibility method and an alias for copyReplaceAll.

Usage example(s):

     '12345678901234567890' replChar:$0 with:$*

replChar: oldChar withString: newString
( an extension from the stx:libcompat package )

return a copy of the receiver, with all oldChars replaced
by newString (i.e. slice in the newString in place of the oldChar).
This is an ST/V compatibility method.

Usage example(s):

     '12345678901234567890' replChar:$0 withString:'foo'    => '123456789foo123456789foo'
     'a string with spaces' replChar:$  withString:' foo '  => 'a foo string foo with foo spaces'

replString: subString withString: newString
( an extension from the stx:libcompat package )

return a copy of the receiver, with all sequences of subString replaced
by newString (i.e. slice in the newString in place of the oldString).
This is an ST/V compatibility method and an alias for copyReplaceString.

Usage example(s):

     '12345678901234567890' replString:'123' withString:'OneTwoThree'
     '12345678901234567890' replString:'123' withString:'*'
     '12345678901234567890' replString:'234' withString:'foo'

     ('a string with spaces' replChar:$  withString:' foo ')
        replString:'foo' withString:'bar'

subString: start to: end
( an extension from the stx:libcompat package )

same as copyFrom:to:
This is an ST/V compatibility method and an alias for copyFrom:to:.

Usage example(s):

     '12345678901234567890' subString:3 to:8

trimBlanks

return a copy of the receiver without leading and trailing spaces.
This is an ST/V compatibility method and an alias for withoutSpaces.

Usage example(s):

     '    spaces at beginning' trimBlanks
     'spaces at end    ' trimBlanks
     '    spaces at beginning and end     ' trimBlanks
     'no spaces' trimBlanks

uncapitalized
( an extension from the stx:libcompat package )

Answer a <readableString> which is a copy of the receiver but with
the first character converted to its lowercase equivalent.

Compatibility-Squeak

asBoldText

return self as a bold text

asDate

Many allowed forms, see Date.readFrom:

Usage example(s):

     '30 Apr 1999' asDate dayName capitalized

asFileReference
( an extension from the stx:libcompat package )

Squeak mimikri

asOneByteString
( an extension from the stx:libcompat package )

return the receiver converted to a 'normal' string.
Same as asSingleByteString - for Squeak/Pharo compatibility.

asTime

Many allowed forms, see Time.readFrom:

Usage example(s):

     '14:22:05' asTime      => 14:22:05
     '02:22:05 am' asTime   => 02:22:05
     '02:22:05 pm' asTime   => 14:22:05

asUrl
( an extension from the stx:libcompat package )

Same as asURL - for Squeak/Pharo compatibility.

asWideString
( an extension from the stx:libcompat package )

return a two-byte string containing the same characters as the receiver.
Same as asTwoByteString - for Squeak/Pharo compatibility.

Usage example(s):

     'abc' asWideString

beginsWith: aStringOrCharacter caseSensitive: caseSensitive
( an extension from the stx:libcompat package )

return true, if the receiver starts with something, aStringOrCharacter.
If the argument is empty, true is returned.
Notice, that this is similar to, but slightly different from VW's and Squeak's beginsWith:,
which are both inconsistent w.r.t. an empty argument.

capitalized
( an extension from the stx:libcompat package )

same as asUppercaseFirst for Squeak/Pharo compatibility

Usage example(s):

     'hello' capitalized

caseInsensitiveLessOrEqual: aString
( an extension from the stx:libcompat package )

compare the receiver against the argument ignoring case differences
For Squeak/Pharo compatibility

caseSensitiveLessOrEqual: aString
( an extension from the stx:libcompat package )

compare the receiver against the argument caring for case differences
For Squeak/Pharo compatibility

charactersExactlyMatching: aString
( an extension from the stx:libcompat package )

marked as obsolete by exept MBP at 11-03-2022

** This is an obsolete interface - do not use it (it may vanish in future versions) **

convertToEncoding: nameOfEncoding
( an extension from the stx:libcompat package )

special case, because it is so common:

Usage example(s):

     'hellöäü' convertToEncoding:'utf8'
     'hello' convertToEncoding:'cp1252'

displayProgressAt: aPoint from: startValue to: endValue during: actionExpectingProgressHolder
( an extension from the stx:libcompat package )

findDelimiters: delimiters startingAt: start
( an extension from the stx:libcompat package )

Answer the index of the character within the receiver, starting at start,
that matches one of the delimiters.
If the receiver does not contain any of the delimiters, answer size + 1.

findLastOccurrenceOfString: aString startingAt: startIndex
( an extension from the stx:libcompat package )

this does a forward search starting at startIndex,
as opposed to lastIndexOfString:startingAt:, which searches backwards from the index

Usage example(s):

     'foo' findLastOccurrenceOfString:' ' startingAt:1       -> 0
     'foo bar' findLastOccurrenceOfString:' ' startingAt:1   -> 4
     'foo bar ' findLastOccurrenceOfString:' ' startingAt:1  -> 8

findString: key startingAt: start caseSensitive: caseSensitive

findTokens: delimiterOrDelimiters
( an extension from the stx:libcompat package )

cg: I am not sure, if this is really the squeak semantics (w.r.t. empty fields)

Usage example(s):

     'a|b#c||e' findTokens:#($# $|) => StringCollection('a' 'b' 'c' 'e')
     'a|b#c||e' findTokens:$|       => StringCollection('a' 'b#c' '' 'e')
     'a b c e' findTokens:' '       => StringCollection('a' 'b' 'c' 'e')
     'a::b::c::e' findTokens:'::'   => StringCollection('a' 'b' 'c' 'e')
     c'a\r\nb\r\nc\r\ne' findTokens:c'\r\n'                               => StringCollection('a' 'b' 'c' 'e')
     c'a\r\nb\r\nc\r\ne' findTokens:{Character return . Character lf}     => StringCollection('a' 'b' 'c' 'e')

findTokens: delimiters keep: keepers
( an extension from the stx:libcompat package )

Answer the collection of tokens that result from parsing self.
The tokens are seperated by delimiters, any of a string of characters.
If a delimiter is also in keepers, make a token for it.
(Very useful for carriage return.
A sole return ends a line, but is also saved as a token so you can see where the line breaks were.)

format: collection
( an extension from the stx:libcompat package )

similar to bindWith but different syntax,
format the receiver by slicing in elements from collection, as in the following examples:
('Five is {1}.' format: { 1 + 4}) >>> 'Five is 5.'
('Five is {five}.' format: (Dictionary with: #five -> 5)) >>> 'Five is 5.'
('In {1} you can escape \{ by prefixing it with \\' format: {'strings'}) >>> 'In strings you can escape { by prefixing it with \'
('In \{1\} you can escape \{ by prefixing it with \\' format: {'strings'}) >>> 'In {1} you can escape { by prefixing it with \'

includesSubString: aString
( an extension from the stx:libcompat package )

return true, if a substring is contained in the receiver.
The compare is case sensitive.

Usage example(s):

     'hello world' includesSubString:'Hel'
     'hello world' includesSubString:'hel'
     'hello world' includesSubString:'llo'

includesSubString: aString caseSensitive: caseSensitive
( an extension from the stx:libcompat package )

sigh - an alias; added for Squeak/Pharo compatibility

includesSubstring: aString
( an extension from the stx:libcompat package )

sigh - an alias; added for Squeak/Pharo compatibility

includesSubstring: aString caseSensitive: caseSensitive
( an extension from the stx:libcompat package )

return true, if a substring is contained in the receiver.
The argument, caseSensitive controls if case is ignored in the compare.

Usage example(s):

     'hello world' includesSubstring:'Hel' caseSensitive:true
     'hello world' includesSubstring:'Hel' caseSensitive:false

     'hello world' includesString:'Hel' caseSensitive:true
     'hello world' includesString:'Hel' caseSensitive:false

intervalFromStartLine: aStartLine startColumn: aStartColumn toEndLine: anEndLine endColumn: anEndColumn
( an extension from the stx:libcompat package )

Returns an interval spanning between startLine @ startColumn to endLine @ endColumn

intervalOfLine: aLineNumber
( an extension from the stx:libcompat package )

Answer an interval spanning between the first and the last character of the line from aLineNumber.
Use this to convert lineNr into a character range.

intervalOfLineCorrespondingToIndex: anIndex
( an extension from the stx:libcompat package )

Answer an interval spanning between the first and the last character of the line containing the given character index

isAllDigits
( an extension from the stx:libcompat package )

Answer whether the receiver's characters are all digits

Usage example(s):

     'hello world' isAllDigits
     '12344' isAllDigits

lastSpacePosition
( an extension from the stx:libcompat package )

return the index of the last space character; 0 if there is none.
Added for Squeak/Pharo compatibility

lineIndicesDo: aBlock
( an extension from the stx:libcompat package )

execute aBlock with 3 arguments for each line:
- start index of line
- end index of line without line delimiter
- end index of line including line delimiter(s) CR, LF or CRLF

linesDo: aBlock

evaluate the argument, aBlock for all lines,
up to the end

openInWorkspaceWithTitle: aTitleString
( an extension from the stx:libcompat package )

Added for Squeak/Pharo compatibility

padded: leftOrRight to: paddedSize with: padCharacter

pad left (leftOrRight == #left) or right

Usage example(s):

     'hello' padded:#right to:10 with:$.
     'hello' padded:#left to:10 with:$.

piecesCutWhereCamelCase
( an extension from the stx:libcompat package )

Breaks apart words written in camel case.

It's not simply using piecesCutWhere: because we want
to also deal with abbreviations and thus we need to
decide based on three characters, not just on two:

This is slightly different from the ST/X camelCaseSeparatedWords in that it handles digits
as separate words whereas the STX function adds them to the previous word.
Also the handling of spaces is different.

Usage example(s):

     ('FOOBar') piecesCutWhereCamelCase asArray                 => #('FOO' 'Bar').
     ('FOOBar12AndSomething') piecesCutWhereCamelCase asArray   => #('FOO' 'Bar' '12' 'And' 'Something')        
     ('FOOBar1AndSomething') piecesCutWhereCamelCase asArray    => #('FOO' 'Bar' '1' 'And' 'Something')        
     ('FOOBar1 12AndSomething') piecesCutWhereCamelCase asArray => #('FOO' 'Bar' '1' ' ' '12' 'And' 'Something')        
     ('FOOBar1 AndSomething') piecesCutWhereCamelCase asArray   => #('FOO' 'Bar' '1' ' And' 'Something')      

     ('FOOBar') camelCaseSeparatedWords asArray                 => #('FOO' 'Bar').
     ('FOOBar1AndSomething') camelCaseSeparatedWords asArray    => #('FOO' 'Bar1' 'And' 'Something')        
     ('FOOBar1 12AndSomething') camelCaseSeparatedWords asArray => #('FOO' 'Bar1 12' 'And' 'Something')        
     ('FOOBar1 AndSomething') camelCaseSeparatedWords asArray   => #('FOO' 'Bar1 ' 'And' 'Something')

prefixCharactersExactlyMatching: aString
( an extension from the stx:libcompat package )

return the number of characters I share as a prefix with the argument, aString.
This method was originally called charactersExactlyMatching:,
and has been renamed to avoid misinterpretation.

Usage example(s):

     'abc'  prefixCharactersExactlyMatching:'abc'
     'abc'  prefixCharactersExactlyMatching:'abcd'
     'abcd' prefixCharactersExactlyMatching:'abc'
     'abc'  prefixCharactersExactlyMatching:'abd'
     'abc'  prefixCharactersExactlyMatching:'xxx'

skipDelimiters: delimiters startingAt: startArg

Answer the index of the character within the receiver, starting at start,
that does NOT match one of the delimiters.
If the receiver does not contain any of the delimiters, answer size + 1.
Assumes the delimiters to be a non-empty string.

Usage example(s):

     '123***7890' skipDelimiters:'*' startingAt:4    
     '123***7890' skipDelimiters:'*' startingAt:3    
     '123***7890' skipDelimiters:'*' startingAt:10   
     '123*******' skipDelimiters:'*' startingAt:10

substrings

return a collection consisting of all words contained in the receiver.
Words are separated by whitespace.
This has been added for Squeak compatibility.
(sigh: it is called #'subStrings' in V'Age, and #'asCollectionOfWords' in ST/X)

Usage example(s):

     'foo bar baz' substrings

substringsSeparatedBy: separatorCharacter

return a collection consisting of all words contained in the receiver.
Words are separated by the given separator character.
This has been added for Squeak/Pharo compatibility.
(sigh: it is called #'subStrings:' in V'Age,
and #'asCollectionOfSubstringsSeparatedBy' in ST/X)

Usage example(s):

     'foo bar, baz' substringsSeparatedBy:$,
     '1.2.3.4' substringsSeparatedBy:$.

translated
( an extension from the stx:libcompat package )

Dummy - Added for Squeak/Pharo compatibility

trimBoth

return a copy of the receiver without leading and trailing whiteSpace.
Added for Squeak compatibility (an alias for withoutSeparators)

unescapePercents
( an extension from the stx:libcompat package )

decode %xx form. This is the opposite of #encodeForHTTP

unescapePercentsWithTextEncoding: encodingName
( an extension from the stx:libcompat package )

decode string including %XX form

urlDecoded
( an extension from the stx:libbasic2 package )

decode %xx form. This is the opposite of #urlEncoded

Usage example(s):

     'abc%61def' unescapePercents
     'abc%61def' urlDecoded
     
      (HTMLUtilities urlEncoded:'_-.*Frankfurt(Main) Hbf') unescapePercents
      (HTMLUtilities urlEncoded:'_-.*Frankfurt(Main) Hbf') urlDecoded

      (HTMLUtilities urlEncoded:'-_.*%exept ex+pecco;') unescapePercents
      (HTMLUtilities urlEncoded:'-_.*%exept+ex+pecco;') urlDecoded

urlEncoded
( an extension from the stx:libbasic2 package )

encode into %xx form. This is the opposite of #urlDecoded

Usage example(s):

     'abcäöüdef' urlEncoded urlDecoded
     'abc%def' urlEncoded urlDecoded
     'abc def' urlEncoded urlDecoded
     
      ('_-.*Frankfurt(Main) Hbf' urlEncoded) unescapePercents
      ('_-.*Frankfurt(Main) Hbf' urlEncoded) urlDecoded

      ('-_.*%exept ex+pecco;' urlEncoded) unescapePercents
      ('-_.*%exept+ex+pecco;' urlEncoded) urlDecoded

withBlanksTrimmed

Return a copy of the receiver from which leading and trailing whitespace have been trimmed.
Notice the bad naming - it is trimming separators, not just blanks.
Added for Squeak compatibility and an alias for withoutSeparators

Usage example(s):

     '  hello    world    ' withBlanksTrimmed

withNoLineLongerThan: aNumber
( an extension from the stx:libcompat package )

Answer a string with the same content as receiver,
but rewrapped so that no line has more characters than the given number

Usage example(s):

     #(5 7 20) collect:
        [:i | 'Fred the bear went down to the brook to read his book in silence' withNoLineLongerThan: i]

withSqueakLineEndings
( an extension from the stx:libcompat package )

assume the string is textual, and that CR, LF, and CRLF are all
valid line endings.
Replace each occurrence with a single line end character.
Notice; that ST/X uses LF as line end internally

withoutLeading: char

return a copy of myself without leading a char.
Returns an empty string, if the receiver consist only of a char.

Usage example(s):

     '****foo****' withoutLeading: $*
     'foo****'     withoutLeading: $*
     '*'           withoutLeading: $*
     ''            withoutLeading: $*
     '****foo'     withoutLeading: $*
     '*******'     withoutLeading: $*
     'foo'         withoutLeading: $*
     'f***o***o'   withoutLeading: $*
     ('**' , Character tab asString , '*foo***') withoutLeading: $* inspect

withoutTrailing: char

return a copy of myself without trailing char.
Returns an empty string, if the receiver consist only of char.

Usage example(s):

     '    foo....' withoutTrailing:$.
     'foo....'     withoutTrailing:$.
     '    foo'     withoutTrailing:$.
     '.......'     withoutTrailing:$.
     'foo'         withoutTrailing:$.

Compatibility-V'Age

addLineDelimiter
( an extension from the stx:libcompat package )

replace all '\'-characters by line delimiter (cr) - characters.
This has been added for VisualAge compatibility.

bindWith: aString

return a copy of the receiver, where a '%1' escape is
replaced by aString.
This has been added for VisualAge compatibility.

Usage example(s):

     'do you like %1 ?' bindWith:'smalltalk'
     'do you like %(foo) ?' bindWithArguments:(Dictionary new at:'foo' put:'smalltalk'; yourself)

bindWith: string1 with: string2

return a copy of the receiver, where a '%1' escape is
replaced by string1 and '%2' is replaced by string2.
This has been added for VisualAge compatibility.

Usage example(s):

     'do you prefer %1 or rather %2 ?'
        bindWith:'smalltalk' with:'c++'

bindWith: str1 with: str2 with: str3

return a copy of the receiver, where a '%1', '%2' and '%3' escapes
are replaced by str1, str2 and str3 respectively.
This has been added for VisualAge compatibility.

Usage example(s):

     'do you prefer %1 or rather %2 (not talking about %3) ?'
        bindWith:'smalltalk' with:'c++' with:'c'

bindWith: str1 with: str2 with: str3 with: str4

return a copy of the receiver, where a '%1', '%2', '%3' and '%4' escapes
are replaced by str1, str2, str3 and str4 respectively.
This has been added for VisualAge compatibility.

Usage example(s):

     'do you prefer %1 or rather %2 (not talking about %3 or even %4) ?'
        bindWith:'smalltalk' with:'c++' with:'c' with:'assembler'

bindWith: str1 with: str2 with: str3 with: str4 with: str5

return a copy of the receiver, where a '%1' .. '%5' escapes
are replaced by str1 .. str5 respectively.
This has been added for VisualAge compatibility.

bindWith: str1 with: str2 with: str3 with: str4 with: str5 with: str6

return a copy of the receiver, where a '%1' .. '%6' escapes
are replaced by str1 .. str6 respectively.
This has been added for VisualAge compatibility.

bindWith: str1 with: str2 with: str3 with: str4 with: str5 with: str6 with: str7

return a copy of the receiver, where a '%1' .. '%7' escapes
are replaced by str1 .. str7 respectively.
This has been added for VisualAge compatibility.

bindWith: str1 with: str2 with: str3 with: str4 with: str5 with: str6 with: str7 with: str8

return a copy of the receiver, where a '%1' .. '%8' escapes
are replaced by str1 .. str8 respectively.
This has been added for VisualAge compatibility.

bindWith: str1 with: str2 with: str3 with: str4 with: str5 with: str6 with: str7 with: str8 with: str9

return a copy of the receiver, where a '%1' .. '%9' escapes
are replaced by str1 .. str9 respectively.
This has been added for VisualAge compatibility.

bindWithArguments: argumentsCollection

return a copy of the receiver, where a '%i' escape
is replaced by the corresponding string from the argument array.
'i' may be between 1 and 9 (i.e. a maximum of 9 placeholders is allowed)
or %(key); the argumentsCollection must then be a dictionary.
To get an integer-indexed placeHolder followed by another digit,
or an index > 9, you must use %(digit).
This has been added for VisualAge compatibility.

Usage example(s):

     'do you prefer %1 or rather %2 (not talking about %3) ?'
        bindWithArguments:#('smalltalk' 'c++' 'c')

     'do you %(what) ?'
        bindWithArguments:(Dictionary new at:#'what' put:'understand'; yourself)

subStrings
( an extension from the stx:libcompat package )

return a collection consisting of all words contained in the receiver.
Words are separated by whitespace.
This has been added for VisualAge compatibility.
(sigh: it is called #'subbtrings' in Squeak, and #'asCollectionOfWords' in ST/X)

Usage example(s):

     'hello world, this is smalltalk' subStrings

subStrings: separatorCharacterOrString

return a collection consisting of all words contained in the receiver.
Words are separated by separatorCharacterOrString.
This is similar to split: (squeak) and asCollectionOfSubstringsSeparatedBy: (st/x)
and has been added for VisualAge compatibility.

Usage example(s):

     'foo:bar:baz:smalltalk' subStrings:$:
     'foo:bar:baz:smalltalk' subStrings:':'
     'foo.bar,baz-smalltalk' subStrings:'.,-'

trimSeparators

return a copy of the receiver without leading and trailing whiteSpace.
Added for VisualAge compatibility (an alias for withoutSeparators)

with: aString

return a copy of the receiver, where a '%1' escape is replaced by aString.
Added for protocol compatibility with resourcePack xlation.

Usage example(s):

     'do you like %1 ?' with:'smalltalk'
     'do you like %(foo) ?' withArguments:(Dictionary new at:'foo' put:'smalltalk'; yourself)

with: string1 with: string2

return a copy of the receiver,
where a '%1' escape is replaced by string1 and '%2' is replaced by string2.
Added for protocol compatibility with resourcePack xlation.

Usage example(s):

     'do you prefer %1 or rather %2 ?' with:'smalltalk' with:'c++'

with: str1 with: str2 with: str3

return a copy of the receiver,
where a '%1', '%2' and '%3' escapes are replaced by str1, str2 and str3 respectively.
Added for protocol compatibility with resourcePack xlation.

Usage example(s):

     'do you prefer %1 or rather %2 (not talking about %3) ?'
        with:'smalltalk' with:'c++' with:'c'

with: str1 with: str2 with: str3 with: str4

return a copy of the receiver, where a '%1', '%2', '%3' and '%4' escapes
are replaced by str1, str2, str3 and str4 respectively.
Added for protocol compatibility with resourcePack xlation.

Usage example(s):

     'do you prefer %1 or rather %2 (not talking about %3 or even %4) ?'
        with:'smalltalk' with:'c++' with:'c' with:'assembler'

with: str1 with: str2 with: str3 with: str4 with: str5

return a copy of the receiver, where a '%1' .. '%5' escapes
are replaced by str1 .. str5 respectively.
Added for protocol compatibility with resourcePack xlation.

with: str1 with: str2 with: str3 with: str4 with: str5 with: str6

return a copy of the receiver, where a '%1' .. '%6' escapes
are replaced by str1 .. str6 respectively.
Added for protocol compatibility with resourcePack xlation.

with: str1 with: str2 with: str3 with: str4 with: str5 with: str6 with: str7

return a copy of the receiver, where a '%1' .. '%7' escapes
are replaced by str1 .. str7 respectively.
Added for protocol compatibility with resourcePack xlation.

with: str1 with: str2 with: str3 with: str4 with: str5 with: str6 with: str7 with: str8

return a copy of the receiver, where a '%1' .. '%8' escapes
are replaced by str1 .. str8 respectively.
Added for protocol compatibility with resourcePack xlation.

with: str1 with: str2 with: str3 with: str4 with: str5 with: str6 with: str7 with: str8 with: str9

return a copy of the receiver, where a '%1' .. '%9' escapes
are replaced by str1 .. str9 respectively.
Added for protocol compatibility with resourcePack xlation.

withArguments: argumentsCollection

return a copy of the receiver, where the '%i' escapes
are replaced by the corresponding string from the argument array.
'i' may be between 1 and 9 (i.e. a maximum of 9 placeholders is allowed)
or %(key); the argumentsCollection must then be a dictionary.
To get an integer-indexed placeHolder followed by another digit,
or an index > 9, you must use %(digit).
This has been added for VisualAge compatibility.

Usage example(s):

     'do you prefer %1 or rather %2 (not talking about %3) ?'
        withArguments:#('smalltalk' 'c++' 'c')

     'do you %(what) ?'
        withArguments:(Dictionary new at:#'what' put:'understand'; yourself)

Compatibility-VW

asComposedText
( an extension from the stx:libcompat package )

ST-80 compatibility
- ST/X does not (as today) support composedTexts.

asLogicalFileSpecification
( an extension from the stx:libcompat package )

asQualifiedReference
( an extension from the stx:libcompat package )

expandMacros

ST80 compatibility - expand '<..>' macros with
argument strings. Similar to #bindWith:.
Read the comment in #expandMacrosWithArguments: about
limited compatibility issues.

Usage example(s):

     'hellofoo' expandMacros

expandMacrosWith: arg

ST80 compatibility - expand '<..>' macros with
argument strings. Similar to #bindWith:.
Read the comment in #expandMacrosWithArguments: about
limited compatibility issues.

expandMacrosWith: arg1 with: arg2

ST80 compatibility - expand '<..>' macros with
argument strings. Similar to #bindWith:.
Read the comment in #expandMacrosWithArguments: about
limited compatibility issues.

expandMacrosWith: arg1 with: arg2 with: arg3

ST80 compatibility - expand '<..>' macros with
argument strings. Similar to #bindWith:.
Read the comment in #expandMacrosWithArguments: about
limited compatibility issues.

expandMacrosWith: arg1 with: arg2 with: arg3 with: arg4

ST80 compatibility - expand '<..>' macros with
argument strings. Similar to #bindWith:.
Read the comment in #expandMacrosWithArguments: about
limited compatibility issues.

expandMacrosWithArguments: argArray

ST80 compatibility - expand '<..>' macros with
argument strings. Similar to #bindWith:.
WARNING: possibly not all ST80 expansions are supported here.

isCharacters

true, if the receiver is a string-like thing.
added for visual works compatibility

JavaScript support

charAt0: index
( an extension from the stx:libjavascript package )

returns the n'th character, using a 0-based indexing scheme (sigh)

charAt1: index
( an extension from the stx:libjavascript package )

returns the n'th character, using a 1-based indexing scheme (sigh)

charCodeAt0: index
( an extension from the stx:libjavascript package )

returns the code of the n'th character, using a 0-based indexing scheme (sigh)

charCodeAt1: index
( an extension from the stx:libjavascript package )

returns the code of the n'th character, using a 1-based indexing scheme (sigh)

indexOf0: aCharacter
( an extension from the stx:libjavascript package )

returns the index of aCharacter, using a 0-based indexing scheme; -1 if not found (sigh)

indexOf1: aCharacter
( an extension from the stx:libjavascript package )

returns the index of aCharacter, using a 1-based indexing scheme; 0 if not found (sigh)

js_add: something
( an extension from the stx:libjavascript package )

For JavaScript only:
Generated for +-operator in javascript.

js_addFromNumber: aNumber
( an extension from the stx:libjavascript package )

For JavaScript only:
Generated for +-operator in javascript.

js_addFromString: aString
( an extension from the stx:libjavascript package )

For JavaScript only:
Generated for +-operator in javascript.

js_addFromTime: aTime
( an extension from the stx:libjavascript package )

For JavaScript only:
Generated for +-operator in javascript.

js_indexOf: aCharacterOrSubstring
( an extension from the stx:libjavascript package )

JS: collection.indexOf(character)
JS: collection.indexOf(substring)
returns the index of anElement/substring, using a 0-based indexing scheme; -1 if not found (sigh).
Selector-xlation to allow redefinition in CharacterArray, which supports substring searching.

js_indexOf: aCharacterOrSubstring _: startIndex
( an extension from the stx:libjavascript package )

JS: collection.indexOf(character, startIndex)
JS: collection.indexOf(substring, startIndex)
returns the index of anElement, using a 0-based indexing scheme; -1 if not found (sigh).
Selector-xlation to allow redefinition in CharacterArray, which supports substring searching.

js_lastIndexOf: aCharacterOrSubstring
( an extension from the stx:libjavascript package )

JS: collection.lastIndexOf(character)
JS: collection.lastIndexOf(substring)
returns the index of the last occurrence of anElement/substring, using a 0-based indexing scheme; -1 if not found (sigh).
Selector-xlation to allow redefinition in CharacterArray, which supports substring searching.

js_lastIndexOf: aCharacterOrSubstring _: startIndex
( an extension from the stx:libjavascript package )

JS: collection.lastIndexOf(character, startIndex)
JS: collection.lastIndexOf(substring, startIndex)
returns the index of the last occurrence of anElement/substring, using a 0-based indexing scheme; -1 if not found (sigh).
Selector-xlation to allow redefinition in CharacterArray, which supports substring searching.

js_split: separator
( an extension from the stx:libjavascript package )

JavaScript: splits the receiver into an array of substrings

js_typeof
( an extension from the stx:libjavascript package )

return a string describing what I am

lastIndexOf0: aCharacter
( an extension from the stx:libjavascript package )

returns the last index of aCharacter, using a 0-based indexing scheme; -1 if not found (sigh)

lastIndexOf1: aCharacter
( an extension from the stx:libjavascript package )

returns the last index of aCharacter, using a 1-based indexing scheme; 0 if not found (sigh)

quote
( an extension from the stx:libjavascript package )

wraps the receiver into quotes.
This is the JavaScript standard quote function.

Usage example(s):

     JavaScriptParser evaluate:'''hello''.quote()'

substr0: index
( an extension from the stx:libjavascript package )

extracts a rest-substring, using a 0-based indexing scheme (sigh)

substr0: index _: count
( an extension from the stx:libjavascript package )

extracts a substring, using a 0-based indexing scheme (sigh)

substr1: index
( an extension from the stx:libjavascript package )

extracts a rest-substring, using a 1-based indexing scheme (sigh)

substr1: index _: count
( an extension from the stx:libjavascript package )

extracts a substring, using a 1-based indexing scheme (sigh)

substring0: index1
( an extension from the stx:libjavascript package )

extracts a substring, using a 0-based indexing scheme (sigh)

substring0: index1 _: index2
( an extension from the stx:libjavascript package )

extracts a substring, using a 0-based indexing scheme (sigh)

substring1: index1
( an extension from the stx:libjavascript package )

extracts a substring, using a 1-based indexing scheme (sigh)

substring1: index1 _: index2
( an extension from the stx:libjavascript package )

extracts a substring, using a 1-based indexing scheme (sigh)

toLowerCase
( an extension from the stx:libjavascript package )

returns a copy of the receiver with all chars in lower case

Usage example(s):

     JavaScriptParser
	evaluate:'''HeLLo''.toLowerCase'

toUpperCase
( an extension from the stx:libjavascript package )

returns a copy of the receiver with all chars in upper case

Usage example(s):

     JavaScriptParser
	evaluate:'''HeLLo''.toUpperCase'

trim
( an extension from the stx:libjavascript package )

returns a copy of the receiver with all leading and trailing whiteSpace removed

Usage example(s):

     JavaScriptParser
	evaluate:'''    He LLo   ''.trim'

trimLeft
( an extension from the stx:libjavascript package )

returns a copy of the receiver with all leading whiteSpace removed

Usage example(s):

     JavaScriptParser
	evaluate:'''    HeLLo   ''.trimLeft'

trimRight
( an extension from the stx:libjavascript package )

returns a copy of the receiver with all trailing whiteSpace removed

Usage example(s):

     JavaScriptParser
	evaluate:'''    HeLLo   ''.trimRight'

unquote

removes double quotes at begin and end from the receiver (but only if matching).
This is the JavaScript standard unquote function.

unquote: quoteCharacter

removes quoteCharacter (if present and matching) from either end of the receiver.

Usage example(s):

     '*hello*' unquote:$*

character searching

includesMatchCharacters

return true if the receiver includes any GLOB meta-match characters (i.e. $* or $#)
for match operations; false if not.
Here, do not care for $\ escapes

Usage example(s):

     '*foo' includesMatchCharacters
     '\*foo' includesMatchCharacters
     '\*foo' includesUnescapedMatchCharacters
     '*foo' includesMatchCharacters
     '\\*foo' includesMatchCharacters
     'foo*' includesMatchCharacters
     'foo\*' includesMatchCharacters
     'foo\' includesMatchCharacters

includesSeparator

return true, if the receiver contains any whitespace characters

Usage example(s):

     'hello world' includesSeparator
     'helloworld' includesSeparator

includesUnescapedMatchCharacters

return true if the receiver really includes any meta characters (i.e. $* or $#)
for match operations; false if not.
Here, care for $\ escapes

Usage example(s):

     '*foo' includesUnescapedMatchCharacters
     '\*foo' includesUnescapedMatchCharacters
     '\\foo' includesUnescapedMatchCharacters
     '\\\$foo' includesUnescapedMatchCharacters
     '*foo' includesUnescapedMatchCharacters
     '\\*foo' includesUnescapedMatchCharacters
     'foo*' includesUnescapedMatchCharacters
     'foo\*' includesUnescapedMatchCharacters
     'foo\' includesUnescapedMatchCharacters

indexOfControlCharacterStartingAt: startIndex

return the index of the next control character;
that is a character with asciiValue < 32.
Start the search at startIndex, searching forward.
Return 0 if none is found.

Usage example(s):

     'hello world' asTwoByteString            indexOfControlCharacterStartingAt:1
     'hello world\foo' withCRsasTwoByteString indexOfControlCharacterStartingAt:1

indexOfNonDigitStartingAt: startIndex

return the index of the next non-digit character,
starting the search at startIndex, searching forward;
return 0 if no non-digit was found

Usage example(s):

     'hello world' indexOfNonDigitStartingAt:1      => 1
     '    hello world' indexOfNonDigitStartingAt:1  => 1
     '    hello world' indexOfNonDigitStartingAt:1  => 1
     '123    ' indexOfNonDigitStartingAt:1          => 4
     'a   ' indexOfNonDigitStartingAt:1             => 1  
     'a   ' indexOfNonDigitStartingAt:2             => 2  
     '123' indexOfNonDigitStartingAt:1              => 0  
     '123' indexOfNonDigitStartingAt:2              => 0 

     'hello world' asUnicode16String indexOfNonDigitStartingAt:1      => 1
     '    hello world' asUnicode16String indexOfNonDigitStartingAt:1  => 1
     '    hello world' asUnicode16String indexOfNonDigitStartingAt:1  => 1
     '123    ' asUnicode16String indexOfNonDigitStartingAt:1          => 4
     'a   ' asUnicode16String indexOfNonDigitStartingAt:1             => 1  
     'a   ' asUnicode16String indexOfNonDigitStartingAt:2             => 2  
     '123' asUnicode16String indexOfNonDigitStartingAt:1              => 0  
     '123' asUnicode16String indexOfNonDigitStartingAt:2              => 0

indexOfNonSeparator

return the index of the first non-whitespace character.
return 0 if no non-separator was found

Usage example(s):

     '    hello world' indexOfNonSeparator
     '    ' indexOfNonSeparator
     'a   ' indexOfNonSeparator
     'abc' indexOfNonSeparator
     ' ' indexOfNonSeparator
     '' indexOfNonSeparator

indexOfNonSeparatorStartingAt: startIndex

return the index of the next non-whitespace character,
starting the search at startIndex, searching forward;
return 0 if no non-separator was found

Usage example(s):

     '    hello world' indexOfNonSeparatorStartingAt:1
     '    ' indexOfNonSeparatorStartingAt:1
     'a   ' indexOfNonSeparatorStartingAt:2

Usage example(s):

     |s index1 index2|
     s := '   foo    bar      baz'.
     index1 := s indexOfNonSeparatorStartingAt:1.
     index2 := s indexOfSeparatorStartingAt:index1.
     s copyFrom:index1 to:index2 - 1

indexOfSeparator

return the index of the first whitespace character;
starting the search at the beginning, searching forward;
return 0 if no separator was found

Usage example(s):

     'hello world' indexOfSeparator
     'helloworld' indexOfSeparator
     'hello   ' indexOfSeparator
     '   hello' indexOfSeparator

indexOfSeparatorOrEndStartingAt: startIndex

return the index of the next whitespace character,
starting the search at startIndex, searching forward;
return the index of one beyond the end of the receiver if no separator was found.
To extract the word, copy from startIndex to the returned index-1

Usage example(s):

     'hello world' indexOfSeparatorOrEndStartingAt:3
     ' hello world' indexOfSeparatorOrEndStartingAt:3
     'hello world ' indexOfSeparatorOrEndStartingAt:3
     'hello world ' indexOfSeparatorOrEndStartingAt:6
     'hello world ' indexOfSeparatorOrEndStartingAt:7
     'helloworld ' indexOfSeparatorOrEndStartingAt:7
     'helloworld' indexOfSeparatorOrEndStartingAt:7
     'helloworld' indexOfSeparatorStartingAt:7

indexOfSeparatorStartingAt: startIndex

return the index of the next whitespace character,
starting the search at startIndex, searching forward;
return 0 if no separator was found

Usage example(s):

     'hello world' indexOfSeparatorStartingAt:3
     ' hello world' indexOfSeparatorStartingAt:3
     'hello world ' indexOfSeparatorStartingAt:3
     'hello world ' indexOfSeparatorStartingAt:6
     'hello world ' indexOfSeparatorStartingAt:7
     'helloworld ' indexOfSeparatorStartingAt:7
     'helloworld' indexOfSeparatorStartingAt:7

isValidMatchPattern

return true if the receiver consists of a valid GLOB match pattern

Usage example(s):

        '[' isValidMatchPattern -> false
        '[]' isValidMatchPattern -> true

lastIndexOfSeparator

return the last index of a whitespace character (space or tab).
(i.e. start the search at the end and search backwards);
Returns 0 if no separator is found.

Usage example(s):

     'hello world' lastIndexOfSeparator
     'helloworld' lastIndexOfSeparator
     'hel lo wor ld' lastIndexOfSeparator
     'hel   ' lastIndexOfSeparator 6

lastIndexOfSeparatorStartingAt: startIndex

return the index of the previous whitespace character,
starting the search at startIndex (and searching backwards);
returns 0 if no separator was found

Usage example(s):

     'hello world' lastIndexOfSeparatorStartingAt:3
     'hello world' lastIndexOfSeparatorStartingAt:7
     'helloworld' lastIndexOfSeparatorStartingAt:7
     ' helloworld' lastIndexOfSeparatorStartingAt:7

comparing

< aString

Compare the receiver with the argument and return true if the
receiver is less than the argument. Otherwise return false.
This comparison is based on the elements ascii code -
i.e. upper/lowercase & upper/lowercase & national characters are NOT treated specially.

<% aString

alias of #compareNaturalWith: answering true if a receiver is less than aString.

<= aString

Compare the receiver with the argument and return true if the
receiver is less than or equal the argument. Otherwise return false.
This comparison is based on the elements ascii code -
i.e. upper/lowercase & upper/lowercase & national characters are NOT treated specially.

Usage example(s):

        '123456789' asUnicodeString <= '123456789' asUnicodeString
        '123456780' asUnicodeString <= '123456789' asUnicodeString
        '12345' asUnicodeString <= '123456780' asUnicodeString
        '123456789' asUnicodeString <= '12345' asUnicodeString
        '123456789' asUnicodeString <= '123456780' asUnicodeString

= aString

Compare the receiver with the argument and return true if the
receiver is equal to the argument. Otherwise return false.

This compare does NOT ignore case differences,
therefore 'foo' = 'Foo' will return false.
Since this is incompatible to ST-80 (at least, V2.x) , this may change.

Usage example(s):

     'foo' = 'Foo'
     'foo' = 'bar'
     'foo' = 'foo'
     'foo' = 'foo' asText
     'foo' asText = 'foo'
     'foo' asText = 'foo' asText

> aString

Compare the receiver with the argument and return true if the
receiver is greater than the argument. Otherwise return false.
This comparison is based on the elements ascii code -
i.e. upper/lowercase & upper/lowercase & national characters are NOT treated specially.

after: aString

Compare the receiver with the argument and return true if the
receiver should come after the argument in a sorted list.
Otherwise return false.
NOTE: The comparison should be language specific, depending on the value of
LC_COLLATE, which is initialized from the environment.

Currently it is for Strings, but not for UnicodeStrings...

STUPID:
#after has a completely different meaning in SeqColl...
... therefore it is marked as obsolete.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

caselessAfter: aString

True if the receiver comes after aString, if compared caseless.
(i.e. if receiver > aString, ignoring case)

Usage example(s):

     'aaa1' > 'aaA2' -> true
     'aaa1' caselessAfter: 'aaA2' -> false

caselessBefore: aString

True if the receiver comes before aString, if compared caseless.
(i.e. if receiver < aString, ignoring case)

Usage example(s):

     'aaa1' < 'aaA2' -> false
     'aaa1' caselessBefore: 'aaA2' -> true

caselessEqual: aString

True if the receiver has the same characters as aString, if compared caseless.
(i.e. if receiver = aString, ignoring case)

Usage example(s):

     'aaa1' = 'aaA1' -> false
     'aaa1' caselessEqual: 'aaA1' -> true

compareAsVersionNumberWith: aStringOrCollection

Compare the receiver with the argument and return 1 if the receiver is
greater, 0 if equal and -1 if less than the argument in a sorted list.
Compare as version numbers in the form a.b.c... .

Usage example(s):

     self assert:('1' compareAsVersionNumberWith:'2') < 0.
     self assert:('2' compareAsVersionNumberWith:'1') > 0.
     self assert:('1.1' compareAsVersionNumberWith:'2.1.2') < 0.
     self assert:('1.1a' compareAsVersionNumberWith:'2.1.2') < 0.
     self assert:('2.1' compareAsVersionNumberWith:'1.2.3') > 0.
     self assert:('1' compareAsVersionNumberWith:'1.1') < 0.
     self assert:('1.1' compareAsVersionNumberWith:'1') > 0.
     self assert:('1.1' compareAsVersionNumberWith:'1.2') < 0.
     self assert:('1.10' compareAsVersionNumberWith:'1.2') > 0.
     self assert:('1.2.3.4' compareAsVersionNumberWith:'1.2.3.5') < 0.
     self assert:('1.2.3.4' compareAsVersionNumberWith:'1.2.3.3') > 0.
     self assert:('1.2.3.4' compareAsVersionNumberWith:'1.2.3') > 0.
     self assert:('1.2.3.4' compareAsVersionNumberWith:'1.2.3.4') = 0.
     self assert:('1.2.3.4' compareAsVersionNumberWith:'01.002.03.004') = 0.
     self assert:('1.2.3.4' compareAsVersionNumberWith:#(1 2 3 4)) = 0.
     self assert:('1.2.3.4' compareAsVersionNumberWith:#('1' 2 3 4)) = 0.

     self assert:('1.1' compareAsVersionNumberWith:'1.1a') < 0.

compareCaselessWith: aString

Compare the receiver against the argument, ignoring case.
Return 1 if the receiver is greater, 0 if equal and -1 if less than the argument.

This comparison is based on the elements ascii code -
i.e. national characters are NOT treated specially.
'foo' compareWith: 'Foo' will return 0

Usage example(s):

     'aaa1' < 'aaA2' -> false
     'aaa1' compareCaselessWith: 'aaA2' -> -1

compareCollatingWith: aString

Compare the receiver with the argument and return 1 if the receiver is
greater, 0 if equal and -1 if less than the argument in a sorted list.
The comparison is language specific, depending on the value of
LC_COLLATE, which is in the shell environment.

compareNaturalWith: aString

Compare the receiver with the argument.
Do a natural compare, treating numbers like humans would:
so 'a3' is less than 'a22'.
Return 1 if the receiver is greater, 0 if equal and -1 if less than the argument.
This comparison is based on the elements' codepoints
i.e. upper/lowercase & national characters are NOT treated specially.

Usage example(s):

^ s compareNaturalWith:aString string.

Usage example(s):

        'a11' compareNaturalWith:'a2'
        'a11' compareNaturalWith:'a11'
        'a222abcdef' compareNaturalWith:'a33abcd'
        'a22zz' compareNaturalWith:'a22zz'
        'abcdef' compareNaturalWith:'abcde'
        'abcde44' compareNaturalWith:'abcde'
        'abcde' compareNaturalWith:'abcde44'
        'abc2.0.0' compareNaturalWith:'abc20.1.0'
        'abc20.00.0' compareNaturalWith:'abc20.1.0'
        '123456789012345678901234567890' compareNaturalWith:'123456789012345678901234567899'

compareWith: aString

Compare the receiver with the argument and return 1 if the receiver is
greater, 0 if equal and -1 if less than the argument.
This comparison is based on the elements' codepoints -
i.e. upper/lowercase & national characters are NOT treated specially.
'foo' compareWith: 'Foo' will return 1.
while 'foo' sameAs:'Foo' will return true

endsWith: aStringOrCharacter

return true, if the receiver ends with something, aStringOrCharacter.
If aStringOrCharacter is empty, true is returned

Usage example(s):

     'hello world' endsWith:'world'
     'hello world' endsWith:$d
     'hello world' asText allBold endsWith:'world'
     'hello world' asText allBold endsWith:$d
     'hello world' endsWith:''
     'hello world' asText allBold endsWith:''
     'hello' endsWith:'hello'
     '' endsWith:'hello'
     '' endsWith:$a
     '' endsWith:1234
     'a' endsWith:1234

endsWith: aStringOrCharacter caseSensitive: caseSensitive

return true, if the receiver ends with something, aStringOrCharacter.
If aStringOrCharacter is empty, true is returned

Usage example(s):

     'hello World' endsWith:'world' caseSensitive:true
     'hello World' endsWith:'world' caseSensitive:false
     '' endsWith:'' caseSensitive:true

endsWithDigit

Answer whether the receiver's final character represents a digit. 3/11/96 sw

Usage example(s):

     'hello' endsWithDigit
     '12hello' endsWithDigit
     'hello12' endsWithDigit

hammingDistanceTo: aString

return the hamming distance (the number of characters which are different).
In information theory, the Hamming distance between two strings of equal length
is the number of positions for which the corresponding symbols are different.
Put another way, it measures the minimum number of substitutions required to change
one into the other, or the number of errors that transformed one string into the other.

Usage example(s):

     'roses' hammingDistanceTo:'toned'
     'roses' hammingDistanceTo:'doses'

hash

return an integer useful as a hash-key

Usage example(s):

whenever changing, also care for String>>hash.

Usage example(s):

Set allSubInstancesDo:[:s | s rehash]

Usage example(s):

     'a' hash
     'a' asUnicode16String hash
     'a' asUnicode32String hash
     'aa' hash
     'aa' asUnicode16String hash
     'aa' asUnicode32String hash
     'ab' hash
     'ab' asUnicode16String hash
     'ab' asUnicode32String hash
     'ab' hash
     'ab' asArray hash

Usage example(s):

        |syms ms|

        syms := Symbol allInstances.
        Transcript show:'syms: '; showCR:syms size.
        Transcript show:'sdbm hashes: '; showCR:(syms collect:[:s| s hash]) asSet size.
        Transcript show:'dragonBook hashes: '; showCR:(syms collect:[:s| s hash_dragonBook]) asSet size.

        ms := Time millisecondsToRun:[
            10 timesRepeat:[
                syms do:[:each| each hash].
            ].
        ].
        Transcript show:'sdbm hash: '; showCR:ms.

        ms := Time millisecondsToRun:[
            10 timesRepeat:[
                syms do:[:each| each hash_dragonBook].
            ].
        ].
        Transcript show:'dragonBook: '; showCR:ms.

        syms := syms collect:[:each| each asUnicode16String].
        ms := Time millisecondsToRun:[
            10 timesRepeat:[
                syms do:[:each| each hash].
            ].
        ].
        Transcript show:'unicode sdbm hash: '; showCR:ms.

        ms := Time millisecondsToRun:[
            10 timesRepeat:[
                syms do:[:each| each hash_dragonBook].
            ].
        ].
        Transcript show:'unicode dragonBook:'; showCR:ms.

hash_dragonBook

return an integer useful as a hash-key

hash_fnv1a

return an integer useful as a hash-key.
This method uses the fnv-1a algorithm
(which is actually a very good one).
Attention: stops when a 0-codepoint is encountered
(for compatibility with the hash used by the VM)
Also: on 64bit CPUs, only small 4-byte hashvalues are returned,
(so hash values are independent from the architecture)

Usage example(s):

     'abc' hash_fnv1a
     'abc' asUnicode16String hash_fnv1a
     'abc' asUnicode32String hash_fnv1a

     'foofooHelloWorld' hash_fnv1a
     'foofooHelloWorld' asUnicode16String hash_fnv1a
     'foofooHelloWorld' asUnicode32String hash_fnv1a

     'blablaHelloWorld' hash_fnv1a
     'blablaHelloWorld' asUnicode16String hash_fnv1a
     'blablaHelloWorld' asUnicode32String hash_fnv1a

hash_fnv1a_64

return a 64bit integer useful as a hash-key.
This method uses the fnv-1a algorithm
(which is actually a very good one).

Usage example(s):

     'abc' hash_fnv1a_64 
     'abc' asUnicode16String hash_fnv1a_64
     'abc' asUnicode32String hash_fnv1a_64

     'foofooHelloWorld' hash_fnv1a_64
     'foofooHelloWorld' asUnicode16String hash_fnv1a_64
     'foofooHelloWorld' asUnicode32String hash_fnv1a_64

     'blablaHelloWorld' hash_fnv1a_64
     'blablaHelloWorld' asUnicode16String hash_fnv1a_64
     'blablaHelloWorld' asUnicode32String hash_fnv1a_64

hash_java

return an integer useful as a hash-key.
This method uses the same algorithm as used in
the java virtual machine
(which is actually not a very good one).

Usage example(s):

     'abc' hash_java
     'foofooHelloWorld' hash_java
     'blablaHelloWorld' hash_java

hash_sdbm

return an integer useful as a hash-key.
This method implements the sdbm algorithm.

levenshteinTo: aString

return the levenshtein distance to the argument, aString;
this value corresponds to the number of replacements that have to be
made to get aString from the receiver.
See IEEE transactions on Computers 1976 Pg 172 ff.

Usage example(s):

     in the following, we assume that omiting a character
     is less of an error than inserting an extra character.
     Therefore the different insertion (i) and deletion (d) values.
        s: substitution weight (4)
        k: keyboard weight (k) (typing a nearby key) - or nil (then use s)
        c: case weight (4)                           - or nil (then use s)
        e: exchange weight (8)                       - or nil (then use s*2)
        i: insertion of extra character weight (2)
        d: delete of a character weight (6)

     Notice that the standard levenshtein uses the same weight for insertion and deletion,
     and is computed by:
        'flaw' levenshteinTo:'lawn' s:2 k:nil c:nil i:1 d:1

Usage example(s):

     'computer' levenshteinTo:'computer'     => 0
     'Computer' levenshteinTo:'computer'     => 4
     'computer' levenshteinTo:'Computer'     => 4

     'cOmputer' levenshteinTo:'computer'     => 4
     'cOmpuTer' levenshteinTo:'computer'     => 8
     'cimputer' levenshteinTo:'computer'     => 4
     'cumputer' levenshteinTo:'computer'     => 4

     'cmputer' levenshteinTo:'computer'      => 2
     'coomputer' levenshteinTo:'computer'    => 6

     'ocmprt' levenshteinTo:'computer'       => 16
     'ocmputer' levenshteinTo:'computer'     => 8
     'cmputer' levenshteinTo:'computer'      => 2
     'computer' levenshteinTo:'cmputer'      => 6
     'Computer' levenshteinTo:'computer'     => 4

     'compiter' levenshteinTo:'computer'     => 4
     'compoter' levenshteinTo:'computer'     => 4

     'comptuer' levenshteinTo:'computer'     => 8

levenshteinTo: aString s: substWeight k: kbdTypoWeight c: caseWeight i: insrtWeight d: deleteWeight

parametrized levenshtein.
return the levenshtein distance to the argument, aString;
this value corrensponds to the number of replacements that have to be
made to get aString from the receiver.
The arguments are the costs for
s:substitution,
k:keyboard type (substitution),
c:case-change,
i:insertion
d:deletion
of a character.
See IEEE transactions on Computers 1976 Pg 172 ff

sameAs: aString

Compare the receiver with the argument like =, but ignore case differences.
Return true or false.

Usage example(s):

     'foo' sameAs: 'Foo'
     'foo' sameAs: 'bar'
     'foo' sameAs: 'foo'

sameAs: aString caseSensitive: caseSensitive

Compare the receiver with the argument.
If caseSensitive is false, this is the same as #sameAs:,
if false, this is the same as #=.

Usage example(s):

     'foo' sameAs:'Foo' caseSensitive:false
     'foo' sameAs:'foo' caseSensitive:true

sameAs: aString ignoreCase: ignoreCase

Compare the receiver with the argument.
If ignoreCase is true, this is the same as #sameAs:,
if false, this is the same as #=.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

sameCharacters: aString

count & return the number of characters which are the same
(ignoring case and emphasis) in the receiver and the argument, aString.

Usage example(s):

     'foobarbaz' sameCharacters: 'foo'
     'foobarbaz' sameCharacters: 'Foo'
     'foobarbaz' sameCharacters: 'baz'

sameEmphasisAs: aStringOrText

compare the receiver's and the argument's emphasis

Usage example(s):

     'hello' asText sameEmphasisAs: 'hello'
     'hello' asText sameEmphasisAs: 'hello' asText
     'hello' asText allBold sameEmphasisAs: 'hello'
     'hello' asText allBold sameEmphasisAs: 'fooba' asText allBold
     'hello' asText allBold sameEmphasisAs: 'fooba' asText allItalic

sameStringAndEmphasisAs: aStringOrText

compare both emphasis and string of the receiver and the argument

Usage example(s):

     'hello' asText sameEmphasisAs: 'hello'
     'hello' asText sameEmphasisAs: 'hello' asText
     'hello' asText allBold sameEmphasisAs: 'hello'
     'hello' asText allBold sameEmphasisAs: 'fooba' asText allBold
     'hello' asText allBold sameEmphasisAs: 'fooba' asText allItalic

     'hello' sameEmphasisAs: 'hello' asText
     'hello' sameEmphasisAs: 'hello' asText allBold
     'hello' sameEmphasisAs: 'fooba'
     'hello' sameEmphasisAs: 'fooba' asText
     'hello' sameEmphasisAs: 'fooba' asText allBold
     'hello' sameEmphasisAs: 'fooba' asText allItalic

     'hello' asText sameStringAndEmphasisAs: 'hello'
     'hello' asText sameStringAndEmphasisAs: 'hello' asText
     'hello' asText allBold sameStringAndEmphasisAs: 'hello'
     'hello' asText allBold sameStringAndEmphasisAs: 'fooba' asText allBold
     'hello' asText allBold sameStringAndEmphasisAs: 'fooba' asText allItalic

     'hello' sameStringAndEmphasisAs: 'hello' asText
     'hello' sameStringAndEmphasisAs: 'hello' asText allBold
     'hello' sameStringAndEmphasisAs: 'fooba'
     'hello' sameStringAndEmphasisAs: 'fooba' asText
     'hello' sameStringAndEmphasisAs: 'fooba' asText allBold
     'hello' sameStringAndEmphasisAs: 'fooba' asText allItalic

spellAgainst: aString

return an integer between 0 and 100 indicating how similar
the argument is to the receiver. No case conversion is done.
This algorithm is much simpler (but also less exact) than the
levenshtein distance. Experiment which is better for your
application.

Usage example(s):

     'Smalltalk' spellAgainst: 'Smalltlak' => 88
     'Smalltalk' spellAgainst: 'smalltlak' => 77
     'Smalltalk' spellAgainst: 'smalltalk' => 88
     'Smalltalk' spellAgainst: 'smalltlk'  => 77
     'Smalltalk' spellAgainst: 'Smalltolk' => 88
     'Smalltalk' spellAgainst: 'Smalltalk' => 100

startsWith: aStringOrCharacter

Usage example(s):

     'abcde' startsWith:#($a $b $c)
     'abcde' startsWith:'abc'
     'abcd' startsWith:'abcde'
     'abcde' startsWith:'abd'
     'hello world' startsWith:'hello'
     'hello world' asText allBold startsWith:'hello'
     'hello world' asText allBold startsWith:''

startsWith: aStringOrCharacter caseSensitive: caseSensitive

Usage example(s):

     'aBCde' startsWith:'abc' caseSensitive:true
     'aBCde' startsWith:'abc' caseSensitive:false

startsWithAnyOf: aCollectionOfStrings caseSensitive: caseSensitive

return true, if the receiver starts with any in aCollectionOfStrings, possibly ignoring case differences.

Usage example(s):

     'abcde' startsWithAnyOf:#('AB' 'xx') caseSensitive:true  => false
     'abcde' startsWithAnyOf:#('AB' 'xx') caseSensitive:false => true
     'abcde' startsWithAnyOf:#('AC' 'ac') caseSensitive:false => false

startsWithDigit

Answer whether the receiver's first character represents a digit. 3/11/96 sw

Usage example(s):

     'hello' startsWithDigit
     '12hello' startsWithDigit
     'hello12' startsWithDigit

startsWithSeparator

Answer whether the receiver's first character is whitespace

Usage example(s):

     'hello' startsWithSeparator 
     ' 12hello' startsWithSeparator    
     (Character tab,'hello12') startsWithSeparator

converting

asAsciiZ

if the receiver does not end with a 0-valued character, return a copy of it,
with an additional 0-character. Otherwise return the receiver. This is sometimes
needed when a string has to be passed to C, which needs 0-terminated strings.
Notice, that all singleByte strings are already 0-terminated in ST/X, whereas wide
strings are not.

Usage example(s):

     'abc' asAsciiZ
     'abc' asUnicode16String asAsciiZ

asByteArray

depending on the size of the characters in the receiver,
return a byteArray containing single-, double- or even 4-bytewise values.
The size of the returned byteArray will be the strings size multiplied by the
size required for the largest character.
Attention: The bytes are in native byte order.
Caveat: better use utf8Encoded, to get reproducible results

asByteArrayMSB: msb

depending on the size of the characters in the receiver,
return a byteArray containing single-, double- or even 4-bytewise values.
The size of the returned byteArray will be the strings size multiplied by the
size required for the largest character.
Caveat: better use utf8Encoded, to get reproducible results.
Caveat: when swapping, this seems to work with twoByte chars only.

asCanonicalizedFilename

return a Filename with pathname taken from the receiver.
The filename is canonicalized, meaning that it cares for trailing directory separators,
'.' components etc.

Usage example(s):

on windows:
     'c:\foo\bar' asFilename                        => PCFilename('c:\foo\bar')
     'c:\foo\bar\' asFilename                       => PCFilename('c:\foo\bar\')
     'c:\foo\bar\..\baz' asFilename                 => PCFilename('c:\foo\bar\..\baz')
     'c:\foo\bar\..\baz\.' asFilename               => PCFilename('c:\foo\bar\..\baz\.')
     'c:\foo\bar' asCanonicalizedFilename           => PCFilename('c:\foo\bar')
     'c:\foo\bar\' asCanonicalizedFilename          => PCFilename('c:\foo\bar')
     'c:\foo\bar\..\baz' asCanonicalizedFilename    => PCFilename('c:\foo\baz')
     'c:\foo\bar\..\baz\.' asCanonicalizedFilename  => PCFilename('c:\foo\baz')
    
    on unix:
     '/foo/bar' asFilename                          => UnixFilename('/foo/bar')
     '/foo/bar/' asFilename                         => UnixFilename('/foo/bar/')
     '/foo/bar/../baz' asFilename                   => UnixFilename('/foo/bar/../baz')
     '/foo/bar/../baz/.' asFilename                 => UnixFilename('/foo/bar/../baz/.') 
     '/foo/bar' asCanonicalizedFilename             => UnixFilename('/foo/bar') 
     '/foo/bar/' asCanonicalizedFilename            => UnixFilename('/foo/bar') 
     '/foo/bar/../baz' asCanonicalizedFilename      => UnixFilename('/foo/baz') 
     '/foo/bar/../baz/.' asCanonicalizedFilename    => UnixFilename('/foo/baz')

    on any:
     '/foo/bar/../baz/.' asUnixFilename asCanonicalizedFilename => UnixFilename('/foo/baz')

asClassIfAbsent: exceptionValue

return the class named after me.
Conceptionally the same as
Smalltalk classNamed:self asSymbol ifNil:exceptionValue
or:
self asSymbol asClassIfAbsent:exceptionValue
but avoids the creation of symbols for unknown classes

Usage example(s):

     'Array' asClassIfAbsent:123
     'Foo' asClassIfAbsent:123

asCollectionOfLines

return a collection containing the lines (separated by cr) of the receiver.
If multiple cr's occur in a row, the result will contain empty strings.
If the string ends with a cr, an empty line will be found as last element of the resulting collection.
See also #asCollectionOfLinesWithReturn
(would have rather changed this method instead of adding another one, but a lot of code already uses
this method and we did not want to risk any incompatibilities)

Usage example(s):

     '1 one\2 two\3 three\4 four\5 five' withCRs asCollectionOfLines
     '1 one\\\\2 two\3 three' withCRs asCollectionOfLines

     ('foo \r\nbar\nbaz\t\r\n\r\nbla' printf:#())
        asCollectionOfLines collect:[:l | (l endsWith:Character return) ifTrue:[l copyButLast:1] ifFalse:l]

asCollectionOfLinesDo: aBlock

evaluate aBlock for each line (separated by cr) of the receiver.
Returns the number of lines (i.e. the number of invocations of aBlock).
This is similar to 'asCollectionOfLines do:...' or 'asStringCollection do:...'
but avoids the creation of a temporary collection.

Usage example(s):

     c'hello\nworld\nisnt\nthis\n\nnice' asCollectionOfLinesDo:[:l | Transcript showCR:l]
     c'hello\nworld\nisnt\nthis\n\nnice' asStringCollection do:[:l | Transcript showCR:l]

     c'hello\nworld\nisnt\nthis\n\nnice\n' asCollectionOfLinesDo:[:l | Transcript showCR:l]
     c'hello\nworld\nisnt\nthis\n\nnice\n' asStringCollection do:[:l | Transcript showCR:l]

     c'hello\nworld\nisnt\nthis\n\nnice' asCollectionOfWordsDo:#transcribeCR
     '    hello\n    world\n   isnt\n   this\n   nice\n  ' asCollectionOfLinesDo:#transcribeCR
     'hello' asCollectionOfLinesDo:#transcribeCR
     '' asCollectionOfLinesDo:#transcribeCR
     '      ' asCollectionOfLinesDo:#transcribeCR

asCollectionOfLinesWithReturn

return a collection containing the lines (separated by cr) of the receiver.
If multiple cr's occur in a row, the result will contain empty strings.

Usage example(s):

     '1\2\3' withCRs asCollectionOfLines
     '1\2\3\' withCRs asCollectionOfLines
     '1\2\3' withCRs asCollectionOfLinesWithReturn
     '1\2\3\' withCRs asCollectionOfLinesWithReturn
     '' withCRs asCollectionOfLinesWithReturn

asCollectionOfSubstringsSeparatedBy: aCharacter

return a collection containing substrings (separated by aCharacter) of the receiver.
If aCharacter occurs multiple times in a row, the result will contain empty strings.
If the receiver starts with aCharacter, an empty string with be the first result element.
If the receiver ends with aCharacter, NO empty string with be the last result element.

Usage example(s):

     '1 one:2 two:3 three:4 four:5 five' asCollectionOfSubstringsSeparatedBy:$:
     '1 one:2 two:3 three:4 four:5 five:' asCollectionOfSubstringsSeparatedBy:$:
     '1 one 2 two 3 three 4 four 5 five' asCollectionOfSubstringsSeparatedBy:Character space

asCollectionOfSubstringsSeparatedBy: aCharacter exceptIn: ch

return a collection containing the substrings (separated by aCharacter) of the receiver.
If aCharacter occurs multiple times in a row, the result will contain empty strings.
The separation is not done, inside a matching pair of ch-substrings.
Can be used to tokenize csv-like strings, which may or may not be enclosed in quotes.

Usage example(s):

     'asd''f;d''dd;s' asCollectionOfSubstringsSeparatedBy:$; exceptIn:$'
     'asd''f;d''dd;s' asText asCollectionOfSubstringsSeparatedBy:$; exceptIn:$'

Usage example(s):

'asd "hello bla" foo "bla bla" bar' asCollectionOfSubstringsSeparatedBy:$  exceptIn:$"

asCollectionOfSubstringsSeparatedBy: aFieldSeparatorString textSeparator: aTextSeparatorOrNil

return a collection containing the words (separated by aFieldSeparatorString) of the receiver.
Individual words might be enclosed in aTextSeparator characters, in case they contain blanks or fieldSeparators.
Typically used for CSV line parsing, with a $; as aFieldSeparator and $'' (dquote) as textSeparator.

Usage example(s):

     self assert:(('#First#, #Second,SecondAdd#, #Third#' asCollectionOfSubstringsSeparatedBy:',' textSeparator: $#)
                  sameContentsAs:#('First' 'Second,SecondAdd' 'Third')).
     self assert:(('#Fir##st#, #Second,SecondAdd#, #Third#' asCollectionOfSubstringsSeparatedBy:',' textSeparator: $#)
                  sameContentsAs:#('Fir#st' 'Second,SecondAdd' 'Third')).
     self assert:(('#Fir##st#, Second,SecondAdd, #Third#' asCollectionOfSubstringsSeparatedBy:',' textSeparator: $#)
                  sameContentsAs:#('Fir#st' 'Second' 'SecondAdd' 'Third')).
     self assert:(('First,Second,Third,,' asCollectionOfSubstringsSeparatedBy:',' textSeparator:nil)
                   sameContentsAs:#('First' 'Second' 'Third' '' '')).
     self assert:(('First,Second,Third,,' asCollectionOfSubstringsSeparatedBy:',' textSeparator:'#')
                   sameContentsAs:#('First' 'Second' 'Third' '' '')).

asCollectionOfSubstringsSeparatedByAll: aSeparatorString

return a collection containing the lines (separated by aSeparatorString) of the receiver.
If aSeparatorString occurs multiple times in a row,
the result will contain empty strings.

Usage example(s):

     '1::2::3::4::5::' asCollectionOfSubstringsSeparatedByAll:'::'

asCollectionOfSubstringsSeparatedByAny: aCollectionOfSeparators

return a collection containing the words (separated by any character
from aCollectionOfSeparators) of the receiver.
This allows breaking up strings using any character as separator.

Usage example(s):

     'hello:world:isnt:this nice' asCollectionOfSubstringsSeparatedByAny:#($:)
     'hello:world:isnt:this nice' asCollectionOfSubstringsSeparatedByAny:':'
     'hello:world:isnt:this nice' asCollectionOfSubstringsSeparatedByAny:(Array with:$: with:Character space)
     'hello:world:isnt:this nice' asCollectionOfSubstringsSeparatedByAny:': '
     'h1e2l3l4o' asCollectionOfSubstringsSeparatedByAny:($1 to: $9)

asCollectionOfSubstringsSeparatedByAny: aFieldSeparatorString textSeparator: aTextSeparatorCharOrNil

return a collection containing the words (separated by any character in aFieldSeparatorString) of the receiver.
Individual words might be enclosed in aTextSeparatorCharOrNil characters, in case they contain blanks or fieldSeparators.
Typically used for CSV line parsing, with a ';,' as aFieldSeparator and $'' (dquote) as textSeparator.

Usage example(s):

     self assert:(('#First#, #Second,;SecondAdd#; #Third#' asCollectionOfSubstringsSeparatedByAny:';,' textSeparator: $#)
                  sameContentsAs:#('First' 'Second,;SecondAdd' 'Third')).
     self assert:(('#Fir##st#, #Second,SecondAdd#, #Th;ird#' asCollectionOfSubstringsSeparatedByAny:',;' textSeparator: $#)
                  sameContentsAs:#('Fir#st' 'Second,SecondAdd' 'Th;ird')).
     self assert:(('First,Second,Third,;' asCollectionOfSubstringsSeparatedByAny:',;' textSeparator:nil)
                   sameContentsAs:#('First' 'Second' 'Third' '' '')).
     self assert:(('First,Second,Third,;' asCollectionOfSubstringsSeparatedByAny:';,' textSeparator:'#')
                   sameContentsAs:#('First' 'Second' 'Third' '' '')).

asCollectionOfWords

return a collection containing the words (separated by whitespace)
of the receiver. Multiple occurrences of whitespace characters will
be treated like one - i.e. whitespace is skipped.
(sigh: it is called #'subStrings' in V'Age, and #'substrings' in Squeak)

Usage example(s):

     'hello world isnt this nice' asCollectionOfWords
     'hello world isnt this nice' asCollectionOfWordsDo:#transcribeCR
     '    hello    world   isnt   this   nice  ' asCollectionOfWords
     'hello' asCollectionOfWords
     '' asCollectionOfWords
     '      ' asCollectionOfWords
     ' foo bar__baz__bla__ bar ' asCollectionOfWords
     ' foo __bar__baz__bla__ bar ' asCollectionOfWords

asCollectionOfWordsDo: aBlock

evaluate aBlock for each word (separated by whitespace) of the receiver.
Multiple occurrences of whitespace characters will be treated like one
- i.e. whitespace is skipped.
Returns the number of words (i.e. the number of invocations of aBlock).
This is the same as 'asCollectionOfWords do:...' but avoids the creation of
a temporary collection.

Usage example(s):

     'hello world isnt this nice' asCollectionOfWordsDo:[:w | Transcript showCR:w]
     'hello world isnt this nice' asCollectionOfWordsDo:#transcribeCR
     '    hello    world   isnt   this   nice  ' asCollectionOfWordsDo:[:w | Transcript showCR:w]
     'hello' asCollectionOfWordsDo:[:w | Transcript showCR:w]
     '' asCollectionOfWordsDo:[:w | Transcript showCR:w]
     '      ' asCollectionOfWordsDo:[:w | Transcript showCR:w]

asDenseUnicodeString

return the receiver as single-byte, double byte or 4-byte unicode string,
depending on the number of bits required to hold all characters in myself.
Use this to extract non-wide parts from a wide string,
i.e. after a substring has been copied out of a wide string

Usage example(s):

     'abc' asUnicode16String asDenseUnicodeString
     'abc' asUnicode32String asDenseUnicodeString
     ('abc',(Character value:16r165)) asDenseUnicodeString
     ('abc',(Character value:16r165)) copyTo:3
     (('abc',(Character value:16r165)) copyTo:3) asDenseUnicodeString
     ('abc',(Character value:16r165)) asUnicode32String asDenseUnicodeString

asFilename

return a Filename with pathname taken from the receiver

asFixedDecimal
( an extension from the stx:libbasic2 package )

return a fixedDecimal approximating the receiver's value.
Takes the scale which is present in the receiver string

Usage example(s):

     '123.45' asFixedDecimal   -> 123.45
     '123.456' asFixedDecimal  -> 123.456
     '123.4' asFixedDecimal    -> 123.4
     '123.' asFixedDecimal     -> 123
     '123' asFixedDecimal      -> 123

asFixedDecimal: scale
( an extension from the stx:libbasic2 package )

return a fixedDecimal approximating the receiver's value
to scale fractional digits

asFixedPoint

marked as obsolete by exept MBP at 18-09-2021

** This is an obsolete interface - do not use it (it may vanish in future versions) **

asFixedPoint: scale

marked as obsolete by exept MBP at 18-09-2021

** This is an obsolete interface - do not use it (it may vanish in future versions) **

asFloat

read a float number from the receiver.
Notice, that a ConversionError may be raised during the read,
so you better setup some exception handler when using this method.

Usage example(s):

     '0.123' asFloat
     '12345' asFloat
     '(1/5)' asFloat
     'blabla' asFloat
     Object errorSignal handle:[:ex | ex return:0] do:['foo' asFloat]

asImmutableCollection

fallback for subclasses of me which are not single byte strings.
return myself

asImmutableString

return a write-protected copy of myself.
Redefined in Symbol and ImmutableString to return self.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

asInteger

convert the receiver into an integer.
Notice, that a ConversionError may be raised during the read,
so you better setup some exception handler when using this method.
Also notice, that this method here is more strict than the code found
in other Smalltalks.
For less strict integer reading, use Integer readFrom:aString

Usage example(s):

     '12345678901234567890' asInteger
     '-1234' asInteger

     The following raises an error:
         '0.123' asInteger              <- reader finds more after reading 0

     whereas the less strict readFrom does not:
         Integer readFrom:'0.123'       <- reader stops at ., returning 0

     '0.123' asInteger
     '0.123' asNumber    <- returns what you expect
     Object errorSignal handle:[:ex | ex return:0] do:['foo' asInteger]

asLowercase

return a copy of myself in lowercase letters

Usage example(s):

     'helloworld' asUnicode16String asLowercase
     'HelloWorld' asLowercase
     'HelloWorld' asUnicode16String asLowercase
     'HelloWorld' asLowercaseFirst
     'HelloWorld' asUppercase
     'ĀĂĄĆĈ' allBold asLowercase
     'HelloWorldŸ' asLowercase - currently returns an U16 string; should this be u8?

asLowercaseFirst

return a copy of myself where the first character is converted to lowercase.
If the first character is already lowercase, or there is no lowercase for it, return the
receiver.

Usage example(s):

     'HelloWorld' asLowercase
     'HelloWorld' asLowercaseFirst
     'HelloWorld' allBold asLowercaseFirst
      #Object asLowercaseFirst
      #Object allBold asLowercaseFirst

asLowercaseLast

return a copy of myself where the last character is
converted to lowercase.

Usage example(s):

     'HelloWorld' asLowercase
     'HelloWorlD' asLowercaseLast
     'HelloWorlD' allBold asLowercaseLast

asMimeType
( an extension from the stx:libview2 package )

return myself as a mimeType instance

Usage example(s):

     'text/html' asMimeType isTextType
     'text/html' asMimeType isImage
     'image/gif' asMimeType isImage
     'image/gif' asMimeType asMimeType

asNumber

read a number from the receiver.
Notice, that (in contrast to ST-80) a ConversionError may be raised during the read,
so you better setup some signal handler when using this method.
Also notice, that this is meant to read end-user numbers from a string;
it does not handle smalltalk numbers (i.e. radix).
To read a smalltalk number, use Number >> readSmalltalkFrom:.
This may change if ANSI specifies it.

Usage example(s):

     '123'     asNumber
     '123.567' asNumber
     '(5/6)'   asNumber
     'foo'     asNumber
     '123a'    asNumber
     Object errorSignal handle:[:ex | ex returnWith:0] do:['foo' asNumber]

asNumberFromFormatString: ignored

read a number from the receiver, ignoring any nonDigit characters.
This is typically used to convert from strings which include
dollar-signs or millenium digits. However, this method also ignores
the decimal point (if any) and therefore should be used with care.
CAVEAT: this is a dummy fallback implementation for compatibility

Usage example(s):

     'USD 123' asNumberFromFormatString:'foo'
     'DM 123'  asNumberFromFormatString:'foo'
     '123'     asNumberFromFormatString:'foo'
     '123.567' asNumberFromFormatString:'foo'
     '(5/6)'   asNumberFromFormatString:'foo'
     'foo'     asNumberFromFormatString:'foo'

asPackageId

given a package-string as receiver, return a packageId object.
packageIds hide the details of module/directory handling inside the path.
See PackageId for the required format of those strings.

Usage example(s):

     'stx:libbasic' asPackageId

asPlainString

return myself as a plain string without any emphasis
Return myself - I am a string.
Subclasses which do no represent plain strings must redefine this method.

asScaledDecimal

read a fixedPoint number from the receiver.
Notice, that a ConversionError may be raised during the read,
so you better setup some signal handler when using this method.

Usage example(s):

     '0.123' asScaledDecimal
     '12345' asScaledDecimal
     '(1/5)' asScaledDecimal
     'foo' asScaledDecimal
     Object errorSignal 
        handle:[:ex | ex return:0] 
        do:['foo' asScaledDecimal]

asScaledDecimal: scale

read a fixedPoint number with scale number of post-decimal digits
from the receiver. Scale controls the number of displayed digits,
not the number of actually valid digits.
Notice, that a ConversionError may be raised during the read,
so you better setup some signal handler when using this method.

Usage example(s):

     '0.123' asScaledDecimal:2
     '123456' asScaledDecimal:2
     ('3.14157' asScaledDecimal:1) asScaledDecimal:5
     '3.14157' asScaledDecimal:2
     'foo' asScaledDecimal:2

asSingleByteStringIfPossible

if possible, return the receiver converted to a 'normal' string.
It is only possible, if there are no characters with codePoints above 255 in the receiver.
If not possible, the (wideString) receiver is returned.

Usage example(s):

     'hello' asSingleByteStringIfPossible
     'hello' asText asSingleByteStringIfPossible
     'hello' asUnicodeString asText asSingleByteStringIfPossible
     'hello' asUnicodeString asSingleByteStringIfPossible

asSingleByteStringReplaceInvalidWith: replacementCharacter

return the receiver converted to a 'normal' string,
with invalid characters replaced by replacementCharacter.
Can be used to convert from 16-bit strings to 8-bit strings
and replace characters above code-255 with some replacement.

asString

return myself - I am a string

asStringCollection

return a collection of lines from myself.

Usage example(s):

     'hello\world\1\2\3' withCRs asStringCollection first      => 'hello'
     c'hello\nworld\n1\n2\n3' asStringCollection first         => 'hello'
     c'hello\r\nworld\r\n1\r\n2\r\n3' asStringCollection first => c'hello\r' attenion: includes return charactern  
     'hello\' withCRs asStringCollection                       => StringCollection('hello')
     'hello' asStringCollection                                => StringCollection('hello')
     '' asStringCollection                                     => StringCollection()

asStringWithBitsPerCharacterAtLeast: numRequiredBitsPerCharacter

return the receiver in a representation which supports numRequiredBitsPerCharacter.
I.e. if required, convert to a Unicode16 or Unicode32 string

Usage example(s):

     self assert:('abc' asStringWithBitsPerCharacterAtLeast:8) bitsPerCharacter == 8.
     self assert:('abc' asStringWithBitsPerCharacterAtLeast:16) bitsPerCharacter == 16.
     self assert:('abc' asStringWithBitsPerCharacterAtLeast:32) bitsPerCharacter == 32.

     self assert:('abc' asUnicode16String asStringWithBitsPerCharacterAtLeast:8) bitsPerCharacter == 16.
     self assert:('abc' asUnicode16String asStringWithBitsPerCharacterAtLeast:16) bitsPerCharacter == 16.
     self assert:('abc' asUnicode16String asStringWithBitsPerCharacterAtLeast:32) bitsPerCharacter == 32.

     self assert:('abc' asUnicode32String asStringWithBitsPerCharacterAtLeast:8) bitsPerCharacter == 32.
     self assert:('abc' asUnicode32String asStringWithBitsPerCharacterAtLeast:16) bitsPerCharacter == 32.
     self assert:('abc' asUnicode32String asStringWithBitsPerCharacterAtLeast:32) bitsPerCharacter == 32.

asSymbol

Return a unique symbol with the name taken from the receiver's characters.
The receiver should be a singleByte-String;
if not, an utf8 encoded version (with BOM) is returned as symbol.

Usage example(s):

     'abc' asSymbolIfInterned
     'abc' asSymbol

     Symbol allowWideSymbols:true.
     'ΔV' asSymbolIfInterned
     'ΔV' asSymbol
     'ϣ0' asSymbolIfInterned   
     'ϣ0' asSymbol

asSymbolIfInterned

If a symbol with the receiver's characters is already known, return it.
Otherwise, return nil.
This can be used to query for an existing symbol and is the same as:
self knownAsSymbol ifTrue:[self asSymbol] ifFalse:[nil]
but slightly faster, since the symbol lookup operation is only performed once.
The receiver should be a singleByte-String;
if not, an utf8 encoded version (with BOM) is tried as symbol.

Usage example(s):

     (Unicode16String with:(Character value:16rFFFF)) asSymbolIfInterned
     (Unicode16String with:(Character value:16rFFFF)) asSymbol

     'new' asUnicodeString asSymbolIfInterned
     'new' asText asSymbolIfInterned
     'new' asUnicodeString asText asSymbolIfInterned

asSymbolIfInternedOrSelf

If a symbol with the receiver's characters is already known, return it.
Otherwise, return self.
This can be used to query for an existing symbol and is the same as:
self knownAsSymbol ifTrue:[self asSymbol] ifFalse:[self]
but slightly faster, since the symbol lookup operation is only performed once.
The receiver must be a singleByte-String.
TwoByte- and FourByteSymbols are (currently ?) not allowed.

Usage example(s):

     (Unicode16String with:(Character value:16rFFFF)) asSymbolIfInternedOrSelf
     'new' asUnicodeString asSymbolIfInternedOrSelf
     'new' asText asSymbolIfInternedOrSelf
     'new' asUnicodeString asText asSymbolIfInternedOrSelf

asText

return a Text-object (string with emphasis) from myself.

asTimeDuration

return an TimeDuration object from the parsing the receiver string.
Notice, that a ConversionError may occur during the read,
so you better setup some exception handler when using this method.

Usage example(s):

     Time now asTimeDuration
     10 asTimeDuration
     10 seconds asTimeDuration
     '10m 20s' asTimeDuration
     'blabla' asTimeDuration

asTimestamp

convert the receiver into an Timestamp.
Notice, that a ConversionError may occur during the read,
so you better setup some exception handler when using this method.

Usage example(s):

     'blablavla' asTimestamp
     '2014-11-10 21:30:22.444' asTimestamp
     '2014-11-10 21:30:22.444Z' asTimestamp
     '2014-11-10 21:30:22.444+0200' asTimestamp

asTitlecase

return a version of the receiver, where the first character is converted to titlecase,
and everything else to lowercase.
See the comment in Character on what titlecase is.

Usage example(s):

     'helloWorld' asTitlecase
     'HelloWorld' allBold asTitlecase
     'HELLOWORLD' asTitlecase
     'helloworld' asTitlecase

asTitlecaseFirst

return a version of the receiver, where the first character is converted to titlecase.
Titlecase is much like uppercase for most characters, with the exception of some combined
(2-character glyphs), which consist of an upper- and lower-case characters.
If the first character is already titlecase, or there is no titlecasepercase for it, return the
receiver.

Usage example(s):

     'helloWorld' asTitlecaseFirst
     'helloWorld' allBold asTitlecaseFirst
     'HelloWorld' asTitlecaseFirst

asTwoByteString

return the receiver converted to a two-byte string.
Will be obsolete soon - use asUnicode16String.

asURI

return an URI with string taken from the receiver

asURL
( an extension from the stx:libhtml package )

return an URL-object from myself.

Usage example(s):

     'http://www.exept.de:80/index.html' asURL host
     'http://www.exept.de:80/index.html' asURL port
     'http://www.exept.de:80/index.html' asURL method
     'http://www.exept.de:80/index.html' asURL path
     'file:///tmp/index.html' asURL path
     'file:///tmp/index.html' asURL method
     'file:///tmp/index.html' asURL asString

asUUID

return self as a UUID.
Notice, that a ConversionError may be raised during the read,
so you better setup some signal handler when using this method.

Usage example(s):

     UUID genUUID asString asUUID
     '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}' asUUID
     '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}' asUnicodeString asUUID
     'EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B' asUUID
     'EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B quatsch' asUUID
     'quark EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B' asUUID

asUnicode16String

return the receiver in a two-byte per character representation.
Normally, the internal ST/X representation should be transparent and not
of the programmer's concern; except when strings are passed to the outside world,
such as wide-string ffi calls or file contents.
This will raise an error if any non-16bit character is encountered
Notice: surrogate pairs are explicitly NOT generated here, because the generated
unicode16String is usually generated to be passed to external programs or Windows-APIs
which do not care for/know about surrogate pairs.
See asUnicode16StringWithSurrogatePairs which does that for data exchange with partners
which do know about it

Usage example(s):

     'abc' asUnicode16String    
     ('abc',(Character value:0x10000)) asUnicode16String
     ('abc',(Character value:0x10000)) asUnicode16StringWithSurrogatePairs

asUnicode16StringReplaceInvalidWith: replacementCharacter

return the receiver converted to a 'normal' 16-bit string,
with invalid characters replaced by replacementCharacter.
Can be used to convert from 32-bit strings to 16-bit strings
and replace characters above code-0xFFFF with some replacement.

Usage example(s):

     ('abc',(Character value:0x10000)) asUnicode16StringReplaceInvalidWith:$*

asUnicode16StringWithSurrogatePairs

return the receiver in a two-byte per character representation.
Same as asUnicode16String, but will generate a surrogate pair,
if any non-16bit character is encountered.
Normally, the internal ST/X representation should be transparent and not
of the programmer's concern; except when strings are passed to the outside world,
such as wide-string ffi calls or file contents.

Usage example(s):

     'abc' asUnicode16String                               => 'abc'  (unicode16String instance)
     'abc' asUnicode16StringWithSurrogatePairs             => 'abc'  (unicode16String instance)
     ('abc',(Character value:0x10000)) asUnicode16String   => error
     ('abc',(Character value:0x10000)) asUnicode16StringWithSurrogatePairs => (unicode16String instance)

asUnicode16StringZ

return the receiver in a two-byte per character representation.
Make sure that is zero terminated (last char is 16r0000).
Normally, the internal ST/X representation should be transparent and not
of the programmer's concern; except when strings are passed to the outside world,
such as wide-string ffi calls or file contents.

Usage example(s):

        '' asUnicode16StringZ
        'abc' asUnicode16StringZ
        'abc' asUnicode16String asUnicode16StringZ

asUnicode32String

return the receiver in a four-byte per character representation.
Normally, the internal ST/X representation should be transparent and not
of the programmer's concern; except when strings are passed to the outside world,
such as wide-string ffi calls or file contents.

asUnicodeString

Usage example(s):

     'Hello World' asUnicodeString

asUnixFilename

return a UnixFilename with pathname taken from the receiver

asUppercase

return a copy of myself in uppercase letters

Usage example(s):

     'helloWorld' asUppercase
     'helloWorld' asUppercaseFirst
     (Character value:16rB5) asString asUppercase   -- needs 16 bits !
     (Character value:16rFF) asString asUppercase   -- needs 16 bits !
     'āăąćĉ' allBold asUppercase   -- needs 16 bits !

asUppercaseFirst

return a version of the receiver, where the first character is converted to uppercase.
If the first character is already uppercase, or there is no uppercase for it, return the
receiver.

Usage example(s):

     'helloWorld' asUppercase
     'helloWorld' allBold asUppercaseFirst
     'helloWorld' asUppercaseFirst
     'HelloWorld' asUppercaseFirst
      #asUppercaseFirst asUppercaseFirst
      #asUppercaseFirst allBold asUppercaseFirst

asUppercaseLast

return a copy of myself where the last character is
converted to uppercase.

Usage example(s):

     'HelloWorld' asUppercase
     '' asUppercaseLast           
     'HelloWorld' asUppercaseLast 
     'HelloWorld' allBold asUppercaseLast

asUtcTimestamp

convert the receiver into an UtcTimestamp (Time is interpreted in the UTC timezone).
Notice, that a ConversionError may be raised during the read,
so you better setup some signal handler when using this method.

Usage example(s):

     '2014-11-10 21:30:22.444' asUtcTimestamp
     'foo' asUtcTimestamp

asValidIdentifier

convert a string to a valie Smalltalk/Javascript identifier.
Answer myself, if I do not contain invalid charcters.

Usage example(s):

     'hello world' asValidIdentifier
     'hello+world' asValidIdentifier
     '' asValidIdentifier
     '12abc' asValidIdentifier

asVersionNumberCollection

Convert a string like 1.2.3a to an Array of numbers (or string, if not a number).
Remove zeroes from the end.

Usage example(s):

     '1' asVersionNumberCollection.
     '1.1' asVersionNumberCollection.
     '1.1a' asVersionNumberCollection.
     '1.1.0' asVersionNumberCollection.
     '01.01.0' asVersionNumberCollection.
     'expecco_18_1_0' asVersionNumberCollection.

literalArrayEncoding

encode myself as an array literal, from which a copy of the receiver
can be reconstructed with #decodeAsLiteralArray.

scanf: dataStreamOrString
( an extension from the stx:libbasic2 package )

Return a Collection of objects found in the Character Stream
<dataStream> as interpreted according to the receiver.
The receiver is assumed to be a conversion control string as
specified in the Unix C-language manual page for scanf(3).
For copyright information, see goodies/String-printf_scanf.chg

Usage example(s):

     '%d %x' scanf:(ReadStream on:'1234 ff00')
     '%d %s' scanf:(ReadStream on:'1234 ff00')
     '%d %b' scanf:(ReadStream on:'1234 1111')
     '%d %f' scanf:(ReadStream on:'1234 1111')
     '%d %f' scanf:(ReadStream on:'1234 1111.2345')
     '%d %q' scanf:(ReadStream on:'1234 1111.2345')

sscanf: string
( an extension from the stx:libbasic2 package )

Return a Collection of objects found in <string> as
interpreted according to the receiver.
The receiver is assumed to be a conversion control string as
specified in the Unix C-language manual page for scanf(3).
For copyright information, see goodies/String-printf_scanf.chg

Usage example(s):

     '%d %x' sscanf:'1234 ff00'     
     '%d 0x%x' sscanf:'1234 0xff00'     
     '%d %x %b' sscanf:'1234 ff00 1001'

string

return the receiver without any emphasis information
i.e. the underlying string. Thats what I am.

copying

, aStringOrCharacterOrAnyOther

redefined to allow characters and mixed strings to be appended.
This is nonStandard, but convenient

Usage example(s):

     'hello' , $1
     'hello' , (Character codePoint:1046)
     'hello' , '1'
     'hello' , 4711
     'hello' , (' world' asText allBold)
     'hello' , (JISEncodedString fromString:' world')
     (JISEncodedString fromString:'hello') , ' world'

     Transcript showCR:
         (Text string:'hello' emphasis:#italic) , (Text string:' world' emphasis:#bold)

     'hello',123,'world'
     'hello' allBold,123,'world'
     'hello',123,'world' allBold

,, aString

concatenate with a newLine in between

Usage example(s):

     'hello' ,, 'world'

chopTo: maxLen

if the receiver's size is less or equal to maxLen, return it.
Otherwise, return a copy of the receiver, where some characters
in the middle have been removed for a total string length
of maxLen.
See also contractAtBeginningTo:, contractAtEndTo: and contractTo:.
This is similar to contractTo:, but removes the characters,
whereas contractTo: replaces them by '...'

Usage example(s):

     '12345678901234'   chopTo:15    
     '123456789012345'  chopTo:15    
     '1234567890123456' chopTo:15    
     'aShortString' chopTo:15
     'aVeryLongNameForAStringThatShouldBeShortened' chopTo:15

contractAtBeginningTo: maxLen

if the receiver's size is less or equal to maxLen, return it.
Otherwise, return a copy of the receiver, where some characters
at the beginning have been replaced by '...' for a total string length
of maxLen.
Can be used to abbreviate long entries in tables.
See also contractAtEndTo:, contractTo: and chopTo:

Usage example(s):

     '12345678901234' contractAtBeginningTo:15
     '123456789012345' contractAtBeginningTo:15
     '1234567890123456' contractAtBeginningTo:15
     'aShortString' contractAtBeginningTo:15
     'aVeryLongNameForAStringThatShouldBeShortened' contractAtBeginningTo:15

contractAtEndTo: maxLen

if the receiver's size is less or equal to maxLen, return it.
Otherwise, return a copy of the receiver, where some characters
at the end have been replaced by '...' for a total string length
of maxLen.
Can be used to abbreviate long entries in tables.
See also contractAtBeginningTo:, contractTo: and chopTo:

Usage example(s):

     '12345678901234' contractAtEndTo:15
     '123456789012345' contractAtEndTo:15
     '1234567890123456' contractAtEndTo:15
     'aShortString' contractAtEndTo:15
     'aVeryLongNameForAStringThatShouldBeShortened' contractAtEndTo:15

contractLeftTo: maxLen

if the receiver's size is less or equal to maxLen, return it.
Otherwise, return a copy of the receiver, where some characters
near the first quarter have been replaced by '...' for a total string length
of maxLen.
Very similar to contractTo:, but better to abbreviate long filename entries,
where the right part is of more interest than the left.
See also contractAtBeginningTo:, contractAtEndTo:, contractTo: and chopTo:

Usage example(s):

     '12345678901234' contractLeftTo:15
     '123456789012345' contractLeftTo:15
     '1234567890123456' contractLeftTo:15
     'aShortString' contractLeftTo:15
     'aVeryLongNameForAStringThatShouldBeShortened' contractLeftTo:15
     'C:\Dokumente und Einstellungen\cg\work\bosch\dapas\hw_schnittstellen\DAPAS__HpibDLL.st' contractLeftTo:40

contractTo: maxLen

if the receiver's size is less or equal to maxLen, return it.
Otherwise, return a copy of the receiver, where some characters
in the middle have been replaced by '...' for a total string length
of maxLen.
Can be used to abbreviate long entries in tables.
See also contractAtBeginningTo:, contractAtEndTo: and chopTo:.
(This is similar to chopTo:, but replaces by '...',
whereas chopTo: removes characters)

Usage example(s):

     '12345678901234' contractTo:15
     '123456789012345' contractTo:15
     '1234567890123456' contractTo:15
     '12345678901234567' contractTo:15
     '123456789012345678' contractTo:15
     'aShortString' contractTo:15
     'aVeryLongNameForAStringThatShouldBeShortened' contractTo:15
     'C:\Dokumente und Einstellungen\cg\work\bosch\dapas\hw_schnittstellen\DAPAS__HpibDLL.st' contractTo:40
     ('1234567890123456789012345678901234567' contractTo:30) size
     ('1234567890123456789012345678901234567' contractTo:29) size

copyBetween: string1 and: string2 caseSensitive: caseSensitive

return the substring between two matching sub-strings.
Returns nil, if not both subStrings are present in the receiver.

Usage example(s):

     'hello funny world' copyBetween:'hello' and:'world' caseSensitive:true -> ' funny '
     'helloworld' copyBetween:'hello' and:'world' caseSensitive:true -> ''
     'helloorld' copyBetween:'hello' and:'world' caseSensitive:true -> nil

     'hello funny World' copyBetween:'hello' and:'world' caseSensitive:true -> nil
     'helloWorld' copyBetween:'hello' and:'world' caseSensitive:true -> nil

     'hello funny World' copyBetween:'hello' and:'world' caseSensitive:false -> ' funny '
     'helloWorld' copyBetween:'hello' and:'world' caseSensitive:false -> ''
     'bla { foo }' copyBetween:'{' and:'}' caseSensitive:true -> ' foo '

copyReplaceAll: oldElement with: newElement

return a copy of the receiver as a string, where all elements equal to oldElement
have been replaced by newElement.

copyReplaceString: subString withString: newString

return a copy of the receiver, with all sequences of subString replaced
by newString (i.e. slice in the newString in place of the oldString).

Usage example(s):

     '12345678901234567890' copyReplaceString:'123' withString:'OneTwoThree'
     '12345678901234567890' copyReplaceString:'123' withString:'*'
     '12345678901234567890' copyReplaceString:'234' withString:'foo'
     '12345678901234567890' asUnicode16String copyReplaceString:'234' asUnicode16String withString:'foo'
     '12345678901234567890' asUnicode16String copyReplaceString:'234' withString:'foo'
     '12345678901234567890' asUnicode16String copyReplaceString:'234' withString:'foo' asUnicode16String
     'ĀĂĄĆĈ' allBold copyReplaceString:'ĆĈ' withString:'foo'

     ('a string with spaces' copyReplaceAll:$  withAll:' foo ')
        copyReplaceString:'foo' withString:'bar'

copyWith: aCharacter

return a new string containing the receiver's characters
and the single new character, aCharacter.
This is different from concatentation, which expects another string
as argument, but equivalent to copy-and-addLast.
The code below cares for different width characters
(i.e. when appending a 16bit char to an 8bit string)

Usage example(s):

        'Hello World ' copyWith:$Ĉ  
        'Hello World ' allBold copyWith:$Ĉ.

restAfter: keyword withoutSeparators: strip

compare the left part of the receiver with keyword,
if it matches return the right rest.
Finally, if strip is true, remove whiteSpace.
If the string does not start with keyword, return nil.

This method is used to match and extract lines of the form:
something: rest
where we are interested in rest, but only if the receiver string
begins with something.

You may wonder why such a specialized method exists here
- this is so common when processing mailboxes,
rcs files, nntp/pop3 responses, that is was considered worth
a special method here to avoid having the code below a hundred
times in variuos places.

Usage example(s):

     'foo: hello world' restAfter:'foo:' withoutSeparators:true
     'funny: something' restAfter:'foo:' withoutSeparators:true

     'foo:     hello world    ' restAfter:'foo:' withoutSeparators:true
     'foo:     hello world    ' restAfter:'foo:' withoutSeparators:false

splitAtString: subString withoutSeparators: stripBoolean

If the receiver is of the form:
<left><subString><right>
return a collection containing left and right only.
If strip is true, remove whiteSpace in the returned substrings.

Usage example(s):

     'hello -> world' splitAtString:'->' withoutSeparators:false
     'hello -> world' splitAtString:'->' withoutSeparators:true
     'hello -> ' splitAtString:'->' withoutSeparators:true
     'hello > error' splitAtString:'->' withoutSeparators:true

wrapForSize: maxLength

similar to splitForSize, but tries to keep words unsplitted.
Useful to wrap long lines eg. when presenting them in a warnbox.
Individual pieces may be smaller.
This is a somewhat q&d naive implementation, which may need more fine tuning

Usage example(s):

     'hello world123 this is a long line wrapped for size 10' wrapForSize:10 
     'hello world123 this is a long line wrapped for size 20' wrapForSize:20 
     'helloworld123 this is a long line wrapped for size 10' wrapForSize:10 
     'hello world123. This is a long line, wrapped for size 10' wrapForSize:10 
     'hello world123. This is a long line, wrapped for size 20' wrapForSize:20

displaying

displayOn: aGC x: x y: y from: start to: stop: display the receiver on a GC
displayOn: aGC x: x y: y from: start to: stop opaque: opaque: display the receiver on a GC
displayOn: aGc x: x y: y opaque: opaque: display the receiver in a graphicsContext - this method allows
strings to be used like DisplayObjects.
displayOpaqueOn: aGC x: x y: y from: start to: stop: display the receiver on a GC

emphasis

actionForAll: aBlock

change the action block of all characters.
Some widgets use this like a href if clicked onto the text.

allBold

return a text object representing the receiver, but all boldified

Usage example(s):

     Transcript showCR:'hello' asText allBold
     Transcript showCR:'hello' allBold

allGray

return a text object representing the receiver, but in gray color.
This is used so often, that it's worth a utility here

Usage example(s):

     Transcript showCR:'hello' asText allBold allGray
     Transcript showCR:'hello' allBold allGray
     Transcript showCR:'hello' allGray

allItalic

return a text object representing the receiver, but all in italic

Usage example(s):

     Transcript showCR:'hello' asText allItalic
     Transcript showCR:'hello' allItalic

allNonBold

make all characters non-bold;
I already have no emphasis, so the receiver string is returned

allRed

return a text object representing the receiver, but in red color.
This is used so often, that it's worth a utility here

Usage example(s):

     Transcript showCR:'hello' asText allBold allRed
     Transcript showCR:'hello' allBold allRed
     Transcript showCR:'hello' allRed

allStrikedOut

return a text object representing the receiver, but all in strikeout

Usage example(s):

     Transcript showCR:'hello' asText allStrikedOut
     Transcript showCR:'hello' allStrikedOut

allUnderlined

return a text object representing the receiver, but all with underline

Usage example(s):

     Transcript showCR:'hello' asText allUnderlined
     Transcript showCR:'hello' allUnderlined

asActionLinkTo: aBlock

change the action block of all characters and colorize as a link.
Some widgets use this like a href if clicked onto the text
(for example, the system-browser's info at the bottom is such a widget).

Usage example(s):

     (Label new)
        label:('This is a link: ', ('browse' asActionLinkTo:[SystemBrowser default open]));
        width:300;
        open

asActionLinkTo: aBlock info: tooltipMessage

change the action block of all characters and colorize as a link.
Some widgets use this like a href if clicked onto the text
(for example, the system-browser's info at the bottom is such a widget).
Caveat: currently the tooltipMessage is ignored (there is no mechanism for that, yet)

Usage example(s):

     (Label new)
        label:('This is a link: ', ('browse' asActionLinkTo:[SystemBrowser default open] info:'Open the browser'));
        width:300;
        open

asActionLinkToOpenWebBrowser

change the action block of all characters and colorize as a link,
to open a web page on the URL represented by the text

Usage example(s):

     (Label new)
        label:('This is a link: ', 'http://www.exept.de' asActionLinkToOpenWebBrowser);
        width:300;
        open

     (Label new)
        label:('click to open exept' asActionLinkToOpenWebBrowserOn:'http://www.exept.de');
        width:300;
        open

asActionLinkToOpenWebBrowserOn: aURL

change the action block of all characters and colorize as a link,
to open a web page on aURL

Usage example(s):

     (Label new)
        label:('This is a link: ', 'www.exept.de' asActionLinkToOpenWebBrowser);
        width:300;
        open

     (Label new)
        label:('click to open exept' asActionLinkToOpenWebBrowserOn:'www.exept.de');
        width:300;
        open

colorizeAllWith: aColor

return a text object representing the receiver, but all colorized

Usage example(s):

     Transcript showCR:('hello' colorizeAllWith:Color red)
     Transcript showCR:('world' colorizeAllWith:Color green darkened)

colorizeAllWith: fgColor on: bgColor

return a text object representing the receiver, but all colorized with
both fg and background color

Usage example(s):

     Transcript showCR:('hello' colorizeAllWith:Color red on:Color yellow)
     Transcript showCR:('world' colorizeAllWith:Color red)

emphasis

return the emphasis.
Since characterArrays do not hold any emphasis information,
nil (no emphasis) is returned here.

emphasis: emphasisCollection

Transcript showCR:('hello' emphasis:#(bold bold bold bold bold))

emphasisAt: characterIndex

return the emphasis at some index.
Since characterArrays do not hold any emphasis information,
nil (no emphasis) is returned here.

emphasisAtX: xOffset on: aGC

return the emphasis at a given x offset, or nil if there is none

emphasisCollection

return the emphasis.
Since characterArrays do not hold any emphasis information,
nil (no emphasis) is returned here.

emphasiseFrom: start to: stop with: newEmphasis

same as emphasizeFrom:to:with:

Usage example(s):

     'hello' emphasizeFrom:2 with:#italic

     Transcript showCR:('hello' emphasizeFrom:2 with:#italic)

     (Text string:'hello') allBold 
        emphasiseFrom:2 to:4 with:#italic

emphasizeAllWith: emphasis

return a text object representing the receiver,
but all emphasized with emphasis

Usage example(s):

     Transcript showCR:('hello' emphasizeAllWith:#bold)
     Transcript showCR:('hello' emphasizeAllWith:(#color -> Color red))
     Transcript showCR:('hello' emphasizeAllWith:(#color -> Color red))

emphasizeFrom: startIndex count: count with: emphasis

Return a text object with its emphasis
set in a range of characters, given startIndex and count.

Usage example(s):

     'hello world' 
        emphasizeFrom:1 count:5 with:#bold

     (Text string:'hello world') 
        emphasizeFrom:1 count:5 with:#bold;
        emphasizeFrom:7 count:5 with:#italic

emphasizeFrom: startIndex to: stopIndex with: newEmphasis

return a text object with its emphasis
set to newEmphasis within some range.

Usage example(s):

     'hello' emphasizeFrom:3 with:#bold

     Transcript showCR:('hello' emphasizeFrom:2 with:#italic)

emphasizeFrom: startIndex with: newEmphasis

return a text object with its emphasis
set to newEmphasis from startIndex to the end

Usage example(s):

     'hello' emphasizeFrom:2 with:#bold

     Transcript showCR:('hello' emphasizeFrom:2 with:#bold)

emphasizeTo: endIndex with: newEmphasis

return a text object with its emphasis
set to newEmphasis from the beginning to endIndex

Usage example(s):

     'hello' emphasizeTo:3 with:#bold

     Transcript showCR:('hello' emphasizeTo:3 with:#bold)

makeSelectorBoldIn: aClass

the receiver represents some source code for a method in aClass.
Change myself to boldify the selector.
Not yet implemented (could easily use the syntaxHighlighter for this ...).
For protocol compatibility with other smalltalks

withBackgroundColor: aColorOrColorSymbol

return a text object representing the receiver, but with all background colorized.
Usage of a colorSymbol is considered bad style (provided for backward compatibility);
please change to pass a proper color
(makes it easier to find color uses)

Usage example(s):

     Transcript showCR:('hello' withBackgroundColor:#red)
     Transcript showCR:('world' withColor:#red)
     Transcript showCR:('hello' withBackgroundColor:Color red)
     Transcript showCR:('world' withColor:Color green darkened)

withColor: aColorOrColorSymbol

return a text object representing the receiver, but all colorized.
Usage of a colorSymbol is considered bad style (provided for backward compatibility);
please change to pass a proper color
(makes it easier to find color uses)

Usage example(s):

     Transcript showCR:('hello' withColor:#red)
     Transcript showCR:('world' withColor:#blue)
     Transcript showCR:('hello' withColor:Color red)
     Transcript showCR:('world' withColor:Color green darkened)
     ('world' withColor:Color green darkened) withColor:nil

withColor: foregroundColorOrColorSymbol on: backgroundColorOrColorSymbol

return a text object representing the receiver, but all colorized with both fg and bg.
Usage of a colorSymbol is considered bad style (provided for backward compatibility);
please change to pass a proper color
(makes it easier to find color uses)

Usage example(s):

     Transcript showCR:('hello' withColor:#red on:#blue)
     Transcript showCR:('hello' withColor:Color red on:Color blue)

withoutAnyColorEmphasis