"

 COPYRIGHT (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.

"

ByteArray subclass:#CharacterArray

       instanceVariableNames:''

       classVariableNames:''

       poolDictionaries:''

       category:'Collections-Text'

!

CharacterArray comment:'

COPYRIGHT (c) 1994 by Claus Gittinger

	      All Rights Reserved

'!

!CharacterArray class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (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.

"

!

version

"

"

!

documentation

"

    CharacterArray is a superclass for all kinds of Strings (i.e.

    (singleByte-)Strings, TwoByteStrings and whatever comes in the future.

    As the name already implies, this class is abstract, meaning that there are

    no instances of it. All this class does is provide common protocol for 

    concrete subclasses.

"

! !

!CharacterArray class methodsFor:'instance creation'!

basicNew

    "return a new empty string"

    ^ self basicNew:0

!

new

    "return a new empty string"

    ^ self basicNew:0

!

fromString:aString

    "return a copy of the argument, aString"

    ^ (self basicNew:(aString size)) replaceFrom:1 with:aString

    "TwoByteString fromString:'hello'"

! !

!CharacterArray methodsFor:'converting'!

asUppercase

    "return a copy of myself in uppercase letters"

    |newStr

     mySize "{ Class: SmallInteger }" |

    mySize := self size.

    newStr := self species new:mySize.

    1 to:mySize do:[:i |

	newStr at:i put:(self at:i) asUppercase

    ].

    ^ newStr

    "

     'helloWorld' asUppercase      

     'helloWorld' asUppercaseFirst 

    "

!

asLowercase

    "return a copy of myself in lowercase letters"

    |newStr

     mySize "{ Class: SmallInteger }" |

    mySize := self size.

    newStr := self species new:mySize.

    1 to:mySize do:[:i |

	newStr at:i put:(self at:i) asLowercase

    ].

    ^ newStr

    "

     'HelloWorld' asLowercase   

     'HelloWorld' asLowercaseFirst   

    "

!

asUppercaseFirst

    "return a copy of myself where the first character is

     converted to uppercase."

    |newString|

    newString := self copy.

    newString size > 0 ifTrue:[

	newString at:1 put:(newString at:1) asUppercase

    ].

    ^ newString

    "

     'helloWorld' asUppercase      

     'helloWorld' asUppercaseFirst 

     'HelloWorld' asUppercaseFirst   

    "

!

asLowercaseFirst

    "return a copy of myself where the first character is

     converted to lowercase."

    |newString|

    newString := self copy.

    newString size > 0 ifTrue:[

	newString at:1 put:(newString at:1) asLowercase

    ].

    ^ newString

    "

     'HelloWorld' asLowercase   

     'HelloWorld' asLowercaseFirst   

    "

!

asString

    "return myself - I am a string"

    ^ self

!

asTwoByteString

    "return the receiver converted to a two-byte string"

    ^ TwoByteString fromString:self

!

asSingleByteString

    "return the receiver converted to a 'normal' string"

    ^ String fromString:self

!

asStringCollection

    "return a collection of lines from myself."

    ^ StringCollection from:self

!

asNumber

    "read a number from the receiver.

     Notice, that errors may occur during the read, so you better

     setup some signal handler when using this method."

    ^ Number readFromString:self

    "

     '123'     asNumber

     '123.567' asNumber

     '(5/6)'   asNumber

     'foo'     asNumber

     Object errorSignal handle:[:ex | ex returnWith:0] do:['foo' asNumber] 

    "

!

asInteger

    "read an integer from the receiver.

     Notice, that errors may occur during the read, so you better

     setup some signal handler when using this method."

    ^ Integer readFromString:self

    "

     '12345678901234567890' asInteger

     '-1234' asInteger

     '0.123' asInteger   <- reader stops at ., returning 0 here

     '0.123' asNumber    <- returns what you expect

     Object errorSignal handle:[:ex | ex returnWith:0] do:['foo' asInteger] 

    "

!

asFloat

    "read a float number from the receiver.

     Notice, that errors may occur during the read, so you better

     setup some signal handler when using this method."

    ^ (Number readFromString:self) asFloat

    "

     '0.123' asFloat 

     '12345' asFloat

     '(1/5)' asFloat

     Object errorSignal handle:[:ex | ex returnWith:0] do:['foo' asFloat] 

    "

!

asFilename

    "return a Filename with pathname taken from the receiver"

    ^ Filename named:self

!

asCollectionOfWords

    "return a collection containing the words (separated by whitespace) 

     of the receiver. Multiple occurences of whitespace characters will

     be treated like one - i.e. whitespace is skipped."

    |words

     start  "{ Class:SmallInteger }" 

     stop   "{ Class:SmallInteger }" 

     mySize "{ Class:SmallInteger }"|

    words := OrderedCollection new.

    start := 1.

    mySize := self size.

    [start <= mySize] whileTrue:[

	start := self indexOfNonSeparatorStartingAt:start.

	start == 0 ifTrue:[

	    ^ words

	].

	stop := self indexOfSeparatorStartingAt:start.

	stop == 0 ifTrue:[

	    words add:(self copyFrom:start to:mySize).

	    ^ words

	].

	words add:(self copyFrom:start to:(stop - 1)).

	start := stop

    ].

    ^ words

    "

     'hello world isnt this nice' asCollectionOfWords

     '    hello    world   isnt   this   nice  ' asCollectionOfWords

     'hello' asCollectionOfWords

     '' asCollectionOfWords

     '      ' asCollectionOfWords

    "

!

asCollectionOfSubstringsSeparatedBy:aCharacter

    "return a collection containing the lines (separated by aCharacter) 

     of the receiver. If aCharacter occurs multiple times in a row, 

     the result will contain empty strings."

    |lines myClass

     numberOfLines "{ Class:SmallInteger }"

     startIndex    "{ Class:SmallInteger }"

     stopIndex     "{ Class:SmallInteger }" |

    "count first, to avoid regrowing"

    numberOfLines := (self occurrencesOf:aCharacter) + 1.

    lines := OrderedCollection new:numberOfLines.

    myClass := self species.

    startIndex := 1.

    1 to:numberOfLines do:[:lineNr |

	stopIndex := self indexOf:aCharacter startingAt:startIndex.

	stopIndex == 0 ifTrue:[

	    stopIndex := self size

	] ifFalse: [

	    stopIndex := stopIndex - 1.

	].

	(stopIndex < startIndex) ifTrue: [

	    lines add:(myClass new:0)

	] ifFalse: [

	    lines add:(self copyFrom:startIndex to:stopIndex)

	].

	startIndex := stopIndex + 2

    ].

    ^ lines

    "

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

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

    "

!

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."

    ^ self asCollectionOfSubstringsSeparatedBy:Character cr

    "

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

     '1 one\\\\2 two\3 three' withCRs asCollectionOfLines  

    "

!

asArrayOfSubstrings

    "return an array of substrings from the receiver, interpreting

     separators (i.e. spaces & newlines) as word-delimiters.

     This is a compatibility method - the actual work is done in

     asCollectionOfWords."

    ^ self asCollectionOfWords asArray

    "

     '1 one two three four 5 five' asArrayOfSubstrings  

    "

!

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."

    |words

     start  "{ Class:SmallInteger }" 

     stop   "{ Class:SmallInteger }" 

     mySize "{ Class:SmallInteger }"|

    words := OrderedCollection new.

    start := 1.

    mySize := self size.

    [start <= mySize] whileTrue:[

	"skip multiple separators"

	[aCollectionOfSeparators includes:(self at:start)] whileTrue:[

	    start := start + 1 .

	    start > mySize ifTrue:[

		^ words

	    ].

	].

	stop := self indexOfAny:aCollectionOfSeparators startingAt:start.

	stop == 0 ifTrue:[

	    words add:(self copyFrom:start to:mySize).

	    ^ words

	].

	words add:(self copyFrom:start to:(stop - 1)).

	start := stop

    ].

    ^ words

    "

     'hello:world:isnt:this nice' asCollectionOfSubstringsSeparatedByAny:#($:)

     'hello:world:isnt:this nice' asCollectionOfSubstringsSeparatedByAny:(Array with:$: with:Character space) 

     'h1e2l3l4o' asCollectionOfSubstringsSeparatedByAny:($1 to: $9) 

    "

!

contractTo:maxLen

    "if the receivers 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."

    |sz halfSize|

    (sz := self size) > maxLen ifTrue:[

	halfSize := maxLen // 2.

	^ self copyReplaceFrom:halfSize - 1

			    to:sz - maxLen + halfSize + 1

			    with:'...'

    ]

    "

     '12345678901234' contractTo:15          

     '123456789012345' contractTo:15          

     '1234567890123456' contractTo:15         

     'aShortString' contractTo:15 

     'aVeryLongNameForAStringThatShouldBeShortened' contractTo:15 

    "

!

contractAtEndTo:maxLen

    "if the receivers 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."

    |sz|

    (sz := self size) > maxLen ifTrue:[

	^ self copyReplaceFrom:maxLen - 3

			    with:'...'

    ]

    "

     '12345678901234' contractAtEndTo:15          

     '123456789012345' contractAtEndTo:15          

     '1234567890123456' contractAtEndTo:15          

     'aShortString' contractAtEndTo:15          

     'aVeryLongNameForAStringThatShouldBeShortened' contractAtEndTo:15 

    "

!

contractAtBeginningTo:maxLen

    "if the receivers 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."

    |sz|

    (sz := self size) > maxLen ifTrue:[

	^ '...' , (self copyFrom:(sz - (maxLen - 4))) 

    ]

    "

     '12345678901234' contractAtBeginningTo:15          

     '123456789012345' contractAtBeginningTo:15          

     '1234567890123456' contractAtBeginningTo:15          

     'aShortString' contractAtBeginningTo:15          

     'aVeryLongNameForAStringThatShouldBeShortened' contractAtBeginningTo:15

    "

! !

!CharacterArray methodsFor:'ST/V compatibility'!

replChar:oldChar with:newChar

    "return a copy of the receiver, with all oldChars replaced

     by newChar.

     This is an ST/V compatibility method."

    ^ self copy replaceAll:oldChar by:newChar

    "

     '12345678901234567890' replChar:$0 with:$* 

    "

!

replChar:oldChar withString:newString

    "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."

    |tmpStream|

    tmpStream := WriteStream on:(self class new).

    self do:[:element |

	element = oldChar ifTrue:[

	    tmpStream nextPutAll:newString

	] ifFalse:[

	    tmpStream nextPut:element 

	].

    ].

    ^ tmpStream contents

   "

     '12345678901234567890' replChar:$0 withString:'foo' 

     'a string with spaces' replChar:$  withString:' foo '  

    "

!

trimBlanks

    "return a copy of the receiver without leading

     and trailing spaces.

     This is an ST/V compatibility method."

    ^ self withoutSpaces

    "

     '    spaces at beginning' trimBlanks     

     'spaces at end    ' trimBlanks           

     '    spaces at beginning and end     ' trimBlanks    

     'no spaces' trimBlanks              

    "

!