public INngResult <IReqRepAsyncContext <IMessage> > CreateReqRepAsyncContext(ISocket socket)
{
var ctx = new ReqAsyncCtx <IMessage>();
ctx.Init(this, socket, ctx.callback);
return(NngResult.Ok <IReqRepAsyncContext <IMessage> >(ctx));
}
public INngResult <ISendReceiveAsyncContext <IMessage> > CreateSendReceiveAsyncContext(ISocket socket)
{
var ctx = new SendReceiveAsyncContext <IMessage>();
ctx.Init(this, socket, ctx.callback);
return(NngResult.Ok <ISendReceiveAsyncContext <IMessage> >(ctx));
}
public static async Task <NngResult <T> > RetryAgain <T>(Func <NngResult <T> > func)
{
NngResult <T> res = func();
while (res.IsErr(Defines.NngErrno.EAGAIN))
{
await Task.Delay(10);
res = func();
}
return(res);
}
public static async Task <NngResult <T> > RetryAgain <T>(CancellationTokenSource cts, Func <NngResult <T> > func)
{
NngResult <T> res = func();
while (res.IsErr(Defines.NngErrno.EAGAIN) && !cts.IsCancellationRequested)
{
await Task.Delay(10);
res = func();
}
return(res);
}
public NngResult <TSocket> Listen <TSocket>(NngResult <TSocket> socketRes, string url) where TSocket : ISocket
{
if (socketRes.TryOk(out var ok))
{
var res = nng_listen(ok.NngSocket, url, 0);
if (res != 0)
{
return(NngResult <TSocket> .Fail(res));
}
}
return(socketRes);
}
public NngResult <ISendReceiveAsyncContext <IMessage> > CreateSendReceiveAsyncContext(ISocket socket, SendReceiveContextSubtype subtype)
{
switch (subtype)
{
case SendReceiveContextSubtype.Bus:
case SendReceiveContextSubtype.Pair:
return(SendReceiveAsyncContext <IMessage> .Create(this, socket));
default:
return(NngResult <ISendReceiveAsyncContext <IMessage> > .Err(NngErrno.EINVAL));
}
}
public INngResult <TSocket> Listen <TSocket>(INngResult <TSocket> socketRes, string url) where TSocket : ISocket
{
if (socketRes is NngOk <TSocket> ok)
{
var res = nng_listen(ok.Result.NngSocket, url, 0);
if (res != 0)
{
return(NngResult.Fail <TSocket>(res));
}
}
return(socketRes);
}
public static T listenOrDial <T>(this NngResult <T> socket, CommandOption listenOpt, CommandOption dialOpt)
where T : ISocket
{
if (listenOpt.HasValue())
{
return(socket.ThenListen(listenOpt.Value()).Unwrap());
}
else if (dialOpt.HasValue())
{
return(socket.ThenDial(dialOpt.Value()).Unwrap());
}
else
{
throw new ArgumentException("Must --listen or --dial");
}
}
public static NngResult <T> ThenListenAs <T>(this NngResult <T> result, out INngListener listener, string url, Native.Defines.NngFlag flags = default)
where T : INngSocket
{
listener = null;
if (result.IsOk())
{
var socket = result.Ok();
var res = socket.ListenWithListener(url, flags);
if (res.IsOk())
{
listener = res.Ok();
}
else
{
return(res.IntoErr <T>());
}
}
return(result);
}
public static NngResult <T> ThenListen <T>(this NngResult <T> result, string url, Native.Defines.NngFlag flags = default)
where T : INngSocket
{
return(result.Then(socket => socket.Listen(url, flags)));
}
/// <summary>
/// Creates a dialer or listener associated with a socket and starts it.
/// </summary>
/// <returns>The or listen.</returns>
/// <param name="factory">Factory used to dial/listen.</param>
/// <param name="socketRes">Socket the dialer/listener is associated with</param>
/// <param name="url">URL used by dialer/listener</param>
/// <param name="isListener">If set to <c>true</c> is listener, else is dialer</param>
/// <typeparam name="TSocket">The 1st type parameter.</typeparam>
/// <typeparam name="TMsg">The 2nd type parameter.</typeparam>
public static NngResult <TSocket> DialOrListen <TSocket, TMsg>(this IAPIFactory <TMsg> factory, NngResult <TSocket> socketRes, string url, bool isListener)
where TSocket : ISocket
{
if (socketRes.IsOk())
{
if (isListener)
{
return(factory.Listen <TSocket>(socketRes, url));
}
else
{
return(factory.Dial <TSocket>(socketRes, url));
}
}
return(socketRes);
}
