Stream.cc

Go to the documentation of this file.

/*
 * Stream.cc
 *
 * Smalltalk like class library for C++
 * Abstract stream.
 *
 * 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 <stlib/Stream.h>
#include <stlib/WriteStream.h>

#include <stlib/Array.h>
#include <stlib/ByteArray.h>
#include <stlib/Character.h>
#include <stlib/Collection.h>
#include <stlib/Integer.h>
#include <stlib/Iterator.h>
#include <stlib/Number.h>
#include <stlib/SequenceableCollection.h>
#include <stlib/String.h>

#include <stlib/POOBoundsError.h>

/* Accessing protocol */
Stream *Stream::basicStream(void)
{
    return this;
}

SequenceableCollection *Stream::next(long items)
{
    SequenceableCollection *newCollection;
    newCollection = contentSpeciesFor(items);
    return next(items, newCollection, 0);
}

SequenceableCollection *Stream::next(long items, SequenceableCollection *newColl, long index)
{
    long stopIndex = index + items;

    while (index < stopIndex) {
        newColl->put(index, next());
        index++;
    }
    return newColl;
}

SequenceableCollection *Stream::nextLine(void)
{
    return upTo(Character::lf());
}

Integer *Stream::nextBigEndianLong(void)
{
    unsigned long number = 0;
    ByteArray *array = dynamic_cast<ByteArray *>(next(4));

    for (int i = 0; i < 4; i++) {
        number = (number << 8) + dynamic_cast<Integer *>(array->at(i))->asLong();
    }

    return Integer::value(number);
}

Integer *Stream::nextBigEndianShort(void)
{
    unsigned long number = 0;
    ByteArray *array = dynamic_cast<ByteArray *>(next(2));

    for (int i = 0; i < 2; i++) {
        number = (number << 8) + dynamic_cast<Integer *>(array->at(i))->asLong();
    }

    return Integer::value(number);
}

Integer *Stream::nextLittleEndianLong(void)
{
    unsigned long number = 0;
    ByteArray *array = dynamic_cast<ByteArray *>(next(4));

    for (int i = 3; i >= 0; i--) {
        number = (number << 8) + dynamic_cast<Integer *>(array->at(i))->asLong();
    }

    return Integer::value(number);
}

Integer *Stream::nextLittleEndianShort(void)
{
    unsigned long number = 0;
    ByteArray *array = dynamic_cast<ByteArray *>(next(2));

    for (int i = 1; i >= 0; i--) {
        number = (number << 8) + dynamic_cast<Integer *>(array->at(i))->asLong();
    }

    return Integer::value(number);
}

void Stream::nextPut(const char object)
{
    nextPut(Character::value((unsigned char) object));
}

void Stream::nextPutAll(const Collection *collection)
{
    if (collection->isSequenceable()) {
        nextPutAll((SequenceableCollection *) collection,
                   collection->size(), 0L);
    } else {
        for (Iterator *i = collection->iterator(); !i->finished(); i->next()) {
            nextPut(i->value());
        }
    }
}

void Stream::nextPutAll(const char *string)
{
    for (const char *pstr = string; *pstr != 0; pstr++) {
        nextPut(*pstr);
    }
}

void Stream::nextPutAll(const SequenceableCollection *collection,
                        long size, long startIndex)
{
    for (long i = startIndex; i < startIndex + size; i++) {
        nextPut(collection->at(i));
    }
}

void Stream::nextPutBigEndianLong(Integer *number)
{
    nextPutBigEndianLong(number->asUnsignedLong());
}

void Stream::nextPutBigEndianLong(unsigned long int number)
{
    unsigned long particle = number;
    ByteArray *ba = new ByteArray(4);
    for (int i = 3; i >= 0; i--) {
        ba->put(i, Integer::value(particle & 0xff));
        particle = particle >> 8;
    }
    nextPutAll(ba);
}

void Stream::nextPutBigEndianShort(Integer *number)
{
    nextPutBigEndianShort((unsigned short) number->asUnsignedLong());
}

void Stream::nextPutBigEndianShort(unsigned short int number)
{
    unsigned short particle = number;
    ByteArray *ba = new ByteArray(2);
    for (int i = 1; i >= 0; i--) {
        ba->put(i, Integer::value(particle & 0xff));
        particle = particle >> 8;
    }
    nextPutAll(ba);
}

void Stream::nextPutLittleEndianLong(Integer *number)
{
    nextPutLittleEndianLong(number->asUnsignedLong());
}

void Stream::nextPutLittleEndianLong(unsigned long int number)
{
    unsigned long particle = number;
    ByteArray *ba = new ByteArray(4);
    for (int i = 0; i < 4; i++) {
        ba->put(i, Integer::value(particle & 0xff));
        particle = particle >> 8;
    }
    nextPutAll(ba);
}

void Stream::nextPutLittleEndianShort(Integer *number)
{
    nextPutLittleEndianShort((unsigned short) number->asUnsignedLong());
}

void Stream::nextPutLittleEndianShort(unsigned short int number)
{
    unsigned short particle = number;
    ByteArray *ba = new ByteArray(2);
    for (int i = 0; i < 2; i++) {
        ba->put(i, Integer::value(particle & 0xff));
        particle = particle >> 8;
    }
    nextPutAll(ba);
}

SequenceableCollection *Stream::upTo(Object *object)
{
    Stream *newStream = contentSpeciesFor(64)->writeStream();
    while (!atEnd()) {
        Object *element = next();
        if (element->isEqual(object))
            break;
        newStream->nextPut(element);
    }
    return newStream->contents();
}

SequenceableCollection *Stream::upToAll(SequenceableCollection *sequence)
{
    int matchCount = 0;
    Stream *writeStream = contentSpeciesFor(64)->writeStream();
    while (!atEnd()) {
        Object *element = next();
        if (element->isEqual(sequence->at(matchCount))) {
            matchCount++;
            if (matchCount == sequence->size()) break;
        } else {
            if (matchCount > 0) {
                writeStream->nextPutAll(dynamic_cast<SequenceableCollection *>(sequence->copy(0, matchCount)));
                matchCount = 0;
            }
            writeStream->nextPut(element);
        }
    }
    return writeStream->contents();
}

SequenceableCollection *Stream::upToAny(Collection *collection)
{
    Stream *newStream = contentSpeciesFor(64)->writeStream();
    while (!atEnd()) {
        Object *element = next();
        if (collection->includes(element))
            break;
        newStream->nextPut(element);
    }
    return newStream->contents();
}

SequenceableCollection *Stream::upToEnd(void)
{
    Stream *newCollectionStream = contentSpeciesFor(256)->writeStream();
    while (!atEnd()) {
        newCollectionStream->nextPut(next());
    }
    return newCollectionStream->contents();
}

SequenceableCollection *Stream::upToSeparator(void)
{
    Stream *newStream = contentSpeciesFor(64)->writeStream();
    while (!atEnd()) {
        Object *element = next();
        if (element->isCharacter() &&
            ((Character *) element)->isSeparator())
            break;
        newStream->nextPut(element);
    }
    return newStream->contents();
}

Object *Stream::peek(void)
{
    if (atEnd()) return nil;
    Object *element = next();
    skip(-1);
    return element;
}

/* Character reading protocol */
void Stream::skipSeparators(void)
{
    Object *element;
    bool atEndFlag;

    while (!(atEndFlag = atEnd()) &&
       (element = next())->isCharacter() &&
       ((Character *) element)->isSeparator());
    /* Cannot use atEnd() here because of ExternalReadStream
       buffer swap side effect */
    if (!atEndFlag) skip(-1);
}

/* Character writing protocol */
void Stream::cr(void)
{
    nextPut(Character::cr());
}

void Stream::lf(void)
{
    nextPut(Character::lf());
}

void Stream::space(void)
{
    nextPut(Character::space());
}

void Stream::tab(void)
{
    nextPut(Character::tab());
}

/* Error handling protocol */
void Stream::positionOutOfBoundsError(String *selector, int position)
{
    (new PositionOutOfBoundsError(selector, position))->raiseFrom(this);
}

/* Printing protocol */
void Stream::print(Object *object)
{
    if (object == nil) {
        nextPutAll("<nil>");
        return;
    }
    object->printOn(this);
}

void Stream::print(long number)
{
    nextPutAll(String::format("%d", number));
}

void Stream::print(double number)
{
    nextPutAll(String::format("%g", number));
}

/* Status protocol */
void Stream::close(void)
{
    /* Does nothing */
}

void Stream::commit(void)
{
    /* Does nothing */
}

/* Testing protocol */
bool Stream::isExternalStream(void)
{
    return false;
}

/* Private protocol */
SequenceableCollection *Stream::contentSpeciesFor(long items)
{
    return new Array(items);
}

---