//
// Methods
//
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
try
{
if (this._connection != null && this._connection.Client.Poll(-1, SelectMode.SelectRead))
{
if (Tools.RuntimePlatform == RuntimePlatform.Mono)
{
int len = this._connection.GetStream().Read(data, offset, size);
if (callback != null)
{
callback(state, len);
}
}
else
{
this._connection.GetStream().BeginRead(data, offset, size, new AsyncCallback(this.ReadCallback), new Tuple <SocketReceiveCallback, object>(callback, state));
}
}
}
catch (ObjectDisposedException)
{
}
catch (Exception e)
{
// Tools.WriteLine(e);
throw e;
}
}
public void AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state = null)
{
var arg = _receivePool.PopFront();
arg.SetBuffer(data, offset, size);
arg.ReceiveCallback = callback;
arg.UserToken = state;
arg.Socket = this;
if (_socket != null)
{
if (!_socket.ReceiveAsync(arg))
{
//The receive was processed synchronously which means the callback wont be executed.
OnReceiveComplete(arg);
}
}
else if (_connection != null)
{
if (!_connection.Client.ReceiveAsync(arg))
{
//The receive was processed synchronously which means the callback wont be executed.
OnReceiveComplete(arg);
}
}
}
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
if (test == null)
{
test = new AsyncCallback()
{
Callback = callback,
Buffer = data,
Offset = offset,
Size = size,
State = state
};
}
else
{
// test.Data = data;
test.Offset = offset;
// test.Data = data;
}
// readQueue.Enqueue(new AsyncCallback()
// {
// Callback = callback,
// Buffer = data,
// Offset = offset,
// Size = size,
// State = state
// });
// Flush();
}
public void Dispose()
{
Callback = null;
Offset = 0;
Size = 0;
Buffer = null;
State = null;
}
void ISocket.AsyncReceive(
byte[] data,
int offset,
int size,
SocketReceiveCallback callback,
object state)
{
this._connection.GetStream().BeginRead(data, offset, size, new AsyncCallback(this.ReadCallback), (object)new Tuple <SocketReceiveCallback, object>(callback, state));
}
void ISocket.AsyncReceive(
byte[] data,
int offset,
int size,
SocketReceiveCallback callback,
object state)
{
new SocialSocket.InternalReadCallback(this.ReadCallback).BeginInvoke(data, offset, size, callback, state, (AsyncCallback)null, (object)null);
}
private void ReadCallback(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
int size2;
while ((size2 = SocialAPI.Network.Receive(this._remoteAddress, data, offset, size)) == 0)
{
Thread.Sleep(1);
}
callback(state, size2);
}
private void ReadCallback(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
int size2;
while ((size2 = SocialAPI.Network.Receive(_remoteAddress, data, offset, size)) == 0)
{
Thread.Sleep(1);
}
callback(state, size2);
}
private void ReadCallback(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
int num;
while (true)
{
int num1 = SocialAPI.Network.Receive(this._remoteAddress, data, offset, size);
num = num1;
if (num1 != 0)
{
break;
}
Thread.Sleep(1);
}
callback(state, num);
}
private void ReadCallback(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
int num;
while (true)
{
int num1 = SocialAPI.Network.Receive(this._remoteAddress, data, offset, size);
num = num1;
if (num1 != 0)
{
break;
}
Thread.Sleep(1);
}
callback(state, num);
}
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
if (_callback == null)
{
_callback = new AsyncCallback()
{
Callback = callback,
Buffer = data,
Offset = offset,
Size = size,
State = state
};
StartReading();
}
else
{
_callback.Offset = offset;
}
}
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
if (_callback == null)
{
_callback = new AsyncCallback()
{
Callback = callback,
Buffer = data,
Offset = offset,
Size = size,
State = state
};
StartReading();
}
else
{
_callback.Offset = offset;
}
}
void Terraria.Net.Sockets.ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
SocialSocket.InternalReadCallback internalReadCallback = new SocialSocket.InternalReadCallback(this.ReadCallback);
internalReadCallback.BeginInvoke(data, offset, size, callback, state, null, null);
}
void Terraria.Net.Sockets.ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
SocialSocket.InternalReadCallback internalReadCallback = new SocialSocket.InternalReadCallback(this.ReadCallback);
internalReadCallback.BeginInvoke(data, offset, size, callback, state, null, null);
}
public void AsyncReceive(byte[] data, int offset, int count, SocketReceiveCallback callback, object state = null)
{
if (_connected && storeWriteOffset > 0)
{
//lock (storeBuffer)
lock (_rxSyncRoot)
{
//var received = storeWriteOffset - storeReadOffset;
int received;
if (!reset)
{
received = storeWriteOffset - storeReadOffset;
}
else
{
received = receiveBuffer.Length - storeReadOffset;
//reset = false;
}
if (count > received) count = received;
if (count == 0) return;
Array.Copy(receiveBuffer, storeReadOffset, data, offset, count);
storeReadOffset += count;
if (reset || storeReadOffset == receiveBuffer.Length)
{
storeReadOffset = 0;
////The write buffer will also be at the end, so it must now also be reset
//storeWriteOffset = 0;
reset = false;
Console.WriteLine("Queue reset");
}
////Recallibrate offsets
//if (storeReadOffset + count >= storeWriteOffset)
//{
// //We have caught up to the receive writer;
// storeReadOffset = 0;
// storeWriteOffset = 0;
//}
//else
//{
// storeReadOffset += count;
//}
available -= count;
}
if (count > 0 && callback != null)
{
callback(state, count);
}
}
}
public void Dispose()
{
Callback = null;
Offset = 0;
Size = 0;
Buffer = null;
State = null;
}
public void AsyncReceive(byte[] data, int offset, int count, SocketReceiveCallback callback, object state = null)
{
if (_connected && storeWriteOffset > 0)
{
//lock (storeBuffer)
lock (_rxSyncRoot)
{
//var received = storeWriteOffset - storeReadOffset;
int received;
if (!reset)
{
received = storeWriteOffset - storeReadOffset;
}
else
{
received = receiveBuffer.Length - storeReadOffset;
//reset = false;
}
if (count > received)
{
count = received;
}
if (count == 0)
{
return;
}
Array.Copy(receiveBuffer, storeReadOffset, data, offset, count);
storeReadOffset += count;
if (reset || storeReadOffset == receiveBuffer.Length)
{
storeReadOffset = 0;
////The write buffer will also be at the end, so it must now also be reset
//storeWriteOffset = 0;
reset = false;
Console.WriteLine("Queue reset");
}
////Recallibrate offsets
//if (storeReadOffset + count >= storeWriteOffset)
//{
// //We have caught up to the receive writer;
// storeReadOffset = 0;
// storeWriteOffset = 0;
//}
//else
//{
// storeReadOffset += count;
//}
available -= count;
}
if (count > 0 && callback != null)
{
callback(state, count);
}
}
}
//
// Methods
//
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
try
{
if (this._connection != null && this._connection.Client.Poll(-1, SelectMode.SelectRead))
{
if (Tools.RuntimePlatform == RuntimePlatform.Mono)
{
int len = this._connection.GetStream().Read(data, offset, size);
if (callback != null)
callback(state, len);
}
else
this._connection.GetStream().BeginRead(data, offset, size, new AsyncCallback(this.ReadCallback), new Tuple<SocketReceiveCallback, object>(callback, state));
}
}
catch (ObjectDisposedException)
{
}
catch (Exception e)
{
// Tools.WriteLine(e);
throw e;
}
}
public void AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state = null)
{
_client?.AsyncReceive(data, offset, size, callback, state);
}
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
new InternalReadCallback(ReadCallback).BeginInvoke(data, offset, size, callback, state, null, null);
}
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state)
{
this._connection.GetStream().BeginRead(data, offset, size, new AsyncCallback(this.ReadCallback), (object)new Tuple<SocketReceiveCallback, object>(callback, state));
}
public void AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state = null)
{
// we don't use terrarias async callbacks, we do it ourself so we arent limited to their buffer sizes
}
