ExternalWriteStream.cc

Go to the documentation of this file.

/*
 * ExternalWriteStream.cc
 *
 * Smalltalk like class library for C++
 * External write 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 <stdio.h>

#include <stlib/ExternalWriteStream.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/Error.h>

ExternalWriteStream::ExternalWriteStream(IOAccessor *accessor)
  : ExternalStream(accessor)
{
    /* Does nothing */
}

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

/* Accessing protocol */
void ExternalWriteStream::flush(void)
{
    if (write_limit == -1 || _position < 1) return;
    io_buffer->bufferChanged();
    io_buffer->flushBufferUpTo(_position);
    collection = io_buffer->buffer();
    _position = io_buffer->firstDataPosition();
    write_limit = collection->size();
}

Object *ExternalWriteStream::next(void)
{
    shouldNotImplement(new String(__PRETTY_FUNCTION__));
    return nil;
}

void ExternalWriteStream::nextPut(Object *object)
{
    if (_position >= write_limit) {
        if (write_limit == -1) {
            write_limit = io_buffer->lastWriteablePosition();
            if (_position >= write_limit) flush();
        } else
            flush();
    }
    collection->put(_position++, object);
}

long ExternalWriteStream::size(void)
{
    flush();
    return io_accessor->dataSize();
}

/* Positioning protocol */
long ExternalWriteStream::position(void)
{
    return writePosition();
}

void ExternalWriteStream::position(long position)
{
    error(new String("ExternalWriteStreams cannot be positioned."),
          new String(__PRETTY_FUNCTION__));
}

long ExternalWriteStream::writePosition(void)
{
    return io_accessor->dataSize() + _position;
}

/* Testing protocol */
bool ExternalWriteStream::atEnd(void)
{
    return true;
}

bool ExternalWriteStream::isReadable(void)
{
    return false;
}

bool ExternalWriteStream::isWritable(void)
{
    return true;
}

/* Private protocol */
void ExternalWriteStream::closeConnection(void)
{
    try {
        flush();
        io_accessor->close();
    }
    catch (Error *ex) {
        fprintf(stderr, "ExternalWriteStream: error occured %s\n", ex->printString()->asCString());
    }
    _position = read_limit = 0;
    write_limit = -1;
}

bool ExternalWriteStream::nextBuffer(void)
{
    flush();
    return true;
}

---