Skip to content

Commit 5b3a5ed

Browse files
kishigurokishiguro
committed
Migrate try!() macro to '?' operator.
1 parent 51f5106 commit 5b3a5ed

File tree

2 files changed

+45
-45
lines changed

2 files changed

+45
-45
lines changed

‎src/lib.rs‎

Lines changed: 33 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -60,9 +60,9 @@ impl SctpStream {
6060

6161
/// Create a new stream by connecting it to a remote endpoint
6262
pub fn connect<A: ToSocketAddrs>(address: A) -> Result<SctpStream> {
63-
let raw_addr = try!(SocketAddr::from_addr(&address));
64-
let sock = try!(SctpSocket::new(raw_addr.family(), SOCK_STREAM));
65-
try!(sock.connect(raw_addr));
63+
let raw_addr = SocketAddr::from_addr(&address)?;
64+
let sock = SctpSocket::new(raw_addr.family(), SOCK_STREAM)?;
65+
sock.connect(raw_addr)?;
6666
return Ok(SctpStream(sock));
6767
}
6868

@@ -72,13 +72,13 @@ impl SctpStream {
7272
let mut vec = Vec::with_capacity(addresses.len());
7373
let mut family = AF_INET;
7474
for address in addresses {
75-
let a = try!(SocketAddr::from_addr(address));
75+
let a = SocketAddr::from_addr(address)?;
7676
if a.family() == AF_INET6 { family = AF_INET6; }
7777
vec.push(a);
7878
}
7979

80-
let sock = try!(SctpSocket::new(family, SOCK_STREAM));
81-
try!(sock.connectx(&vec));
80+
let sock = SctpSocket::new(family, SOCK_STREAM)?;
81+
sock.connectx(&vec)?;
8282
return Ok(SctpStream(sock));
8383
}
8484

@@ -91,7 +91,7 @@ impl SctpStream {
9191
/// Read bytes. On success, return a tuple with the quantity of
9292
/// bytes received and the stream they were recived on
9393
pub fn recvmsg(&self, msg: &mut [u8]) -> Result<(usize, u16)> {
94-
let (size, stream, _) = try!(self.0.recvmsg(msg));
94+
let (size, stream, _) = self.0.recvmsg(msg)?;
9595
return Ok((size, stream));
9696
}
9797

@@ -118,7 +118,7 @@ impl SctpStream {
118118

119119
/// Verify if SCTP_NODELAY option is activated for this socket
120120
pub fn has_nodelay(&self) -> Result<bool> {
121-
let val: libc::c_int = try!(self.0.sctp_opt_info(sctp_sys::SCTP_NODELAY, 0));
121+
let val: libc::c_int = self.0.sctp_opt_info(sctp_sys::SCTP_NODELAY, 0)?;
122122
return Ok(val == 1);
123123
}
124124

@@ -129,8 +129,8 @@ impl SctpStream {
129129
}
130130

131131
/// Get the socket buffer size for the direction specified by `dir`
132-
pub fn get_buffer_size(&self, dir: SoDirection) -> Result<(usize)> {
133-
let val: u32 = try!(self.0.getsockopt(SOL_SOCKET, dir.buffer_opt()));
132+
pub fn get_buffer_size(&self, dir: SoDirection) -> Result<usize> {
133+
let val: u32 = self.0.getsockopt(SOL_SOCKET, dir.buffer_opt())?;
134134
return Ok(val as usize);
135135
}
136136

@@ -144,7 +144,7 @@ impl SctpStream {
144144
/// Try to clone the SctpStream. On success, returns a new stream
145145
/// wrapping a new socket handler
146146
pub fn try_clone(&self) -> Result<SctpStream> {
147-
return Ok(SctpStream(try!(self.0.try_clone())));
147+
return Ok(SctpStream(self.0.try_clone()?));
148148
}
149149
}
150150

@@ -200,10 +200,10 @@ impl SctpEndpoint {
200200

201201
/// Create a one-to-many SCTP endpoint bound to a single address
202202
pub fn bind<A: ToSocketAddrs>(address: A) -> Result<SctpEndpoint> {
203-
let raw_addr = try!(SocketAddr::from_addr(&address));
204-
let sock = try!(SctpSocket::new(raw_addr.family(), SOCK_SEQPACKET));
205-
try!(sock.bind(raw_addr));
206-
try!(sock.listen(-1));
203+
let raw_addr = SocketAddr::from_addr(&address)?;
204+
let sock = SctpSocket::new(raw_addr.family(), SOCK_SEQPACKET)?;
205+
sock.bind(raw_addr)?;
206+
sock.listen(-1)?;
207207
return Ok(SctpEndpoint(sock));
208208
}
209209

@@ -213,14 +213,14 @@ impl SctpEndpoint {
213213
let mut vec = Vec::with_capacity(addresses.len());
214214
let mut family = AF_INET;
215215
for address in addresses {
216-
let a = try!(SocketAddr::from_addr(address));
216+
let a = SocketAddr::from_addr(address)?;
217217
if a.family() == AF_INET6 { family = AF_INET6; }
218218
vec.push(a);
219219
}
220220

221-
let sock = try!(SctpSocket::new(family, SOCK_SEQPACKET));
222-
try!(sock.bindx(&vec, BindOp::AddAddr));
223-
try!(sock.listen(-1));
221+
let sock = SctpSocket::new(family, SOCK_SEQPACKET)?;
222+
sock.bindx(&vec, BindOp::AddAddr)?;
223+
sock.listen(-1)?;
224224
return Ok(SctpEndpoint(sock));
225225
}
226226

@@ -255,7 +255,7 @@ impl SctpEndpoint {
255255

256256
/// Verify if SCTP_NODELAY option is activated for this socket
257257
pub fn has_nodelay(&self) -> Result<bool> {
258-
let val: libc::c_int = try!(self.0.sctp_opt_info(sctp_sys::SCTP_NODELAY, 0));
258+
let val: libc::c_int = self.0.sctp_opt_info(sctp_sys::SCTP_NODELAY, 0)?;
259259
return Ok(val == 1);
260260
}
261261

@@ -266,8 +266,8 @@ impl SctpEndpoint {
266266
}
267267

268268
/// Get the socket buffer size for the direction specified by `dir`
269-
pub fn get_buffer_size(&self, dir: SoDirection) -> Result<(usize)> {
270-
let val: u32 = try!(self.0.getsockopt(SOL_SOCKET, dir.buffer_opt()));
269+
pub fn get_buffer_size(&self, dir: SoDirection) -> Result<usize> {
270+
let val: u32 = self.0.getsockopt(SOL_SOCKET, dir.buffer_opt())?;
271271
return Ok(val as usize);
272272
}
273273

@@ -280,7 +280,7 @@ impl SctpEndpoint {
280280

281281
/// Try to clone this socket
282282
pub fn try_clone(&self) -> Result<SctpEndpoint> {
283-
return Ok(SctpEndpoint(try!(self.0.try_clone())));
283+
return Ok(SctpEndpoint(self.0.try_clone()?));
284284
}
285285
}
286286

@@ -336,10 +336,10 @@ impl SctpListener {
336336

337337
/// Create a listener bound to a single address
338338
pub fn bind<A: ToSocketAddrs>(address: A) -> Result<SctpListener> {
339-
let raw_addr = try!(SocketAddr::from_addr(&address));
340-
let sock = try!(SctpSocket::new(raw_addr.family(), SOCK_STREAM));
341-
try!(sock.bind(raw_addr));
342-
try!(sock.listen(-1));
339+
let raw_addr = SocketAddr::from_addr(&address)?;
340+
let sock = SctpSocket::new(raw_addr.family(), SOCK_STREAM)?;
341+
sock.bind(raw_addr)?;
342+
sock.listen(-1)?;
343343
return Ok(SctpListener(sock));
344344
}
345345

@@ -349,20 +349,20 @@ impl SctpListener {
349349
let mut vec = Vec::with_capacity(addresses.len());
350350
let mut family = AF_INET;
351351
for address in addresses {
352-
let a = try!(SocketAddr::from_addr(address));
352+
let a = SocketAddr::from_addr(address)?;
353353
if a.family() == AF_INET6 { family = AF_INET6; }
354354
vec.push(a);
355355
}
356356

357-
let sock = try!(SctpSocket::new(family, SOCK_STREAM));
358-
try!(sock.bindx(&vec, BindOp::AddAddr));
359-
try!(sock.listen(-1));
357+
let sock = SctpSocket::new(family, SOCK_STREAM)?;
358+
sock.bindx(&vec, BindOp::AddAddr)?;
359+
sock.listen(-1)?;
360360
return Ok(SctpListener(sock));
361361
}
362362

363363
/// Accept a new connection
364364
pub fn accept(&self) -> Result<(SctpStream, SocketAddr)> {
365-
let (sock, addr) = try!(self.0.accept());
365+
let (sock, addr) = self.0.accept()?;
366366
return Ok((SctpStream(sock), addr));
367367
}
368368

@@ -385,7 +385,7 @@ impl SctpListener {
385385

386386
/// Try to clone this listener
387387
pub fn try_clone(&self) -> Result<SctpListener> {
388-
return Ok(SctpListener(try!(self.0.try_clone())));
388+
return Ok(SctpListener(self.0.try_clone()?));
389389
}
390390
}
391391

‎src/sctpsock.rs‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -167,7 +167,7 @@ impl RawSocketAddr for SocketAddr {
167167
}
168168

169169
fn from_addr<A: ToSocketAddrs>(address: A) -> Result<SocketAddr> {
170-
return try!(address.to_socket_addrs().or(Err(Error::new(ErrorKind::InvalidInput, "Address is not valid"))))
170+
return address.to_socket_addrs().or(Err(Error::new(ErrorKind::InvalidInput, "Address is not valid")))?
171171
.next().ok_or(Error::new(ErrorKind::InvalidInput, "Address is not valid"));
172172
}
173173
}
@@ -180,13 +180,13 @@ impl SctpSocket {
180180
/// Create a new SCTP socket
181181
pub fn new(family: libc::c_int, sock_type: libc::c_int) -> Result<SctpSocket> {
182182
unsafe {
183-
return Ok(SctpSocket(try!(check_socket(socket(family, sock_type, sctp_sys::IPPROTO_SCTP)))));
183+
return Ok(SctpSocket(check_socket(socket(family, sock_type, sctp_sys::IPPROTO_SCTP))?));
184184
}
185185
}
186186

187187
/// Connect the socket to `address`
188188
pub fn connect<A: ToSocketAddrs>(&self, address: A) -> Result<()> {
189-
let raw_addr = try!(SocketAddr::from_addr(&address));
189+
let raw_addr = SocketAddr::from_addr(&address)?;
190190
unsafe {
191191
return match connect(self.0, raw_addr.as_ptr(), raw_addr.addr_len()) {
192192
0 => Ok(()),
@@ -205,7 +205,7 @@ impl SctpSocket {
205205
}
206206
let mut offset = 0isize;
207207
for address in addresses {
208-
let raw = try!(SocketAddr::from_addr(address));
208+
let raw = SocketAddr::from_addr(address)?;
209209
let len = raw.addr_len();
210210
std::ptr::copy_nonoverlapping(raw.as_ptr() as *mut u8, buf.offset(offset), len as usize);
211211
offset += len as isize;
@@ -223,7 +223,7 @@ impl SctpSocket {
223223

224224
/// Bind the socket to a single address
225225
pub fn bind<A: ToSocketAddrs>(&self, address: A) -> Result<()> {
226-
let raw_addr = try!(SocketAddr::from_addr(&address));
226+
let raw_addr = SocketAddr::from_addr(&address)?;
227227
unsafe {
228228
return match bind(self.0, raw_addr.as_ptr(), raw_addr.addr_len()) {
229229
0 => Ok(()),
@@ -242,7 +242,7 @@ impl SctpSocket {
242242
}
243243
let mut offset = 0isize;
244244
for address in addresses {
245-
let raw = try!(SocketAddr::from_addr(address));
245+
let raw = SocketAddr::from_addr(address)?;
246246
let len = raw.addr_len();
247247
std::ptr::copy_nonoverlapping(raw.as_ptr() as *mut u8, buf.offset(offset), len as usize);
248248
offset += len as isize;
@@ -273,8 +273,8 @@ impl SctpSocket {
273273
let mut len: socklen_t = size_of::<sockaddr_in6>() as socklen_t;
274274
unsafe {
275275
let addr_ptr: *mut sockaddr = transmute(&mut addr);
276-
let sock = try!(check_socket(accept(self.0, addr_ptr, &mut len)));
277-
let addr = try!(SocketAddr::from_raw_ptr(addr_ptr, len));
276+
let sock = check_socket(accept(self.0, addr_ptr, &mut len))?;
277+
let addr = SocketAddr::from_raw_ptr(addr_ptr, len)?;
278278
return Ok((SctpSocket(sock), addr));
279279
}
280280
}
@@ -298,7 +298,7 @@ impl SctpSocket {
298298
return Err(Error::new(ErrorKind::Other, format!("Unsupported address family : {}", f)));
299299
}
300300
} as socklen_t;
301-
vec.push(try!(SocketAddr::from_raw_ptr(sockaddr, len)));
301+
vec.push(SocketAddr::from_raw_ptr(sockaddr, len)?);
302302
offset += len as isize;
303303
}
304304
what.free(addrs as *mut sockaddr);
@@ -350,7 +350,7 @@ impl SctpSocket {
350350
let addr_ptr: *mut sockaddr = transmute(&mut addr);
351351
let mut info: sctp_sys::sctp_sndrcvinfo = std::mem::zeroed();
352352
return match sctp_sys::sctp_recvmsg(self.0, msg.as_mut_ptr() as *mut libc::c_void, len, addr_ptr, &mut addr_len, &mut info, &mut flags) {
353-
res if res > 0 => Ok((res as usize, info.sinfo_stream, try!(SocketAddr::from_raw_ptr(addr_ptr, addr_len)))),
353+
res if res > 0 => Ok((res as usize, info.sinfo_stream, SocketAddr::from_raw_ptr(addr_ptr, addr_len)?)),
354354
_ => Err(Error::last_os_error())
355355
};
356356
}
@@ -362,7 +362,7 @@ impl SctpSocket {
362362
let len = msg.len() as libc::size_t;
363363
let (raw_addr, addr_len) = match address {
364364
Some(a) => {
365-
let mut addr = try!(SocketAddr::from_addr(a));
365+
let mut addr = SocketAddr::from_addr(a)?;
366366
(addr.as_mut_ptr(), addr.addr_len())
367367
},
368368
None => (std::ptr::null_mut(), 0)
@@ -425,7 +425,7 @@ impl SctpSocket {
425425
/// Try to clone this socket
426426
pub fn try_clone(&self) -> Result<SctpSocket> {
427427
unsafe {
428-
let new_sock = try!(check_socket(libc::dup(self.0 as i32) as SOCKET));
428+
let new_sock = check_socket(libc::dup(self.0 as i32) as SOCKET)?;
429429
return Ok(SctpSocket(new_sock));
430430
}
431431
}

0 commit comments

Comments
 (0)