public T Decode <T>()
{
if (_codec.Wrap)
{
Multicodec.ConsumeHeader(_stream, _codec.Header);
}
var hdr = Multicodec.PeekHeader(_stream);
if (hdr == null || hdr.Length == 0)
{
throw new EndOfStreamException();
}
var subcodec = _codec._codecs.SingleOrDefault(c => c.Header.SequenceEqual(hdr));
if (subcodec == null)
{
throw new Exception($"no codec found for {Encoding.UTF8.GetString(hdr)}");
}
_codec.Last = subcodec;
return(subcodec.Decoder(_stream).Decode <T>());
}
public async Task <T> DecodeAsync <T>(CancellationToken cancellationToken = default(CancellationToken))
{
if (_codec.Wrap)
{
await Multicodec.ConsumeHeaderAsync(_stream, _codec.Header, cancellationToken);
}
var hdr = await Multicodec.PeekHeaderAsync(_stream, cancellationToken);
if (hdr == null || hdr.Length == 0)
{
throw new EndOfStreamException();
}
var subcodec = _codec._codecs.SingleOrDefault(c => c.Header.SequenceEqual(hdr));
if (subcodec == null)
{
throw new Exception($"no codec found for {Encoding.UTF8.GetString(hdr)}");
}
_codec.Last = subcodec;
return(await subcodec.Decoder(_stream).DecodeAsync <T>(cancellationToken));
}
public T Decode <T>()
{
if (_codec._multicodec)
{
Multicodec.ConsumeHeader(_stream, _codec.Header);
}
return(CBORObject.Read(_stream).ToObject <T>());
}
public async Task<T> DecodeAsync<T>(CancellationToken cancellationToken)
{
if (_codec._multicodec)
await Multicodec.ConsumeHeaderAsync(_stream, _codec.Header, cancellationToken);
var bytes = await MessageIo.ReadMessageAsync(_stream, cancellationToken);
return (T)(object)bytes;
}
private static void Paths(StreamWriter w, StreamReader r)
{
Decode(r, (codec, obj) =>
{
var p = Multicodec.HeaderPath(codec.Last.Header);
w.WriteLine(Encoding.UTF8.GetString(p));
return(true);
});
}
public T Decode<T>()
{
if (_codec._multicodec)
Multicodec.ConsumeHeader(_stream, _codec.Header);
var bytes = MessageIo.ReadMessage(_stream);
return (T)(object)bytes;
}
public async Task <T> DecodeAsync <T>(CancellationToken cancellationToken = default(CancellationToken))
{
if (_codec._multicodec)
{
await Multicodec.ConsumeHeaderAsync(_stream, _codec.Header, cancellationToken);
}
return(CBORObject.Read(_stream).ToObject <T>());
}
public T Decode <T>()
{
if (_codec._multicodec)
{
Multicodec.ConsumeHeader(_stream, _codec.Header);
}
var cbor = CBORObject.Read(_stream);
return(JsonConvert.DeserializeObject <T>(cbor.ToJSONString()));
}
public async Task <T> DecodeAsync <T>(CancellationToken cancellationToken)
{
if (_codec._multicodec)
{
await Multicodec.ConsumeHeaderAsync(_stream, _codec.Header, cancellationToken);
}
var cbor = CBORObject.Read(_stream);
return(JsonConvert.DeserializeObject <T>(cbor.ToJSONString()));
}
private static void P2H(StreamWriter w, StreamReader r)
{
while (true)
{
var p = r.ReadLine();
if (string.IsNullOrEmpty(p))
{
break;
}
var hdr = Multicodec.Header(Encoding.UTF8.GetBytes(p));
w.Write(hdr);
}
}
private static void H2P(StreamWriter w, StreamReader r)
{
while (true)
{
var hdr = Multicodec.ReadHeader(r.BaseStream);
if (hdr == null || hdr.Length == 0)
{
return;
}
var p = Encoding.UTF8.GetString(Multicodec.HeaderPath(hdr));
w.WriteLine(p);
}
}
public async Task <T> DecodeAsync <T>(CancellationToken cancellationToken = default(CancellationToken))
{
if (_codec._multicodec)
{
await Multicodec.ConsumeHeaderAsync(_stream, _codec.Header, cancellationToken);
}
if (_codec._msgio)
{
return(Deserialize <T>(await MessageIo.ReadMessageAsync(_stream, cancellationToken)));
}
return(ProtoBuf.Serializer.DeserializeWithLengthPrefix <T>(_stream, PrefixStyle.Fixed32BigEndian));
}
public T Decode <T>()
{
if (_codec._multicodec)
{
Multicodec.ConsumeHeader(_stream, _codec.Header);
}
if (_codec._msgio)
{
return(Deserialize <T>(MessageIo.ReadMessage(_stream)));
}
return(ProtoBuf.Serializer.DeserializeWithLengthPrefix <T>(_stream, PrefixStyle.Fixed32BigEndian));
}
private static void Filter(StreamWriter w, StreamReader r, string path)
{
throw new NotImplementedException();
var hdr = Multicodec.Header(Encoding.UTF8.GetBytes(path));
Decode(r, (codec, value) =>
{
if (!codec.Last.Header.SequenceEqual(hdr))
{
return(true);
}
return(true);
});
}
public async Task<T> DecodeAsync<T>(CancellationToken cancellationToken)
{
if (_codec._multicodec)
await Multicodec.ConsumeHeaderAsync(_stream, _codec.Header, cancellationToken);
var json = string.Empty;
if (_codec._msgio)
{
var bytes = await MessageIo.ReadMessageAsync(_stream, cancellationToken);
json = Encoding.UTF8.GetString(bytes);
}
else
{
json = await ReadLineAsync(_stream, cancellationToken);
}
return JsonConvert.DeserializeObject<T>(json);
}
public T Decode<T>()
{
if (_codec._multicodec)
Multicodec.ConsumeHeader(_stream, _codec.Header);
var json = string.Empty;
if (_codec._msgio)
{
var bytes = MessageIo.ReadMessage(_stream);
json = Encoding.UTF8.GetString(bytes);
}
else
{
json = ReadLine(_stream);
}
return JsonConvert.DeserializeObject<T>(json);
}
private static ICodec CodecWithPath(string path)
{
var hdr = Multicodec.Header(Encoding.UTF8.GetBytes(path));
return(MuxCodec.CodecWithHeader(hdr, MuxCodec.Standard.Codecs));
}
private static void Header(StreamWriter w, string path)
{
w.Write(Multicodec.Header(Encoding.UTF8.GetBytes(path)));
}
