public override object Deserialize(string serialized)
{
var b = Convert.FromBase64String(serialized);
using (var stream = new MemoryStream(b))
{
stream.Seek(0, SeekOrigin.Begin);
return(_serializer.Deserialize(stream));
}
}
public static T FromBytes(byte[] bytes)
{
using (var buffer = new MemoryStream(bytes))
{
return(ser.Deserialize(buffer));
}
}
private IEnumerable <object> ReadObjects <T>(StreamReader sr, IAvroSerializer <T> avroSerializer, Func <object, bool?> filterFunc = null)
{
while (true)
{
object obj = null;
try
{
obj = avroSerializer.Deserialize(sr.BaseStream);
if (IsDynamicType)
{
obj = new ChoDynamicObject(obj as Dictionary <string, object>);
}
}
catch (System.OverflowException)
{
break;
}
catch (SerializationException sEx)
{
if (sEx.Message.StartsWith("Invalid integer value in the input stream"))
{
break;
}
throw;
}
yield return(obj);
}
}
/// <summary>
/// Generate and store the metadata necessary to serialze and deserialize a specific message type.
/// </summary>
/// <typeparam name="TMessage">The class type of the message being registered.</typeparam>
internal void Register <TMessage>()
{
Logr.Log(Level.Info, "Registering message type: {0} {1}",
typeof(TMessage).FullName, typeof(TMessage).Name);
IAvroSerializer <TMessage> messageSerializer = AvroSerializer.Create <TMessage>();
Serialize serialize = (MemoryStream stream, object message) =>
{
messageSerializer.Serialize(stream, (TMessage)message);
};
serializeMap.Add(typeof(TMessage).Name, serialize);
Deserialize deserialize = (MemoryStream stream, object observer, long sequence) =>
{
TMessage message = messageSerializer.Deserialize(stream);
var msgObserver = observer as IObserver <IMessageInstance <TMessage> >;
if (msgObserver != null)
{
msgObserver.OnNext(new MessageInstance <TMessage>(sequence, message));
}
else
{
Logr.Log(Level.Warning, "Unhandled message received: {0}", message);
}
};
deserializeMap.Add(typeof(TMessage).Name, deserialize);
}
public static DefinedRuntimes FromBytes(byte[] serializedData)
{
using (Stream stream = new MemoryStream(serializedData))
{
return(Serializer.Deserialize(stream));
}
}
public T Deserialize(byte[] data)
{
using (var buffer = new MemoryStream(data))
{
return(_serializer.Deserialize(buffer));
}
}
/// <summary>
/// Read a message from the input byte array.
/// </summary>
/// <param name="data">Byte array containing a header message and message to be deserialized.</param>
/// <param name="observer">An object which implements the IObserver<>
/// interface for the message being deserialized.</param>
public void Read <T>(byte[] data, IObserver <IMessageInstance <T> > observer)
{
try
{
using (MemoryStream stream = new MemoryStream(data))
{
Header head = headerSerializer.Deserialize(stream);
Deserialize deserialize;
if (deserializeMap.TryGetValue(head.className, out deserialize))
{
deserialize(stream, observer, head.sequence);
}
else
{
throw new SeializationException(
"Request to deserialize unknown message type: " + head.className);
}
}
}
catch (Exception e)
{
Logr.Log(Level.Error, "Failure reading message.", e);
throw e;
}
}
/// <summary>
/// Read a message from the input byte array.
/// </summary>
/// <param name="data">Byte array containing a header message and message to be deserialized.</param>
/// <param name="observer">An object which implements the IObserver<>
/// interface for the message being deserialized.</param>
public void Read(byte[] data, object observer)
{
try
{
using (MemoryStream stream = new MemoryStream(data))
{
Header head = _headerSerializer.Deserialize(stream);
Log.Log(Level.Verbose, "Message header {0}", head);
Deserialize deserialize;
if (_deserializeMap.TryGetValue(head.className, out deserialize))
{
deserialize(stream, observer, head.sequence);
}
else
{
throw new SeializationException(
"Request to deserialize unknown message type: " + head.className);
}
}
}
catch (Exception e)
{
Log.Log(Level.Error, "Failure reading message.", e);
throw e;
}
}
public T Deserialize(byte[] arrayToDeserialize)
{
using (var memStream = new MemoryStream(arrayToDeserialize))
{
return(avroSerializer.Deserialize(memStream));
}
}
/// <summary>
/// Converts a byte array to an object using Avro deserialization.
/// </summary>
/// <param name="data">The byte array to deserialize</param>
/// <returns>The deserialized object</returns>
public static T AvroDeserialize <T>(byte[] data)
{
IAvroSerializer <T> deserializer = AvroSerializer.Create <T>();
using (MemoryStream stream = new MemoryStream(data))
{
return(deserializer.Deserialize(stream));
}
}
public T Deserialize(byte[] data)
{
var buffer = data.Skip(5).ToArray();
using (var memoryStream = new MemoryStream(buffer))
{
return(avroSerializer.Deserialize(memoryStream));
}
}
public TestKafkaModel Deserialize(byte[] data)
{
try
{
using (var memoryStream = new MemoryStream(data))
{
var result = (AvroRecord)avroSerializer.Deserialize(memoryStream);
return(new TestKafkaModel
{
Timestamp = result.GetField <long>("timestamp"),
Payload = result.GetField <byte[]>("payload")
});
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public Tuple <K, V> ConsumeNext()
{
var next = ConsumeInternal();
using (var keyStream = new MemoryStream(next.Key))
using (var keyReader = new BinaryReader(keyStream))
using (var valueStream = new MemoryStream(next.Payload))
using (var valueReader = new BinaryReader(valueStream))
{
keyReader.ReadByte();
var keySchemaId = keyReader.ReadInt32();
var key = _keySerde.Deserialize(keyStream);
valueReader.ReadByte();
var valueSchemaId = valueReader.ReadInt32();
var value = _valueSerde.Deserialize(valueStream);
return(new Tuple <K, V>(key, value));
}
}
public override Catalog Deserialize(Stream stream)
{
return(serializer.Deserialize(stream));
}
private object Deserialize(Stream stream)
{
return(_serializer.Deserialize(stream));
}