String.cc

Go to the documentation of this file.

/*
 * String.cc
 *
 * Smalltalk like class library for C++
 * Textual string.
 *
 * Copyright (c) 2003-6 Milan Cermak
 */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <stdio.h>
#include <string.h>
#include <stdarg.h>

#include <stlib/String.h>
#include <stlib/Array.h>
#include <stlib/ByteArray.h>
#include <stlib/ByteString.h>
#include <stlib/Character.h>
#include <stlib/CharacterArray.h>
#include <stlib/EncodedStream.h>
#include <stlib/InternalEncodedStreamFactory.h>
#include <stlib/Number.h>
#include <stlib/OrderedCollection.h>
#include <stlib/Stream.h>
#include <stlib/TwoByteString.h>
#include <stlib/Visitor.h>
#include <stlib/WriteStream.h>
#include <stlib/SOOBoundsError.h>

String::String(long size)
{
    if (size < 0) {
        fprintf(stderr, "Warning: Constructing String with negative size. Creating empty.\n");
        size = 0;
    }
    implementor = new ByteString(size);
}

String::String(const char *str)
{
    if (str == NULL) {
        fprintf(stderr, "Warning: Constructing String from NULL argument. Creating empty.\n");
        implementor = new ByteString(0);
    } else {
        int length = strlen(str);
        implementor = new ByteString(length);
        for (int i = 0; i < length; i++) {
            if (str[i] < 0) {
                (new Error(new String("Illegal character. 7-bit only accepted."),
                           new String(__PRETTY_FUNCTION__)))->raise();
            }
            implementor->put(i, Character::value((unsigned char) str[i]));
        }
    }
}

String::String(const ByteArray *byteArray)
{
    long length = byteArray->size();
    const unsigned char *ba = byteArray->rawBytesReadOnly();
    implementor = new ByteString(length);
    for (long i = 0; i < length; i++) {
        implementor->put(i, Character::value(ba[i]));
    }
}

String::~String(void)
{
    delete implementor;
}

/* Copying protocol */
String::String(const String &origin)
{
    long tally = origin.size();
    implementor = new ByteString(tally);
    for (long i = 0; i < tally; i++) {
                put(i, dynamic_cast<Character *>(origin.at(i)));
    }
}

/* Class-accessing protocol */
String *String::className(void) const
{
    return new String("String");
}

/* Class-instance creation protocol */
String *String::with(Character *object)
{
    String *newString = new String(1);
    newString->put(0, object);
    return newString;
}

String *String::with(Character *obj1, Character *obj2)
{
    String *newString = new String(2);
    newString->put(0, obj1);
    newString->put(1, obj2);
    return newString;
}

String *String::with(Character *obj1, Character *obj2, Character *obj3)
{
    String *newString = new String(3);
    newString->put(0, obj1);
    newString->put(1, obj2);
    newString->put(2, obj3);
    return newString;
}

String *String::with(Character *obj1, Character *obj2, Character *obj3, Character *obj4)
{
    String *newString = new String(4);
    newString->put(0, obj1);
    newString->put(1, obj2);
    newString->put(2, obj3);
    newString->put(3, obj4);
    return newString;
}

String *String::withAll(Collection *coll)
{
    String *newString = new String(coll->size());
    int index = 0;
    for (Iterator *i = coll->iterator(); !i->finished(); i->next()) {
        newString->put(index++, i->value());
    }
    return newString;
}

/* Accessing protocol */
Object *String::at(int index) const
{
    if (index < 0 || index >= size())
        (new SubscriptOutOfBoundsError(__PRETTY_FUNCTION__, index))->raiseFrom(this);
    return implementor->at(index);
}

void String::put(int index, Object *obj)
{
    if (obj == nil || !obj->isCharacter()) {
        error(new String("String stores only Characters."),
              new String(__PRETTY_FUNCTION__), obj);
    }
    if (index < 0 || index >= size())
        (new SubscriptOutOfBoundsError(__PRETTY_FUNCTION__, index))->raiseFrom(this);

    Character *chr = dynamic_cast<Character *>(obj);

    if (chr->byteSize() > implementor->byteSize()) {
        changeWideToFit(chr->byteSize());
    }

    implementor->put(index, chr);
}

void String::put(int index, char obj)
{
    put(index, Character::value(obj));
}

long String::size(void) const
{
    return implementor->size();
}

long String::indexOf(const char obj) const
{
    return SequenceableCollection::indexOf(Character::value(obj));
}

long String::lastIndexOf(const char obj) const
{
    return SequenceableCollection::lastIndexOf(Character::value(obj));
}

long String::nextIndexOf(const char element, long startIndex, long stopIndex) const
{
    return SequenceableCollection::nextIndexOf(Character::value(element),
                                               startIndex, stopIndex);
}

long String::prevIndexOf(const char element, long startIndex, long stopIndex) const
{
    return SequenceableCollection::prevIndexOf(Character::value(element),
                                               startIndex, stopIndex);
}

/* Adding protocol */
void String::add(Object *)
{
    shouldNotImplement(new String(__PRETTY_FUNCTION__));
}

void String::changeSize(long newSize)
{
    if (newSize < 0) {
        fprintf(stderr, "Warning: Changing size of String to negative. Making zero instead.\n");
        newSize = 0;
    }
    implementor->changeSize(newSize);
}

/* Comparing protocol */
long String::hash(void) const
{
    long hashConst = 0x12345;
    int length = size();

    if (length > 0) {
        hashConst ^= ((Character *) at(0))->asInteger();
        if (length > 1) {
            hashConst ^= ((Character *) at(length-1))->asInteger();
            if (length > 3) {
                hashConst ^= ((Character *) at(length/2-1))->asInteger()
                             ^ ((Character *) at(length/2+1))->asInteger();
            }
        }
    }
    return hashConst;
}

bool String::isEqual(const Object *object) const
{
/*    long length = size();
    if (object->isString() &&
        length == ((String *) object)->size()) {
        String *charArray = (String *) object;
        for (long i = 0; i < length; i++) {
            if (!at(i)->isEqual(charArray->at(i)))
                return false;
        }
        return true;
    }
    return false;
*/
    if (!object->isString()) return false;
    String *otherOne = (String *) object;
    if (otherOne->size() != this->size()) return false;
    return this->implementor->isEqual(otherOne->implementor);
}

bool String::isEqual(const char *string) const
{
    long i, length = size();
    for (i = 0; i < length && string[i] != 0; i++) {
        if (!((Character *) at(i))->isEqual(string[i]))
            return false;
    }
    if (i < length || string[i] != 0) return false;
    return true;
}

bool String::match(String *str)
{
    return match(str, true);
}

bool String::match(const char *string)
{
    return match(new String(string), true);
}

bool String::match(String *str, bool ignoreCase)
{
    return str->matchesPattern(this, ignoreCase);
}

bool String::match(const char *str, bool ignoreCase)
{
    return (new String(str))->matchesPattern(this, ignoreCase);
}

bool String::matchesPattern(String *pattern, bool ignoreCase)
{
    long stringSize, stringIndex, stringStartScan;
    long patternSize, patternIndex, patternStartScan;

    stringSize = size();
    stringIndex = 0;
    patternSize = pattern->size();
    patternIndex = 0;
    stringStartScan = -1;
    patternStartScan = 0;

    while (patternIndex < patternSize) {
        Character *p = (Character *) pattern->at(patternIndex);
        patternIndex++;
        if (p->isEqual('*')) {
            /* We found a successful match after the last *, if any. */
            if (patternIndex >= patternSize)
                return true;
            stringStartScan = stringIndex;
            patternStartScan = patternIndex;
        } else {
            if (stringIndex >= stringSize)
                return false;
            Character *t = (Character *) at(stringIndex);
            stringIndex++;
            if (t->isEqual(p) || p->isEqual('#') ||
                (ignoreCase && t->asUppercase()->isEqual(p->asUppercase()))) {
                if (patternIndex >= patternSize && stringIndex < stringSize) {
                    if (stringStartScan < 0)
                        return false;
                    stringIndex = stringIndex + patternStartScan - patternIndex + 1;
                    patternIndex = patternStartScan;
                }
            } else {
                if (stringStartScan < 0)
                    return false;
                stringIndex = stringIndex + patternStartScan - patternIndex + 1;
                patternIndex = patternStartScan;
            }
        }
    }

    if (stringIndex < stringSize)
        return false;
    return true;
}

/* Converting protocol */
char *String::asCString(void) const
{
    Stream *stream = (new ByteArray(size()))->withEncoding("default")->writeStream();
    for (int i = 0; i < size(); i++) {
        try {
            stream->nextPut(at(i));
        }
        catch (Error *ex) {
            stream->nextPut('?');
        }
    }
    return dynamic_cast<ByteArray *>(stream->contents())->asCString();
}

String* String::format(const char* format, ...)
{
    String *result;
    va_list ap;

    va_start(ap, format);
    result = formatArgumentsIntoString(format, ap);
    va_end(ap);

    return result;
}

String* String::format(const String* format, ...)
{
    String *result;
    va_list ap;

    va_start(ap, format);
    result = formatArgumentsIntoString(format->asCString(), ap);
    va_end(ap);
    return result;
}

String::operator char*(void) const
{
    return asCString();
}

Array *String::asArrayOfSubstrings(void)
{
    return asArrayOfSubstringsSeparatedBy(Character::space());
}

Array *String::asArrayOfSubstringsSeparatedBy(Character *ch)
{
    OrderedCollection *answer = new OrderedCollection;
    long startIndex = 0, stopIndex;
    long length = size();

    while (startIndex < length) {
        while (startIndex < length && at(startIndex) == ch) {
            startIndex++;
        }
        stopIndex = startIndex;
        while (stopIndex < length && at(stopIndex) != ch) {
            stopIndex++;
        }
        if (stopIndex > startIndex) {
            answer->add(copy(startIndex, stopIndex));
            startIndex = stopIndex;
        }
    }
    return answer->asArray();
}

Array *String::asArrayOfSubstringsSeparatedBy(const char ch)
{
    return asArrayOfSubstringsSeparatedBy(Character::value(ch));
}

ByteArray *String::asByteArray(void) const
{
    return asByteArrayEncoding("default");
}

ByteArray *String::asByteArrayEncoding(String *encoding) const
{
    return ByteArray::fromStringEncoding(this, encoding);
}

ByteArray *String::asByteArrayEncoding(const char *encoding) const
{
    return asByteArrayEncoding(new String(encoding));
}

String *String::asLowercase(void)
{
    long length = size();
    String *newString = (String *) copyEmpty(length);
    for (long i = 0; i < length; i++) {
        newString->put(i, ((Character *) at(i))->asLowercase());
    }
    return newString;
}

Number *String::asNumber(void)
{
    return Number::fromString(this);
}

Number *String::asNumberRadix(int radix)
{
    return Number::fromStringRadix(this, radix);
}

String *String::asUppercase(void)
{
    long length = size();
    String *newString = (String *) copyEmpty(length);
    for (long i = 0; i < length; i++) {
        newString->put(i, ((Character *) at(i))->asUppercase());
    }
    return newString;
}

String *String::asUppercaseFirst(void)
{
    long length = size();
    if (length <= 0) return this;
    String *newString = (String *) copyEmpty(length);
    newString->put(0, ((Character *) at(0))->asUppercase());
    for (long i = 1; i < length; i++) {
        newString->put(i, ((Character *) at(i))->asLowercase());
    }
    return newString;
}

String *String::asString(void)
{
    return this;
}

/* Copying protocol */
Object *String::copy(void)
{
    return new String(*this);
}

Object *String::copyEmpty(long size)
{
    return new String(size);
}

SequenceableCollection &String::operator+(SequenceableCollection &collection)
{
    return *copyReplace(size(), size(), &collection);
}

String &String::operator+(const char *string)
{
    return *concatenateWith(string);
}

String *String::concatenateWith(String *string)
{
    return (String *) copyReplace(size(), size(), string);
}

String *String::concatenateWith(const char *string)
{
    return concatenateWith(new String(string));
}

/* Printing protocol */
void String::printOn(Stream *stream) const
{
    stream->nextPut('\"');
    stream->nextPutAll(this);
    stream->nextPut('\"');
}

/* Testing protocol */
bool String::includes(const char element)
{
    return includes(Character::value(element));
}

bool String::isString(void) const
{
    return true;
}

bool String::isDigitString(void)
{
    long length = size();
    for (long i = 0; i < length; i++) {
        if (!((Character *) at(i))->isDigit())
            return false;
    }
    return true;
}

bool String::startsWith(const char *str) const
{
    return startsWith(new String(str));
}

bool String::endsWith(const char *str) const
{
    return endsWith(new String(str));
}

bool String::isByteString(void) const
{
    return implementor->isByteString();
}

bool String::isTwoByteString(void) const
{
    return implementor->isTwoByteString();
}

bool String::isCharacterArray(void) const
{
    return implementor->isCharacterArray();
}

/* Utilities protocol */
String *String::trimBlanks(void)
{
    String *separators = new String(" \t\n\r");
    long index = 0, length = size();

    if (length == 0) return this;
    while (index < length && separators->includes(this->at(index)))
        index++;
    while (index < length && separators->includes(this->at(length-1)))
        length--;
    if (index == length) return new String;
    if (index == 0 && length == size()) return this;
    return dynamic_cast<String *>(copy(index, length));
}

String *String::demangleMethodName(void)
{
#if __GNUC_PREREQ(3,0)
    Stream *stream = (new String(size()))->writeStream();
    long segmentLength = 3, segmentStart = 0;
    String *buffer = this;
    String *segment;

    /* Skip prefix */
    while (!dynamic_cast<Character *>(buffer->at(segmentStart + segmentLength))->isDigit()) {
        segmentLength++;
    }

    while (dynamic_cast<Character *>(buffer->at(segmentStart + segmentLength))->isDigit()) {
        if (buffer != this) stream->nextPutAll("::");
        buffer = dynamic_cast<String *>(buffer->copy(segmentLength + segmentStart, buffer->size()));
        segmentStart = 0;
        segmentLength = buffer->asNumber()->asLong();
        while (dynamic_cast<Character *>(buffer->at(segmentStart))->isDigit())
            segmentStart++;
        segment = dynamic_cast<String *>(buffer->copy(segmentStart, segmentStart + segmentLength));
        stream->nextPutAll(segment);
        if (buffer->at(segmentStart + segmentLength)->isEqual(Character::value('D'))) {
            stream->nextPutAll("::~");
            stream->nextPutAll(segment);
        }
    }
    if (buffer == this) {
        /* Can't demangle */
        return this;
    }
    stream->nextPutAll("()");

    return dynamic_cast<String *>(stream->contents());
#else
    /* Don't know how to demangle */
    return this;
#endif
}

/* Visiting protocol */
void String::visitBy(Visitor *visitor)
{
    visitor->visitString(this);
}

/* Private protocol */
String *String::formatArgumentsIntoString(const char *format, va_list args)
{
    char buf[1025];

    vsnprintf(buf, 1024, format, args);
    return (new ByteArray(buf, strlen(buf)))->asString();
}

void String::changeWideToFit(int width)
{
    switch (width) {
    case 1 :
        implementor = implementor->asByteString();
        break;
    case 2 :
        implementor = implementor->asTwoByteString();
        break;
    case 4 :
        implementor = implementor->asCharacterArray();
        break;
    }
}

---