Smalltalk like C++ Class Library: Core::ExternalStream Class Reference

00036 {
00037     io_accessor = accessor;
00038     io_buffer = new IOBuffer(io_accessor);
00039     PositionableStream::initialize(io_buffer->buffer());
00040     _position = io_buffer->firstDataPosition();
00041     read_limit = 0;
00042     write_limit = -1;
00043 }

00095 {
00096     if (!basicAtEnd()) return false;
00097     if (!nextBuffer()) return true;
00098     return _position == read_limit;
00099 }

00047 {
00048     return new String("ExternalStream");
00049 }

00075 {
00076     if (!closed()) {
00077         closeConnection();
00078         io_buffer = nil;
00079         collection = contentSpeciesFor(0);
00080     }
00081 }

00113 {
00114     try {
00115         flush();
00116         io_accessor->close();
00117         _position = read_limit = 0;
00118         write_limit = -1;
00119     }
00120     catch (Error *ex) {
00121         /* Do nothing */
00122     }
00123 }

00084 {
00085     return io_buffer == nil;
00086 }

00089 {
00090     io_buffer->commit();
00091 }

00053 {
00054     long dataSize;
00055     Stream *newCollectionStream;
00056 
00057     dataSize = io_accessor->dataSize();
00058     newCollectionStream = contentSpeciesFor(dataSize < 256 ? 256 : dataSize)
00059                               ->writeStream();
00060     while (!atEnd()) {
00061         newCollectionStream->nextPut(next());
00062     }
00063     return newCollectionStream->contents();
00064 }

00102 {
00103     return true;
00104 }

00107 {
00108     return true;
00109 }

00126 {
00127     long offset;
00128 
00129     flush();
00130     collection = io_buffer->nextAndSetOffset(offset);
00131     _position = offset;
00132     read_limit = io_buffer->lastDataPosition();
00133     return read_limit > _position;
00134 }

00137 {
00138     // openIfClosed();
00139     if (_position < read_limit)
00140         return collection->at(_position++);
00141     if (nextBuffer())
00142         return collection->at(_position++);
00143     /* End of stream. Must be signaled somehow. */
00144     return nil;
00145 }

00068 {
00069     // openIfClosed();
00070     return io_buffer->currentBufferPosition() + _position;
00071 }

00148 {
00149     long offset;
00150 
00151     if (index < 0) {
00152         Error *ex = new Error(new String("Attempt to position to a negative number."),
00153                               new String(__PRETTY_FUNCTION__));
00154         ex->raiseFrom(this);
00155     }
00156     flush();
00157     collection = io_buffer->readPositionAndSetOffset(index, offset);
00158     _position = offset;
00159     read_limit = io_buffer->lastDataPosition();
00160 }


Public Member Functions
	ExternalStream (IOAccessor *accessor)
virtual String *	className (void) const
	Answer receiver class name.
virtual SequenceableCollection *	contents (void)
	Answer content of the receiver.
virtual long	readPosition (void)
virtual void	close (void)
virtual bool	closed (void)
virtual void	commit (void)
virtual bool	atEnd (void)
virtual bool	isBinary (void)
virtual bool	isExternalStream (void)
virtual void	closeConnection (void)
virtual bool	nextBuffer (void)
virtual Object *	pastEnd (void)
virtual void	setPosition (long position)
Protected Attributes
IOAccessor *	io_accessor
IOBuffer *	io_buffer

Core::ExternalStream Class Reference

Public Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation