"

 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:#AbstractString

       instanceVariableNames:''

       classVariableNames:''

       poolDictionaries:''

       category:'Collections-Text'

!

AbstractString comment:'

COPYRIGHT (c) 1994 by Claus Gittinger

              All Rights Reserved

'!

!AbstractString 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

"

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

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

"

! !

!AbstractString 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'"

! !

!AbstractString 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

!

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

!

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

!

asText

    "return a Text-object (collection of lines) from myself.

     BIG warning: Text is totally misnamed here 

         - ST/X's Text has nothing to do with PP's Text.

         Therefore it will be removed/renamed soon."

    ^ Text from:self

!

asNumber

    "read a number from the receiver"

    ^ Number readFromString:self

!

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"

    |words ch

     start  "{ Class:SmallInteger }" 

     stop   "{ Class:SmallInteger }" 

     mySize "{ Class:SmallInteger }"|

    words := OrderedCollection new.

    start := 1.

    mySize := self size.

    [start <= mySize] whileTrue:[

    ].

    ^ words

!

asCollectionOfLines

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

     of the receiver."

    |lines myClass

     numberOfLines "{ Class:SmallInteger }"

     startIndex    "{ Class:SmallInteger }"

     stopIndex     "{ Class:SmallInteger }" |

    "count first, to avoid regrowing"

    numberOfLines := (self occurrencesOf:Character cr) + 1.

    lines := OrderedCollection new:numberOfLines.

    myClass := self species.

    startIndex := 1.

    1 to:numberOfLines do:[:lineNr |

        stopIndex := self indexOf:(Character cr) 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 asCollectionOfLines

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

    "

! !

!AbstractString methodsFor:'printing & storing'!

article

    "return an article string"

    |firstChar|

    firstChar := (self at:1) asLowercase. 

    (firstChar isVowel or:[firstChar == $x]) ifTrue:[

         ^ 'an'

    ].

    ^ 'a'

!

printOn:aStream

    "print the receiver on aStream"

    aStream nextPutAll:self

!

printString

    "return a string for printing - thats myself"

    ^ self

!

displayString

    "return a string to display the receiver - use storeString to have

     quotes around"

    ^ self storeString

! !

!AbstractString methodsFor:'comparing'!

hash

    "return an integer useful as a hash-key"

%{  /* NOCONTEXT */

    REGISTER int g, val;

    REGISTER unsigned char *cp, *cp0;

    int l;

    cp = _stringVal(self);

    l = _stringSize(self);

    if (_qClass(self) != String) {

        cp += n;

        l -= n;

    }

    /*

     * this is the dragon-book algorithm with a funny start

     * value (to give short strings a number above 8192)

     */

    val = 12345;

    for (cp0 = cp, cp += l - 1; cp >= cp0; cp--) {

        val = (val << 5) + (*cp & 0x1F);

        if (g = (val & 0x3E000000))

            val ^= g >> 25 /* 23 */ /* 25 */;

        val &= 0x3FFFFFFF;

    }

    if (l) {

        l |= 1; 

        val = (val * l) & 0x3FFFFFFF;

    }

    RETURN ( _MKSMALLINT(val) );

%}

!

<= something

    "Compare the receiver with the argument and return true if the

     receiver is less than or equal to the argument. Otherwise return false."

    ^ (self > something) not

!

< something

    "Compare the receiver with the argument and return true if the

     receiver is less than the argument. Otherwise return false."

    ^ (something > self)

!

>= something

    "Compare the receiver with the argument and return true if the

     receiver is greater than or equal to the argument.

     Otherwise return false."

    ^ (something > self) not

!

> aString

    "Compare the receiver with the argument and return true if the

     receiver is greater than the argument. Otherwise return false.

     In contrast to ST-80, case differences are NOT ignored, thus

     'foo' > 'Foo' will return true. 

     This may change."

    mySize := self size.

    otherSize := aString size.

    1 to:(mySize min:otherSize) do:[:index |

        c1 := self at:index.

        c2 := aString at:index.

        c1 > c2 ifTrue:[^ true].

        c1 < c2 ifTrue:[^ false].

    ].

    ^ mySize > otherSize

!

= aString

    "Compare the receiver with the argument and return true if the

    mySize := self size.

    otherSize := aString size.

    mySize == otherSize ifFalse:[^ false].

    1 to:mySize do:[:index |

        (self at:index) = (aString at:index) ifFalse:[^ false].

    ].

    ^ true

!

sameAs:aString

    "Compare the receiver with the argument like =, but ignore

     case differences. Return true or false"

    mySize := self size.

    otherSize := aString size.

    mySize == otherSize ifFalse:[^ false].

    1 to:mySize do:[:index |

    ].

    ^ true

! !