OrderedCollection.cc

Go to the documentation of this file.

/*
 * OrderedCollection.cc
 *
 * Smalltalk like class library for C++
 * Variable size collection, index-accessable.
 *
 * 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/OrderedCollection.h>
#include <stlib/Array.h>
#include <stlib/CollectionIterator.h>
#include <stlib/String.h>

OrderedCollection::OrderedCollection(int size)
{
    content = new Array(size);
    firstIndex = 0;
    lastIndex = -1;
}

OrderedCollection::~OrderedCollection(void)
{
    delete content;
}

/* Copying protocol */
OrderedCollection::OrderedCollection(const OrderedCollection &origin)
{
    firstIndex = origin.firstIndex;
    lastIndex = origin.lastIndex;
    content = (Array *) origin.content->copy();
}

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

/* Class-instance creation protocol */
OrderedCollection *OrderedCollection::with(Object *object)
{
    OrderedCollection *coll = new OrderedCollection(1);
    coll->add(object);
    return coll;
}

OrderedCollection *OrderedCollection::with(Object *obj1, Object *obj2)
{
    OrderedCollection *coll = new OrderedCollection(2);
    coll->add(obj1);
    coll->add(obj2);
    return coll;
}

OrderedCollection *OrderedCollection::with(Object *obj1, Object *obj2, Object *obj3)
{
    OrderedCollection *coll = new OrderedCollection(3);
    coll->add(obj1);
    coll->add(obj2);
    coll->add(obj3);
    return coll;
}

OrderedCollection *OrderedCollection::with(Object *obj1, Object *obj2, Object *obj3, Object *obj4)
{
    OrderedCollection *coll = new OrderedCollection(4);
    coll->add(obj1);
    coll->add(obj2);
    coll->add(obj3);
    coll->add(obj4);
    return coll;
}

OrderedCollection *OrderedCollection::withAll(Collection *coll)
{
    OrderedCollection *newColl = new OrderedCollection(coll->size());
    for (Iterator *i = coll->iterator(); !i->finished(); i->next()) {
        newColl->add(i->value());
    }
    return newColl;
}

/* Accessing protocol */
Object *OrderedCollection::at(int index) const
{
    if (index < 0 || index + firstIndex > lastIndex) {
        SubscriptOutOfBoundsError *ex;
        ex = new SubscriptOutOfBoundsError(__PRETTY_FUNCTION__, index);
        ex->raiseFrom(this);
    }
    return content->at(index + firstIndex);
}

void OrderedCollection::put(int index, Object *obj)
{
    if (index < 0 || index + firstIndex > lastIndex) {
        SubscriptOutOfBoundsError *ex;
        ex = new SubscriptOutOfBoundsError(__PRETTY_FUNCTION__, index);
        ex->raiseFrom(this);
    }
    return content->put(index + firstIndex, obj);
}

long OrderedCollection::capacity(void) const
{
    return content->size();
}

long OrderedCollection::size(void) const
{
    return lastIndex - firstIndex + 1;
}

Object *OrderedCollection::first(void)
{
    emptyCheck();
    return content->at(firstIndex);
}

Object *OrderedCollection::last(void)
{
    emptyCheck();
    return content->at(lastIndex);
}

/* Adding protocol */
void OrderedCollection::add(Object *object)
{
    addLast(object);
}

void OrderedCollection::addFirst(Object *object)
{
    if (firstIndex == 0) makeRoomAtFirst();
    firstIndex--;
    content->put(firstIndex, object);
}

void OrderedCollection::addLast(Object *object)
{
    lastIndex++;
    if (lastIndex == capacity()) makeRoomAtLast();
    content->put(lastIndex, object);
}

void OrderedCollection::changeSize(long newSize)
{
    Array *oldContent = content;
    content = new Array(newSize);
    long length = size();
    content->replace(0, (length < newSize) ? length : newSize, oldContent);
    delete oldContent;
}

/* Converting protocol */
OrderedCollection *OrderedCollection::asOrderedCollection(void)
{
    return this;
}

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

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

/* Removing protocol */
Object *OrderedCollection::remove(Object *object)
{
    for (int i = firstIndex; i <= lastIndex; i++) {
        if (content->at(i)->isEqual(object)) {
            removeIndex(i);
            return object;
        }
    }
    (new NotFoundError(__PRETTY_FUNCTION__, object))->raiseFrom(this);
}

Object *OrderedCollection::removeFirst(void)
{
    Object *firstObject;

    emptyCheck();
    firstObject = content->at(firstIndex);
    content->put(firstIndex, nil);
    firstIndex++;
    return firstObject;
}

Object *OrderedCollection::removeLast(void)
{
    Object *lastObject;

    emptyCheck();
    lastObject = content->at(lastIndex);
    content->put(lastIndex, nil);
    lastIndex--;
    return lastObject;
}

/* protected methods */
/* Enumeration protocol */
Object *OrderedCollection::privNextForIterator(CollectionIterator *iter) const
{
    if (iter->position() + firstIndex > lastIndex) {
        iter->position(capacity());
        return nil;
    }
    return content->at(iter->position() + firstIndex);
}

/* Private protocol */
void OrderedCollection::changeCapacity(int newCapacity)
{
    Array *oldContent;

    oldContent = content;
    content = new Array(newCapacity);
    for (int i = firstIndex; i < lastIndex; i++) {
        content->put(i, oldContent->at(i));
    }
    delete oldContent;
}

void OrderedCollection::grow(void)
{
    increaseCapacity();
}

void OrderedCollection::increaseCapacity(void)
{
    changeCapacity(size() + growSize());
}

void OrderedCollection::makeRoomAtFirst(void)
{
    int delta;

    delta = capacity() - lastIndex - 1;
    if (delta <= 0) {
        /* There is no room left */
        increaseCapacity();
        if (firstIndex == 0) makeRoomAtFirst();
        return;
    }
    for (int i = lastIndex; i >= firstIndex; i--) {
        content->put(i + delta, content->at(i));
    }
    for (int i = firstIndex; i < firstIndex + delta; i++) {
        content->put(i, nil);
    }
    firstIndex += delta;
    lastIndex = capacity() - 1;
}

void OrderedCollection::makeRoomAtLast(void)
{
    int delta;

    delta = -firstIndex;
    if (delta == 0) {
        /* There is no room left */
        increaseCapacity();
        return;
    }
    for (int i = firstIndex; i < lastIndex; i++) {
        content->put(i + delta, content->at(i));
    }
    for (int i = lastIndex + delta; i < lastIndex; i++) {
        content->put(i, nil);
    }
    firstIndex = 0;
    lastIndex += delta;
}

void OrderedCollection::removeIndex(int index)
{
    for (; index < lastIndex; index++) {
        content->put(index, content->at(index+1));
    }
    content->put(lastIndex, nil);
    lastIndex--;
}

---