public DynamicElementLengthDelimitedArrayReflector(Type classThatHasThisField, String fieldName,
IsLastElement isLastElementCallback, IInstanceSerializer <ElementType> elementSerializer)
: base(classThatHasThisField, fieldName, typeof(ElementType[]))
{
this.isLastElementCallback = isLastElementCallback;
this.elementSerializer = elementSerializer;
}
public DynamicSizeElementArrayReflector(Type classThatHasThisField, String fieldName, Byte arraySizeByteCount,
IInstanceSerializer <ElementType> elementSerializer)
: base(classThatHasThisField, fieldName, typeof(ElementType[]))
{
this.arraySizeByteCount = arraySizeByteCount;
this.elementSerializer = elementSerializer;
}
public static UInt32 SerializeCommand <T>(IInstanceSerializer <T> serializer, Byte commandID, T command, Buf buffer, UInt32 offset)
{
UInt32 commandLength = 1 + serializer.SerializationLength(command);
offset = FrameProtocol.SetupFrame(buffer, offset, commandLength);
buffer.array[offset++] = commandID;
return(serializer.Serialize(buffer.array, offset, command));
}
public static String DataSmallString <T>(this IInstanceSerializer <T> instanceSerializer, T instance, StringBuilder builder)
{
builder.Length = 0;
instanceSerializer.DataSmallString(instance, builder);
String dataString = builder.ToString();
builder.Length = 0;
return(dataString);
}
public T CallBlockingTcp <T>(UInt32 procedureNumber, ISerializer requestSerializer, IInstanceSerializer <T> responseSerializer, ByteArrayReference buffer)
{
UInt32 transmissionID = nextTransactionID++;
RpcMessage callMessage = new RpcMessage(transmissionID, new RpcCall(programHeader,
procedureNumber, credentials, verifier));
callMessage.SendTcp(socket, buffer, requestSerializer);
UInt32 contentOffset, contentOffsetLimit;
RpcMessage replyMessage = new RpcMessage(socket, buffer, out contentOffset, out contentOffsetLimit);
if (replyMessage.messageType != RpcMessageType.Reply)
{
throw new InvalidOperationException(String.Format("Received an Rpc call from '{0}' but expected an rpc reply", socket.RemoteEndPoint));
}
if (replyMessage.transmissionID != transmissionID)
{
throw new InvalidOperationException(String.Format("Expected reply with transmission id {0} but got {1}", transmissionID, replyMessage.transmissionID));
}
RpcReply reply = replyMessage.reply;
RpcCallFailedException.VerifySuccessfulReply(callMessage.call, reply);
T instance;
UInt32 offset = responseSerializer.Deserialize(buffer.array, contentOffset, contentOffsetLimit, out instance);
if (offset != contentOffsetLimit)
{
StringBuilder dataBuidler = new StringBuilder();
throw new InvalidOperationException(String.Format("Deserialization of rpc message '{0}' as the following '{1}' resulted in an offset of {2}, but the record had {3} bytes",
DataStringBuilder.DataString(reply, dataBuidler), DataStringBuilder.DataString(responseSerializer, instance, dataBuidler), offset, contentOffsetLimit));
}
return(instance);
}
public InstanceSerializerAdapter(IInstanceSerializer <T> serializer, T instance)
{
this.serializer = serializer;
this.instance = instance;
}
