private static IEnumerator Enumerator(List <PacketReader> list, PacketConverter converter)
{
for (var i = 0; i < list.Count; i++)
{
yield return(converter.GetObjectChecked(list[i].block));
}
}
public StompSource(PacketConverter <T> packetConverter, string serverPortTopic) : base(packetConverter)
{
string server = "localhost";
int port = StompConnection.DEFAULT_PORT;
string topic = packetConverter.GetDefaultTopic(true);
PacketSource <T> .ParseServerPortTopic(serverPortTopic, ref server, ref port, ref topic);
// Create STOMP connection
stompConnection = null;
try
{
stompConnection = new StompConnection(server, port);
}
catch (Exception) {; }
if (stompConnection != null)
{
// Subscribe to a topic
stompConnection.Subscribe(topic);
// Create threaded listener and add a message handler
stompListener = new StompListener(stompConnection);
stompListener.ReceivedMessage += stompListener_ReceivedMessage;
}
}
internal void ToDictionary <TK, TV>(PacketConverter indexConverter, PacketConverter elementConverter, DictionaryAbstract <TK, TV> dictionary)
{
if (this.Length == 0)
{
return;
}
var indexGeneric = (PacketConverter <TK>)indexConverter;
var elementGeneric = (PacketConverter <TV>)elementConverter;
var vernier = (Vernier)this;
try
{
while (vernier.Any)
{
vernier.FlushExcept(indexGeneric.Length);
var key = indexGeneric.GetValue(vernier.Buffer, vernier.Offset, vernier.Length);
vernier.FlushExcept(elementGeneric.Length);
var value = elementGeneric.GetValue(vernier.Buffer, vernier.Offset, vernier.Length);
dictionary.Add(key, value);
}
}
catch (Exception ex) when(PacketException.ReThrowFilter(ex))
{
throw PacketException.ConversionError(ex);
}
}
private static T[] InternalToArray <T>(PacketReader reader, PacketConverter converter)
{
var readerList = reader.GetList();
var count = readerList.Count;
if (count < 1)
{
return(new T[0]);
}
try
{
var result = new T[count];
var generic = (PacketConverter <T>)converter;
for (var i = 0; i < count; i++)
{
result[i] = generic.GetValue(readerList[i].block);
}
return(result);
}
catch (Exception ex) when(PacketException.ReThrowFilter(ex))
{
throw PacketException.ConversionError(ex);
}
}
public SlipSource(PacketConverter <T> packetConverter, Stream stream) : base(packetConverter)
{
this.stream = stream;
quitReceiver = false;
receiverThread = new Thread(new ThreadStart(this.Listener));
receiverThread.Start();
}
internal static byte[][] GetBytesFromEnumerableNonGeneric(PacketConverter converter, IEnumerable enumerable)
{
var result = new List <byte[]>();
foreach (var i in enumerable)
{
result.Add(converter.GetBytesChecked(i));
}
return(result.ToArray());
}
public NetworkClientMachine(IMessagesManagerNetwork messagesManager)
{
_isConnected = false;
_ip = IPAddress.Parse("127.0.0.1");
_server = new UserNetwork();
_server.Socket.SendBufferSize = 1024;
_server.Socket.ReceiveBufferSize = 1024;
_messagesManager = messagesManager;
_converter = new PacketConverter(new Packer(), new Unpacker());
}
internal static byte[][] FromList <T>(PacketConverter converter, List <T> list)
{
var generic = (PacketConverter <T>)converter;
var result = new byte[list.Count][];
for (var i = 0; i < list.Count; i++)
{
result[i] = generic.GetBytesChecked(list[i]);
}
return(result);
}
internal static byte[][] FromArray <T>(PacketConverter converter, T[] array)
{
var generic = (PacketConverter <T>)converter;
var result = new byte[array.Length][];
for (var i = 0; i < array.Length; i++)
{
result[i] = generic.GetBytesChecked(array[i]);
}
return(result);
}
public OscDest(PacketConverter <T> packetConverter, string serverPortTopic) : base(packetConverter)
{
string server = OscReceiver.DEFAULT_INTERFACE;
int port = OscReceiver.DEFAULT_PORT;
string topic = packetConverter.GetDefaultTopic(false);
PacketSource <T> .ParseServerPortTopic(serverPortTopic, ref server, ref port, ref topic);
oscTransmitter = new OscTransmitter(server, port);
this.topic = topic;
}
internal static byte[][] FromEnumerable <T>(PacketConverter converter, IEnumerable <T> enumerable)
{
if (enumerable is ICollection <T> collection && collection.Count > 15)
{
return(FromArray(converter, collection.ToArray()));
}
var generic = (PacketConverter <T>)converter;
var result = new List <byte[]>();
foreach (var i in enumerable)
{
result.Add(generic.GetBytesChecked(i));
}
return(result.ToArray());
}
internal static T GetValueChecked <T>(this PacketConverter <T> converter, byte[] buffer, int offset, int length, bool check = false)
{
try
{
if (check && converter.Length > length)
{
throw PacketException.Overflow();
}
return(converter.GetValue(buffer, offset, length));
}
catch (Exception ex) when(PacketException.ReThrowFilter(ex))
{
throw PacketException.ConversionError(ex);
}
}
/*
* Run the client.
* Starts server connection and packet sending.
*/
public void Run()
{
SetUpServerConnection();
Console.WriteLine("Connected to server!");
//Start listening to input on secondary thread.
Thread inputThread = new Thread(new ThreadStart(HandleInput));
inputThread.Start();
//Accept packets from server in async.
_ = AcceptServerPacketAsync(_tcpClient, _cancellationTokenSource.Token);
Console.WriteLine("Starting packet sending..");
//At this point we have connected. Let's send some messages until we aren't.
while (_tcpClient.Connected)
{
//Go through all PacketsToSend and send them.
Packet packet;
NetworkStream stream = _tcpClient.GetStream();
while (_packetsToSend.TryDequeue(out packet))
{
//Convert packet to byte array.
byte[] packetBuffer = PacketConverter.CreatePacketByteArray(packet.PacketType, packet.Data);
//Write to stream.
stream.Write(packetBuffer, 0, packetBuffer.Length);
}
while (_packetsRecieved.TryDequeue(out packet))
{
//Grab packet handler if it exists.
HandlePacketDelegate packetDelegate;
if (_packetHandlers.TryGetValue(packet.PacketType, out packetDelegate))
{
packetDelegate.Invoke(packet);
}
}
Thread.Sleep(50);
}
Console.WriteLine("Disconnected from server. Press ENTER to exit.");
Console.ReadLine();
}
async Task AcceptServerPacketAsync(TcpClient client, CancellationToken cancellationToken)
{
//Accept client packets until we are cancelled.
while (!cancellationToken.IsCancellationRequested)
{
NetworkStream stream = client.GetStream();
//Read packetSize.
byte[] packetSizeBuffer = new byte[sizeof(int)];
await stream.ReadAsync(packetSizeBuffer, 0, sizeof(int));
//Create databuffer with packetSize.
byte[] packetData = new byte[BitConverter.ToInt32(packetSizeBuffer, 0)];
stream.Read(packetData, 0, packetData.Length);
_packetsRecieved.Enqueue(PacketConverter.ReadPacketFromByteArray(client, packetData));
}
}
public StompDest(PacketConverter <T> packetConverter, string serverPortTopic) : base(packetConverter)
{
string server = "localhost";
int port = StompConnection.DEFAULT_PORT;
string topic = packetConverter.GetDefaultTopic(false);
PacketSource <T> .ParseServerPortTopic(serverPortTopic, ref server, ref port, ref topic);
this.topic = topic;
// Create STOMP connection
stompConnection = null;
try
{
stompConnection = new StompConnection(server, port);
}
catch (Exception) {; }
}
internal static byte[] GetBytesChecked <T>(this PacketConverter <T> converter, T value)
{
try
{
var buffer = converter.GetBytes(value);
if (buffer == null)
{
buffer = Empty.Array <byte>();
}
var define = converter.Length;
if (define > 0 && define != buffer.Length)
{
throw PacketException.ConversionMismatch(define);
}
return(buffer);
}
catch (Exception ex) when(PacketException.ReThrowFilter(ex))
{
throw PacketException.ConversionError(ex);
}
}
/*
* Run Server.
* Starts networking and main loop.
*/
public void Run()
{
Console.WriteLine("Server has started.");
//Accept new clients in async.
_ = AcceptConnectionsAsync();
while (_isRunning)
{
Packet packet;
//Handle recieved packets.
while (_packetsRecieved.TryDequeue(out packet))
{
//Grab packet handler if it exists.
List <HandlePacketDelegate> packetDelegate;
if (_packetHandlers.TryGetValue(packet.PacketType, out packetDelegate))
{
foreach (HandlePacketDelegate pDel in packetDelegate)
{
pDel.Invoke(packet);
}
}
}
//Send packets we have queued up to send.
while (_packetsToSend.TryDequeue(out packet))
{
foreach (TcpClient tcpClient in _connectedClients)
{
byte[] packetByteArray = PacketConverter.CreatePacketByteArray(packet.PacketType, packet.Data);
tcpClient.GetStream().Write(packetByteArray, 0, packetByteArray.Length);
}
}
Thread.Sleep(50);
}
CloseServer();
}
public OscSource(PacketConverter <T> packetConverter, string serverPortTopic) : base(packetConverter)
{
string server = OscReceiver.DEFAULT_INTERFACE;
int port = OscReceiver.DEFAULT_PORT;
string topic = packetConverter.GetDefaultTopic(false);
PacketSource <T> .ParseServerPortTopic(serverPortTopic, ref server, ref port, ref topic);
this.topic = topic;
// Create OSC connection
OscReceiver oscReceiver = null;
try
{
oscReceiver = new OscReceiver(port); // OscReceiver.DEFAULT_PORT
oscReceiver.ReceivedBundle += oscReceiver_ReceivedBundle;
oscReceiver.ReceivedMessage += oscReceiver_ReceivedMessage;
oscReceiver.Start();
}
catch (Exception) {; }
}
internal T[] ToArray <T>(PacketConverter converter)
{
if (this.Length < 1)
{
return(new T[0]);
}
if (typeof(T) == typeof(byte))
{
return((T[])(object)UnmanagedArrayConverter <byte> .ToValue(this.Buffer, this.Offset, this.Length));
}
else if (typeof(T) == typeof(sbyte))
{
return((T[])(object)UnmanagedArrayConverter <sbyte> .ToValue(this.Buffer, this.Offset, this.Length));
}
var define = converter.Length;
var quotient = Math.DivRem(this.Length, define, out var remainder);
if (remainder != 0)
{
throw PacketException.Overflow();
}
try
{
var target = new T[quotient];
var generic = (PacketConverter <T>)converter;
for (var i = 0; i < quotient; i++)
{
target[i] = generic.GetValue(this.Buffer, this.Offset + i * define, define);
}
return(target);
}
catch (Exception ex) when(PacketException.ReThrowFilter(ex))
{
throw PacketException.ConversionError(ex);
}
}
internal static T GetValueChecked <T>(this PacketConverter <T> converter, Block block, bool check = false) => GetValueChecked(converter, block.Buffer, block.Offset, block.Length, check);
internal static object GetObjectChecked(this PacketConverter converter, Block block, bool check = false) => GetObjectChecked(converter, block.Buffer, block.Offset, block.Length, check);
public SlipDest(PacketConverter <T> packetConverter, Stream stream) : base(packetConverter)
{
this.stream = stream;
}
public LogDest(PacketConverter <T> packetConverter, TextWriter textWriter) : base(packetConverter)
{
this.textWriter = textWriter;
}
internal static Dictionary <TK, TV> ToDictionary <TK, TV>(PacketReader reader, PacketConverter indexConverter, PacketConverter elementConverter)
{
var builder = new DictionaryBuilder <TK, TV>();
reader.block.ToDictionary(indexConverter, elementConverter, builder);
return(builder.dictionary);
}
internal static T GetValue <T>(this PacketConverter <T> converter, Block block) => converter.GetValue(block.Buffer, block.Offset, block.Length);
public AsyncServer(int port, PacketConverter packetconverter, GlobalFilter globalFilter)
{
this.port = port;
__pc = packetconverter;
globalhandler = globalFilter;
}
internal Context(PacketConverter pc, GlobalFilter gf, Client client)
{
this.clnt = client;
this.gf = gf;
this.packetconverter = pc;
}
internal static List <T> ToList <T>(PacketReader reader, PacketConverter converter)
{
return(converter.Length < 1
? InternalToList <T>(reader, converter)
: reader.block.ToList <T>(converter));
}
public AsyncServer(int port, PacketConverter packetconverter)
{
this.port = port;
__pc = packetconverter;
globalhandler = new GlobalFilter(new PacketPolicy());
}
internal static Enumerable <T> ToEnumerable <T>(PacketReader reader, PacketConverter converter)
{
return(new Enumerable <T>(reader, converter));
}
