Merge pull request #1949 from lewurm/fixtype

[mono.git] / mcs / class / System.Net.Http / System.Net.Http.Headers / RangeHeaderValue.cs

diff --git a/mcs/class/System.Net.Http/System.Net.Http.Headers/RangeHeaderValue.cs b/mcs/class/System.Net.Http/System.Net.Http.Headers/RangeHeaderValue.cs
index e32af2d2aa5bf06665cbd82a97445d25ddbb672e..17790fbe7920dc9e9762354d21abdced065cfb29 100644 (file)
--- a/mcs/class/System.Net.Http/System.Net.Http.Headers/RangeHeaderValue.cs
+++ b/mcs/class/System.Net.Http/System.Net.Http.Headers/RangeHeaderValue.cs
@@ -27,6 +27,7 @@
 //
 
 using System.Collections.Generic;
+using System.Text;
 
 namespace System.Net.Http.Headers
 {
@@ -92,7 +93,7 @@ namespace System.Net.Http.Headers
 
                public override int GetHashCode ()
                {
-                       return Unit.GetHashCode () ^ HashCodeCalculator.Calculate (ranges);
+                       return Unit.ToLowerInvariant ().GetHashCode () ^ HashCodeCalculator.Calculate (ranges);
                }
 
                public static RangeHeaderValue Parse (string input)
@@ -106,7 +107,119 @@ namespace System.Net.Http.Headers
 
                public static bool TryParse (string input, out RangeHeaderValue parsedValue)
                {
-                       throw new NotImplementedException ();
+                       parsedValue = null;
+
+                       var lexer = new Lexer (input);
+                       var t = lexer.Scan ();
+                       if (t != Token.Type.Token)
+                               return false;
+
+                       var value = new RangeHeaderValue ();
+                       value.unit = lexer.GetStringValue (t);
+
+                       t = lexer.Scan ();
+                       if (t != Token.Type.SeparatorEqual)
+                               return false;
+
+                       bool token_read;
+                       do {
+                               long? from = null, to = null;
+                               long number;
+                               token_read = false;
+
+                               t = lexer.Scan (recognizeDash: true);
+                               switch (t.Kind) {
+                               case Token.Type.SeparatorDash:
+                                       t = lexer.Scan ();
+                                       if (!lexer.TryGetNumericValue (t, out number))
+                                               return false;
+
+                                       to = number;
+                                       break;
+                               case Token.Type.Token:
+                                       string s = lexer.GetStringValue (t);
+                                       var values = s.Split (new [] { '-' }, StringSplitOptions.RemoveEmptyEntries);
+                                       if (!Parser.Long.TryParse (values[0], out number))
+                                               return false;
+
+                                       switch (values.Length) {
+                                       case 1:
+                                               t = lexer.Scan (recognizeDash: true);
+                                               from = number;
+                                               switch (t.Kind) {
+                                               case Token.Type.SeparatorDash:
+                                                       t = lexer.Scan ();
+                                                       if (t != Token.Type.Token) {
+                                                               token_read = true;
+                                                               break;
+                                                       }
+
+                                                       if (!lexer.TryGetNumericValue (t, out number))
+                                                               return false;
+
+                                                       to = number;
+                                                       if (to < from)
+                                                               return false;
+
+                                                       break;
+                                               case Token.Type.End:
+                                                       if (s.Length > 0 && s [s.Length - 1] != '-')
+                                                               return false;
+
+                                                       token_read = true;
+                                                       break;
+                                               case Token.Type.SeparatorComma:
+                                                       token_read = true;
+                                                       break;
+                                               default:
+                                                       return false;
+                                               }
+                                               break;
+                                       case 2:
+                                               from = number;
+
+                                               if (!Parser.Long.TryParse (values[1], out number))
+                                                       return false;
+
+                                               to = number;
+                                               if (to < from)
+                                                       return false;
+
+                                               break;
+                                       default:
+                                               return false;
+                                       }
+
+                                       break;
+                               default:
+                                       return false;
+                               }
+
+                               value.Ranges.Add (new RangeItemHeaderValue (from, to));
+                               if (!token_read)
+                                       t = lexer.Scan ();
+
+                       } while (t == Token.Type.SeparatorComma);
+
+                       if (t != Token.Type.End)
+                               return false;
+
+                       parsedValue = value;
+                       return true;
+               }
+
+               public override string ToString ()
+               {
+                       var sb = new StringBuilder (unit);
+                       sb.Append ("=");
+                       for (int i = 0; i < Ranges.Count; ++i) {
+                               if (i > 0)
+                                       sb.Append (", ");
+
+                               sb.Append (ranges[i]);
+                       }
+
+                       return sb.ToString ();
                }
        }
 }