Added NightAlert project for travel kit

ThirdParty/SocketIoClientDotNet/Src/SocketIoClientDotNet.net45/Parser/Binary.cs

@@ -0,0 +1,242 @@
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+
+namespace Quobject.SocketIoClientDotNet.Parser
+{
+    public class Binary
+    {
+        private static readonly string KEY_PLACEHOLDER = "_placeholder";
+
+        private static readonly string KEY_NUM = "num";
+
+        public static DeconstructedPacket DeconstructPacket(Packet packet)
+        {
+            var buffers = new List<byte[]>();
+
+            packet.Data = _deconstructPacket(packet.Data, buffers);
+            packet.Attachments = buffers.Count;
+
+            var result = new DeconstructedPacket();
+            result.Packet = packet;
+            result.Buffers = buffers.ToArray();
+            return result;
+        }
+
+        private static JToken _deconstructPacket(object data, List<byte[]> buffers)
+        {
+            if (data == null)
+            {
+                return null;
+            }
+
+            if (data is byte[])
+            {
+                var byteArray = (byte[])data;
+                return AddPlaceholder(buffers, byteArray);
+            }
+
+            var jToken = data as JToken;
+            if (jToken == null)
+            {
+                throw new NotImplementedException();
+            }
+
+            switch (jToken.Type)
+            {
+                case JTokenType.Object:
+                    var newJObject = new JObject();
+                    var jObject = (JObject)jToken;
+                    foreach (var property in jObject.Properties())
+                    {
+                        try
+                        {
+                            newJObject[property.Name] = _deconstructPacket(property.Value, buffers);
+                        }
+                        catch (Exception)
+                        {
+                            return null;
+                        }
+                    }
+                    return newJObject;
+
+                case JTokenType.Array:
+                    var newJArray = new JArray();
+                    var jArray = (JArray)jToken;
+                    for (int i = 0; i < jArray.Count; i++)
+                    {
+                        try
+                        {
+                            newJArray.Add(_deconstructPacket(jArray[i], buffers));
+                        }
+                        catch (Exception)
+                        {
+                            return null;
+                        }
+                    }
+                    return newJArray;
+
+                case JTokenType.Bytes:
+                    var byteArray = jToken.Value<byte[]>();
+                    return AddPlaceholder(buffers, byteArray);
+
+                case JTokenType.None:
+                case JTokenType.Constructor:
+                case JTokenType.Property:
+                case JTokenType.Comment:
+                    throw new NotImplementedException();
+
+                default:
+                    return jToken;
+            }
+        }
+
+        private static JToken AddPlaceholder(List<byte[]> buffers, byte[] byteArray)
+        {
+            var placeholder = new JObject();
+            try
+            {
+                placeholder.Add(KEY_PLACEHOLDER, true);
+                placeholder.Add(KEY_NUM, buffers.Count);
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+            buffers.Add(byteArray);
+            return placeholder;
+        }
+
+        public static Packet ReconstructPacket(Packet packet, byte[][] buffers)
+        {
+            packet.Data = _reconstructPacket(packet.Data, buffers);
+            packet.Attachments = -1;
+            return packet;
+        }
+
+        private static object _reconstructPacket(object data, byte[][] buffers)
+        {
+            //var t = data.GetType();
+
+            if (data is JValue)
+            {
+                var dataStr = data.ToString();
+                if (!dataStr.StartsWith("[") && !dataStr.StartsWith("{"))
+                {
+                    //
+                    return dataStr;
+                }
+                var jdata = JToken.Parse(data.ToString());
+                if (jdata.SelectToken(KEY_PLACEHOLDER) != null)
+                {
+                    var jpl = jdata[KEY_PLACEHOLDER];
+                    var jnum = jdata[KEY_NUM];
+                    if (jpl != null && jnum != null)
+                    {
+                        var placeholder = jpl.ToObject<bool>();
+                        if (placeholder)
+                        {
+                            var num = jnum.ToObject<int>();
+                            return buffers[num];
+                        }
+                    }
+                }
+                else
+                {
+                    var recValue = _reconstructPacket(jdata, buffers);
+                    return recValue;
+                }
+
+             
+
+                //jdata
+            }else if (data is JArray)
+            {
+                var _data = (JArray)data;
+                int len = _data.Count;
+                var newData = new JArray();
+                for (int i = 0; i < len; i++)
+                {
+                    try
+                    {
+                        var recValue = _reconstructPacket(_data[i], buffers);
+                        if (recValue is string)
+                        {
+                            //newData[i] = (string) recValue;
+                            newData.Add((string)recValue);
+                        }
+                        else if (recValue is byte[])
+                        {
+                            newData.Add((byte[])recValue);
+                        }
+                        else if (recValue is JArray)
+                        {
+                            //newData[i] = (JArray) recValue;
+                            newData.Add((JArray)recValue);
+                        }
+                        else if (recValue is JObject)
+                        {
+                            //newData[i] = (JObject)recValue;
+                            newData.Add((JObject)recValue);
+                        }
+                    }
+                    catch (Exception)
+                    {
+                        return null;
+                    }
+                }
+                return newData;
+            }
+            if (!(data is JObject))
+            {
+                return data;
+            }
+
+            var newData1 = new JObject();
+            var _data1 = (JObject)data;
+
+            //if ((bool) _data1[KEY_PLACEHOLDER])
+            if (_data1.SelectToken(KEY_PLACEHOLDER) != null && (bool) _data1[KEY_PLACEHOLDER])
+            {
+                var num = (int)_data1[KEY_NUM];
+                return num >= 0 && num < buffers.Length ? buffers[num] : null;
+            }
+
+            foreach (var property in _data1.Properties())
+            {               
+                try
+                {
+                    var recValue = _reconstructPacket(property.Value, buffers);
+                    if (recValue is string)
+                    {
+                        newData1[property.Name] = (string)recValue;
+                    }
+                    else if (recValue is byte[])
+                    {
+                        newData1[property.Name] = (byte[])recValue;
+                    }
+                    else if (recValue is JArray)
+                    {
+                        newData1[property.Name] = (JArray)recValue;
+                    }
+                    else if (recValue is JObject)
+                    {
+                        newData1[property.Name] = (JObject)recValue;
+                    }
+                }
+                catch (Exception)
+                {
+                    return null;
+                }
+            }
+            return newData1;                
+        }
+
+
+        public class DeconstructedPacket
+        {
+            public Packet Packet;
+            public byte[][] Buffers;
+        }
+    }
+}