private void KeepAliveFilterForIdleStatus(IdleStatus status)
{
using (AsyncSocketConnector connector = new AsyncSocketConnector())
{
KeepAliveFilter filter = new KeepAliveFilter(new ClientFactory(), status, KeepAliveRequestTimeoutHandler.Exception, INTERVAL, TIMEOUT);
filter.ForwardEvent = true;
connector.FilterChain.AddLast("keep-alive", filter);
Boolean gotException = false;
connector.ExceptionCaught += (s, e) =>
{
// A KeepAliveRequestTimeoutException will be thrown if no keep-alive response is received.
Console.WriteLine(e.Exception);
gotException = true;
};
IConnectFuture future = connector.Connect(new IPEndPoint(IPAddress.Loopback, port)).Await();
IoSession session = future.Session;
Assert.IsNotNull(session);
Thread.Sleep((INTERVAL + TIMEOUT + 3) * 1000);
Assert.IsFalse(gotException, "got an exception on the client");
session.Close(true);
}
}
//Constructor
public ECIdleState(GameObject _childCell, EnemyChildFSM _ecFSM)
{
m_Child = _childCell;
m_ecFSM = _ecFSM;
m_Main = m_ecFSM.m_EMain;
m_EMTransform = m_Main.transform;
m_fMaxMagnitude = 7.5f;
m_fTimerLimit = 1.5f;
m_fSpreadRange = m_Child.GetComponent <SpriteRenderer>().bounds.size.x / 10;
m_EMControl = m_Main.GetComponent <EMController>();
m_EMBounds = m_Main.GetComponent <SpriteRenderer>().bounds;
m_EMFSM = m_Main.GetComponent <EnemyMainFSM>();
m_ChildRB = m_Child.GetComponent <Rigidbody2D>();
m_MainRB = m_Main.GetComponent <Rigidbody2D>();
m_Collisions = new Collider2D[m_EMFSM.ECList.Count];
m_Neighbours = new List <GameObject>();
m_ecFSM.rigidbody2D.drag = 0f;
m_nIdleCount = 0;
m_CurrentIdleState = IdleStatus.None;
m_ShrinkRate = new Vector3(0.025f, -0.025f, 0f);
}
/// <inheritdoc/>
public override void SessionIdle(IoSession session, IdleStatus status)
{
if (status == IdleStatus.ReaderIdle)
{
throw new IOException("Read timeout");
}
}
//Constructor
public ECIdleState(GameObject _childCell, EnemyChildFSM _ecFSM)
{
m_Child = _childCell;
m_ecFSM = _ecFSM;
m_Main = m_ecFSM.m_EMain;
m_EMTransform = m_Main.transform;
m_fMaxMagnitude = 7.5f;
m_fTimerLimit = 1.5f;
m_fSpreadRange = m_Child.GetComponent<SpriteRenderer>().bounds.size.x/10;
m_EMControl = m_Main.GetComponent<EMController>();
m_EMBounds = m_Main.GetComponent<SpriteRenderer>().bounds;
m_EMFSM = m_Main.GetComponent<EnemyMainFSM>();
m_ChildRB = m_Child.GetComponent<Rigidbody2D>();
m_MainRB = m_Main.GetComponent<Rigidbody2D>();
m_Collisions = new Collider2D[m_EMFSM.ECList.Count];
m_Neighbours = new List<GameObject>();
m_ecFSM.rigidbody2D.drag = 0f;
m_nIdleCount = 0;
m_CurrentIdleState = IdleStatus.None;
m_ShrinkRate = new Vector3(0.025f,-0.025f,0f);
}
/// <inheritdoc/>
public Int32 GetIdleCount(IdleStatus status)
{
if (Config.GetIdleTime(status) == 0)
{
switch (status)
{
case IdleStatus.BothIdle:
Interlocked.Exchange(ref _idleCountForBoth, 0);
break;
case IdleStatus.ReaderIdle:
Interlocked.Exchange(ref _idleCountForRead, 0);
break;
case IdleStatus.WriterIdle:
Interlocked.Exchange(ref _idleCountForWrite, 0);
break;
}
}
switch (status)
{
case IdleStatus.BothIdle:
return(_idleCountForBoth);
case IdleStatus.ReaderIdle:
return(_idleCountForRead);
case IdleStatus.WriterIdle:
return(_idleCountForWrite);
default:
throw new ArgumentException("Unknown status", "status");
}
}
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
if (status == IdleStatus.ReaderIdle)
{
session.Close(true);
}
}
private void KeepAliveFilterForIdleStatus(IdleStatus status)
{
using (AsyncSocketConnector connector = new AsyncSocketConnector())
{
KeepAliveFilter filter = new KeepAliveFilter(new ClientFactory(), status, KeepAliveRequestTimeoutHandler.Exception, INTERVAL, TIMEOUT);
filter.ForwardEvent = true;
connector.FilterChain.AddLast("keep-alive", filter);
Boolean gotException = false;
connector.ExceptionCaught += (s, e) =>
{
// A KeepAliveRequestTimeoutException will be thrown if no keep-alive response is received.
Console.WriteLine(e.Exception);
gotException = true;
};
IConnectFuture future = connector.Connect(new IPEndPoint(IPAddress.Loopback, port)).Await();
IoSession session = future.Session;
Assert.IsNotNull(session);
Thread.Sleep((INTERVAL + TIMEOUT + 3) * 1000);
Assert.IsFalse(gotException, "got an exception on the client");
session.Close(true);
}
}
public void SessionIdle(IoSession session, IdleStatus status)
{
List <IAriesEventSubscriber> _subs;
lock (EventSubscribers)
_subs = new List <IAriesEventSubscriber>(EventSubscribers);
_subs.ForEach(x => x.SessionIdle(this));
}
/// <inheritdoc/>
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
if (IsBlocked(session))
BlockSession(session);
else
// forward if not blocked
base.SessionIdle(nextFilter, session, status);
}
void IoHandler.SessionIdle(IoSession session, IdleStatus status)
{
EventHandler <IoSessionIdleEventArgs> act = _service.SessionIdle;
if (act != null)
{
act(_service, new IoSessionIdleEventArgs(session, status));
}
}
/// <inheritdoc/>
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
if ((_eventTypes & IoEventType.SessionIdle) == IoEventType.SessionIdle)
{
IoFilterEvent ioe = new IoFilterEvent(nextFilter, IoEventType.SessionIdle, session, status);
FireEvent(ioe);
}
else
{
base.SessionIdle(nextFilter, session, status);
}
}
/// <inheritdoc/>
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
if (IsBlocked(session))
{
BlockSession(session);
}
else
{
// forward if not blocked
base.SessionIdle(nextFilter, session, status);
}
}
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
if ((_eventTypes & IoEventType.SessionIdle) == IoEventType.SessionIdle)
{
IoFilterEvent ioe = new IoFilterEvent(nextFilter, IoEventType.SessionIdle, session, status);
FireEvent(ioe);
}
else
{
base.SessionIdle(nextFilter, session, status);
}
}
public int GetIdleTime(IdleStatus status)
{
switch (status)
{
case IdleStatus.ReaderIdle:
return ReaderIdleTime;
case IdleStatus.WriterIdle:
return WriteTimeout;
case IdleStatus.BothIdle:
return BothIdleTime;
default:
throw new ArgumentException("Unknown status", nameof(status));
}
}
/// <inheritdoc/>
public Int32 GetIdleTime(IdleStatus status)
{
switch (status)
{
case IdleStatus.ReaderIdle:
return _idleTimeForRead;
case IdleStatus.WriterIdle:
return _idleTimeForWrite;
case IdleStatus.BothIdle:
return _idleTimeForBoth;
default:
throw new ArgumentException("Unknown status", "status");
}
}
/// <inheritdoc/>
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
if (status == _interestedIdleStatus)
{
if (!session.ContainsAttribute(WAITING_FOR_RESPONSE))
{
Object pingMessage = _messageFactory.GetRequest(session);
if (pingMessage != null)
{
nextFilter.FilterWrite(session, new DefaultWriteRequest(pingMessage));
//session.Write(pingMessage);
// If policy is OFF, there's no need to wait for
// the response.
if (_requestTimeoutHandler != KeepAliveRequestTimeoutHandler.DeafSpeaker)
{
MarkStatus(session);
if (_interestedIdleStatus == IdleStatus.BothIdle)
{
session.SetAttribute(IGNORE_READER_IDLE_ONCE);
}
}
else
{
ResetStatus(session);
}
}
}
else
{
HandlePingTimeout(session);
}
}
else if (status == IdleStatus.ReaderIdle)
{
if (session.RemoveAttribute(IGNORE_READER_IDLE_ONCE) == null)
{
if (session.ContainsAttribute(WAITING_FOR_RESPONSE))
{
HandlePingTimeout(session);
}
}
}
if (_forwardEvent)
{
nextFilter.SessionIdle(session, status);
}
}
public KeepAliveFilter(IKeepAliveMessageFactory messageFactory, IdleStatus interestedIdleStatus,
IKeepAliveRequestTimeoutHandler strategy, Int32 keepAliveRequestInterval, Int32 keepAliveRequestTimeout)
{
if (messageFactory == null)
throw new ArgumentNullException("messageFactory");
if (strategy == null)
throw new ArgumentNullException("strategy");
WAITING_FOR_RESPONSE = new AttributeKey(GetType(), "waitingForResponse");
IGNORE_READER_IDLE_ONCE = new AttributeKey(GetType(), "ignoreReaderIdleOnce");
_messageFactory = messageFactory;
_interestedIdleStatus = interestedIdleStatus;
_requestTimeoutHandler = strategy;
RequestInterval = keepAliveRequestInterval;
RequestTimeout = keepAliveRequestTimeout;
}
/// <inheritdoc/>
public DateTime GetLastIdleTime(IdleStatus status)
{
switch (status)
{
case IdleStatus.BothIdle:
return(_lastIdleTimeForBoth);
case IdleStatus.ReaderIdle:
return(_lastIdleTimeForRead);
case IdleStatus.WriterIdle:
return(_lastIdleTimeForWrite);
default:
throw new ArgumentException("Unknown status", "status");
}
}
public void SetIdleTime(IdleStatus status, int idleTime)
{
switch (status)
{
case IdleStatus.ReaderIdle:
ReaderIdleTime = idleTime;
break;
case IdleStatus.WriterIdle:
WriteTimeout = idleTime;
break;
case IdleStatus.BothIdle:
BothIdleTime = idleTime;
break;
default:
throw new ArgumentException("Unknown status", nameof(status));
}
}
public int GetIdleTime(IdleStatus status)
{
switch (status)
{
case IdleStatus.ReaderIdle:
return(ReaderIdleTime);
case IdleStatus.WriterIdle:
return(WriteTimeout);
case IdleStatus.BothIdle:
return(BothIdleTime);
default:
throw new ArgumentException("Unknown status", nameof(status));
}
}
/// <inheritdoc/>
public Boolean IsIdle(IdleStatus status)
{
switch (status)
{
case IdleStatus.BothIdle:
return(_idleCountForBoth > 0);
case IdleStatus.ReaderIdle:
return(_idleCountForRead > 0);
case IdleStatus.WriterIdle:
return(_idleCountForWrite > 0);
default:
throw new ArgumentException("Unknown status", "status");
}
}
internal Transition(StateMachine <TState, TTransition, TSignal> machine, TTransition name, TickType tickType) : base(name)
{
this.MachineI = machine;
this.CanTransitionI = true;
this.SignalsI = new List <Signal <TState, TTransition, TSignal> >();
this.actions = new TransitionActionList();
this.tickableActions = new TickableList();
this.startConditions = new TransitionConditionList();
this.finishConditions = new TransitionConditionList();
this.idleStatus = new IdleStatus(this, tickType);
this.startingStatus = new StartingStatus(this, tickType);
this.finishingStatus = new FinishingStatus(this, tickType);
this.status = this.idleStatus;
this.signal = null;
}
public override void Enter()
{
m_Child.transform.localScale = Vector3.one;
//If there is no idle status specified, start the idle status being the seperate status and set the previous status time being the current time in-game
if (m_CurrentIdleState == IdleStatus.None)
{
m_CurrentIdleState = IdleStatus.Seperate;
m_fPreviousStatusTime = Time.time;
}
//Obtain the specific seperate direction for the enemy child cell from the direction database
m_ecFSM.m_bHitWall = false;
m_SeperateDirection = DirectionDatabase.Instance.Extract();
m_fIdleScale = m_Main.transform.localScale.x * 0.85f;
m_ecFSM.rigidbody2D.drag = 0f;
m_nIdleCount++;
ECTracker.s_Instance.IdleCells.Add(m_ecFSM);
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="messageFactory">the factory to generate keep-alive messages</param>
/// <param name="interestedIdleStatus"></param>
/// <param name="strategy"></param>
/// <param name="keepAliveRequestInterval">the interval to send a keep-alive request</param>
/// <param name="keepAliveRequestTimeout">the time to wait for a keep-alive response before timed out</param>
public KeepAliveFilter(IKeepAliveMessageFactory messageFactory, IdleStatus interestedIdleStatus,
IKeepAliveRequestTimeoutHandler strategy, Int32 keepAliveRequestInterval, Int32 keepAliveRequestTimeout)
{
if (messageFactory == null)
{
throw new ArgumentNullException("messageFactory");
}
if (strategy == null)
{
throw new ArgumentNullException("strategy");
}
WAITING_FOR_RESPONSE = new AttributeKey(GetType(), "waitingForResponse");
IGNORE_READER_IDLE_ONCE = new AttributeKey(GetType(), "ignoreReaderIdleOnce");
_messageFactory = messageFactory;
_interestedIdleStatus = interestedIdleStatus;
_requestTimeoutHandler = strategy;
RequestInterval = keepAliveRequestInterval;
RequestTimeout = keepAliveRequestTimeout;
}
public void SetIdleTime(IdleStatus status, Int32 idleTime)
{
switch (status)
{
case IdleStatus.ReaderIdle:
_idleTimeForRead = idleTime;
break;
case IdleStatus.WriterIdle:
_idleTimeForWrite = idleTime;
break;
case IdleStatus.BothIdle:
_idleTimeForBoth = idleTime;
break;
default:
throw new ArgumentException("Unknown status", "status");
}
}
public void SetIdleTime(IdleStatus status, int idleTime)
{
switch (status)
{
case IdleStatus.ReaderIdle:
ReaderIdleTime = idleTime;
break;
case IdleStatus.WriterIdle:
WriteTimeout = idleTime;
break;
case IdleStatus.BothIdle:
BothIdleTime = idleTime;
break;
default:
throw new ArgumentException("Unknown status", nameof(status));
}
}
public override void Execute()
{
/*If the current idle status is cohesioning and the child cell had enter the main cell, stop its movement and let it follow the enemy main cell.
* Once all idling enemy child cell in the enemy main cell, reset their velocity, change the current idle status to seperate state and set the current time be the previous status time*/
if (m_CurrentIdleState == IdleStatus.Cohesion)
{
if (HasChildEnterMain(m_Child))
{
m_ChildRB.velocity = m_MainRB.velocity;
if (m_EMControl.bIsAllChildWithinMain)
{
AudioManager.PlayEMSoundEffect(EnemyMainSFX.IdleExpand);
ResetAllChildVelocity();
ResetAllHitWall();
m_CurrentIdleState = IdleStatus.Seperate;
m_fPreviousStatusTime = Time.time;
}
}
}
//If the current idle status is seperating, all the child cells are being spread out fully and it has been 1.5s since the previous change of state or the time passed had been 1.75s, change the idle status to cohesion and record the time
else if (m_CurrentIdleState == IdleStatus.Seperate && Time.time - m_fPreviousStatusTime > m_fTimerLimit)
{
AudioManager.PlayEMSoundEffect(EnemyMainSFX.IdleContract);
ResetAllHitWall();
m_CurrentIdleState = IdleStatus.Cohesion;
m_fPreviousStatusTime = Time.time;
}
if (m_CurrentIdleState == IdleStatus.Seperate && Time.time - m_fPreviousStatusTime > 0.75f * m_fTimerLimit && m_Child.transform.localScale.y > 0.5f)
{
m_Child.transform.localScale += m_ShrinkRate;
}
if (m_CurrentIdleState == IdleStatus.Cohesion && m_Child.transform.localScale != Vector3.one && m_Child.transform.localScale.y < 1f)
{
m_Child.transform.localScale -= m_ShrinkRate;
}
}
/// <summary>
/// Increases idle count.
/// </summary>
/// <param name="status">the <see cref="IdleStatus"/></param>
/// <param name="currentTime">the time</param>
public void IncreaseIdleCount(IdleStatus status, DateTime currentTime)
{
switch (status)
{
case IdleStatus.BothIdle:
Interlocked.Increment(ref _idleCountForBoth);
_lastIdleTimeForBoth = currentTime;
break;
case IdleStatus.ReaderIdle:
Interlocked.Increment(ref _idleCountForRead);
_lastIdleTimeForRead = currentTime;
break;
case IdleStatus.WriterIdle:
Interlocked.Increment(ref _idleCountForWrite);
_lastIdleTimeForWrite = currentTime;
break;
default:
throw new ArgumentException("Unknown status", "status");
}
}
public long GetIdleTimeInMillis(IdleStatus status)
{
return(GetIdleTime(status) * 1000L);
}
public void SessionIdle(IoSession session, IdleStatus status)
{
}
public override void SessionIdle(IoSession session, IdleStatus status)
{
countdown.Signal();
}
/// <summary>
/// Creates a new instance with the default properties.
/// <ul>
/// <li>keepAliveRequestInterval - 60 (seconds)</li>
/// <li>keepAliveRequestTimeout - 30 (seconds)</li>
/// </ul>
/// </summary>
/// <param name="messageFactory">the factory to generate keep-alive messages</param>
/// <param name="interestedIdleStatus"></param>
/// <param name="strategy"></param>
public KeepAliveFilter(IKeepAliveMessageFactory messageFactory, IdleStatus interestedIdleStatus,
IKeepAliveRequestTimeoutHandler strategy)
: this(messageFactory, interestedIdleStatus, strategy, 60, 30)
{ }
/// <inheritdoc/>
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
if (status == _interestedIdleStatus)
{
if (!session.ContainsAttribute(WAITING_FOR_RESPONSE))
{
Object pingMessage = _messageFactory.GetRequest(session);
if (pingMessage != null)
{
nextFilter.FilterWrite(session, new DefaultWriteRequest(pingMessage));
//session.Write(pingMessage);
// If policy is OFF, there's no need to wait for
// the response.
if (_requestTimeoutHandler != KeepAliveRequestTimeoutHandler.DeafSpeaker)
{
MarkStatus(session);
if (_interestedIdleStatus == IdleStatus.BothIdle)
{
session.SetAttribute(IGNORE_READER_IDLE_ONCE);
}
}
else
{
ResetStatus(session);
}
}
}
else
{
HandlePingTimeout(session);
}
}
else if (status == IdleStatus.ReaderIdle)
{
if (session.RemoveAttribute(IGNORE_READER_IDLE_ONCE) == null)
{
if (session.ContainsAttribute(WAITING_FOR_RESPONSE))
{
HandlePingTimeout(session);
}
}
}
if (_forwardEvent)
nextFilter.SessionIdle(session, status);
}
public override void SessionIdle(IoSession session, IdleStatus status)
{
Console.WriteLine("*** IDLE #" + session.GetIdleCount(IdleStatus.BothIdle) + " ***");
}
/// <summary>
/// </summary>
public IoSessionIdleEventArgs(IoSession session, IdleStatus idleStatus)
: base(session)
{
_idleStatus = idleStatus;
}
/// <inheritdoc/>
public override void SessionIdle(IoSession session, IdleStatus status)
{
if (status == IdleStatus.ReaderIdle)
throw new IOException("Read timeout");
}
public static void ResetStatics()
{
m_CurrentIdleState = IdleStatus.None;
}
/// <inheritdoc/>
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
Log(SessionIdleLevel, "IDLE");
base.SessionIdle(nextFilter, session, status);
}
public void SetIdleTime(IdleStatus status, Int32 idleTime)
{
switch (status)
{
case IdleStatus.ReaderIdle:
_idleTimeForRead = idleTime;
break;
case IdleStatus.WriterIdle:
_idleTimeForWrite = idleTime;
break;
case IdleStatus.BothIdle:
_idleTimeForBoth = idleTime;
break;
default:
throw new ArgumentException("Unknown status", "status");
}
}
public Int64 GetIdleTimeInMillis(IdleStatus status)
{
return GetIdleTime(status) * 1000L;
}
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
if (status == IdleStatus.ReaderIdle) session.Close(true);
}
public override void Enter()
{
m_Child.transform.localScale = Vector3.one;
//If there is no idle status specified, start the idle status being the seperate status and set the previous status time being the current time in-game
if(m_CurrentIdleState == IdleStatus.None)
{
m_CurrentIdleState = IdleStatus.Seperate;
m_fPreviousStatusTime = Time.time;
}
//Obtain the specific seperate direction for the enemy child cell from the direction database
m_ecFSM.m_bHitWall = false;
m_SeperateDirection = DirectionDatabase.Instance.Extract();
m_fIdleScale = m_Main.transform.localScale.x * 0.85f;
m_ecFSM.rigidbody2D.drag = 0f;
m_nIdleCount++;
ECTracker.s_Instance.IdleCells.Add(m_ecFSM);
}
/// <summary>
/// </summary>
public IoSessionIdleEventArgs(IoSession session, IdleStatus idleStatus)
: base(session)
{
_idleStatus = idleStatus;
}
/// <inheritdoc/>
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
_filter.SessionIdle(nextFilter, session, status);
}
public void SessionIdle(IoSession session, IdleStatus status)
{
// Do nothing
}
/// <inheritdoc/>
public virtual void SessionIdle(IoSession session, IdleStatus status)
{
// Empty handler
}
/// <summary>
/// On idle, we just write a message on the console
/// </summary>
public override void SessionIdle(IoSession session, IdleStatus status)
{
Console.WriteLine("IDLE " + session.GetIdleCount(status));
}
/// <summary>
/// </summary>
public IdleEventArgs(IdleStatus idleStatus)
{
_idleStatus = idleStatus;
}
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
_filter.SessionIdle(nextFilter, session, status);
}
/// <summary>
/// Creates a new instance with the default properties.
/// <ul>
/// <li>strategy - <see cref="KeepAliveRequestTimeoutHandler.Close"/></li>
/// <li>keepAliveRequestInterval - 60 (seconds)</li>
/// <li>keepAliveRequestTimeout - 30 (seconds)</li>
/// </ul>
/// </summary>
/// <param name="messageFactory">the factory to generate keep-alive messages</param>
/// <param name="interestedIdleStatus"></param>
public KeepAliveFilter(IKeepAliveMessageFactory messageFactory, IdleStatus interestedIdleStatus)
: this(messageFactory, interestedIdleStatus, KeepAliveRequestTimeoutHandler.Close)
{ }
/// <inheritdoc/>
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
Profile(_profileSessionIdle, _sessionIdleTimerWorker, () => nextFilter.SessionIdle(session, status));
}
public override void SessionIdle(IoSession session, IdleStatus status)
{
session.Close(true);
}
public override void SessionIdle(IoSession session, IdleStatus status)
{
test.testResult += "HSI";
}
/// <inheritdoc/>
public virtual void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
nextFilter.SessionIdle(session, status);
}
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
test.testResult += id + "SI";
nextFilter.SessionIdle(session, status);
}
public override void SessionIdle(IoSession session, IdleStatus status)
{
endpointClient.RemoveSession(endpoint, endpointSession);
}
public override void SessionIdle(IoSession session, IdleStatus status)
{
base.SessionIdle(session, status);
}
/// <inheritdoc/>
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
Filter(new IoFilterEvent(nextFilter, IoEventType.SessionIdle, session, status));
}
/// <inheritdoc/>
public override void SessionIdle(INextFilter nextFilter, IoSession session, IdleStatus status)
{
Profile(_profileSessionIdle, _sessionIdleTimerWorker, () => nextFilter.SessionIdle(session, status));
}
