[squeak-dev] The Trunk: Collections-ul.610.mcz
commits at source.squeak.org
commits at source.squeak.org
Sun Apr 5 13:05:46 UTC 2015
Levente Uzonyi uploaded a new version of Collections to project The Trunk:
http://source.squeak.org/trunk/Collections-ul.610.mcz
==================== Summary ====================
Name: Collections-ul.610
Author: ul
Time: 5 April 2015, 3:01:45.533 pm
UUID: 66e95716-d97a-425e-b14c-4c8825bdde8d
Ancestors: Collections-cmm.608
- Slightly faster SequenceableCollection >> #copyUpT* (for ByteString receivers).
- SequenceableCollection >> #shuffled belongs to the shuffling category.
- Added FormatCharacterSet to String, which will be used by the new implementation of #format:
- Removed an unused temporary from String >> #expandMacrosWithArguments:
=============== Diff against Collections-cmm.608 ===============
Item was changed:
----- Method: SequenceableCollection>>copyUpThrough: (in category 'copying') -----
copyUpThrough: anElement
"Answer all elements up to and including anObject. If there
is no such object, answer a copy of the receiver."
+ | index |
+ index := self indexOf: anElement.
+ index = 0 ifTrue: [ ^self copy ].
+ ^self first: index!
- ^self first: (self indexOf: anElement ifAbsent: [^ self copy])!
Item was changed:
----- Method: SequenceableCollection>>copyUpTo: (in category 'copying') -----
copyUpTo: anElement
"Answer all elements up to but not including anObject. If there
is no such object, answer a copy of the receiver."
+ | index |
+ index := self indexOf: anElement.
+ index = 0 ifTrue: [ ^self copy ].
+ ^self first: index - 1!
- ^ self first: (self indexOf: anElement ifAbsent: [^ self copy]) - 1!
Item was changed:
----- Method: SequenceableCollection>>copyUpToLast: (in category 'copying') -----
copyUpToLast: anElement
"Answer a copy of the receiver from index 1 to the last occurrence of
anElement, not including anElement."
+ | index |
+ index := self lastIndexOf: anElement.
+ index = 0 ifTrue: [ ^self copy ].
+ ^self first: index - 1!
- ^ self first: (self lastIndexOf: anElement ifAbsent: [^ self copy]) - 1!
Item was changed:
+ ----- Method: SequenceableCollection>>shuffled (in category 'shuffling') -----
- ----- Method: SequenceableCollection>>shuffled (in category 'copying') -----
shuffled
- ^ self shuffledBy: ThreadSafeRandom value
+ ^self shuffledBy: ThreadSafeRandom value
+
"Examples:
($A to: $Z) shuffled
"!
Item was changed:
ArrayedCollection subclass: #String
instanceVariableNames: ''
+ classVariableNames: 'AsciiOrder CSMacroCharacters CaseInsensitiveOrder CaseSensitiveOrder CrLfExchangeTable FormatCharacterSet HtmlEntities LowercasingTable Tokenish UppercasingTable'
- classVariableNames: 'AsciiOrder CSMacroCharacters CaseInsensitiveOrder CaseSensitiveOrder CrLfExchangeTable HtmlEntities LowercasingTable Tokenish UppercasingTable'
poolDictionaries: ''
category: 'Collections-Strings'!
!String commentStamp: '<historical>' prior: 0!
A String is an indexed collection of Characters. Class String provides the abstract super class for ByteString (that represents an array of 8-bit Characters) and WideString (that represents an array of 32-bit characters). In the similar manner of LargeInteger and SmallInteger, those subclasses are chosen accordingly for a string; namely as long as the system can figure out so, the String is used to represent the given string.
Strings support a vast array of useful methods, which can best be learned by browsing and trying out examples as you find them in the code.
Here are a few useful methods to look at...
String match:
String contractTo:
String also inherits many useful methods from its hierarchy, such as
SequenceableCollection ,
SequenceableCollection copyReplaceAll:with:
!
Item was changed:
----- Method: String class>>initialize (in category 'initialization') -----
initialize "self initialize"
| order |
AsciiOrder := (0 to: 255) as: ByteArray.
CaseInsensitiveOrder := AsciiOrder copy.
($a to: $z) do:
[:c | CaseInsensitiveOrder at: c asciiValue + 1
put: (CaseInsensitiveOrder at: c asUppercase asciiValue +1)].
"Case-sensitive compare sorts space, digits, letters, all the rest..."
CaseSensitiveOrder := ByteArray new: 256 withAll: 255.
order := -1.
' 0123456789' do: "0..10"
[:c | CaseSensitiveOrder at: c asciiValue + 1 put: (order := order+1)].
($a to: $z) do: "11-64"
[:c | CaseSensitiveOrder at: c asUppercase asciiValue + 1 put: (order := order+1).
CaseSensitiveOrder at: c asciiValue + 1 put: (order := order+1)].
1 to: CaseSensitiveOrder size do:
[:i | (CaseSensitiveOrder at: i) = 255 ifTrue:
[CaseSensitiveOrder at: i put: (order := order+1)]].
order = 255 ifFalse: [self error: 'order problem'].
"a table for translating to lower case"
LowercasingTable := String withAll: (Character allByteCharacters collect: [:c | c asLowercase]).
"a table for translating to upper case"
UppercasingTable := String withAll: (Character allByteCharacters collect: [:c | c asUppercase]).
"a table for testing tokenish (for fast numArgs)"
Tokenish := String withAll: (Character allByteCharacters collect:
[:c | c tokenish ifTrue: [c] ifFalse: [$~]]).
"% and < for #expandMacros*"
CSMacroCharacters := CharacterSet newFrom: '%<'.
+
+ "{\ used by #format:"
+ FormatCharacterSet := CharacterSet newFrom: '{\'.
"a table for exchanging cr with lf and vica versa"
CrLfExchangeTable := Character allByteCharacters collect: [ :each |
each
caseOf: {
[ Character cr ] -> [ Character lf ].
[ Character lf ] -> [ Character cr ] }
otherwise: [ each ] ]!
Item was changed:
----- Method: String>>expandMacrosWithArguments: (in category 'formatting') -----
expandMacrosWithArguments: anArray
^self class new: self size streamContents: [ :output |
+ | lastIndex nextIndex |
- | lastIndex nextIndex characterSet |
lastIndex := 1.
[ (nextIndex := self indexOfAnyOf: CSMacroCharacters startingAt: lastIndex) = 0 ] whileFalse: [
nextIndex = lastIndex ifFalse: [
output next: nextIndex - lastIndex putAll: self startingAt: lastIndex ].
(self at: nextIndex) == $%
ifTrue: [ output nextPut: (self at: (nextIndex := nextIndex + 1)) ]
ifFalse: [
| nextCharacter argumentIndex |
nextCharacter := (self at: (nextIndex := nextIndex + 1)) asUppercase.
nextCharacter == $N ifTrue: [ output cr ].
nextCharacter == $T ifTrue: [ output tab ].
(nextCharacter between: $0 and: $9) ifTrue: [
argumentIndex := nextCharacter digitValue.
[ (nextIndex := nextIndex + 1) <= self size and: [
(nextCharacter := self at: nextIndex) between: $0 and: $9 ] ] whileTrue: [
argumentIndex := argumentIndex * 10 + nextCharacter digitValue ].
nextCharacter := nextCharacter asUppercase ].
nextCharacter == $P ifTrue: [ output print: (anArray at: argumentIndex) ].
nextCharacter == $S ifTrue: [ output nextPutAll: (anArray at: argumentIndex) ].
nextCharacter == $? ifTrue: [
| trueEnd falseEnd |
trueEnd := self indexOf: $: startingAt: nextIndex + 1.
falseEnd := self indexOf: $> startingAt: trueEnd + 1.
(anArray at: argumentIndex)
ifTrue: [ output next: trueEnd - nextIndex - 1 putAll: self startingAt: nextIndex + 1 ]
ifFalse: [ output next: falseEnd - trueEnd - 1 putAll: self startingAt: trueEnd + 1 ].
nextIndex := falseEnd - 1 ].
(self at: (nextIndex := nextIndex + 1)) == $> ifFalse: [
self error: '> expected' ] ].
lastIndex := nextIndex + 1 ].
lastIndex <= self size ifTrue: [
output next: self size - lastIndex + 1 putAll: self startingAt: lastIndex ] ]!
More information about the Squeak-dev
mailing list
|