rm web-demo

Author: icattlecoder

Qiniu/IO/IOClient.cs

@@ -5,7 +5,6 @@
 using Qiniu.Auth;
 using Qiniu.RPC;
 using Qiniu.Util;
-using Qiniu.IO.Resumable;
 using System.Collections.Specialized;
 
 namespace Qiniu.IO
@@ -53,7 +52,7 @@ public PutRet PutFile(string upToken, string key, string localFile, PutExtra ext
 				new Exception (string.Format ("{0} does not exist", localFile));
 			}
             PutRet ret;
-			key = key.ToUrlEncode ();
+		
             NameValueCollection formData = getFormData(upToken, key, extra);
             try
             {

Qiniu/Newtonsoft.Json/Bson/BsonBinaryType.cs

@@ -0,0 +1,42 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace Newtonsoft.Json.Bson
+{
+  internal enum BsonBinaryType : byte
+  {
+    Binary = 0x00,
+    Function = 0x01,
+    [Obsolete("This type has been deprecated in the BSON specification. Use Binary instead.")]
+    BinaryOld = 0x02,
+    [Obsolete("This type has been deprecated in the BSON specification. Use Uuid instead.")]
+    UuidOld = 0x03,
+    Uuid = 0x04,
+    Md5 = 0x05,
+    UserDefined = 0x80
+  }
+}

Qiniu/Newtonsoft.Json/Bson/BsonBinaryWriter.cs

@@ -0,0 +1,325 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Bson
+{
+  internal class BsonBinaryWriter
+  {
+    private static readonly Encoding Encoding = new UTF8Encoding(false);
+
+    private readonly BinaryWriter _writer;
+
+    private byte[] _largeByteBuffer;
+
+    public DateTimeKind DateTimeKindHandling { get; set; }
+
+    public BsonBinaryWriter(BinaryWriter writer)
+    {
+      DateTimeKindHandling = DateTimeKind.Utc;
+      _writer = writer;
+    }
+
+    public void Flush()
+    {
+      _writer.Flush();
+    }
+
+    public void Close()
+    {
+#if !(NETFX_CORE || PORTABLE40 || PORTABLE)
+      _writer.Close();
+#else
+      _writer.Dispose();
+#endif
+    }
+
+    public void WriteToken(BsonToken t)
+    {
+      CalculateSize(t);
+      WriteTokenInternal(t);
+    }
+
+    private void WriteTokenInternal(BsonToken t)
+    {
+      switch (t.Type)
+      {
+        case BsonType.Object:
+          {
+            BsonObject value = (BsonObject)t;
+            _writer.Write(value.CalculatedSize);
+            foreach (BsonProperty property in value)
+            {
+              _writer.Write((sbyte)property.Value.Type);
+              WriteString((string)property.Name.Value, property.Name.ByteCount, null);
+              WriteTokenInternal(property.Value);
+            }
+            _writer.Write((byte)0);
+          }
+          break;
+        case BsonType.Array:
+          {
+            BsonArray value = (BsonArray)t;
+            _writer.Write(value.CalculatedSize);
+            ulong index = 0;
+            foreach (BsonToken c in value)
+            {
+              _writer.Write((sbyte)c.Type);
+              WriteString(index.ToString(CultureInfo.InvariantCulture), MathUtils.IntLength(index), null);
+              WriteTokenInternal(c);
+              index++;
+            }
+            _writer.Write((byte)0);
+          }
+          break;
+        case BsonType.Integer:
+          {
+            BsonValue value = (BsonValue)t;
+            _writer.Write(Convert.ToInt32(value.Value, CultureInfo.InvariantCulture));
+          }
+          break;
+        case BsonType.Long:
+          {
+            BsonValue value = (BsonValue)t;
+            _writer.Write(Convert.ToInt64(value.Value, CultureInfo.InvariantCulture));
+          }
+          break;
+        case BsonType.Number:
+          {
+            BsonValue value = (BsonValue)t;
+            _writer.Write(Convert.ToDouble(value.Value, CultureInfo.InvariantCulture));
+          }
+          break;
+        case BsonType.String:
+          {
+            BsonString value = (BsonString)t;
+            WriteString((string)value.Value, value.ByteCount, value.CalculatedSize - 4);
+          }
+          break;
+        case BsonType.Boolean:
+          {
+            BsonValue value = (BsonValue)t;
+            _writer.Write((bool)value.Value);
+          }
+          break;
+        case BsonType.Null:
+        case BsonType.Undefined:
+          break;
+        case BsonType.Date:
+          {
+            BsonValue value = (BsonValue)t;
+
+            long ticks = 0;
+
+            if (value.Value is DateTime)
+            {
+              DateTime dateTime = (DateTime)value.Value;
+              if (DateTimeKindHandling == DateTimeKind.Utc)
+                dateTime = dateTime.ToUniversalTime();
+              else if (DateTimeKindHandling == DateTimeKind.Local)
+                dateTime = dateTime.ToLocalTime();
+
+              ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(dateTime, false);
+            }
+#if !NET20
+            else
+            {
+              DateTimeOffset dateTimeOffset = (DateTimeOffset)value.Value;
+              ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(dateTimeOffset.UtcDateTime, dateTimeOffset.Offset);
+            }
+#endif
+
+            _writer.Write(ticks);
+          }
+          break;
+        case BsonType.Binary:
+          {
+            BsonBinary value = (BsonBinary)t;
+
+            byte[] data = (byte[])value.Value;
+            _writer.Write(data.Length);
+            _writer.Write((byte)value.BinaryType);
+            _writer.Write(data);
+          }
+          break;
+        case BsonType.Oid:
+          {
+            BsonValue value = (BsonValue)t;
+
+            byte[] data = (byte[])value.Value;
+            _writer.Write(data);
+          }
+          break;
+        case BsonType.Regex:
+          {
+            BsonRegex value = (BsonRegex)t;
+
+            WriteString((string)value.Pattern.Value, value.Pattern.ByteCount, null);
+            WriteString((string)value.Options.Value, value.Options.ByteCount, null);
+          }
+          break;
+        default:
+          throw new ArgumentOutOfRangeException("t", "Unexpected token when writing BSON: {0}".FormatWith(CultureInfo.InvariantCulture, t.Type));
+      }
+    }
+
+    private void WriteString(string s, int byteCount, int? calculatedlengthPrefix)
+    {
+      if (calculatedlengthPrefix != null)
+        _writer.Write(calculatedlengthPrefix.Value);
+
+      WriteUtf8Bytes(s, byteCount);
+
+      _writer.Write((byte)0);
+    }
+
+    public void WriteUtf8Bytes(string s, int byteCount)
+    {
+      if (s != null)
+      {
+        if (_largeByteBuffer == null)
+        {
+          _largeByteBuffer = new byte[256];
+        }
+        if (byteCount <= 256)
+        {
+          Encoding.GetBytes(s, 0, s.Length, _largeByteBuffer, 0);
+          _writer.Write(_largeByteBuffer, 0, byteCount);
+        }
+        else
+        {
+          byte[] bytes = Encoding.GetBytes(s);
+          _writer.Write(bytes);
+        }
+      }
+    }
+
+    private int CalculateSize(int stringByteCount)
+    {
+      return stringByteCount + 1;
+    }
+
+    private int CalculateSizeWithLength(int stringByteCount, bool includeSize)
+    {
+      int baseSize = (includeSize)
+        ? 5 // size bytes + terminator
+        : 1; // terminator
+
+      return baseSize + stringByteCount;
+    }
+
+    private int CalculateSize(BsonToken t)
+    {
+      switch (t.Type)
+      {
+        case BsonType.Object:
+          {
+            BsonObject value = (BsonObject)t;
+
+            int bases = 4;
+            foreach (BsonProperty p in value)
+            {
+              int size = 1;
+              size += CalculateSize(p.Name);
+              size += CalculateSize(p.Value);
+
+              bases += size;
+            }
+            bases += 1;
+            value.CalculatedSize = bases;
+            return bases;
+          }
+        case BsonType.Array:
+          {
+            BsonArray value = (BsonArray)t;
+
+            int size = 4;
+            ulong index = 0;
+            foreach (BsonToken c in value)
+            {
+              size += 1;
+              size += CalculateSize(MathUtils.IntLength(index));
+              size += CalculateSize(c);
+              index++;
+            }
+            size += 1;
+            value.CalculatedSize = size;
+
+            return value.CalculatedSize;
+          }
+        case BsonType.Integer:
+          return 4;
+        case BsonType.Long:
+          return 8;
+        case BsonType.Number:
+          return 8;
+        case BsonType.String:
+          {
+            BsonString value = (BsonString)t;
+            string s = (string)value.Value;
+            value.ByteCount = (s != null) ? Encoding.GetByteCount(s) : 0;
+            value.CalculatedSize = CalculateSizeWithLength(value.ByteCount, value.IncludeLength);
+
+            return value.CalculatedSize;
+          }
+        case BsonType.Boolean:
+          return 1;
+        case BsonType.Null:
+        case BsonType.Undefined:
+          return 0;
+        case BsonType.Date:
+          return 8;
+        case BsonType.Binary:
+          {
+            BsonBinary value = (BsonBinary)t;
+
+            byte[] data = (byte[])value.Value;
+            value.CalculatedSize = 4 + 1 + data.Length;
+
+            return value.CalculatedSize;
+          }
+        case BsonType.Oid:
+          return 12;
+        case BsonType.Regex:
+          {
+            BsonRegex value = (BsonRegex)t;
+            int size = 0;
+            size += CalculateSize(value.Pattern);
+            size += CalculateSize(value.Options);
+            value.CalculatedSize = size;
+
+            return value.CalculatedSize;
+          }
+        default:
+          throw new ArgumentOutOfRangeException("t", "Unexpected token when writing BSON: {0}".FormatWith(CultureInfo.InvariantCulture, t.Type));
+      }
+    }
+  }
+}