public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
if (_buffer == null)
{
if (input.Remaining >= _length)
{
Int32 limit = input.Limit;
input.Limit = input.Position + _length;
IoBuffer product = input.Slice();
input.Position = input.Position + _length;
input.Limit = limit;
return(FinishDecode(product, output));
}
_buffer = IoBuffer.Allocate(_length);
_buffer.Put(input);
return(this);
}
if (input.Remaining >= _length - _buffer.Position)
{
Int32 limit = input.Limit;
input.Limit = input.Position + _length - _buffer.Position;
_buffer.Put(input);
input.Limit = limit;
IoBuffer product = _buffer;
_buffer = null;
return(FinishDecode(product.Flip(), output));
}
_buffer.Put(input);
return(this);
}
public void FinishDecode(IoSession session, IProtocolDecoderOutput output)
{
lock (_decoder)
{
_decoder.FinishDecode(session, output);
}
}
public void Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
lock (_decoder)
{
_decoder.Decode(session, input, output);
}
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
if (input.HasRemaining)
return FinishDecode(input.Get(), output);
return this;
}
public MessageDecoderResult Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
// Try to skip header if not read.
if (!_readHeader)
{
input.GetInt16(); // Skip 'type'.
_sequence = input.GetInt32(); // Get 'sequence'.
_readHeader = true;
}
// Try to decode body
AbstractMessage m = DecodeBody(session, input);
// Return NEED_DATA if the body is not fully read.
if (m == null)
{
return(MessageDecoderResult.NeedData);
}
else
{
_readHeader = false; // reset readHeader for the next decode
}
m.Sequence = _sequence;
output.Write(m);
return(MessageDecoderResult.OK);
}
public MessageDecoderResult Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
// Try to skip header if not read.
if (!_readHeader)
{
input.GetInt16(); // Skip 'type'.
_sequence = input.GetInt32(); // Get 'sequence'.
_readHeader = true;
}
// Try to decode body
AbstractMessage m = DecodeBody(session, input);
// Return NEED_DATA if the body is not fully read.
if (m == null)
{
return MessageDecoderResult.NeedData;
}
else
{
_readHeader = false; // reset readHeader for the next decode
}
m.Sequence = _sequence;
output.Write(m);
return MessageDecoderResult.OK;
}
private void DecodeAll(ByteBuffer buf, IProtocolDecoderOutput output)
{
for ( ; ;)
{
int oldPos = buf.Position;
bool decoded = DoDecode(buf, output);
if (decoded)
{
if (buf.Position == oldPos)
{
throw new Exception(
"doDecode() can't return true when buffer is not consumed.");
}
if (!buf.HasRemaining)
{
break;
}
}
else
{
break;
}
}
}
/// <inheritdoc/>
public override void SessionClosed(INextFilter nextFilter, IoSession session)
{
// Call finishDecode() first when a connection is closed.
IProtocolDecoder decoder = _factory.GetDecoder(session);
IProtocolDecoderOutput decoderOut = GetDecoderOut(session, nextFilter);
try
{
decoder.FinishDecode(session, decoderOut);
}
catch (Exception ex)
{
ProtocolDecoderException pde = ex as ProtocolDecoderException;
if (pde == null)
{
pde = new ProtocolDecoderException(null, ex);
}
throw pde;
}
finally
{
// Dispose everything
DisposeCodec(session);
decoderOut.Flush(nextFilter, session);
}
// Call the next filter
nextFilter.SessionClosed(session);
}
public void FinishDecode(IoSession session, IProtocolDecoderOutput output)
{
lock (_decoder)
{
_decoder.FinishDecode(session, output);
}
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
if (_buffer == null)
{
if (input.Remaining >= _length)
{
Int32 limit = input.Limit;
input.Limit = input.Position + _length;
IoBuffer product = input.Slice();
input.Position = input.Position + _length;
input.Limit = limit;
return FinishDecode(product, output);
}
_buffer = IoBuffer.Allocate(_length);
_buffer.Put(input);
return this;
}
if (input.Remaining >= _length - _buffer.Position)
{
Int32 limit = input.Limit;
input.Limit = input.Position + _length - _buffer.Position;
_buffer.Put(input);
input.Limit = limit;
IoBuffer product = _buffer;
_buffer = null;
return FinishDecode(product.Flip(), output);
}
_buffer.Put(input);
return this;
}
public IDecodingState FinishDecode(IProtocolDecoderOutput output)
{
IDecodingState nextState;
IDecodingState state = CurrentState;
try
{
while (true)
{
IDecodingState oldState = state;
state = state.FinishDecode(_childOutput);
if (state == null)
// Finished
break;
// Exit if state didn't change.
if (oldState == state)
break;
}
}
catch (Exception ex)
{
state = null;
Debug.WriteLine("Ignoring the exception caused by a closed session. {0}", ex);
}
finally
{
_currentState = state;
nextState = FinishDecode(_childProducts, output);
if (state == null)
Cleanup();
}
return nextState;
}
public void Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
lock (_decoder)
{
_decoder.Decode(session, input, output);
}
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
while (input.HasRemaining)
{
switch (_counter)
{
case 0:
_firstByte = input.Get() & 0xff;
break;
case 1:
_secondByte = input.Get() & 0xff;
break;
case 2:
_thirdByte = input.Get() & 0xff;
break;
case 3:
_counter = 0;
return(FinishDecode((_firstByte << 24) | (_secondByte << 16) | (_thirdByte << 8) | (input.Get() & 0xff), output));
}
_counter++;
}
return(this);
}
public void Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
if (_session == null)
_session = session;
else if (_session != session)
throw new InvalidOperationException(GetType().Name + " is a stateful decoder. "
+ "You have to create one per session.");
_undecodedBuffers.Enqueue(input);
while (true)
{
IoBuffer b;
if (!_undecodedBuffers.TryPeek(out b))
break;
Int32 oldRemaining = b.Remaining;
_state.Decode(b, output);
Int32 newRemaining = b.Remaining;
if (newRemaining != 0)
{
if (oldRemaining == newRemaining)
throw new InvalidOperationException(_state.GetType().Name
+ " must consume at least one byte per decode().");
}
else
{
_undecodedBuffers.TryDequeue(out b);
}
}
}
public void Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
Context ctx = GetContext(session);
if (LineDelimiter.Auto.Equals(_delimiter))
DecodeAuto(ctx, session, input, output);
else
DecodeNormal(ctx, session, input, output);
}
/// <inheritdoc/>
protected override Boolean DoDecode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
if (!input.PrefixedDataAvailable(4, _maxObjectSize))
return false;
input.GetInt32();
output.Write(input.GetObject());
return true;
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
if (input.HasRemaining)
{
return(FinishDecode(input.Get(), output));
}
return(this);
}
/// <summary>
/// Cumulates content of <tt>in</tt> into internal buffer and forwards
/// decoding request to {@link #doDecode(IoSession, ByteBuffer, ProtocolDecoderOutput)}.
/// <tt>doDecode()</tt> is invoked repeatedly until it returns <tt>false</tt>
/// and the cumulative buffer is compacted after decoding ends.
/// </summary>
/// <exception cref="Exception">
/// if your <tt>doDecode()</tt> returned <tt>true</tt> not consuming the cumulative buffer.
/// </exception>
public void Decode(ByteBuffer input, IProtocolDecoderOutput output)
{
if ( _remaining.Position != 0 ) // If there were remaining undecoded bytes
{
DecodeRemainingAndInput(input, output);
} else
{
DecodeInput(input, output);
}
}
public MessageDecoderResult Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
var instr = session.GetAttribute <IInstruction>(KeyName.INSTRUCTION);
if (instr != null)
{
output.Write(instr.CreateDecoder().Decode(input));
}
return(MessageDecoderResult.OK);
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
IDecodingState state = CurrentState;
Int32 limit = input.Limit, pos = input.Position;
try
{
while (true)
{
// Wait for more data if all data is consumed.
if (pos == limit)
{
break;
}
IDecodingState oldState = state;
state = state.Decode(input, _childOutput);
// If finished, call finishDecode
if (state == null)
{
return(FinishDecode(_childProducts, output));
}
Int32 newPos = input.Position;
// Wait for more data if nothing is consumed and state didn't change.
if (newPos == pos && oldState == state)
{
break;
}
pos = newPos;
}
return(this);
}
catch (Exception)
{
state = null;
throw;
}
finally
{
_currentState = state;
// Destroy if decoding is finished or failed.
if (state == null)
{
Cleanup();
}
}
}
protected override Boolean DoDecode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
if (input.PrefixedDataAvailable(PrefixLength, MaxDataLength))
{
String msg = input.GetPrefixedString(PrefixLength, Encoding);
output.Write(msg);
return true;
}
return false;
}
/// <summary>
/// Cumulates content of <tt>in</tt> into internal buffer and forwards
/// decoding request to {@link #doDecode(IoSession, ByteBuffer, ProtocolDecoderOutput)}.
/// <tt>doDecode()</tt> is invoked repeatedly until it returns <tt>false</tt>
/// and the cumulative buffer is compacted after decoding ends.
/// </summary>
/// <exception cref="Exception">
/// if your <tt>doDecode()</tt> returned <tt>true</tt> not consuming the cumulative buffer.
/// </exception>
public void Decode(ByteBuffer input, IProtocolDecoderOutput output)
{
if (_remaining.Position != 0) // If there were remaining undecoded bytes
{
DecodeRemainingAndInput(input, output);
}
else
{
DecodeInput(input, output);
}
}
protected override Boolean DoDecode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
if (input.PrefixedDataAvailable(PrefixLength, MaxDataLength))
{
String msg = input.GetPrefixedString(PrefixLength, Encoding);
output.Write(msg);
return(true);
}
return(false);
}
/// <inheritdoc/>
protected override Boolean DoDecode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
if (!input.PrefixedDataAvailable(4, _maxObjectSize))
{
return(false);
}
input.GetInt32();
output.Write(input.GetObject());
return(true);
}
protected override Boolean DoDecode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
Assert.IsTrue(input.HasRemaining);
if (input.Remaining < 4)
{
return(false);
}
output.Write(input.GetInt32());
return(true);
}
/// <inheritdoc/>
public override void FinishDecode(IoSession session, IProtocolDecoderOutput output)
{
base.FinishDecode(session, output);
State state = GetState(session);
IMessageDecoder currentDecoder = state.currentDecoder;
if (currentDecoder == null)
{
return;
}
currentDecoder.FinishDecode(session, output);
}
public AmqpChannel(IByteChannel byteChannel, IProtocolDecoderOutput decoderOutput)
{
_byteChannel = byteChannel;
_decoderOutput = decoderOutput;
_syncLock = new object();
AMQProtocolProvider protocolProvider = new AMQProtocolProvider();
IProtocolCodecFactory factory = protocolProvider.CodecFactory;
_encoder = factory.Encoder;
_decoder = factory.Decoder;
}
private void TestDecoderAndInputStream(String expected, IoBuffer input)
{
// Test ProtocolDecoder
IProtocolDecoder decoder = new ObjectSerializationDecoder();
ProtocolCodecSession session = new ProtocolCodecSession();
IProtocolDecoderOutput decoderOut = session.DecoderOutput;
decoder.Decode(session, input.Duplicate(), decoderOut);
Assert.AreEqual(1, session.DecoderOutputQueue.Count);
Assert.AreEqual(expected, session.DecoderOutputQueue.Dequeue());
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
Int32 terminatorPos = input.IndexOf(_terminator);
if (terminatorPos >= 0)
{
Int32 limit = input.Limit;
IoBuffer product;
if (input.Position < terminatorPos)
{
input.Limit = terminatorPos;
if (_buffer == null)
{
product = input.Slice();
}
else
{
_buffer.Put(input);
product = _buffer.Flip();
_buffer = null;
}
input.Limit = limit;
}
else
{
// When input contained only terminator rather than actual data...
if (_buffer == null)
{
product = IoBuffer.Allocate(0);
}
else
{
product = _buffer.Flip();
_buffer = null;
}
}
input.Position = terminatorPos + 1;
return(FinishDecode(product, output));
}
if (_buffer == null)
{
_buffer = IoBuffer.Allocate(input.Remaining);
_buffer.AutoExpand = true;
}
_buffer.Put(input);
return(this);
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
Int32 terminatorPos = input.IndexOf(_terminator);
if (terminatorPos >= 0)
{
Int32 limit = input.Limit;
IoBuffer product;
if (input.Position < terminatorPos)
{
input.Limit = terminatorPos;
if (_buffer == null)
{
product = input.Slice();
}
else
{
_buffer.Put(input);
product = _buffer.Flip();
_buffer = null;
}
input.Limit = limit;
}
else
{
// When input contained only terminator rather than actual data...
if (_buffer == null)
{
product = IoBuffer.Allocate(0);
}
else
{
product = _buffer.Flip();
_buffer = null;
}
}
input.Position = terminatorPos + 1;
return FinishDecode(product, output);
}
if (_buffer == null)
{
_buffer = IoBuffer.Allocate(input.Remaining);
_buffer.AutoExpand = true;
}
_buffer.Put(input);
return this;
}
private IProtocolDecoderOutput GetDecoderOut(IoSession session, INextFilter nextFilter)
{
IProtocolDecoderOutput output = session.GetAttribute <IProtocolDecoderOutput>(DECODER_OUT);
if (output == null)
{
// Create a new instance, and stores it into the session
output = new ProtocolDecoderOutputImpl();
session.SetAttribute(DECODER_OUT, output);
}
return(output);
}
/// <inheritdoc/>
public void Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
Context ctx = GetContext(session);
if (LineDelimiter.Auto.Equals(_delimiter))
{
DecodeAuto(ctx, session, input, output);
}
else
{
DecodeNormal(ctx, session, input, output);
}
}
protected override Boolean DoDecode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
if (input.Remaining >= 4)
{
Message request = input.GetMessage();
output.Write(request);
return true;
}
else
{
return false;
}
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
if (_buffer == null)
{
_buffer = IoBuffer.Allocate(256);
_buffer.AutoExpand = true;
}
if (_buffer.Position + input.Remaining > _maxLength)
throw new ProtocolDecoderException("Received data exceeds " + _maxLength + " byte(s).");
_buffer.Put(input);
return this;
}
public IDecodingState FinishDecode(IProtocolDecoderOutput output)
{
IoBuffer readData;
if (_buffer == null)
{
readData = IoBuffer.Allocate(0);
}
else
{
readData = _buffer.Flip();
_buffer = null;
}
return FinishDecode(readData, output);
}
/// <summary>
/// Decodes the specified session.
/// </summary>
/// <param name="inbuf">The inbuf.</param>
/// <param name="output">The protocol output.</param>
/// <returns></returns>
public MessageDecoderResult Decode(ByteBuffer inbuf, IProtocolDecoderOutput output)
{
byte[] header = new byte[4];
inbuf.GetBytes(header);
ProtocolInitiation pi = new ProtocolInitiation();
pi.Header = new char[] { 'A', 'M', 'Q', 'P' };
pi.ProtocolClass = inbuf.GetByte();
pi.ProtocolInstance = inbuf.GetByte();
pi.ProtocolMajor = inbuf.GetByte();
pi.ProtocolMinor = inbuf.GetByte();
output.Write(pi);
return(MessageDecoderResult.OK);
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
Boolean found = false;
Boolean finished = false;
while (input.HasRemaining)
{
Byte b = input.Get();
if (!_hasCR)
{
if (b == CR)
{
_hasCR = true;
}
else
{
if (b == LF)
{
found = true;
}
else
{
input.Position = input.Position - 1;
found = false;
}
finished = true;
break;
}
}
else
{
if (b == LF)
{
found = true;
finished = true;
break;
}
throw new ProtocolDecoderException("Expected LF after CR but was: " + (b & 0xff));
}
}
if (finished)
{
_hasCR = false;
return(FinishDecode(found, output));
}
return(this);
}
public MessageDecoderResult Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
var value = input.GetRemaining().Array;
input.Position = value.Length;
if (value == null)
{
return(MessageDecoderResult.NeedData);
}
output.Write(value);
return(MessageDecoderResult.OK);
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
Boolean found = false;
Boolean finished = false;
while (input.HasRemaining)
{
Byte b = input.Get();
if (!_hasCR)
{
if (b == CR)
{
_hasCR = true;
}
else
{
if (b == LF)
{
found = true;
}
else
{
input.Position = input.Position - 1;
found = false;
}
finished = true;
break;
}
}
else
{
if (b == LF)
{
found = true;
finished = true;
break;
}
throw new ProtocolDecoderException("Expected LF after CR but was: " + (b & 0xff));
}
}
if (finished)
{
_hasCR = false;
return FinishDecode(found, output);
}
return this;
}
public IDecodingState FinishDecode(IProtocolDecoderOutput output)
{
IoBuffer product;
// When input contained only terminator rather than actual data...
if (_buffer == null)
{
product = IoBuffer.Allocate(0);
}
else
{
product = _buffer.Flip();
_buffer = null;
}
return FinishDecode(product, output);
}
private void DecodeInput(ByteBuffer input, IProtocolDecoderOutput output)
{
_logger.Debug(string.Format("DecodeInput: input {0}", input.Remaining));
// Just decode the input buffer and remember any remaining undecoded bytes.
try
{
DecodeAll(input, output);
} finally
{
if ( input.HasRemaining )
{
_remaining.Put(input);
}
}
}
private void DecodeInput(ByteBuffer input, IProtocolDecoderOutput output)
{
_logger.Debug(string.Format("DecodeInput: input {0}", input.Remaining));
// Just decode the input buffer and remember any remaining undecoded bytes.
try
{
DecodeAll(input, output);
} finally
{
if (input.HasRemaining)
{
_remaining.Put(input);
}
}
}
public IDecodingState FinishDecode(IProtocolDecoderOutput output)
{
IoBuffer readData;
if (_buffer == null)
{
readData = IoBuffer.Allocate(0);
}
else
{
readData = _buffer.Flip();
_buffer = null;
}
return(FinishDecode(readData, output));
}
public MessageDecoderResult Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
int totalLen = input.GetInt32();
int len = totalLen - 4;
if (input.Remaining < len)
{
return(MessageDecoderResult.NeedData);
}
byte[] jsonBuffer = new byte[len];
input.Get(jsonBuffer, 0, len);
string msg = System.Text.Encoding.UTF8.GetString(jsonBuffer);
output.Write(msg);
return(MessageDecoderResult.OK);
}
public IDecodingState FinishDecode(IProtocolDecoderOutput output)
{
IoBuffer product;
// When input contained only CR or LF rather than actual data...
if (_buffer == null)
{
product = IoBuffer.Allocate(0);
}
else
{
product = _buffer.Flip();
_buffer = null;
}
return(FinishDecode(product, output));
}
public IDecodingState FinishDecode(IProtocolDecoderOutput output)
{
try
{
if (_buffer == null)
{
_buffer = IoBuffer.Allocate(0);
}
_buffer.Flip();
return(FinishDecode(_buffer, output));
}
finally
{
_buffer = null;
}
}
public MessageDecoderResult Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
int limit = input.Limit;
int position = input.Position;
var len = input.GetInt32();
var version = input.Get();
input.Position = position;
input.Limit = input.Position + len;
var buffer = input.Slice();
input.Position = input.Limit;
input.Limit = limit;
var message = DoDecode(version.ToEnum<MessageVersion>(), buffer);
if (message != null)
output.Write(message);
return MessageDecoderResult.OK;
}
public IDecodingState FinishDecode(IProtocolDecoderOutput output)
{
try
{
if (_buffer == null)
{
_buffer = IoBuffer.Allocate(0);
}
_buffer.Flip();
return FinishDecode(_buffer, output);
}
finally
{
_buffer = null;
}
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
if (_buffer == null)
{
_buffer = IoBuffer.Allocate(256);
_buffer.AutoExpand = true;
}
if (_buffer.Position + input.Remaining > _maxLength)
{
throw new ProtocolDecoderException("Received data exceeds " + _maxLength + " byte(s).");
}
_buffer.Put(input);
return(this);
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
IDecodingState state = CurrentState;
Int32 limit = input.Limit, pos = input.Position;
try
{
while (true)
{
// Wait for more data if all data is consumed.
if (pos == limit)
break;
IDecodingState oldState = state;
state = state.Decode(input, _childOutput);
// If finished, call finishDecode
if (state == null)
return FinishDecode(_childProducts, output);
Int32 newPos = input.Position;
// Wait for more data if nothing is consumed and state didn't change.
if (newPos == pos && oldState == state)
break;
pos = newPos;
}
return this;
}
catch (Exception)
{
state = null;
throw;
}
finally
{
_currentState = state;
// Destroy if decoding is finished or failed.
if (state == null)
Cleanup();
}
}
public MessageDecoderResult Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
try
{
input.Skip(MIN_REQUIRED_FRAME_LENGTH);
var command = commandParser.Parse(input);
output.Write(command);
return MessageDecoderResult.OK;
}
catch (Exception ex)
{
var remoteAddr = string.Empty;
if (session != null && session.RemoteEndPoint != null) remoteAddr = session.RemoteEndPoint.ToString();
log.Error(ex, new Dictionary<string, string> { { "RemoteAddr", remoteAddr } });
return MessageDecoderResult.NotOK;
}
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
while (input.HasRemaining)
{
switch (_counter)
{
case 0:
_highByte = input.Get() & 0xff;
break;
case 1:
_counter = 0;
return FinishDecode((Int16)((_highByte << 8) | (input.Get() & 0xff)), output);
}
_counter++;
}
return this;
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
while (input.HasRemaining)
{
switch (_counter)
{
case 0:
_highByte = input.Get() & 0xff;
break;
case 1:
_counter = 0;
return(FinishDecode((Int16)((_highByte << 8) | (input.Get() & 0xff)), output));
}
_counter++;
}
return(this);
}
private void DecodeRemainingAndInput(ByteBuffer input, IProtocolDecoderOutput output)
{
_logger.Debug(string.Format("DecodeRemainingAndInput: input {0}, remaining {1}", input.Remaining, _remaining.Position));
// replace the _remainder buffer, so that we can leave the
// original one alone. Necessary because some consumer splice
// the buffer and only consume it until later, causing
// a race condition if we compact it too soon.
ByteBuffer newRemainding = AllocateBuffer();
ByteBuffer temp = _remaining;
_remaining = newRemainding;
temp.Put(input);
temp.Flip();
try
{
DecodeAll(temp, output);
} finally
{
if ( temp.Remaining > 0 )
_remaining.Put(temp);
}
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
Int32 beginPos = input.Position;
Int32 limit = input.Limit;
for (Int32 i = beginPos; i < limit; i++)
{
Byte b = input.Get(i);
if (!CanSkip(b))
{
input.Position = i;
Int32 answer = _skippedBytes;
_skippedBytes = 0;
return FinishDecode(answer);
}
_skippedBytes++;
}
input.Position = limit;
return this;
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
while (input.HasRemaining)
{
switch (_counter)
{
case 0:
_firstByte = input.Get() & 0xff;
break;
case 1:
_secondByte = input.Get() & 0xff;
break;
case 2:
_thirdByte = input.Get() & 0xff;
break;
case 3:
_counter = 0;
return FinishDecode((_firstByte << 24) | (_secondByte << 16) | (_thirdByte << 8) | (input.Get() & 0xff), output);
}
_counter++;
}
return this;
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
Int32 beginPos = input.Position;
Int32 limit = input.Limit;
Int32 terminatorPos = -1;
for (Int32 i = beginPos; i < limit; i++)
{
Byte b = input.Get(i);
if (b == CR)
{
_lastIsCR = true;
}
else
{
if (b == LF && _lastIsCR)
{
terminatorPos = i;
break;
}
_lastIsCR = false;
}
}
if (terminatorPos >= 0)
{
IoBuffer product;
Int32 endPos = terminatorPos - 1;
if (beginPos < endPos)
{
input.Limit = endPos;
if (_buffer == null)
{
product = input.Slice();
}
else
{
_buffer.Put(input);
product = _buffer.Flip();
_buffer = null;
}
input.Limit = limit;
}
else
{
// When input contained only CR or LF rather than actual data...
if (_buffer == null)
{
product = IoBuffer.Allocate(0);
}
else
{
product = _buffer.Flip();
_buffer = null;
}
}
input.Position = terminatorPos + 1;
return FinishDecode(product, output);
}
input.Position = beginPos;
if (_buffer == null)
{
_buffer = IoBuffer.Allocate(input.Remaining);
_buffer.AutoExpand = true;
}
_buffer.Put(input);
if (_lastIsCR)
{
_buffer.Position = _buffer.Position - 1;
}
return this;
}
protected abstract IDecodingState FinishDecode(IoBuffer product, IProtocolDecoderOutput output);
public void FinishDecode(IoSession session, IProtocolDecoderOutput output)
{
}
protected abstract IDecodingState FinishDecode(Boolean foundCRLF, IProtocolDecoderOutput output);
