Collection.cc

Go to the documentation of this file.

/*
 * Collection.cc
 *
 * Smalltalk like class library for C++
 * Abstract collection with common functionality.
 *
 * 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/Collection.h>
#include <stlib/CollectionIterator.h>
#include <stlib/Array.h>
#include <stlib/OrderedCollection.h>
#include <stlib/Set.h>
#include <stlib/String.h>
#include <stlib/Stream.h>
#include <stlib/Visitor.h>
#include <stlib/WriteStream.h>

#include <stlib/Error.h>

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

/* Accessing protocol */
long Collection::capacity(void) const
{
    return size();
}

/* Adding protocol */
void Collection::addAll(Collection *otherColl)
{
    Iterator *i;
    for (i = otherColl->iterator(); !i->finished(); i->next()) {
        add(i->value());
    }
}

/* Converting protocol */
Array *Collection::asArray(void)
{
    Array *array;
    Iterator *i;
    int idx;

    array = new Array(size());
    for (idx = 0, i = iterator(); !i->finished(); i->next(), idx++) {
        array->put(idx, i->value());
    }
    delete i;
    return array;
}

OrderedCollection *Collection::asOrderedCollection(void)
{
    OrderedCollection *coll;

    coll = new OrderedCollection(size());
    for (Iterator *i = iterator(); !i->finished(); i->next()) {
        coll->addLast(i->value());
    }
    return coll;
}

Set *Collection::asSet(void)
{
    Set *set;
    Iterator *i;

    set = new Set(size());
    for (i = iterator(); !i->finished(); i->next()) {
        set->add(i->value());
    }
    delete i;
    return set;
}

/* Enumaration protocol */
Iterator *Collection::iterator(void) const
{
    return new CollectionIterator(this);
}

/* Printing protocol */
void Collection::printOn(Stream *stream) const
{
    Iterator *i;
    stream->nextPutAll(className());
    stream->nextPutAll(" (");
    i = iterator();
    while (!i->finished()) {
        if (i->value() == nil) stream->nextPutAll("nil");
                          else i->value()->printOn(stream);
        i->next();
        if (!i->finished()) {
            stream->space();
        }
    }
    stream->nextPut(')');
    delete i;
}

String *Collection::printSeparatedBy(String *separator) const
{
    Stream *stream = (new String(20))->writeStream();
    printSeparatedOn(stream, separator);
    return dynamic_cast<String *>(stream->contents());
}

String *Collection::printSeparatedBy(const char *separator) const
{
    return printSeparatedBy(new String(separator));
}

void Collection::printSeparatedOn(Stream *stream, String *separator) const
{
    bool first = true;
    for (Iterator *i = iterator(); !i->finished(); i->next()) {
        if (!first) stream->nextPutAll(separator);
        i->value()->printOn(stream);
        first = false;
    }
}

void Collection::printSeparatedOn(Stream *stream, const char *separator) const
{
    printSeparatedOn(stream, new String(separator));
}

/* Removing protocol */
void Collection::removeAll(Collection *items)
{
    for (Iterator *i = items->iterator(); !i->finished(); i->next()) {
        remove(i->value());
    }
}

/* Testing protocol */
bool Collection::includes(Object *obj)
{
    Iterator *i;

    for (i = iterator(); !i->finished(); i->next()) {
        if (i->value()->isEqual(obj)) {
            delete i;
            return true;
        }
    }
    delete i;
    return false;
}

bool Collection::isByteArray(void)
{
    return false;
}

bool Collection::isEmpty(void)
{
    return size() == 0;
}

bool Collection::isSequenceable(void) const
{
    return false;
}

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

/* protected methods */
/* Private protocol */
void Collection::emptyCheck(void)
{
    if (isEmpty())
        error(new String("This collection is empty."),
              new String(__PRETTY_FUNCTION__));
}

long Collection::growSize(void)
{
    long cap = capacity();
    return cap > 2 ? cap : 2;
}

---