public static DuplexStreamMessage CreateOnCompleted(DuplexCallbackId id, StreamQbservableProtocol protocol)
{
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <DuplexStreamMessage>() != null);
return(CreateWithoutValue(QbservableProtocolMessageKind.DuplexOnCompleted, id, protocol));
}
public static DuplexStreamMessage CreateDisposeEnumerator(int clientId, StreamQbservableProtocol protocol)
{
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <DuplexStreamMessage>() != null);
return(CreateWithoutValue(QbservableProtocolMessageKind.DuplexDisposeEnumerator, clientId, protocol));
}
public static bool TryParse(StreamMessage message, StreamQbservableProtocol protocol, out DuplexStreamMessage duplexMessage)
{
Contract.Requires(message != null);
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <bool>() == (Contract.ValueAtReturn(out duplexMessage) != null));
switch (message.Kind)
{
case QbservableProtocolMessageKind.DuplexInvoke:
case QbservableProtocolMessageKind.DuplexResponse:
case QbservableProtocolMessageKind.DuplexSubscribeResponse:
case QbservableProtocolMessageKind.DuplexGetEnumeratorResponse:
case QbservableProtocolMessageKind.DuplexEnumeratorResponse:
case QbservableProtocolMessageKind.DuplexOnNext:
// The following cases are handled the same as the above cases to ensure that extra data is read, though it's unexpected.
case QbservableProtocolMessageKind.DuplexOnCompleted:
case QbservableProtocolMessageKind.DuplexSubscribe:
case QbservableProtocolMessageKind.DuplexDisposeSubscription:
case QbservableProtocolMessageKind.DuplexGetEnumerator:
case QbservableProtocolMessageKind.DuplexMoveNext:
case QbservableProtocolMessageKind.DuplexResetEnumerator:
case QbservableProtocolMessageKind.DuplexDisposeEnumerator:
duplexMessage = new DuplexStreamMessage(
message.Kind,
BitConverter.ToInt64(message.Data, 0),
protocol.Deserialize <object>(message.Data, offset: DuplexCallbackId.Size),
message.Data,
message.Length);
return(true);
case QbservableProtocolMessageKind.DuplexErrorResponse:
case QbservableProtocolMessageKind.DuplexGetEnumeratorErrorResponse:
case QbservableProtocolMessageKind.DuplexEnumeratorErrorResponse:
case QbservableProtocolMessageKind.DuplexOnError:
duplexMessage = new DuplexStreamMessage(
message.Kind,
BitConverter.ToInt64(message.Data, 0),
ExceptionDispatchInfo.Capture(protocol.Deserialize <Exception>(message.Data, offset: DuplexCallbackId.Size)),
message.Data,
message.Length);
return(true);
default:
duplexMessage = null;
return(false);
}
}
private static byte[] Serialize(DuplexCallbackId id, object value, StreamQbservableProtocol protocol)
{
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <byte[]>() != null);
var idData = BitConverter.GetBytes(id);
long serializedDataLength;
var serializedData = protocol.Serialize(value, out serializedDataLength);
var data = new byte[idData.Length + serializedDataLength];
Array.Copy(idData, data, idData.Length);
Array.Copy(serializedData, 0, data, idData.Length, serializedDataLength);
return(data);
}
public StreamServerDuplexQbservableProtocolSink(StreamQbservableProtocol protocol)
{
Contract.Requires(protocol != null);
this.protocol = protocol;
}
public static DuplexStreamMessage CreateInvoke(DuplexCallbackId id, object[] arguments, StreamQbservableProtocol protocol)
{
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <DuplexStreamMessage>() != null);
return(new DuplexStreamMessage(QbservableProtocolMessageKind.DuplexInvoke, id, arguments, Serialize(id, arguments, protocol)));
}
private static DuplexStreamMessage CreateWithoutValue(QbservableProtocolMessageKind kind, DuplexCallbackId id, StreamQbservableProtocol protocol)
{
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <DuplexStreamMessage>() != null);
return(new DuplexStreamMessage(kind, id, value: null, data: Serialize(id, null, protocol)));
}
public static DuplexStreamMessage CreateOnError(DuplexCallbackId id, ExceptionDispatchInfo error, StreamQbservableProtocol protocol)
{
Contract.Requires(error != null);
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <DuplexStreamMessage>() != null);
return(new DuplexStreamMessage(QbservableProtocolMessageKind.DuplexOnError, id, error, Serialize(id, error.SourceException, protocol)));
}
public static DuplexStreamMessage CreateOnNext(DuplexCallbackId id, object value, StreamQbservableProtocol protocol)
{
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <DuplexStreamMessage>() != null);
return(new DuplexStreamMessage(QbservableProtocolMessageKind.DuplexOnNext, id, value, Serialize(id, value, protocol)));
}
public static DuplexStreamMessage CreateSubscribeResponse(DuplexCallbackId id, int clientSubscriptionId, StreamQbservableProtocol protocol)
{
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <DuplexStreamMessage>() != null);
return(new DuplexStreamMessage(QbservableProtocolMessageKind.DuplexSubscribeResponse, id, clientSubscriptionId, Serialize(id, clientSubscriptionId, protocol)));
}
public static DuplexStreamMessage CreateEnumeratorResponse(DuplexCallbackId id, bool result, object current, StreamQbservableProtocol protocol)
{
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <DuplexStreamMessage>() != null);
var value = Tuple.Create(result, current);
return(new DuplexStreamMessage(QbservableProtocolMessageKind.DuplexEnumeratorResponse, id, value, Serialize(id, value, protocol)));
}
public static DuplexStreamMessage CreateDisposeSubscription(int subscriptionId, StreamQbservableProtocol protocol)
{
Contract.Requires(protocol != null);
Contract.Ensures(Contract.Result <DuplexStreamMessage>() != null);
return(CreateWithoutValue(QbservableProtocolMessageKind.DuplexDisposeSubscription, subscriptionId, protocol));
}
