ExternalStream.cc

Go to the documentation of this file.

/*
 * ExternalStream.cc
 *
 * Smalltalk like class library for C++
 * Abstract external stream.
 *
 * 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/ExternalStream.h>

#include <stlib/ByteArray.h>
#include <stlib/Character.h>
#include <stlib/IOAccessor.h>
#include <stlib/IOBuffer.h>
#include <stlib/SequenceableCollection.h>
#include <stlib/String.h>
#include <stlib/WriteStream.h>
#include <stlib/Error.h>

ExternalStream::ExternalStream(IOAccessor *accessor)
{
    io_accessor = accessor;
    io_buffer = new IOBuffer(io_accessor);
    PositionableStream::initialize(io_buffer->buffer());
    _position = io_buffer->firstDataPosition();
    read_limit = 0;
    write_limit = -1;
}

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

/* Accessing protocol */
SequenceableCollection *ExternalStream::contents(void)
{
    long dataSize;
    Stream *newCollectionStream;

    dataSize = io_accessor->dataSize();
    newCollectionStream = contentSpeciesFor(dataSize < 256 ? 256 : dataSize)
                              ->writeStream();
    while (!atEnd()) {
        newCollectionStream->nextPut(next());
    }
    return newCollectionStream->contents();
}

/* Positioning protocol */
long ExternalStream::readPosition(void)
{
    // openIfClosed();
    return io_buffer->currentBufferPosition() + _position;
}

/* Status protocol */
void ExternalStream::close(void)
{
    if (!closed()) {
        closeConnection();
        io_buffer = nil;
        collection = contentSpeciesFor(0);
    }
}

bool ExternalStream::closed(void)
{
    return io_buffer == nil;
}

void ExternalStream::commit(void)
{
    io_buffer->commit();
}

/* Testing protocol */
bool ExternalStream::atEnd(void)
{
    if (!basicAtEnd()) return false;
    if (!nextBuffer()) return true;
    return _position == read_limit;
}

bool ExternalStream::isBinary(void)
{
    return true;
}

bool ExternalStream::isExternalStream(void)
{
    return true;
}

/* Private protocol */
void ExternalStream::closeConnection(void)
{
    try {
        flush();
        io_accessor->close();
        _position = read_limit = 0;
        write_limit = -1;
    }
    catch (Error *ex) {
        /* Do nothing */
    }
}

bool ExternalStream::nextBuffer(void)
{
    long offset;

    flush();
    collection = io_buffer->nextAndSetOffset(offset);
    _position = offset;
    read_limit = io_buffer->lastDataPosition();
    return read_limit > _position;
}

Object *ExternalStream::pastEnd(void)
{
    // openIfClosed();
    if (_position < read_limit)
        return collection->at(_position++);
    if (nextBuffer())
        return collection->at(_position++);
    /* End of stream. Must be signaled somehow. */
    return nil;
}

void ExternalStream::setPosition(long index)
{
    long offset;

    if (index < 0) {
        Error *ex = new Error(new String("Attempt to position to a negative number."),
                              new String(__PRETTY_FUNCTION__));
        ex->raiseFrom(this);
    }
    flush();
    collection = io_buffer->readPositionAndSetOffset(index, offset);
    _position = offset;
    read_limit = io_buffer->lastDataPosition();
}

---