public ContextGroupTimeout(Dispatcher dispatcher, ContextGroup contextGroup, std::chrono.nanoseconds timeout)
{
this.workingContextGroup = dispatcher;
this.timeoutTimer = dispatcher;
//C++ TO C# CONVERTER TODO TASK: Only lambda expressions having all locals passed by reference can be converted to C#:
//ORIGINAL LINE: workingContextGroup.spawn([&, timeout]
workingContextGroup.spawn(() =>
{
try
{
timeoutTimer.sleep(timeout);
contextGroup.interrupt();
}
catch (InterruptedException)
{
}
});
}
public OperationTimeout(Dispatcher dispatcher, T @object, std::chrono.nanoseconds timeout)
{
this.@object = @object;
this.timerContext = dispatcher;
this.timeoutTimer = dispatcher;
//C++ TO C# CONVERTER TODO TASK: Only lambda expressions having all locals passed by reference can be converted to C#:
//ORIGINAL LINE: timerContext.spawn([this, timeout]()
timerContext.spawn(() =>
{
try
{
timeoutTimer.sleep(timeout);
timerContext.interrupt();
}
catch
{
}
});
}
public void sleep(std::chrono.nanoseconds duration)
{
Debug.Assert(dispatcher != null);
Debug.Assert(context == null);
if (dispatcher.interrupted())
{
throw InterruptedException();
}
if (duration.count() == 0)
{
dispatcher.yield();
}
else
{
timer = dispatcher.getTimer();
var seconds = std::chrono.duration_cast <std::chrono.seconds>(duration);
itimerspec expires = new itimerspec();
expires.it_interval.tv_nsec = expires.it_interval.tv_sec = 0;
expires.it_value.tv_sec = seconds.count();
expires.it_value.tv_nsec = std::chrono.duration_cast <std::chrono.nanoseconds>(duration - seconds).count();
timerfd_settime(timer, 0, expires, null);
ContextPair contextPair = new ContextPair();
OperationContext timerContext = new OperationContext();
timerContext.interrupted = false;
timerContext.context = dispatcher.getCurrentContext();
contextPair.writeContext = null;
contextPair.readContext = timerContext;
epoll_event timerEvent = new epoll_event();
timerEvent.events = EPOLLIN | EPOLLONESHOT;
timerEvent.data.ptr = contextPair;
if (epoll_ctl(dispatcher.getEpoll(), EPOLL_CTL_MOD, timer, timerEvent) == -1)
{
throw new System.Exception("Timer::sleep, epoll_ctl failed, " + lastErrorMessage());
}
dispatcher.getCurrentContext().interruptProcedure = () =>
{
Debug.Assert(dispatcher != null);
Debug.Assert(context != null);
OperationContext timerContext = (OperationContext)context;
if (!timerContext.interrupted)
{
uint64_t value = 0;
if (global::read(timer, value, sizeof(uint64_t)) == -1)
{
//C++ TO C# CONVERTER TODO TASK: There is no equivalent to most C++ 'pragma' directives in C#:
//#pragma GCC diagnostic push
//C++ TO C# CONVERTER TODO TASK: There is no equivalent to most C++ 'pragma' directives in C#:
//#pragma GCC diagnostic ignored "-Wlogical-op"
if (errno == EAGAIN || errno == EWOULDBLOCK)
{
//C++ TO C# CONVERTER TODO TASK: There is no equivalent to most C++ 'pragma' directives in C#:
//#pragma GCC diagnostic pop
timerContext.interrupted = true;
dispatcher.pushContext(timerContext.context);
}
else
{
throw new System.Exception("Timer::sleep, interrupt procedure, read failed, " + lastErrorMessage());
}
}
else
{
Debug.Assert(value > 0);
dispatcher.pushContext(timerContext.context);
}
epoll_event timerEvent = new epoll_event();
timerEvent.events = EPOLLONESHOT;
timerEvent.data.ptr = null;
if (epoll_ctl(dispatcher.getEpoll(), EPOLL_CTL_MOD, timer, timerEvent) == -1)
{
throw new System.Exception("Timer::sleep, interrupt procedure, epoll_ctl failed, " + lastErrorMessage());
}
}
};
context = timerContext;
dispatcher.dispatch();
dispatcher.getCurrentContext().interruptProcedure = null;
Debug.Assert(dispatcher != null);
Debug.Assert(timerContext.context == dispatcher.getCurrentContext());
Debug.Assert(contextPair.writeContext == null);
Debug.Assert(context == &timerContext);
context = null;
timerContext.context = null;
dispatcher.pushTimer(timer);
if (timerContext.interrupted)
{
throw InterruptedException();
}
}
}
//C++ TO C# CONVERTER TODO TASK: 'rvalue references' have no equivalent in C#:
public P2pContext(Dispatcher dispatcher, TcpConnection && conn, bool isIncoming, NetworkAddress remoteAddress, std::chrono.nanoseconds timedSyncInterval, CORE_SYNC_DATA timedSyncData)
{
this.incoming = isIncoming;
this.remoteAddress = new NetworkAddress(remoteAddress);
this.dispatcher = dispatcher;
this.contextGroup = dispatcher;
this.timeStarted = Clock.now();
//C++ TO C# CONVERTER TODO TASK: The following line was determined to be a copy assignment (rather than a reference assignment) - this should be verified and a 'CopyFrom' method should be created:
//ORIGINAL LINE: this.timedSyncInterval = timedSyncInterval;
this.timedSyncInterval.CopyFrom(timedSyncInterval);
this.timedSyncData = new CryptoNote.CORE_SYNC_DATA(timedSyncData);
this.timedSyncTimer = dispatcher;
this.timedSyncFinished = dispatcher;
this.connection = new System.TcpConnection(std::move(conn));
this.writeEvent = dispatcher;
this.readEvent = dispatcher;
writeEvent.set();
readEvent.set();
//C++ TO C# CONVERTER TODO TASK: The following line was determined to be a copy assignment (rather than a reference assignment) - this should be verified and a 'CopyFrom' method should be created:
//ORIGINAL LINE: lastReadTime = timeStarted;
lastReadTime.CopyFrom(timeStarted); // use current time
contextGroup.spawn(std::bind(this.timedSyncLoop, this));
}
public void setConnectTimeout(std::chrono.nanoseconds timeout)
{
//C++ TO C# CONVERTER TODO TASK: The following line was determined to be a copy assignment (rather than a reference assignment) - this should be verified and a 'CopyFrom' method should be created:
//ORIGINAL LINE: connectTimeout = timeout;
connectTimeout.CopyFrom(timeout);
}
// setters
// setters
public void setTimedSyncInterval(std::chrono.nanoseconds interval)
{
//C++ TO C# CONVERTER TODO TASK: The following line was determined to be a copy assignment (rather than a reference assignment) - this should be verified and a 'CopyFrom' method should be created:
//ORIGINAL LINE: timedSyncInterval = interval;
timedSyncInterval.CopyFrom(interval);
}
