Merge pull request #2831 from razzfazz/fix_dllimport

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

diff --git a/mcs/class/System.Net.Http/System.Net.Http.Headers/NameValueHeaderValue.cs b/mcs/class/System.Net.Http/System.Net.Http.Headers/NameValueHeaderValue.cs
index 2a4cb07098fa9e0c1ce385cc33e6ebf0ced5a369..e3766a4eb154b6e6e3e3a900985f50974ccded22 100644 (file)
--- a/mcs/class/System.Net.Http/System.Net.Http.Headers/NameValueHeaderValue.cs
+++ b/mcs/class/System.Net.Http/System.Net.Http.Headers/NameValueHeaderValue.cs
@@ -26,11 +26,13 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
+using System.Collections.Generic;
+
 namespace System.Net.Http.Headers
 {
        public class NameValueHeaderValue : ICloneable
        {
-               string value;
+               internal string value;
 
                public NameValueHeaderValue (string name)
                        : this (name, null)
@@ -39,6 +41,8 @@ namespace System.Net.Http.Headers
 
                public NameValueHeaderValue (string name, string value)
                {
+                       Parser.Token.Check (name);
+
                        this.Name = name;
                        this.Value = value;
                }
@@ -46,20 +50,41 @@ namespace System.Net.Http.Headers
                protected internal NameValueHeaderValue (NameValueHeaderValue source)
                {
                        this.Name = source.Name;
-                       this.Value = source.Value;
+                       this.value = source.value;
+               }
+
+               internal NameValueHeaderValue ()
+               {
                }
 
-               public string Name { get; private set; }
+               public string Name { get; internal set; }
 
                public string Value {
                        get {
                                return value;
                        }
                        set {
+                               if (!string.IsNullOrEmpty (value)) {
+                                       var lexer = new Lexer (value);
+                                       var token = lexer.Scan ();
+                                       if (lexer.Scan () != Token.Type.End || !(token == Token.Type.Token || token == Token.Type.QuotedString))
+                                               throw new FormatException ();
+
+                                       value = lexer.GetStringValue (token);
+                               }
+
                                this.value = value;
                        }
                }
 
+               internal static NameValueHeaderValue Create (string name, string value)
+               {
+                       return new NameValueHeaderValue () {
+                               Name = name,
+                               value = value
+                       };
+               }
+
                object ICloneable.Clone ()
                {
                        return new NameValueHeaderValue (this);
@@ -96,9 +121,93 @@ namespace System.Net.Http.Headers
                        throw new FormatException (input);
                }
 
+               internal static bool TryParsePragma (string input, int minimalCount, out List<NameValueHeaderValue> result)
+               {
+                       return CollectionParser.TryParse (input, minimalCount, TryParseElement, out result);
+               }
+
+               internal static bool TryParseParameters (Lexer lexer, out List<NameValueHeaderValue> result, out Token t)
+               {               
+                       var list = new List<NameValueHeaderValue> ();
+                       result = null;
+
+                       while (true) {
+                               var attr = lexer.Scan ();
+                               if (attr != Token.Type.Token) {
+                                       t = Token.Empty;
+                                       return false;
+                               }
+
+                               string value = null;
+
+                               t = lexer.Scan ();
+                               if (t == Token.Type.SeparatorEqual) {
+                                       t = lexer.Scan ();
+                                       if (t != Token.Type.Token && t != Token.Type.QuotedString)
+                                               return false;
+
+                                       value = lexer.GetStringValue (t);
+
+                                       t = lexer.Scan ();
+                               }
+
+                               list.Add (new NameValueHeaderValue () {
+                                       Name = lexer.GetStringValue (attr),
+                                       value = value
+                               });
+
+                               if (t == Token.Type.SeparatorSemicolon)
+                                       continue;
+
+                               result = list;
+                               return true;
+                       }
+               }
+
+               public override string ToString ()
+               {
+                       if (string.IsNullOrEmpty (value))
+                               return Name;
+
+                       return Name + "=" + value;
+               }
+
                public static bool TryParse (string input, out NameValueHeaderValue parsedValue)
                {
-                       throw new NotImplementedException ();
+                       var lexer = new Lexer (input);
+                       Token token;
+                       if (TryParseElement (lexer, out parsedValue, out token) && token == Token.Type.End)
+                               return true;
+
+                       parsedValue = null;
+                       return false;
+               }
+
+               static bool TryParseElement (Lexer lexer, out NameValueHeaderValue parsedValue, out Token t)
+               {
+                       parsedValue = null;
+
+                       t = lexer.Scan ();
+                       if (t != Token.Type.Token)
+                               return false;
+
+                       parsedValue = new NameValueHeaderValue () {
+                               Name = lexer.GetStringValue (t),
+                       };
+
+                       t = lexer.Scan ();
+                       if (t == Token.Type.SeparatorEqual) {
+                               t = lexer.Scan ();
+
+                               if (t == Token.Type.Token || t == Token.Type.QuotedString) {
+                                       parsedValue.value = lexer.GetStringValue (t);
+                                       t = lexer.Scan ();
+                               } else {
+                                       return false;
+                               }
+                       }
+
+                       return true;
                }
        }
 }