private async Task <int> ComplexRead(BytesSegment bs)
{
await WaitBeforeRead;
WaitBeforeRead = AwaitableWrapper.GetCompleted();
var r = await _ReadAsyncR(bs, true);
OnRead(bs.Sub(0, r));
return(r);
}
private async Task <BytesSegment> ReadNB_Complex(int maxSize)
{
await WaitBeforeRead;
WaitBeforeRead = AwaitableWrapper.GetCompleted();
var r = await ReadNB(maxSize, true);
OnRead(r);
return(r);
}
private void MoveNext()
{
if (step == 0)
{
}
else if (step == 1)
{
goto STEP1;
}
else
{
throw new Exception();
}
//while (pos < bs.Len) {
WHILE:
try {
if (!(pos < bs.Len))
{
goto EWHILE;
}
awaitable = myStream.ReadAsyncR(bs.Sub(pos));
step = 1;
if (awaitable.IsCompleted)
{
goto STEP1;
}
awaitable.UnsafeOnCompleted(_moveNext);
} catch (Exception e) {
ResetState();
SetException(e);
return;
}
return;
STEP1:
try {
var read = awaitable.GetResult();
if (read == 0)
{
throw new DisconnectedException($"unexpected EOF while ReadFull() (count={bs.Len}, pos={pos})");
}
pos += read;
} catch (Exception e) {
ResetState();
SetException(e);
return;
}
goto WHILE;
//}
EWHILE:
ResetState();
SetResult(VoidType.Void);
return;
}
public AwaitableWrapper WriteAsyncR(BytesSegment bs)
{
var rSync = TryWriteNonblocking(bs);
if (rSync == bs.Len)
{
Interlocked.Increment(ref ctr.Wsync);
return(AwaitableWrapper.GetCompleted());
}
bs.SubSelf(Math.Max(rSync, 0));
return(WriteAsyncRImpl(bs));
}
public virtual AwaitableWrapper ReadFullAsyncR(BytesSegment bs)
{
if (LengthCanSyncRead >= bs.Len)
{
var task = ReadAsyncR(bs, true);
if (!(task.IsCompleted && task.GetResult() == bs.Len))
{
Logging.errorAndThrow($"BUG in ReadAsync(bs, true)! (bs.Len={bs.Len})");
}
return(AwaitableWrapper.GetCompleted());
}
else
{
return(ReadFullAsyncRImpl(bs));
}
}
private AwaitableWrapper <BytesSegment> ReadNBAsyncRWrapper(int maxSize)
{
if (_nb_ra == null)
{
_nb_ra = new ReusableAwaiter <BytesSegment>();
}
else
{
_nb_ra.Reset();
}
var bs = BufferPool.GlobalGetBs(maxSize);
var awaiter = BaseStream.ReadAsyncR(bs);
if (awaiter.IsCompleted)
{
_nb_ra.SetResult(bs.Sub(0, awaiter.GetResult()));
}
else
{
_nb_bs = bs;
if (_nb_continuation == null)
{
_nb_continuation = () => {
var _bs = _nb_bs;
var _awaiter = _nb_awaiter;
_nb_bs.ResetSelf();
_nb_awaiter = default(AwaitableWrapper <int>);
int r;
try {
r = _awaiter.GetResult();
} catch (Exception e) {
_nb_ra.SetException(e);
return;
}
_nb_ra.SetResult(_bs.Sub(0, r));
}
}
;
_nb_awaiter = awaiter;
awaiter.OnCompleted(_nb_continuation);
}
return(new AwaitableWrapper <BytesSegment>(_nb_ra));
}
public AwaitableWrapper Send(BytesSegment bs, IPEndPoint destEP)
{
relay.ActiveConnection(this);
Interlocked.Increment(ref relay.sentPackets);
return(remoteUdp?.WriteToAsyncR(bs, destEP) ?? AwaitableWrapper.GetCompleted());
}
