Use new slice syntax

Author: sfackler

src/error.rs

@@ -205,7 +205,6 @@ make_errors!(
     "38003" => ProhibitedSqlStatementAttemptedExternalRoutine,
     "38004" => ReadingSqlDataNotPermittedExternalRoutine,
 
-
     // Class 39 — External Routine Invocation Exception
     "39000" => ExternalRoutineInvocationException,
     "39001" => InvalidSqlstateReturned,
@@ -484,15 +483,15 @@ impl PostgresDbError {
         let mut map: HashMap<_, _> = fields.into_iter().collect();
         Ok(PostgresDbError {
             severity: try!(map.pop(&b'S').ok_or(())),
-            code: PostgresSqlState::from_code(try!(map.pop(&b'C').ok_or(())).as_slice()),
+            code: PostgresSqlState::from_code(try!(map.pop(&b'C').ok_or(()))[]),
             message: try!(map.pop(&b'M').ok_or(())),
             detail: map.pop(&b'D'),
             hint: map.pop(&b'H'),
             position: match map.pop(&b'P') {
-                Some(pos) => Some(Position(try!(from_str(pos.as_slice()).ok_or(())))),
+                Some(pos) => Some(Position(try!(from_str(pos[]).ok_or(())))),
                 None => match map.pop(&b'p') {
                     Some(pos) => Some(InternalPosition {
-                        position: try!(from_str(pos.as_slice()).ok_or(())),
+                        position: try!(from_str(pos[]).ok_or(())),
                         query: try!(map.pop(&b'q').ok_or(()))
                     }),
                     None => None
@@ -505,7 +504,7 @@ impl PostgresDbError {
             datatype: map.pop(&b'd'),
             constraint: map.pop(&b'n'),
             file: try!(map.pop(&b'F').ok_or(())),
-            line: try!(map.pop(&b'L').and_then(|l| from_str(l.as_slice())).ok_or(())),
+            line: try!(map.pop(&b'L').and_then(|l| from_str(l[])).ok_or(())),
             routine: map.pop(&b'R').unwrap()
         })
     }

src/io.rs

@@ -86,7 +86,7 @@ fn open_socket(params: &PostgresConnectParams)
     let port = params.port.unwrap_or(DEFAULT_PORT);
     let socket = match params.target {
         TargetTcp(ref host) =>
-            tcp::TcpStream::connect(host.as_slice(), port).map(|s| TcpStream(s)),
+            tcp::TcpStream::connect(host[], port).map(|s| TcpStream(s)),
         TargetUnix(ref path) => {
             let mut path = path.clone();
             path.push(format!(".s.PGSQL.{}", port));

src/lib.rs

@@ -224,8 +224,8 @@ impl IntoConnectParams for Url {
             ..
         } = self;
 
-        let maybe_path = try!(url::decode_component(host.as_slice()).map_err(InvalidUrl));
-        let target = if maybe_path.as_slice().starts_with("/") {
+        let maybe_path = try!(url::decode_component(host[]).map_err(InvalidUrl));
+        let target = if maybe_path[].starts_with("/") {
             TargetUnix(Path::new(maybe_path))
         } else {
             TargetTcp(host)
@@ -238,7 +238,7 @@ impl IntoConnectParams for Url {
 
         let database = if !path.is_empty() {
             // path contains the leading /
-            let (_, path) = path.as_slice().slice_shift_char();
+            let (_, path) = path[].slice_shift_char();
             Some(path.to_string())
         } else {
             None
@@ -413,7 +413,7 @@ impl InnerPostgresConnection {
 
         try_pg_conn!(conn.write_messages([StartupMessage {
             version: message::PROTOCOL_VERSION,
-            parameters: options.as_slice()
+            parameters: options[]
         }]));
 
         try!(conn.handle_auth(user));
@@ -476,7 +476,7 @@ impl InnerPostgresConnection {
                     None => return Err(MissingPassword)
                 };
                 try_pg_conn!(self.write_messages([PasswordMessage {
-                        password: pass.as_slice(),
+                        password: pass[],
                     }]));
             }
             AuthenticationMD5Password { salt } => {
@@ -487,14 +487,14 @@ impl InnerPostgresConnection {
                 let hasher = Hasher::new(MD5);
                 hasher.update(pass.as_bytes());
                 hasher.update(user.user.as_bytes());
-                let output = hasher.final().as_slice().to_hex();
+                let output = hasher.final()[].to_hex();
                 let hasher = Hasher::new(MD5);
                 hasher.update(output.as_bytes());
                 hasher.update(salt);
                 let output = format!("md5{}",
-                                     hasher.final().as_slice().to_hex());
+                                     hasher.final()[].to_hex());
                 try_pg_conn!(self.write_messages([PasswordMessage {
-                        password: output.as_slice()
+                        password: output[]
                     }]));
             }
             AuthenticationKerberosV5
@@ -530,13 +530,13 @@ impl InnerPostgresConnection {
 
         try_pg!(self.write_messages([
             Parse {
-                name: stmt_name.as_slice(),
+                name: stmt_name[],
                 query: query,
                 param_types: []
             },
             Describe {
                 variant: b'S',
-                name: stmt_name.as_slice(),
+                name: stmt_name[],
             },
             Sync]));
 
@@ -598,17 +598,17 @@ impl InnerPostgresConnection {
         let _ = util::comma_join(&mut query, rows.iter().map(|&e| e));
         let _ = write!(query, " FROM {}", table);
         let query = String::from_utf8(query.unwrap()).unwrap();
-        let (stmt_name, _, result_desc) = try!(self.raw_prepare(query.as_slice()));
+        let (stmt_name, _, result_desc) = try!(self.raw_prepare(query[]));
 
         let column_types = result_desc.iter().map(|desc| desc.ty.clone()).collect();
-        try!(self.close_statement(stmt_name.as_slice()));
+        try!(self.close_statement(stmt_name[]));
 
         let mut query = MemWriter::new();
         let _ = write!(query, "COPY {} (", table);
         let _ = util::comma_join(&mut query, rows.iter().map(|&e| e));
         let _ = write!(query, ") FROM STDIN WITH (FORMAT binary)");
         let query = String::from_utf8(query.unwrap()).unwrap();
-        let (stmt_name, _, _) = try!(self.raw_prepare(query.as_slice()));
+        let (stmt_name, _, _) = try!(self.raw_prepare(query[]));
 
         Ok(PostgresCopyInStatement {
             conn: conn,
@@ -656,7 +656,7 @@ impl InnerPostgresConnection {
             None => {}
         }
         let name = try!(self.quick_query(format!("SELECT typname FROM pg_type \
-                                                  WHERE oid={}", oid).as_slice()))
+                                                  WHERE oid={}", oid)[]))
             .into_iter().next().unwrap().into_iter().next().unwrap().unwrap();
         self.unknown_types.insert(oid, name.clone());
         Ok(name)
@@ -687,7 +687,7 @@ impl InnerPostgresConnection {
                 ReadyForQuery { .. } => break,
                 DataRow { row } => {
                     result.push(row.into_iter().map(|opt| {
-                        opt.map(|b| String::from_utf8_lossy(b.as_slice()).into_string())
+                        opt.map(|b| String::from_utf8_lossy(b[]).into_string())
                     }).collect());
                 }
                 ErrorResponse { fields } => {
@@ -1149,7 +1149,7 @@ impl<'conn> PostgresStatement<'conn> {
     fn finish_inner(&mut self) -> PostgresResult<()> {
         let mut conn = self.conn.conn.borrow_mut();
         check_desync!(conn);
-        conn.close_statement(self.name.as_slice())
+        conn.close_statement(self.name[])
     }
 
     fn inner_execute(&self, portal_name: &str, row_limit: i32, params: &[&ToSql])
@@ -1170,9 +1170,9 @@ impl<'conn> PostgresStatement<'conn> {
         try_pg!(conn.write_messages([
             Bind {
                 portal: portal_name,
-                statement: self.name.as_slice(),
+                statement: self.name[],
                 formats: [1],
-                values: values.as_slice(),
+                values: values[],
                 result_formats: [1]
             },
             Execute {
@@ -1200,7 +1200,7 @@ impl<'conn> PostgresStatement<'conn> {
         self.next_portal_id.set(id + 1);
         let portal_name = format!("{}p{}", self.name, id);
 
-        try!(self.inner_execute(portal_name.as_slice(), row_limit, params));
+        try!(self.inner_execute(portal_name[], row_limit, params));
 
         let mut result = PostgresRows {
             stmt: self,
@@ -1217,12 +1217,12 @@ impl<'conn> PostgresStatement<'conn> {
 
     /// Returns a slice containing the expected parameter types.
     pub fn param_types(&self) -> &[PostgresType] {
-        self.param_types.as_slice()
+        self.param_types[]
     }
 
     /// Returns a slice describing the columns of the result of the query.
     pub fn result_descriptions(&self) -> &[ResultDescription] {
-        self.result_desc.as_slice()
+        self.result_desc[]
     }
 
     /// Executes the prepared statement, returning the number of rows modified.
@@ -1349,7 +1349,7 @@ impl<'stmt> PostgresRows<'stmt> {
         try_pg!(conn.write_messages([
             Close {
                 variant: b'P',
-                name: self.name.as_slice()
+                name: self.name[]
             },
             Sync]));
 
@@ -1404,7 +1404,7 @@ impl<'stmt> PostgresRows<'stmt> {
     fn execute(&mut self) -> PostgresResult<()> {
         try_pg!(self.stmt.conn.write_messages([
             Execute {
-                portal: self.name.as_slice(),
+                portal: self.name[],
                 max_rows: self.row_limit
             },
             Sync]));
@@ -1535,7 +1535,7 @@ impl RowIndex for uint {
 impl<'a> RowIndex for &'a str {
     #[inline]
     fn idx(&self, stmt: &PostgresStatement) -> Option<uint> {
-        stmt.result_descriptions().iter().position(|d| d.name.as_slice() == *self)
+        stmt.result_descriptions().iter().position(|d| d.name[] == *self)
     }
 }
 
@@ -1587,12 +1587,12 @@ impl<'a> PostgresCopyInStatement<'a> {
     fn finish_inner(&mut self) -> PostgresResult<()> {
         let mut conn = self.conn.conn.borrow_mut();
         check_desync!(conn);
-        conn.close_statement(self.name.as_slice())
+        conn.close_statement(self.name[])
     }
 
     /// Returns a slice containing the expected column types.
     pub fn column_types(&self) -> &[PostgresType] {
-        self.column_types.as_slice()
+        self.column_types[]
     }
 
     /// Executes the prepared statement.
@@ -1608,7 +1608,7 @@ impl<'a> PostgresCopyInStatement<'a> {
         try_pg!(conn.write_messages([
             Bind {
                 portal: "",
-                statement: self.name.as_slice(),
+                statement: self.name[],
                 formats: [],
                 values: [],
                 result_formats: []
@@ -1657,7 +1657,7 @@ impl<'a> PostgresCopyInStatement<'a> {
                             }
                             Some(val) => {
                                 let _ = buf.write_be_i32(val.len() as i32);
-                                let _ = buf.write(val.as_slice());
+                                let _ = buf.write(val[]);
                             }
                         }
                     }
@@ -1674,15 +1674,15 @@ impl<'a> PostgresCopyInStatement<'a> {
 
             try_pg_desync!(conn, conn.stream.write_message(
                 &CopyData {
-                    data: buf.unwrap().as_slice()
+                    data: buf.unwrap()[]
                 }));
             buf = MemWriter::new();
         }
 
         let _ = buf.write_be_i16(-1);
         try_pg!(conn.write_messages([
             CopyData {
-                data: buf.unwrap().as_slice(),
+                data: buf.unwrap()[],
             },
             CopyDone,
             Sync]));

src/message.rs

@@ -168,7 +168,7 @@ impl<W: Writer> WriteMessage for W {
                         }
                         Some(ref value) => {
                             try!(buf.write_be_i32(value.len() as i32));
-                            try!(buf.write(value.as_slice()));
+                            try!(buf.write(value[]));
                         }
                     }
                 }
@@ -229,8 +229,8 @@ impl<W: Writer> WriteMessage for W {
             StartupMessage { version, parameters } => {
                 try!(buf.write_be_u32(version));
                 for &(ref k, ref v) in parameters.iter() {
-                    try!(buf.write_cstr(k.as_slice()));
-                    try!(buf.write_cstr(v.as_slice()));
+                    try!(buf.write_cstr(k[]));
+                    try!(buf.write_cstr(v[]));
                 }
                 try!(buf.write_u8(0));
             }
@@ -251,7 +251,7 @@ impl<W: Writer> WriteMessage for W {
         let buf = buf.unwrap();
         // add size of length value
         try!(self.write_be_i32((buf.len() + mem::size_of::<i32>()) as i32));
-        try!(self.write(buf.as_slice()));
+        try!(self.write(buf[]));
 
         Ok(())
     }

src/types/array.rs

@@ -152,7 +152,7 @@ impl<T> ArrayBase<T> {
 
 impl<T> Array<T> for ArrayBase<T> {
     fn dimension_info<'a>(&'a self) -> &'a [DimensionInfo] {
-        self.info.as_slice()
+        self.info[]
     }
 
     fn slice<'a>(&'a self, idx: int) -> ArraySlice<'a, T> {
@@ -220,7 +220,7 @@ impl<'parent, T> Array<T> for ArraySlice<'parent, T> {
             MutSliceParent(p) => p.dimension_info(),
             BaseParent(p) => p.dimension_info()
         };
-        info.slice_from(1)
+        info[1..]
     }
 
     fn slice<'a>(&'a self, idx: int) -> ArraySlice<'a, T> {
@@ -272,7 +272,7 @@ impl<'parent, T> Array<T> for MutArraySlice<'parent, T> {
                 MutBaseParent(ref p) => mem::transmute(p.dimension_info()),
             }
         };
-        info.slice_from(1)
+        info[1..]
     }
 
     fn slice<'a>(&'a self, idx: int) -> ArraySlice<'a, T> {