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

00118 {
00119     return basicAtEnd();
00120 }

00139 {
00140     return _position >= read_limit;
00141 }

00042 {
00043     return new String("PositionableStream");
00044 }

00048 {
00049     return dynamic_cast<SequenceableCollection *>(collection->copy(0, read_limit - 1));
00050 }

00144 {
00145     return (SequenceableCollection *) collection->copyEmpty(items);
00146 }

00034 {
00035     collection = coll;
00036     read_limit = write_limit = coll->size();
00037     _position = 0;
00038 }

00133 {
00134     return collection->isByteArray();
00135 }

00123 {
00124     return _position == 0;
00125 }

00055 {
00056     if (items < 1) return newColl;
00057     if (atEnd())
00058         (new IncompleteNextCountError(__PRETTY_FUNCTION__, 0))->raiseFrom(this);
00059 
00060     /* Use next for the first read to make sure that the receiver is readable. */
00061     newColl->put(startIndex, next());
00062 
00063     long howManyRead = 1;
00064     while (howManyRead < items) {
00065         long increment, newHowManyRead;
00066         if (atEnd())
00067             (new IncompleteNextCountError(__PRETTY_FUNCTION__, howManyRead))->raiseFrom(this);
00068         long m1 = read_limit - _position;
00069         long m2 = items - howManyRead;
00070         increment = (m1 < m2) ? m1 : m2;
00071         newHowManyRead = howManyRead + increment;
00072         newColl->replace(startIndex + howManyRead, startIndex + newHowManyRead,
00073                          collection, _position);
00074         _position += increment;
00075         howManyRead = newHowManyRead;
00076     }
00077     return newColl;
00078 }

00054       { return Stream::next(items); }

00128 {
00129     return _position > 0;
00130 }

00081 {
00082     if (atEnd()) return false;
00083     Object *element = next();
00084     if (element->isEqual(object)) return true;
00085     skip(-1);
00086     return false;
00087 }

00096 {
00097     read_limit = (read_limit < _position) ? _position : read_limit;
00098     // PositionableStream::position(pos);
00099     if (pos >= 0 && pos <= read_limit)
00100         _position = pos;
00101     else
00102         positionOutOfBoundsError(new String(__PRETTY_FUNCTION__), pos);
00103 }

00091 {
00092     return _position;
00093 }

00106 {
00107     read_limit = (read_limit < _position) ? _position : read_limit;
00108     _position = 0;
00109 }

00112 {
00113     position(_position + length);
00114 }


Public Member Functions
virtual String *	className (void) const
	Answer receiver class name.
virtual SequenceableCollection *	contents (void)
	Answer content of the receiver.
virtual Object *	next (void) abstract
virtual SequenceableCollection *	next (long items)
virtual SequenceableCollection *	next (long items, SequenceableCollection *newColl, long index)
virtual bool	peekFor (Object *obj)
virtual long	position (void)
virtual void	position (long position)
virtual void	reset (void)
virtual void	skip (long length)
virtual bool	atEnd (void)
virtual bool	isEmpty (void)
virtual bool	notEmpty (void)
virtual bool	isBinary (void)
virtual bool	basicAtEnd (void)
Protected Member Functions
virtual void	initialize (SequenceableCollection *coll)
virtual SequenceableCollection *	contentSpeciesFor (long items)
Protected Attributes
SequenceableCollection *	collection
long	_position
long	read_limit
long	write_limit

Core::PositionableStream Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Member Function Documentation

Member Data Documentation