Reads a command block on the underlying stream that is constrained by a length marker preceeding the command. More...

Inheritance diagram for Deveel.Data.Protocol.LengthMarkedBufferedInputStream:

Public Member Functions
	LengthMarkedBufferedInputStream (IInputStream input)

override int	ReadByte ()

override void	Write (byte[] buffer, int offset, int count)

override void	Flush ()

override long	Seek (long offset, SeekOrigin origin)

override void	SetLength (long value)

override int	Read (byte[] b, int off, int len)

bool	PollForCommand (int maxSize)
	Checks to see if there is a complete command waiting on the input stream. More...

void	BlockForCommand ()
	Blocks until a complete command has been read in. More...

Properties
override bool	CanRead `[get]`

override bool	CanSeek `[get]`

override bool	CanWrite `[get]`

override long	Length `[get]`

override long	Position `[get, set]`

int	Available `[get]`

Private Member Functions
void	EnsureCapacity (int newSize)
	Ensures that the buffer is large enough to store the given value. More...

void	HandleEndReached ()
	Called when the end of the marked length is reached. More...

Private Attributes
const int	InitialBufferSize = 512
	The initial buffer size of the internal input buffer. More...

readonly IInputStream	input
	The chained InputStream that is underneath this object. More...

byte[]	buf
	The buffer that is used to read in whatever is on the stream. More...

int	count
	The number of valid bytes in the buffer. More...

int	markedLength
	The area of the buffer that is marked as being an available command. If it's -1 then there is no area marked. More...

int	markedIndex
	The current index of the marked area that is being read. More...

Detailed Description

Reads a command block on the underlying stream that is constrained by a length marker preceeding the command.

This can be used as a hack work around for non-blocking IO because we know ahead of time how much data makes up the next block of information over the stream.

Definition at line 16 of file LengthMarkedBufferedInputStream.cs.

Constructor & Destructor Documentation

Deveel.Data.Protocol.LengthMarkedBufferedInputStream.LengthMarkedBufferedInputStream ( IInputStream input )

inline

Definition at line 48 of file LengthMarkedBufferedInputStream.cs.

                                                                    {
             this.input = input;
             buf = new byte[InitialBufferSize];
             count = 0;
             markedLength = -1;
             markedIndex = -1;
         }

Member Function Documentation

void Deveel.Data.Protocol.LengthMarkedBufferedInputStream.BlockForCommand ( )

inline

Blocks until a complete command has been read in.

Definition at line 247 of file LengthMarkedBufferedInputStream.cs.

                                       {
             lock (this) {
                 while (true) {
                     // Is there a command available?
                     if (count >= 4) {
                         int lengthMarker = ByteBuffer.ReadInt4(buf, 0);
                         if (count >= lengthMarker + 4) {
                             // Yes, complete command available.
                             // mark this area up.
                             markedLength = lengthMarker + 4;
                             markedIndex = 4;
                             return;
                         }
                     }
 
                     // If the buffer is full grow it larger.
                     if (count >= buf.Length) {
                         EnsureCapacity(count + InitialBufferSize);
                     }
                     // Read in a block of data, block if nothing there
                     int read_in = input.Read(buf, count, buf.Length - count);
                     if (read_in == 0) {
                         //TODO: Check this format...
                         // throw new EndOfStreamException();
 
                         // zero bytes read means that the stream is finished...
                         return;
                     }
                     count += read_in;
                 }
             }
         }

void Deveel.Data.Protocol.LengthMarkedBufferedInputStream.EnsureCapacity ( int newSize )

inlineprivate

Ensures that the buffer is large enough to store the given value.

Parameters

newSize

If the buffer is not large enough this method grows it so it is big enough.

Definition at line 63 of file LengthMarkedBufferedInputStream.cs.

                                                  {
             int old_size = buf.Length;
             if (newSize > old_size) {
                 int cap = (old_size * 3) / 2 + 1;
                 if (cap < newSize)
                     cap = newSize;
                 byte[] oldBuf = buf;
                 buf = new byte[cap];
                 //      // Copy all the contents except the first 4 bytes (the size marker)
                 Array.Copy(oldBuf, 0, buf, 0, count);
             }
         }

override void Deveel.Data.Protocol.LengthMarkedBufferedInputStream.Flush ( )

inline

Definition at line 143 of file LengthMarkedBufferedInputStream.cs.

143 {

144 }

void Deveel.Data.Protocol.LengthMarkedBufferedInputStream.HandleEndReached ( )

inlineprivate

Called when the end of the marked length is reached.

It performs various maintenance operations to ensure the buffer consistency is maintained.

Assumes we are calling from a synchronized method.

Definition at line 86 of file LengthMarkedBufferedInputStream.cs.

                                         {
             // Move anything from the end of the buffer to the start.
             Array.Copy(buf, markedIndex, buf, 0, count - markedLength);
             count -= markedLength;
 
             // Reset the state
             markedLength = -1;
             markedIndex = -1;
         }

bool Deveel.Data.Protocol.LengthMarkedBufferedInputStream.PollForCommand ( int maxSize )

inline

Checks to see if there is a complete command waiting on the input stream.

Parameters

maxSize The maximum number of bytes we are allowing before an IOException is thrown.

If this method returns true then it is safe to go ahead and process a single command from this stream. This will return true only once while there is a command pending until that command is completely read in.

Returns: Returns true if there is a complete command.

Definition at line 204 of file LengthMarkedBufferedInputStream.cs.

                                                 {
             lock (this) {
                 if (markedLength == -1) {
                     int available = input.Available;
                     if (count > 0 || available > 0) {
                         if ((count + available) > maxSize) {
                             throw new IOException("Marked length is greater than max size ( " +
                                                   (count + available) + " > " + maxSize + " )");
                         }
 
                         EnsureCapacity(count + available);
                         int readIn = input.Read(buf, count, available);
 
                         if (readIn == 0) {
                             //TODO: Check this format...
                             // throw new EndOfStreamException();
 
                             // zero bytes read means that the stream is finished...
                             return false;
                         }
                         count = count + readIn;
 
                         // Check: Is a complete command available?
                         if (count >= 4) {
                             int lengthMarker = ByteBuffer.ReadInt4(buf, 0);
 
                             if (count >= lengthMarker + 4) {
                                 // Yes, complete command available.
                                 // mark this area up.
                                 markedLength = lengthMarker + 4;
                                 markedIndex = 4;
                                 return true;
                             }
                         }
                     }
                 }
                 return false;
             }
         }

override int Deveel.Data.Protocol.LengthMarkedBufferedInputStream.Read	(	byte[]	b,
		int	off,
		int	len
	)

inline

Definition at line 154 of file LengthMarkedBufferedInputStream.cs.

                                                              {
             lock (this) {
                 if (markedIndex == -1)
                     throw new IOException("No mark has been read yet.");
 
                 int readUpto = markedIndex + len;
                 if (readUpto > markedLength) {
                     String debug_msg = "Read over end of length marked buffer.  ";
                     debug_msg += "(marked_index=" + markedIndex;
                     debug_msg += ",len=" + len;
                     debug_msg += ",marked_length=" + markedLength + ")";
                     throw new IOException(debug_msg);
                 }
                 Array.Copy(buf, markedIndex, b, off, len);
                 markedIndex = readUpto;
                 if (markedIndex >= markedLength) {
                     HandleEndReached();
                 }
                 return len;
             }
         }

override int Deveel.Data.Protocol.LengthMarkedBufferedInputStream.ReadByte ( )

inline

Definition at line 98 of file LengthMarkedBufferedInputStream.cs.

                                        {
             lock (this) {
                 if (markedIndex == -1)
                     throw new IOException("No mark has been read yet.");
 
                 if (markedIndex >= markedLength) {
                     string debugMsg = "Read over end of length marked buffer.  ";
                     debugMsg += "(marked_index=" + markedIndex;
                     debugMsg += ",marked_length=" + markedLength + ")";
                     debugMsg += ")";
                     throw new IOException(debugMsg);
                 }
                 int n = buf[markedIndex++] & 0x0FF;
                 if (markedIndex >= markedLength) {
                     HandleEndReached();
                 }
                 return n;
             }
         }

override long Deveel.Data.Protocol.LengthMarkedBufferedInputStream.Seek	(	long	offset,
		SeekOrigin	origin
	)

inline

Definition at line 146 of file LengthMarkedBufferedInputStream.cs.

                                                                   {
             throw new NotSupportedException();
         }

override void Deveel.Data.Protocol.LengthMarkedBufferedInputStream.SetLength ( long value )

inline

Definition at line 150 of file LengthMarkedBufferedInputStream.cs.

                                                    {
             throw new NotSupportedException();
         }

override void Deveel.Data.Protocol.LengthMarkedBufferedInputStream.Write	(	byte[]	buffer,
		int	offset,
		int	count
	)

inline

Definition at line 118 of file LengthMarkedBufferedInputStream.cs.

                                                                          {
             throw new NotSupportedException();
         }

Member Data Documentation

byte [] Deveel.Data.Protocol.LengthMarkedBufferedInputStream.buf

private

The buffer that is used to read in whatever is on the stream.

Definition at line 30 of file LengthMarkedBufferedInputStream.cs.

int Deveel.Data.Protocol.LengthMarkedBufferedInputStream.count

private

The number of valid bytes in the buffer.

Definition at line 35 of file LengthMarkedBufferedInputStream.cs.

const int Deveel.Data.Protocol.LengthMarkedBufferedInputStream.InitialBufferSize = 512

private

The initial buffer size of the internal input buffer.

Definition at line 20 of file LengthMarkedBufferedInputStream.cs.

readonly IInputStream Deveel.Data.Protocol.LengthMarkedBufferedInputStream.input

private

The chained InputStream that is underneath this object.

Definition at line 25 of file LengthMarkedBufferedInputStream.cs.

int Deveel.Data.Protocol.LengthMarkedBufferedInputStream.markedIndex

private

The current index of the marked area that is being read.

Definition at line 46 of file LengthMarkedBufferedInputStream.cs.

int Deveel.Data.Protocol.LengthMarkedBufferedInputStream.markedLength

private

The area of the buffer that is marked as being an available command. If it's -1 then there is no area marked.

Definition at line 41 of file LengthMarkedBufferedInputStream.cs.

Property Documentation

int Deveel.Data.Protocol.LengthMarkedBufferedInputStream.Available

get

Definition at line 176 of file LengthMarkedBufferedInputStream.cs.

override bool Deveel.Data.Protocol.LengthMarkedBufferedInputStream.CanRead

get

Definition at line 122 of file LengthMarkedBufferedInputStream.cs.

override bool Deveel.Data.Protocol.LengthMarkedBufferedInputStream.CanSeek

get

Definition at line 126 of file LengthMarkedBufferedInputStream.cs.

override bool Deveel.Data.Protocol.LengthMarkedBufferedInputStream.CanWrite

get

Definition at line 130 of file LengthMarkedBufferedInputStream.cs.

override long Deveel.Data.Protocol.LengthMarkedBufferedInputStream.Length

get

Definition at line 134 of file LengthMarkedBufferedInputStream.cs.

override long Deveel.Data.Protocol.LengthMarkedBufferedInputStream.Position

getset

Definition at line 138 of file LengthMarkedBufferedInputStream.cs.

The documentation for this class was generated from the following file:

/var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Protocol/LengthMarkedBufferedInputStream.cs

Public Member Functions

Properties

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation