/// <summary>
/// Begins receiving the incoming message by handler as
/// an asynchronous call. It will not block the caller.
/// </summary>
/// <param name="handler">An instance of the incoming message handler.</param>
public void Receive(NetworkIncomingMessageHandler handler)
{
if (listener.IsAvailable(identifier))
{
incoming.ReceiveOrCallback(handler);
}
}
public void Process(NetworkIncomingMessageHandler handler, int count)
{
if (listener.IsAvailable(identifier))
{
if (count > 0)
{
if (offset + length >= memory.Length)
{
Decrypt(offset + length - memory.Length, count);
}
else
{
Decrypt(offset + length, count);
}
length += count;
handler.OnMessage(new NetworkIncomingBufferMessage(this));
}
else
{
listener.Disconnect(identifier);
handler.OnDisconnected();
}
}
}
public NetworkPoolDecrypt(NetworkPoolListener listener, long identifier, NetworkIncomingBuffer buffer, NetworkIncomingMessageHandler handler, int count)
{
this.listener = listener;
this.identifier = identifier;
this.buffer = buffer;
this.handler = handler;
this.count = count;
}
/// <summary>
/// Begins receiving data first from the local buffer. If nothing is available
/// from the remote endpoint. In both cases the caller will be notified in
/// asynchronous way.
/// </summary>
/// <param name="handler">An instance of the incoming message handler.</param>
public void ReceiveOrCallback(NetworkIncomingMessageHandler handler)
{
if (listener.IsAvailable(identifier))
{
if (length > 0)
{
listener.Schedule(new NetworkPoolReceive(handler, new NetworkIncomingBufferMessage(this)));
}
else
{
Receive(handler);
}
}
}
/// <summary>
/// Begins receiving data from the remote endpoint. If the buffer already
/// contains data it will wait anyway for additional remote data. The handler
/// will be notified in asynchronous way.
/// </summary>
/// <param name="handler">An instance of the incoming message handler.</param>
public void Receive(NetworkIncomingMessageHandler handler)
{
if (listener.IsAvailable(identifier))
{
int receiveOffset;
int receiveSize;
if (offset + length >= memory.Length)
{
receiveOffset = offset + length - memory.Length;
receiveSize = offset - (offset + length) % memory.Length;
}
else
{
receiveOffset = offset + length;
receiveSize = memory.Length - offset - length;
}
socket.Receive(new SocketBuffer(memory.Data, receiveOffset, receiveSize), context => OnReceived(context, handler));
}
}
public void Continue(NetworkIncomingMessageHandler handler)
{
inner.Continue(handler);
}
public NetworkPoolReceive(NetworkIncomingMessageHandler handler, NetworkIncomingBufferMessage message)
{
this.handler = handler;
this.message = message;
}
/// <summary>
/// Continues handling the message by requesting more bytes from
/// the remote endpoint. The current message will not be marked as handled
/// and next message will continue all bytes from current message concatenated
/// with newly received bytes.
/// </summary>
/// <param name="handler">The incoming message handler to use.</param>
public void Continue(NetworkIncomingMessageHandler handler)
{
buffer.Receive(handler);
}
public void Continue(NetworkIncomingMessageHandler handler)
{
}
private void OnReceived(TcpSocketReceive received, NetworkIncomingMessageHandler handler)
{
listener.Schedule(new NetworkPoolDecrypt(listener, identifier, this, handler, received.Count));
}
