public void write(byte[] data, int size, WriteFinishedFunc finished_func, bool immediate)
{
if (dropped || sendingHeaderError)
{
return;
}
lock (write_callback_mutex)
{
if (write_callback != null)
{
writeTransport();
}
if (write_callback != null)
{
throw new Exception("Not finished writing previous data on this connection");
}
write_callback = finished_func;
write_buffer = data;
write_size = size;
transport.enableWrite();
if (immediate)
{
writeTransport();
}
}
}
public void writeHeader(IDictionary key_vals, WriteFinishedFunc finished_func)
{
header_written_callback = finished_func;
if (!transport.getRequiresHeader())
{
onHeaderWritten(this);
return;
}
int len = 0;
byte[] buffer = null;
header.Write(key_vals, ref buffer, ref len);
uint msg_len = (uint)len + 4;
byte[] full_msg = new byte[msg_len];
uint j = 0;
byte[] blen = Header.ByteLength(len);
for (; j < 4; j++)
{
full_msg[j] = blen[j];
}
for (uint i = 0; j < msg_len; j++)
{
i = j - 4;
full_msg[j] = buffer[i];
}
write(full_msg, msg_len, onHeaderWritten, true);
}
private bool onHeaderWritten(Connection conn)
{
Debug.Assert(conn == this);
if (header_written_callback == null)
{
throw new InvalidOperationException("`header_written_callback` was not registered.");
}
header_written_callback(conn);
header_written_callback = null;
return(true);
}
private void onHeaderWritten(Connection conn)
{
if (conn != this)
{
throw new Exception("THAT EVENT IS NOT FOR MEEE!");
}
if (header_written_callback == null)
{
throw new Exception(
"NOBODY CARES ABOUT YOU, YOUR CHILDREN (neither present nor future), NOR YOUR GRANDCHILDREN (neither present nor future)");
}
header_written_callback(conn);
header_written_callback = null;
}
private void writeTransport()
{
if (dropped || writing)
{
return;
}
lock (write_mutex)
{
writing = true;
bool can_write_more = true;
while (write_callback != null && can_write_more && !dropped)
{
uint to_write = write_size - write_sent;
int bytes_sent = transport.write(write_buffer, write_sent, to_write);
if (bytes_sent <= 0)
{
writing = false;
return;
}
write_sent += (uint)bytes_sent;
if (bytes_sent < write_size - write_sent)
{
can_write_more = false;
}
if (write_sent == write_size && !dropped)
{
WriteFinishedFunc callback;
lock (write_callback_mutex)
{
callback = write_callback;
write_callback = null;
write_buffer = null;
write_sent = 0;
write_size = 0;
}
callback(this);
}
}
writing = false;
}
}
private void writeTransport()
{
lock (writing)
{
if (dropped)
{
return;
}
ScopedTimer.Ping();
bool can_write_more = true;
while (write_callback != null && can_write_more && !dropped)
{
int to_write = write_size - write_sent;
int bytes_sent = transport.write(write_buffer, write_sent, to_write);
if (bytes_sent <= 0)
{
return;
}
write_sent += (int)bytes_sent;
if (bytes_sent < write_size - write_sent)
{
can_write_more = false;
}
if (write_sent == write_size && !dropped)
{
lock (write_callback_mutex)
{
WriteFinishedFunc callback = write_callback;
write_callback = null;
write_buffer = null;
write_sent = 0;
write_size = 0;
if (!callback(this))
{
Console.WriteLine("Failed to invoke " + callback.Method.Name);
}
}
}
}
}
}
private void writeTransport()
{
lock ( writing )
{
if (dropped)
{
return;
}
bool can_write_more = true;
while (write_callback != null && can_write_more && !dropped)
{
int to_write = write_size - write_sent;
int bytes_sent = transport.write(write_buffer, write_sent, to_write);
if (bytes_sent <= 0)
{
return;
}
write_sent += (int)bytes_sent;
if (bytes_sent < write_size - write_sent)
{
can_write_more = false;
}
if (write_sent == write_size && !dropped)
{
WriteFinishedFunc callback = write_callback;
write_callback = null;
write_buffer = null;
write_sent = 0;
write_size = 0;
if (!callback(this))
{
ROS.Error()($"[{ThisNode.Name}] Failed to invoke {callback.GetMethodInfo().Name}");
}
}
}
}
}
public void writeHeader(IDictionary key_vals, WriteFinishedFunc finished_func)
{
header_written_callback = finished_func;
if (!transport.getRequiresHeader())
{
onHeaderWritten(this);
return;
}
int len = 0;
byte[] buffer = null;
header.Write(key_vals, ref buffer, ref len);
uint msg_len = (uint) len + 4;
byte[] full_msg = new byte[msg_len];
uint j = 0;
byte[] blen = Header.ByteLength(len);
for (; j < 4; j++)
full_msg[j] = blen[j];
for (uint i = 0; j < msg_len; j++)
{
i = j - 4;
full_msg[j] = buffer[i];
}
write(full_msg, msg_len, onHeaderWritten, true);
}
private void writeTransport()
{
if (dropped || writing) return;
lock (write_mutex)
{
writing = true;
bool can_write_more = true;
while (write_callback != null && can_write_more && !dropped)
{
uint to_write = write_size - write_sent;
int bytes_sent = transport.write(write_buffer, write_sent, to_write);
if (bytes_sent <= 0)
{
writing = false;
return;
}
write_sent += (uint) bytes_sent;
if (bytes_sent < write_size - write_sent)
can_write_more = false;
if (write_sent == write_size && !dropped)
{
WriteFinishedFunc callback;
lock (write_callback_mutex)
{
callback = write_callback;
write_callback = null;
write_buffer = null;
write_sent = 0;
write_size = 0;
}
callback(this);
}
}
writing = false;
}
}
private void onHeaderWritten(Connection conn)
{
if (conn != this) throw new Exception("THAT EVENT IS NOT FOR MEEE!");
if (header_written_callback == null)
throw new Exception(
"NOBODY CARES ABOUT YOU, YOUR CHILDREN (neither present nor future), NOR YOUR GRANDCHILDREN (neither present nor future)");
header_written_callback(conn);
header_written_callback = null;
}
public void write(byte[] data, uint size, WriteFinishedFunc finished_func, bool immediate)
{
if (dropped || sendingHeaderError) return;
lock (write_callback_mutex)
{
if (write_callback != null)
throw new Exception("NOYOUBLO");
write_callback = finished_func;
write_buffer = data;
write_size = size;
transport.enableWrite();
if (immediate)
writeTransport();
}
}
public void write(byte[] data, uint size, WriteFinishedFunc finished_func)
{
write(data, size, finished_func, true);
}
public void write(byte[] data, uint size, WriteFinishedFunc finished_func)
{
write(data, size, finished_func, true);
}
private void writeTransport()
{
lock (writing)
{
if (dropped) return;
ScopedTimer.Ping();
bool can_write_more = true;
while (write_callback != null && can_write_more && !dropped)
{
int to_write = write_size - write_sent;
int bytes_sent = transport.write(write_buffer, write_sent, to_write);
if (bytes_sent <= 0)
{
return;
}
write_sent += (int) bytes_sent;
if (bytes_sent < write_size - write_sent)
can_write_more = false;
if (write_sent == write_size && !dropped)
{
lock (write_callback_mutex)
{
WriteFinishedFunc callback = write_callback;
write_callback = null;
write_buffer = null;
write_sent = 0;
write_size = 0;
if (!callback(this))
Console.WriteLine("Failed to invoke " + callback.Method.Name);
}
}
}
}
}
