Replace ~[T] to std::vec_ng::Vec<T> as possible

Kroisse · Kroisse · commit 2fe82a466e4a · 2014-03-16T22:23:05.000+09:00
diff --git a/src/examples/server/apache_fake/main.rs b/src/examples/server/apache_fake/main.rs
@@ -8,6 +8,8 @@ extern crate extra;
 extern crate time;
 extern crate http;
 
+use std::vec_ng::Vec;
+
 use std::io::net::ip::{SocketAddr, Ipv4Addr};
 use std::io::Writer;
 
@@ -44,13 +46,13 @@ impl Server for ApacheFakeServer {
                                 weak: false,
                                 opaque_tag: ~"501b29-b1-4a285ed47404a" });
         w.headers.accept_ranges = Some(headers::accept_ranges::RangeUnits(
-                                            ~[headers::accept_ranges::Bytes]));
+                                            Vec::from_slice([headers::accept_ranges::Bytes])));
         w.headers.content_length = Some(177);
         w.headers.vary = Some(~"Accept-Encoding");
         w.headers.content_type = Some(headers::content_type::MediaType {
             type_: ~"text",
             subtype: ~"html",
-            parameters: ~[]
+            parameters: Vec::new()
         });
         w.headers.extensions.insert(~"X-Pad", ~"avoid browser bug");
 
diff --git a/src/examples/server/hello_world/main.rs b/src/examples/server/hello_world/main.rs
@@ -6,6 +6,8 @@ extern crate extra;
 extern crate time;
 extern crate http;
 
+use std::vec_ng::Vec;
+
 use std::io::net::ip::{SocketAddr, Ipv4Addr};
 use std::io::Writer;
 
@@ -26,7 +28,7 @@ impl Server for HelloWorldServer {
         w.headers.content_type = Some(MediaType {
             type_: ~"text",
             subtype: ~"plain",
-            parameters: ~[(~"charset", ~"UTF-8")]
+            parameters: Vec::from_slice([(~"charset", ~"UTF-8")])
         });
         w.headers.server = Some(~"Example");
 
diff --git a/src/examples/server/info/main.rs b/src/examples/server/info/main.rs
@@ -7,6 +7,8 @@ extern crate extra;
 extern crate time;
 extern crate http;
 
+use std::vec_ng::Vec;
+
 use std::io::net::ip::{SocketAddr, Ipv4Addr};
 use std::io::Writer;
 
@@ -27,7 +29,7 @@ impl Server for InfoServer {
         w.headers.content_type = Some(MediaType {
             type_: ~"text",
             subtype: ~"html",
-            parameters: ~[(~"charset", ~"UTF-8")]
+            parameters: Vec::from_slice([(~"charset", ~"UTF-8")])
         });
         w.headers.server = Some(~"Rust Thingummy/0.0-pre");
         w.write(bytes!("<!DOCTYPE html><title>Rust HTTP server</title>")).unwrap();
diff --git a/src/examples/server/request_uri/main.rs b/src/examples/server/request_uri/main.rs
@@ -10,6 +10,8 @@ extern crate extra;
 extern crate time;
 extern crate http;
 
+use std::vec_ng::Vec;
+
 use std::io::net::ip::{SocketAddr, Ipv4Addr};
 use std::io::Writer;
 
@@ -47,7 +49,7 @@ impl Server for RequestUriServer {
             (&Options, &Star) => {
                 // Querying server capabilities. That's nice and simple. I can handle these methods:
                 // (TODO: let user code override this, providing a default method.)
-                w.headers.allow = Some(~[Get, Head, Post, Put, Delete, Trace, Options, Connect, Patch]);
+                w.headers.allow = Some(Vec::from_slice([Get, Head, Post, Put, Delete, Trace, Options, Connect, Patch]));
                 w.headers.content_length = Some(0);
                 return;
             },
@@ -62,7 +64,7 @@ impl Server for RequestUriServer {
         w.headers.content_type = Some(MediaType {
             type_: ~"text",
             subtype: ~"html",
-            parameters: ~[]
+            parameters: Vec::new()
         });
 
         w.write(bytes!("<!DOCTYPE html><title>Rust HTTP server</title>")).unwrap();
diff --git a/src/http/buffer.rs b/src/http/buffer.rs
@@ -2,6 +2,7 @@
 
 use std::io::{IoResult, Stream};
 use std::cmp::min;
+use std::vec_ng::Vec;
 use std::vec;
 use std::num::ToStrRadix;
 
@@ -12,22 +13,22 @@ static WRITE_BUF_SIZE: uint = 0x10000;
 
 pub struct BufferedStream<T> {
     wrapped: T,
-    read_buffer: ~[u8],
+    read_buffer: Vec<u8>,
     // The current position in the buffer
     read_pos: uint,
     // The last valid position in the reader
     read_max: uint,
-    write_buffer: ~[u8],
+    write_buffer: Vec<u8>,
     write_len: uint,
 
     writing_chunked_body: bool,
 }
 
 impl<T: Stream> BufferedStream<T> {
     pub fn new(stream: T) -> BufferedStream<T> {
-        let mut read_buffer = vec::with_capacity(READ_BUF_SIZE);
+        let mut read_buffer = Vec::with_capacity(READ_BUF_SIZE);
         unsafe { read_buffer.set_len(READ_BUF_SIZE); }
-        let mut write_buffer = vec::with_capacity(WRITE_BUF_SIZE);
+        let mut write_buffer = Vec::with_capacity(WRITE_BUF_SIZE);
         unsafe { write_buffer.set_len(WRITE_BUF_SIZE); }
         BufferedStream {
             wrapped: stream,
@@ -52,14 +53,14 @@ impl<T: Reader> BufferedStream<T> {
             (0, _) => fail!("poke called when buffer is full"),
             (_, _) => self.read_pos -= 1,
         }
-        self.read_buffer[self.read_pos] = byte;
+        self.read_buffer.as_mut_slice()[self.read_pos] = byte;
     }
 
     #[inline]
     fn fill_buffer(&mut self) -> IoResult<()> {
         assert_eq!(self.read_pos, self.read_max);
         self.read_pos = 0;
-        match self.wrapped.read(self.read_buffer) {
+        match self.wrapped.read(self.read_buffer.as_mut_slice()) {
             Ok(i) => {
                 self.read_max = i;
                 Ok(())
@@ -80,7 +81,7 @@ impl<T: Reader> BufferedStream<T> {
             try!(self.fill_buffer());
         }
         self.read_pos += 1;
-        Ok(self.read_buffer[self.read_pos - 1])
+        Ok(self.read_buffer.as_slice()[self.read_pos - 1])
     }
 }
 
@@ -135,17 +136,20 @@ impl<T: Writer> Writer for BufferedStream<T> {
                 try!(self.wrapped.write(bytes!("\r\n")));
             }
         } else {
-            unsafe { self.write_buffer.mut_slice_from(self.write_len).copy_memory(buf); }
+            unsafe {
+                let len = self.write_buffer.len();
+                self.write_buffer.mut_slice(self.write_len, len).copy_memory(buf);
+            }
 
             self.write_len += buf.len();
             if self.write_len == self.write_buffer.len() {
                 if self.writing_chunked_body {
                     let s = format!("{}\r\n", self.write_len.to_str_radix(16));
                     try!(self.wrapped.write(s.as_bytes()));
-                    try!(self.wrapped.write(self.write_buffer));
+                    try!(self.wrapped.write(self.write_buffer.as_slice()));
                     try!(self.wrapped.write(bytes!("\r\n")));
                 } else {
-                    try!(self.wrapped.write(self.write_buffer));
+                    try!(self.wrapped.write(self.write_buffer.as_slice()));
                 }
                 self.write_len = 0;
             }
diff --git a/src/http/headers/accept_ranges.rs b/src/http/headers/accept_ranges.rs
@@ -1,5 +1,6 @@
 //! The Accept-Ranges request header, defined in RFC 2616, Section 14.5.
 
+use std::vec_ng::Vec;
 use std::io::IoResult;
 use std::ascii::StrAsciiExt;
 
@@ -13,7 +14,7 @@ pub enum RangeUnit {
 #[deriving(Clone,Eq)]
 // RFC 2616: acceptable-ranges = 1#range-unit | "none"
 pub enum AcceptableRanges {
-    RangeUnits(~[RangeUnit]),
+    RangeUnits(Vec<RangeUnit>),
     NoAcceptableRanges,
 }
 
@@ -23,7 +24,7 @@ static BYTES: &'static [u8] = bytes!("bytes");
 impl super::HeaderConvertible for AcceptableRanges {
     fn from_stream<R: Reader>(reader: &mut super::HeaderValueByteIterator<R>)
             -> Option<AcceptableRanges> {
-        let mut range_units = ~[];
+        let mut range_units = Vec::new();
         loop {
             match reader.read_token() {
                 Some(token) => {
diff --git a/src/http/headers/connection.rs b/src/http/headers/connection.rs
@@ -58,24 +58,25 @@ impl super::HeaderConvertible for Connection {
 
 #[test]
 fn test_connection() {
+    use std::vec_ng::Vec;
     use headers::test_utils::{assert_conversion_correct,
                               assert_interpretation_correct,
                               assert_invalid};
-    assert_conversion_correct("close", ~[Close]);
-    assert_conversion_correct("Foo", ~[Token(~"Foo")]);
-    assert_conversion_correct("Foo, Keep-Alive", ~[Token(~"Foo"), Token(~"Keep-Alive")]);
-    assert_conversion_correct("Foo, close", ~[Token(~"Foo"), Close]);
-    assert_conversion_correct("close, Bar", ~[Close, Token(~"Bar")]);
+    assert_conversion_correct("close", Vec::from_slice([Close]));
+    assert_conversion_correct("Foo", Vec::from_slice([Token(~"Foo")]));
+    assert_conversion_correct("Foo, Keep-Alive", Vec::from_slice([Token(~"Foo"), Token(~"Keep-Alive")]));
+    assert_conversion_correct("Foo, close", Vec::from_slice([Token(~"Foo"), Close]));
+    assert_conversion_correct("close, Bar", Vec::from_slice([Close, Token(~"Bar")]));
 
-    assert_interpretation_correct("close", ~[Close]);
-    assert_interpretation_correct("foo", ~[Token(~"Foo")]);
-    assert_interpretation_correct("close \r\n , keep-ALIVE", ~[Close, Token(~"Keep-Alive")]);
-    assert_interpretation_correct("foo,close", ~[Token(~"Foo"), Close]);
-    assert_interpretation_correct("close, bar", ~[Close, Token(~"Bar")]);
+    assert_interpretation_correct("close", Vec::from_slice([Close]));
+    assert_interpretation_correct("foo", Vec::from_slice([Token(~"Foo")]));
+    assert_interpretation_correct("close \r\n , keep-ALIVE", Vec::from_slice([Close, Token(~"Keep-Alive")]));
+    assert_interpretation_correct("foo,close", Vec::from_slice([Token(~"Foo"), Close]));
+    assert_interpretation_correct("close, bar", Vec::from_slice([Close, Token(~"Bar")]));
     assert_interpretation_correct("CLOSE", Close);
 
-    assert_invalid::<~[Connection]>("foo bar");
-    assert_invalid::<~[Connection]>("foo bar");
-    assert_invalid::<~[Connection]>("foo, bar baz");
-    assert_invalid::<~[Connection]>("foo, , baz");
+    assert_invalid::<Vec<Connection>>("foo bar");
+    assert_invalid::<Vec<Connection>>("foo bar");
+    assert_invalid::<Vec<Connection>>("foo, bar baz");
+    assert_invalid::<Vec<Connection>>("foo, , baz");
 }
diff --git a/src/http/headers/content_type.rs b/src/http/headers/content_type.rs
@@ -1,16 +1,17 @@
 //! The Content-Type entity header, defined in RFC 2616, Section 14.17.
 use headers::serialization_utils::{push_parameters, WriterUtil};
+use std::vec_ng::Vec;
 use std::io::IoResult;
 use std::fmt;
 
 #[deriving(Clone, Eq)]
 pub struct MediaType {
     type_: ~str,
     subtype: ~str,
-    parameters: ~[(~str, ~str)],
+    parameters: Vec<(~str, ~str)>,
 }
 
-pub fn MediaType(type_: ~str, subtype: ~str, parameters: ~[(~str, ~str)]) -> MediaType {
+pub fn MediaType(type_: ~str, subtype: ~str, parameters: Vec<(~str, ~str)>) -> MediaType {
     MediaType {
         type_: type_,
         subtype: subtype,
@@ -28,7 +29,7 @@ impl fmt::Show for MediaType {
         //s.push_parameters(self.parameters);
         //s
         let s = format!("{}/{}", self.type_, self.subtype);
-        f.buf.write(push_parameters(s, self.parameters).as_bytes())
+        f.buf.write(push_parameters(s, self.parameters.as_slice()).as_bytes())
     }
 }
 
@@ -63,7 +64,7 @@ impl super::HeaderConvertible for MediaType {
         try!(writer.write_token(self.type_));
         try!(writer.write(['/' as u8]));
         try!(writer.write_token(self.subtype));
-        writer.write_parameters(self.parameters)
+        writer.write_parameters(self.parameters.as_slice())
     }
 
     fn http_value(&self) -> ~str {
@@ -75,13 +76,13 @@ impl super::HeaderConvertible for MediaType {
 fn test_content_type() {
     use headers::test_utils::{assert_conversion_correct, assert_interpretation_correct,
                               assert_invalid};
-    assert_conversion_correct("type/subtype", MediaType(~"type", ~"subtype", ~[]));
+    assert_conversion_correct("type/subtype", MediaType(~"type", ~"subtype", Vec::new()));
     assert_conversion_correct("type/subtype;key=value",
-                              MediaType(~"type", ~"subtype", ~[(~"key", ~"value")]));
+                              MediaType(~"type", ~"subtype", Vec::from_slice([(~"key", ~"value")])));
     assert_conversion_correct("type/subtype;key=value;q=0.1",
-            MediaType(~"type", ~"subtype", ~[(~"key", ~"value"), (~"q", ~"0.1")]));
+            MediaType(~"type", ~"subtype", Vec::from_slice([(~"key", ~"value"), (~"q", ~"0.1")])));
     assert_interpretation_correct("type/subtype ; key = value ; q = 0.1",
-            MediaType(~"type", ~"subtype", ~[(~"key", ~"value"), (~"q", ~"0.1")]));
+            MediaType(~"type", ~"subtype", Vec::from_slice([(~"key", ~"value"), (~"q", ~"0.1")])));
 
     assert_invalid::<MediaType>("");
     assert_invalid::<MediaType>("/");
diff --git a/src/http/headers/mod.rs b/src/http/headers/mod.rs
@@ -4,6 +4,7 @@
 //! known HTTP headers are type checked, rather than being dealt with as strings all the time. Only
 //! unknown headers are stored in a map in the traditional way.
 
+use std::vec_ng::Vec;
 use std::io::IoResult;
 use time::{Tm, strptime};
 use extra::url::Url;
@@ -332,8 +333,8 @@ impl<'a, R: Reader> HeaderValueByteIterator<'a, R> {
     ///
     /// The return value ``None`` is reserved for syntax errors in parameters that exist; a mere
     /// absense of parameters will lead to returning an empty vector instead.
-    fn read_parameters(&mut self) -> Option<~[(~str, ~str)]> {
-        let mut result = ~[];
+    fn read_parameters(&mut self) -> Option<Vec<(~str, ~str)>> {
+        let mut result = Vec::new();
         loop {
             match self.next() {
                 //This catches the LWS after the last ';', and can probably be replaced with
@@ -556,9 +557,9 @@ pub trait HeaderConvertible: Eq + Clone {
 /// comma.
 pub trait CommaListHeaderConvertible: HeaderConvertible {}
 
-impl<T: CommaListHeaderConvertible> HeaderConvertible for ~[T] {
-    fn from_stream<R: Reader>(reader: &mut HeaderValueByteIterator<R>) -> Option<~[T]> {
-        let mut result = ~[];
+impl<T: CommaListHeaderConvertible> HeaderConvertible for Vec<T> {
+    fn from_stream<R: Reader>(reader: &mut HeaderValueByteIterator<R>) -> Option<Vec<T>> {
+        let mut result = Vec::new();
         loop {
             match HeaderConvertible::from_stream(reader) {
                 Some(h) => result.push(h),
@@ -871,6 +872,7 @@ macro_rules! headers_mod {
             $attr;
 
             #[allow(unused_imports)];
+            use std::vec_ng::Vec;
             use std::io::IoResult;
             use extra;
             use time;
@@ -1013,11 +1015,11 @@ headers_mod! {
 
     // RFC 2616, Section 4.5: General Header Fields
      0, "Cache-Control",     "Cache-Control",     CacheControl,     cache_control,     ~str;
-     1, "Connection",        "Connection",        Connection,       connection,        ~[headers::connection::Connection];
+     1, "Connection",        "Connection",        Connection,       connection,        Vec<headers::connection::Connection>;
      2, "Date",              "Date",              Date,             date,              time::Tm;
      3, "Pragma",            "Pragma",            Pragma,           pragma,            ~str;
      4, "Trailer",           "Trailer",           Trailer,          trailer,           ~str;
-     5, "Transfer-Encoding", "Transfer-Encoding", TransferEncoding, transfer_encoding, ~[headers::transfer_encoding::TransferCoding];
+     5, "Transfer-Encoding", "Transfer-Encoding", TransferEncoding, transfer_encoding, Vec<headers::transfer_encoding::TransferCoding>;
      6, "Upgrade",           "Upgrade",           Upgrade,          upgrade,           ~str;
      7, "Via",               "Via",               Via,              via,               ~str;
      8, "Warning",           "Warning",           Warning,          warning,           ~str;
@@ -1044,7 +1046,7 @@ headers_mod! {
     27, "User-Agent",          "User-Agent",          UserAgent,          user_agent,          ~str;
 
     // RFC 2616, Section 7.1: Entity Header Fields
-    28, "Allow",            "Allow",            Allow,           allow,            ~[::method::Method];
+    28, "Allow",            "Allow",            Allow,           allow,            Vec<::method::Method>;
     29, "Content-Encoding", "Content-Encoding", ContentEncoding, content_encoding, ~str;
     30, "Content-Language", "Content-Language", ContentLanguage, content_language, ~str;
     31, "Content-Length",   "Content-Length",   ContentLength,   content_length,   uint;
@@ -1064,11 +1066,11 @@ headers_mod! {
 
     // RFC 2616, Section 4.5: General Header Fields
      0, "Cache-Control",     "Cache-Control",     CacheControl,     cache_control,     ~str;
-     1, "Connection",        "Connection",        Connection,       connection,        ~[headers::connection::Connection];
+     1, "Connection",        "Connection",        Connection,       connection,        Vec<headers::connection::Connection>;
      2, "Date",              "Date",              Date,             date,              time::Tm;
      3, "Pragma",            "Pragma",            Pragma,           pragma,            ~str;
      4, "Trailer",           "Trailer",           Trailer,          trailer,           ~str;
-     5, "Transfer-Encoding", "Transfer-Encoding", TransferEncoding, transfer_encoding, ~[headers::transfer_encoding::TransferCoding];
+     5, "Transfer-Encoding", "Transfer-Encoding", TransferEncoding, transfer_encoding, Vec<headers::transfer_encoding::TransferCoding>;
      6, "Upgrade",           "Upgrade",           Upgrade,          upgrade,           ~str;
      7, "Via",               "Via",               Via,              via,               ~str;
      8, "Warning",           "Warning",           Warning,          warning,           ~str;
@@ -1086,7 +1088,7 @@ headers_mod! {
     18, "WWW-Authenticate",   "Www-Authenticate",   WwwAuthenticate,   www_authenticate,   ~str;
 
     // RFC 2616, Section 7.1: Entity Header Fields
-    19, "Allow",            "Allow",            Allow,           allow,            ~[::method::Method];
+    19, "Allow",            "Allow",            Allow,           allow,            Vec<::method::Method>;
     20, "Content-Encoding", "Content-Encoding", ContentEncoding, content_encoding, ~str;
     21, "Content-Language", "Content-Language", ContentLanguage, content_language, ~str;
     22, "Content-Length",   "Content-Length",   ContentLength,   content_length,   uint;
diff --git a/src/http/headers/serialization_utils.rs b/src/http/headers/serialization_utils.rs
diff --git a/src/http/headers/transfer_encoding.rs b/src/http/headers/transfer_encoding.rs
diff --git a/src/http/server/response.rs b/src/http/server/response.rs
