public static bool TryParse(ReadOnlyMemory <byte> bytes, out NewConnectionIdFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new NewConnectionIdFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeBytes);
if (!type.IsNewConnectionId())
{
return(false);
}
var sequenceNumber = VariableLengthEncoding.Decode32(afterTypeBytes.Span, out var decodedLength);
var afterSequenceNumberBytes = afterTypeBytes.Slice(decodedLength);
var sequenceNumberToRetire = VariableLengthEncoding.Decode32(afterSequenceNumberBytes.Span, out decodedLength);
var afterSequenceNumberToRetiryBytes = afterSequenceNumberBytes.Slice(decodedLength);
if (sequenceNumberToRetire > sequenceNumber)
{
throw new EncodingException();
}
var connectionId = PacketConnectionId.Parse(afterSequenceNumberToRetiryBytes, out var afterConnectionIdBytes);
var resetToken = ParseResetToken(afterConnectionIdBytes, out var afterTokenBytes);
result = new NewConnectionIdFrame(sequenceNumber, sequenceNumberToRetire, connectionId, resetToken);
remainings = afterTokenBytes;
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out ConnectionCloseFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new ConnectionCloseFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeBytes);
if (!type.IsConnectionClose())
{
return(false);
}
var error = new Error();
var afterErrorBytes = afterTypeBytes;
if (type.HasApplicationError())
{
error = Error.ParseApplication(afterTypeBytes, out afterErrorBytes);
}
if (type.HasTransportError())
{
error = Error.ParseTransport(afterTypeBytes, out afterErrorBytes);
}
var afterErrorFrameTypeBytes = afterErrorBytes;
var errorFrameType = type.HasTransportError() ? FrameType.Parse(afterErrorBytes, out afterErrorFrameTypeBytes) : new FrameType?();
var reasonPhrase = ReasonPhrase.Parse(afterErrorFrameTypeBytes, out var afterReasonPhraseBytes);
result = new ConnectionCloseFrame(error, errorFrameType, reasonPhrase);
remainings = afterReasonPhraseBytes;
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out DataBlockedFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new DataBlockedFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeBytes);
if (!type.IsDataBlocked())
{
return(false);
}
var dataLimit = VariableLengthEncoding.Decode32(afterTypeBytes.Span, out var decodedLength);
result = new DataBlockedFrame(dataLimit);
remainings = afterTypeBytes.Slice(decodedLength);
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out StreamsBlockedFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new StreamsBlockedFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeBytes);
if (!type.IsStreamsBlocked())
{
return(false);
}
var streamLimit = VariableLengthEncoding.Decode32(afterTypeBytes.Span, out var decodedLength);
result = new StreamsBlockedFrame(streamLimit, type.ForBidirectional(), type.ForUnidirectional());
remainings = afterTypeBytes.Slice(decodedLength);
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out PathFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new PathFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeBytes);
if (!type.IsPath())
{
return(false);
}
var data = ParseData(afterTypeBytes, out var afterDataBytes);
result = new PathFrame(type.IsChallenge(), type.IsResponse(), data);
remainings = afterDataBytes;
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out NewTokenFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new NewTokenFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeRemainings);
if (!type.IsNewToken())
{
return(false);
}
var token = PacketToken.Parse(afterTypeRemainings, out var afterTokenBytes);
result = new NewTokenFrame(token);
remainings = afterTokenBytes;
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out MaxStreamDataFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new MaxStreamDataFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeBytes);
if (!type.IsMaxStreamData())
{
return(false);
}
var streamId = StreamId.Parse(afterTypeBytes, out var afterStreamIdBytes);
var maxDataLength = VariableLengthEncoding.Decode32(afterStreamIdBytes.Span, out var decodedLength);
result = new MaxStreamDataFrame(streamId, maxDataLength);
remainings = afterStreamIdBytes.Slice(decodedLength);
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out RetireConnectionIdFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new RetireConnectionIdFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeBytes);
if (!type.IsRetireConnectionId())
{
return(false);
}
var sequenceNumber = VariableLengthEncoding.Decode32(afterTypeBytes.Span, out var decodedLength);
var afterSequenceNumberBytes = afterTypeBytes.Slice(decodedLength);
result = new RetireConnectionIdFrame(sequenceNumber);
remainings = afterSequenceNumberBytes;
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out StopSendingFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new StopSendingFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeRemainings);
if (!type.IsStopSending())
{
return(false);
}
var streamId = StreamId.Parse(afterTypeRemainings, out var afterStreamIdBytes);
var applicationError = Error.ParseApplication(afterStreamIdBytes, out var afterApplicationErrorBytes);
result = new StopSendingFrame(streamId, applicationError);
remainings = afterApplicationErrorBytes;
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out ResetStreamFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new ResetStreamFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeRemainings);
if (!type.IsResetStream())
{
return(false);
}
var streamId = StreamId.Parse(afterTypeRemainings, out var afterStreamIdBytes);
var error = Error.ParseApplication(afterStreamIdBytes, out var afterApplicationErrorBytes);
var finalSize = VariableLengthEncoding.Decode32(afterApplicationErrorBytes.Span, out var decodedLength);
result = new ResetStreamFrame(streamId, error, finalSize);
remainings = afterApplicationErrorBytes.Slice(decodedLength);
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out StreamFrame result, out ReadOnlyMemory <byte> remainings)
{
result = new StreamFrame();
remainings = ReadOnlyMemory <byte> .Empty;
var type = FrameType.Parse(bytes, out var afterTypeBytes);
if (!type.IsStream())
{
return(false);
}
var streamId = StreamId.Parse(afterTypeBytes, out var afterStreamIdBytes);
var offset = ParseOffset(afterStreamIdBytes, type, out var afterOffsetBytes);
var data = ParseData(afterOffsetBytes, type, out var afterDataBytes);
var isFinal = type.HasFinal();
result = new StreamFrame(streamId, offset, isFinal, data);
remainings = afterDataBytes;
return(true);
}
public static bool TryParse(ReadOnlyMemory <byte> bytes, out ReadOnlyMemory <byte> remainings)
{
return(FrameType
.Parse(bytes, out remainings)
.IsHandshakeDone());
}
