Make instances of HeaderValue and ContentType immutable

sdk/lib/io/http.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.io;
 
 /**
  * HTTP status codes.
  */
 abstract class HttpStatus {
@@ skipping 381 matching lines @@
  * [HeaderValue] can be used to conveniently build and parse header
  * values on this form.
  *
  * To build an [:accepts:] header with the value
  *
  *     text/plain; q=0.3, text/html
  *
  * use code like this:
  *
  *     HttpClientRequest request = ...;
- *     var v = new HeaderValue();
- *     v.value = "text/plain";
- *     v.parameters["q"] = "0.3"
+ *     var v = new HeaderValue("text/plain", {"q": "0.3"});
  *     request.headers.add(HttpHeaders.ACCEPT, v);
  *     request.headers.add(HttpHeaders.ACCEPT, "text/html");
  *
  * To parse the header values use the [:fromString:] constructor.
  *
  *     HttpRequest request = ...;
  *     List<String> values = request.headers[HttpHeaders.ACCEPT];
  *     values.forEach((value) {
  *       HeaderValue v = new HeaderValue.fromString(value);
  *       // Use v.value and v.parameters
  *     });
+ *
+ * An instance of [HeaderValue] is immutable.
  */
 abstract class HeaderValue {
   /**
    * Creates a new header value object setting the value part.
    */
-  factory HeaderValue([String value = ""]) => new _HeaderValue(value);
+  factory HeaderValue([String value = "", Map<String, String> parameters]) {
+    return new _HeaderValue(value, parameters);
+  }
 
   /**
    * Creates a new header value object from parsing a header value
    * string with both value and optional parameters.
    */
   factory HeaderValue.fromString(String value,
                                  {String parameterSeparator: ";"}) {
     return new _HeaderValue.fromString(
         value, parameterSeparator: parameterSeparator);
   }
 
   /**
-   * Gets and sets the header value.
+   * Gets the header value.
    */
-  String value;
+  String get value;
 
   /**
    * Gets the map of parameters.
    */
   Map<String, String> get parameters;
 
   /**
    * Returns the formatted string representation in the form:
    *
    *     value; parameter1=value1; parameter2=value2
@@ skipping 19 matching lines @@
   void set onTimeout(void callback());
 
   /**
    * Is true if the session has not been sent to the client yet.
    */
   bool get isNew;
 }
 
 
 /**
- * Representation of a content type.
+ * Representation of a content type. An instance of [ContentType] is
+ * immutable.
  */
 abstract class ContentType implements HeaderValue {
   /**
    * Creates a new content type object setting the primary type and
-   * sub type.
+   * sub type. The charset and additional parameters can also be set
+   * using [charset] and [parameters]. If charset is passed and
+   * [parameters] contains charset as well the passed [charset] will
+   * override the value in parameters. Keys and values passed in
+   * parameters will be converted to lower case.
    */
-  factory ContentType([String primaryType = "", String subType = ""]) {
-    return new _ContentType(primaryType, subType);
+  factory ContentType(String primaryType,
+                      String subType,
+                      {String charset, Map<String, String> parameters}) {
+    return new _ContentType(primaryType, subType, charset, parameters);
   }
 
   /**
    * Creates a new content type object from parsing a Content-Type
    * header value. As primary type, sub type and parameter names and
    * values are not case sensitive all these values will be converted
    * to lower case. Parsing this string
    *
    *     text/html; charset=utf-8
    *
    * will create a content type object with primary type [:text:], sub
    * type [:html:] and parameter [:charset:] with value [:utf-8:].
    */
   factory ContentType.fromString(String value) {
     return new _ContentType.fromString(value);
   }
 
   /**
-   * Gets and sets the content type in the form "primaryType/subType".
+   * Gets the primary type.
    */
-  String value;
+  String get primaryType;
 
   /**
-   * Gets and sets the primary type.
+   * Gets the sub type.
    */
-  String primaryType;
+  String get subType;
 
   /**
-   * Gets and sets the sub type.
+   * Gets the character set.
    */
-  String subType;
-
-  /**
-   * Gets and sets the character set.
-   */
-  String charset;
+  String get charset;
 }
 
 
 /**
  * Representation of a cookie. For cookies received by the server as
  * Cookie header values only [:name:] and [:value:] fields will be
  * set. When building a cookie for the 'set-cookie' header in the server
  * and when receiving cookies in the client as 'set-cookie' headers all
  * fields can be used.
  */
@@ skipping 586 matching lines @@
 class RedirectLimitExceededException extends RedirectException {
   const RedirectLimitExceededException(List<RedirectInfo> redirects)
       : super("Redirect limit exceeded", redirects);
 }
 
 
 class RedirectLoopException extends RedirectException {
   const RedirectLoopException(List<RedirectInfo> redirects)
       : super("Redirect loop detected", redirects);
 }