Fixed various messageChunker issues and added more helpers to verify chunks

Author: TwoTenPvP

MLAPI/NetworkingManagerComponents/MessageChunker.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 
 namespace MLAPI.NetworkingManagerComponents
 {
@@ -37,21 +36,67 @@ public static List<byte[]> GetChunkedMessage(ref byte[] message, int chunkSize)
             return chunks;
         }
 
+        public static bool HasMissingParts(ref List<byte[]> chunks, uint expectedChunksCount)
+        {
+            if (chunks.Count < expectedChunksCount)
+                return true;
+
+            HashSet<uint> chunkIndexes = new HashSet<uint>();
+            uint duplicateCount = 0;
+            for (int i = 0; i < chunks.Count; i++)
+            {
+                uint chunkIndex = BitConverter.ToUInt32(chunks[i], 0);
+                if (chunkIndexes.Contains(chunkIndex))
+                    duplicateCount++;
+                else
+                    chunkIndexes.Add(chunkIndex);
+            }
+            return chunks.Count - duplicateCount != expectedChunksCount;
+        }
+
+        public static bool IsOrdered(ref List<byte[]> chunks)
+        {
+            uint lastChunkIndex = 0;
+            for (int i = 0; i < chunks.Count; i++)
+            {
+                uint chunkIndex = BitConverter.ToUInt32(chunks[i], 0);
+                //This can't be right?
+                if (chunkIndex <= lastChunkIndex)
+                    lastChunkIndex++;
+                else
+                    return false;
+            }
+            return true;
+        }
+
+        public static bool HasDuplicates(ref List<byte[]> chunks, uint expectedChunksCount)
+        {
+            if (chunks.Count > expectedChunksCount)
+                return true;
+
+            HashSet<uint> chunkIndexes = new HashSet<uint>();
+            for (int i = 0; i < chunks.Count; i++)
+            {
+                uint chunkIndex = BitConverter.ToUInt32(chunks[i], 0);
+                if (chunkIndexes.Contains(chunkIndex))
+                    return true;
+                else
+                    chunkIndexes.Add(chunkIndex);
+            }
+            return false;
+        }
+
+
         public static byte[] GetMessageOrdered(ref List<byte[]> chunks, int chunkSize = -1)
         {
             if (chunks.Count == 0)
                 return new byte[0];
             if (chunkSize == -1)
                 chunkSize = chunks[0].Length - 4;
 
-            uint lastIndex = 0;
             uint messageSize = 0;
             for (int i = 0; i < chunks.Count; i++)
             {
-                uint chunkIndex =  BitConverter.ToUInt32(chunks[i], 0);
-                if (chunkIndex <= lastIndex)
-                    throw new ArgumentException("Chunks not in order");
-                lastIndex = chunkIndex;
                 messageSize += Convert.ToUInt32(chunks[i].Length - 4);
             }
             byte[] message = new byte[messageSize];
@@ -61,5 +106,34 @@ public static byte[] GetMessageOrdered(ref List<byte[]> chunks, int chunkSize =
             }
             return message;
         }
+
+        public static byte[] GetMessageUnordered(ref List<byte[]> chunks, int chunkSize = -1)
+        {
+            if (chunks.Count == 0)
+                return new byte[0];
+            if (chunkSize == -1)
+                chunkSize = chunks[0].Length - 4;
+
+            uint messageSize = 0;
+            for (int i = 0; i < chunks.Count; i++)
+            {
+                messageSize += Convert.ToUInt32(chunks[i].Length - 4);
+            }
+            byte[] message = new byte[messageSize];
+            uint nextIndex = 0;
+            //Loop as many times as there are chunks.
+            for (int i = 0; i < chunks.Count; i++)
+            {
+                //For each chunk, find the right chunk
+                for (int j = 0; j < chunks.Count; j++)
+                {
+                    if(BitConverter.ToUInt32(chunks[j], 0) == nextIndex)
+                    {
+                        Array.Copy(chunks[j], 3, message, nextIndex * chunkSize, chunkSize);
+                    }
+                }
+            }
+            return message;
+        }
     }
 }