SequenceableCollection.cc

Go to the documentation of this file.

/*
 * SequenceableCollection.cc
 *
 * Smalltalk like class library for C++
 * Abstract index-accessible collection.
 *
 * Copyright (c) 2003 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 <stlib/SequenceableCollection.h>

#include <stlib/Array.h>
#include <stlib/ByteArray.h>
#include <stlib/CollectionIterator.h>
#include <stlib/String.h>
#include <stlib/ReadStream.h>
#include <stlib/ReadAppendStream.h>
#include <stlib/WriteStream.h>

/* Accessing protocol */
Object *SequenceableCollection::any(void)
{
    return first();
}

Object *SequenceableCollection::first(void)
{
    emptyCheck();
    return at(0);
}

Object *SequenceableCollection::last(void)
{
    emptyCheck();
    return at(size()-1);
}

void SequenceableCollection::replace(long start, long stop,
                                     const SequenceableCollection *collection)
{
    if (collection->size() != stop - start)
        error(new String("Size of replacement doesn\'t match."),
              new String(__PRETTY_FUNCTION__));
    replace(start, stop, collection, 0);
}

void SequenceableCollection::replace(long start, long stop,
                                     const SequenceableCollection *replacement,
                                     long repStart)
{
    long repOff = repStart - start;
    if (this == replacement && repStart < start) {
        /* Replacement would be overwritten, copy in reverse order. */
        for (long i = stop - 1; i >= start; i--)
            put(i, replacement->at(repOff + i));
    } else {
        for (long i = start; i < stop; i++)
            put(i, replacement->at(repOff + i));
    }
}

void SequenceableCollection::replaceAll(Object *element, Object *replacement)
{
    replaceAll(element, replacement, 0, size());
}

void SequenceableCollection::replaceAll(Object *element, Object *replacement,
                                        long startIndex, long stopIndex)
{
    long index = startIndex - 1;

    while ((index = nextIndexOf(element, index+1, stopIndex)) < stopIndex) {
        put(index, replacement);
    }
}

long SequenceableCollection::indexOf(Object *element) const
{
    long index;

    index = nextIndexOf(element, 0, size());
    if (index < 0 || index >= size()) index = -1;
    return index;
}

long SequenceableCollection::lastIndexOf(Object *element) const
{
    long index;

    index = prevIndexOf(element, size(), 0);
    if (index < 0 || index >= size()) index = -1;
    return index;
}

long SequenceableCollection::nextIndexOf(Object *element, long startIndex,
                                         long stopIndex) const
{
    for (long index = startIndex; index < stopIndex; index++) {
        if (at(index)->isEqual(element))
            return index;
    }
    return stopIndex;
}

long SequenceableCollection::prevIndexOf(Object *element, long startIndex,
                                         long stopIndex) const
{
    for (long index = startIndex - 1; index >= stopIndex; index--) {
        if (at(index)->isEqual(element))
            return index;
    }
    return stopIndex - 1;
}

long SequenceableCollection::indexOfSubCollection(SequenceableCollection *coll) const
{
    return indexOfSubCollection(coll, 0);
}

long SequenceableCollection::indexOfSubCollection(SequenceableCollection *coll,
                                                  long startIndex) const
{
    long subSize = coll->size();
    Object *firstElement;
    long len, matchIndex;

    if (subSize == 0) return -1;
    if (subSize + startIndex > size()) return -1;
    firstElement = coll->at(0);
    len = size() - subSize + 1;
    matchIndex = nextIndexOf(firstElement, startIndex, len);
    if (subSize == 1)
        return (matchIndex >= 0 && matchIndex < len) ? matchIndex : -1;
    while (matchIndex < len) {
        long index = 1;
        while (this->at(matchIndex + index)->isEqual(coll->at(index))) {
            index++;
            if (index == subSize) return matchIndex;
        }
        matchIndex = nextIndexOf(firstElement, matchIndex + 1, len);
    }
    return -1;
}

/* Adding protocol */
void SequenceableCollection::grow(void)
{
    changeSize(size() + growSize());
}

void SequenceableCollection::growToAtLeast(long items)
{
    if (items < size()) return;
    changeSize(items + growSize());
}

/* Converting protocol */
Array *SequenceableCollection::asArray(void)
{
    Array *newArray = new Array(size());
    for (long i = 0; i < size(); i++) {
        newArray->put(i, at(i));
    }
    return newArray;
}

ByteArray *SequenceableCollection::asByteArray(void)
{
    shouldNotImplement(new String(__PRETTY_FUNCTION__));
    return nil;
}

String *SequenceableCollection::asString(void)
{
    shouldNotImplement(new String(__PRETTY_FUNCTION__));
    return nil;
}

ReadStream *SequenceableCollection::readStream(void)
{
    return new ReadStream(this);
}

ReadAppendStream *SequenceableCollection::readAppendStream(void)
{
    return new ReadAppendStream(this);
}

WriteStream *SequenceableCollection::writeStream(void)
{
    return new WriteStream(this);
}

/* Copying protocol */
Object *SequenceableCollection::copy(long from, long to)
{
    SequenceableCollection *newColl;
    int newSize = to - from;

    newColl = (SequenceableCollection *) copyEmpty(newSize);
    newColl->replace(0, newSize, this, from);
    return newColl;
}

SequenceableCollection *SequenceableCollection::copyReplace(long from, long to,
                                                            SequenceableCollection *replacement)
{
    SequenceableCollection *newCollection;
    long newSize;
    long endReplacement;

    newSize = size() - (to - from) + replacement->size();
    endReplacement = from + replacement->size();
    newCollection = (SequenceableCollection *) copyEmpty(newSize);
    newCollection->replace(0, from, this, 0);
    newCollection->replace(from, endReplacement, replacement, 0);
    newCollection->replace(endReplacement, newSize, this, to);
    return newCollection;
}

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

/* Removing protocol */
Object *SequenceableCollection::remove(Object *)
{
    shouldNotImplement(new String(__PRETTY_FUNCTION__));
    return nil;
}

/* Testing protocol */
bool SequenceableCollection::includesSubcollection(SequenceableCollection *coll) const
{
    return indexOfSubCollection(coll) >= 0 || coll->isEmpty();
}

bool SequenceableCollection::isSequenceable(void) const
{
    return true;
}

bool SequenceableCollection::startsWith(SequenceableCollection *coll) const
{
    return indexOfSubCollection(coll) == 0 || coll->isEmpty();
}

bool SequenceableCollection::endsWith(SequenceableCollection *coll) const
{
    int start = size() - coll->size();
    if (start < 0) return false;
    return indexOfSubCollection(coll, start) >= 0 || coll->isEmpty();
}

/* Enumeration protocol */
Object *SequenceableCollection::privNextForIterator(CollectionIterator *iter) const
{
    long index = iter->position();
    for (; index < size(); index += 1) {
        Object *item = at(index);
        if (item != nil) {
            iter->position(index);
            return item;
        }
    }
    iter->position(index);
    return nil;
}

---