Skip to content

Commit 3bab457

Browse files
pfpacketpfpacket
committed
Use ? operator instead of try macro
Converted by `untry`
1 parent 7208cf9 commit 3bab457

File tree

4 files changed

+82
-83
lines changed

4 files changed

+82
-83
lines changed

‎example/utils.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ pub fn create_buffer(size: usize) -> Vec<u8> {
2020
}
2121

2222
pub fn get_qid<T: AsRef<Path> + ?Sized>(path: &T) -> rs9p::Result<Qid> {
23-
Ok(qid_from_attr( &try!(fs::symlink_metadata(path.as_ref())) ))
23+
Ok(qid_from_attr( &fs::symlink_metadata(path.as_ref())? ))
2424
}
2525

2626
pub fn qid_from_attr(attr: &fs::Metadata) -> Qid {
@@ -33,7 +33,7 @@ pub fn qid_from_attr(attr: &fs::Metadata) -> Qid {
3333

3434
pub fn get_dirent_from<P: AsRef<Path> + ?Sized>(p: &P, offset: u64) -> rs9p::Result<DirEntry> {
3535
Ok(DirEntry {
36-
qid: try!(get_qid(p)),
36+
qid: get_qid(p)?,
3737
offset: offset,
3838
typ: 0,
3939
name: p.as_ref().to_string_lossy().into_owned()
@@ -42,7 +42,7 @@ pub fn get_dirent_from<P: AsRef<Path> + ?Sized>(p: &P, offset: u64) -> rs9p::Res
4242

4343
pub fn get_dirent(entry: &fs::DirEntry, offset: u64) -> rs9p::Result<DirEntry> {
4444
Ok(DirEntry {
45-
qid: qid_from_attr(&try!(entry.metadata())),
45+
qid: qid_from_attr(&entry.metadata()?),
4646
offset: offset,
4747
typ: 0,
4848
name: entry.file_name().to_string_lossy().into_owned()

‎src/serialize.rs

Lines changed: 57 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -87,7 +87,7 @@ impl<W: WriteBytesExt> Encoder<W> {
8787

8888
/// Encode data, equivalent to: decoder << data
8989
pub fn encode<T: Encodable,>(&mut self, data: &T) -> Result<usize> {
90-
let bytes = try!(data.encode(&mut self.writer));
90+
let bytes = data.encode(&mut self.writer)?;
9191
self.bytes += bytes;
9292
Ok(bytes)
9393
}
@@ -178,8 +178,8 @@ impl Encodable for u64 {
178178

179179
impl Encodable for String {
180180
fn encode<W: WriteBytesExt>(&self, w: &mut W) -> Result<usize> {
181-
let mut bytes = try!((self.len() as u16).encode(w));
182-
bytes += try!(w.write_all(self.as_bytes()).and(Ok(self.len())));
181+
let mut bytes = (self.len() as u16).encode(w)?;
182+
bytes += w.write_all(self.as_bytes()).and(Ok(self.len()))?;
183183
Ok(bytes)
184184
}
185185
}
@@ -245,8 +245,8 @@ impl Encodable for DirEntryData {
245245
impl Encodable for Data {
246246
fn encode<W: WriteBytesExt>(&self, w: &mut W) -> Result<usize> {
247247
let size = self.0.len();
248-
let bytes = try!((size as u32).encode(w)) + size;
249-
try!(w.write_all(&self.0));
248+
let bytes = (size as u32).encode(w)? + size;
249+
w.write_all(&self.0)?;
250250
Ok(bytes)
251251
}
252252
}
@@ -388,8 +388,8 @@ impl Decodable for u64 {
388388

389389
impl Decodable for String {
390390
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
391-
let len: u16 = try!(Decodable::decode(r));
392-
let buf = try!(read_exact(r, len as usize));
391+
let len: u16 = Decodable::decode(r)?;
392+
let buf = read_exact(r, len as usize)?;
393393
String::from_utf8(buf).or(res!(io_err!(Other, "Invalid UTF-8 sequence")))
394394
}
395395
}
@@ -398,94 +398,94 @@ impl Decodable for Qid {
398398
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
399399
Ok(Qid {
400400
typ: decode!(QidType, *r),
401-
version: try!(Decodable::decode(r)),
402-
path: try!(Decodable::decode(r))
401+
version: Decodable::decode(r)?,
402+
path: Decodable::decode(r)?
403403
})
404404
}
405405
}
406406

407407
impl Decodable for Statfs {
408408
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
409409
Ok(Statfs {
410-
typ: try!(Decodable::decode(r)),
411-
bsize: try!(Decodable::decode(r)),
412-
blocks: try!(Decodable::decode(r)),
413-
bfree: try!(Decodable::decode(r)),
414-
bavail: try!(Decodable::decode(r)),
415-
files: try!(Decodable::decode(r)),
416-
ffree: try!(Decodable::decode(r)),
417-
fsid: try!(Decodable::decode(r)),
418-
namelen: try!(Decodable::decode(r)),
410+
typ: Decodable::decode(r)?,
411+
bsize: Decodable::decode(r)?,
412+
blocks: Decodable::decode(r)?,
413+
bfree: Decodable::decode(r)?,
414+
bavail: Decodable::decode(r)?,
415+
files: Decodable::decode(r)?,
416+
ffree: Decodable::decode(r)?,
417+
fsid: Decodable::decode(r)?,
418+
namelen: Decodable::decode(r)?,
419419
})
420420
}
421421
}
422422

423423
impl Decodable for Time {
424424
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
425425
Ok(Time {
426-
sec: try!(Decodable::decode(r)),
427-
nsec: try!(Decodable::decode(r)),
426+
sec: Decodable::decode(r)?,
427+
nsec: Decodable::decode(r)?,
428428
})
429429
}
430430
}
431431

432432
impl Decodable for Stat {
433433
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
434434
Ok(Stat {
435-
mode: try!(Decodable::decode(r)),
436-
uid: try!(Decodable::decode(r)),
437-
gid: try!(Decodable::decode(r)),
438-
nlink: try!(Decodable::decode(r)),
439-
rdev: try!(Decodable::decode(r)),
440-
size: try!(Decodable::decode(r)),
441-
blksize: try!(Decodable::decode(r)),
442-
blocks: try!(Decodable::decode(r)),
443-
atime: try!(Decodable::decode(r)),
444-
mtime: try!(Decodable::decode(r)),
445-
ctime: try!(Decodable::decode(r)),
435+
mode: Decodable::decode(r)?,
436+
uid: Decodable::decode(r)?,
437+
gid: Decodable::decode(r)?,
438+
nlink: Decodable::decode(r)?,
439+
rdev: Decodable::decode(r)?,
440+
size: Decodable::decode(r)?,
441+
blksize: Decodable::decode(r)?,
442+
blocks: Decodable::decode(r)?,
443+
atime: Decodable::decode(r)?,
444+
mtime: Decodable::decode(r)?,
445+
ctime: Decodable::decode(r)?,
446446
})
447447
}
448448
}
449449

450450
impl Decodable for SetAttr {
451451
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
452452
Ok(SetAttr {
453-
mode: try!(Decodable::decode(r)),
454-
uid: try!(Decodable::decode(r)),
455-
gid: try!(Decodable::decode(r)),
456-
size: try!(Decodable::decode(r)),
457-
atime: try!(Decodable::decode(r)),
458-
mtime: try!(Decodable::decode(r)),
453+
mode: Decodable::decode(r)?,
454+
uid: Decodable::decode(r)?,
455+
gid: Decodable::decode(r)?,
456+
size: Decodable::decode(r)?,
457+
atime: Decodable::decode(r)?,
458+
mtime: Decodable::decode(r)?,
459459
})
460460
}
461461
}
462462

463463
impl Decodable for DirEntry {
464464
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
465465
Ok(DirEntry {
466-
qid: try!(Decodable::decode(r)),
467-
offset: try!(Decodable::decode(r)),
468-
typ: try!(Decodable::decode(r)),
469-
name: try!(Decodable::decode(r)),
466+
qid: Decodable::decode(r)?,
467+
offset: Decodable::decode(r)?,
468+
typ: Decodable::decode(r)?,
469+
name: Decodable::decode(r)?,
470470
})
471471
}
472472
}
473473

474474
impl Decodable for DirEntryData {
475475
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
476-
let count: u32 = try!(Decodable::decode(r));
476+
let count: u32 = Decodable::decode(r)?;
477477
let mut data: Vec<DirEntry> = Vec::with_capacity(count as usize);
478478
for _ in 0..count {
479-
data.push(try!(Decodable::decode(r)));
479+
data.push(Decodable::decode(r)?);
480480
}
481481
Ok(DirEntryData::with(data))
482482
}
483483
}
484484

485485
impl Decodable for Data {
486486
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
487-
let len: u32 = try!(Decodable::decode(r));
488-
let buf = try!(read_exact(r, len as usize));
487+
let len: u32 = Decodable::decode(r)?;
488+
let buf = read_exact(r, len as usize)?;
489489
Ok(Data(buf))
490490
}
491491
}
@@ -495,10 +495,10 @@ impl Decodable for Flock {
495495
Ok(Flock {
496496
typ: decode!(LockType, *r),
497497
flags: decode!(LockFlag, *r),
498-
start: try!(Decodable::decode(r)),
499-
length: try!(Decodable::decode(r)),
500-
proc_id: try!(Decodable::decode(r)),
501-
client_id: try!(Decodable::decode(r)),
498+
start: Decodable::decode(r)?,
499+
length: Decodable::decode(r)?,
500+
proc_id: Decodable::decode(r)?,
501+
client_id: Decodable::decode(r)?,
502502
})
503503
}
504504
}
@@ -507,20 +507,20 @@ impl Decodable for Getlock {
507507
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
508508
Ok(Getlock {
509509
typ: decode!(LockType, *r),
510-
start: try!(Decodable::decode(r)),
511-
length: try!(Decodable::decode(r)),
512-
proc_id: try!(Decodable::decode(r)),
513-
client_id: try!(Decodable::decode(r)),
510+
start: Decodable::decode(r)?,
511+
length: Decodable::decode(r)?,
512+
proc_id: Decodable::decode(r)?,
513+
client_id: Decodable::decode(r)?,
514514
})
515515
}
516516
}
517517

518518
impl<T: Decodable> Decodable for Vec<T> {
519519
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
520-
let len: u16 = try!(Decodable::decode(r));
520+
let len: u16 = Decodable::decode(r)?;
521521
let mut buf = Vec::new();
522522
for _ in 0..len {
523-
buf.push(try!(Decodable::decode(r)));
523+
buf.push(Decodable::decode(r)?);
524524
}
525525
Ok(buf)
526526
}
@@ -530,8 +530,8 @@ impl Decodable for Msg {
530530
fn decode<R: ReadBytesExt>(r: &mut R) -> Result<Self> {
531531
use MsgType::*;
532532

533-
let size = try!(r.read_u32::<LittleEndian>()) - 4;
534-
let mut buf = Cursor::new(try!(read_exact(r, size as usize)));
533+
let size = r.read_u32::<LittleEndian>()? - 4;
534+
let mut buf = Cursor::new(read_exact(r, size as usize)?);
535535

536536
let msg_type = MsgType::from_u8(decode!(buf));
537537
let tag = decode!(buf);

‎src/srv.rs

Lines changed: 21 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -150,16 +150,15 @@ impl<Fs, RwExt> ServerInstance<Fs, RwExt>
150150

151151
fn dispatch(&mut self) -> Result<()> {
152152
loop {
153-
let msg = try!(serialize::read_msg(&mut self.stream));
153+
let msg = serialize::read_msg(&mut self.stream)?;
154154

155155
debug!("\t→ {:?}", msg);
156-
let (fcall, tag) = try!(dispatch_once(
156+
let (fcall, tag) = dispatch_once(
157157
msg,
158158
&mut self.fs,
159-
&mut self.fids)
160-
);
159+
&mut self.fids)?;
161160

162-
try!(utils::respond(&mut self.stream, tag, fcall));
161+
utils::respond(&mut self.stream, tag, fcall)?;
163162
}
164163
}
165164
}
@@ -184,16 +183,16 @@ impl<Fs, RwExt> SpawnServerInstance<Fs, RwExt>
184183

185184
fn dispatch(&mut self) -> Result<()> {
186185
loop {
187-
let msg = try!(serialize::read_msg(&mut self.stream));
186+
let msg = serialize::read_msg(&mut self.stream)?;
188187

189188
debug!("\t→ {:?}", msg);
190-
let (fcall, tag) = try!(dispatch_once(
189+
let (fcall, tag) = dispatch_once(
191190
msg,
192191
&mut *self.fs.lock().unwrap(),
193192
&mut self.fids
194-
));
193+
)?;
195194

196-
try!(utils::respond(&mut self.stream, tag, fcall));
195+
utils::respond(&mut self.stream, tag, fcall)?;
197196
}
198197
}
199198
}
@@ -265,9 +264,9 @@ fn dispatch_once<FsFid>(msg: Msg, fs: &mut Filesystem<Fid=FsFid>, fsfids: &mut H
265264
/// This function forks a child process to handle its 9P messages
266265
/// when a client connects to the server.
267266
pub fn srv<Fs: Filesystem>(filesystem: Fs, addr: &str) -> Result<()> {
268-
let (proto, sockaddr) = try!(utils::parse_proto(addr).ok_or(
267+
let (proto, sockaddr) = utils::parse_proto(addr).ok_or(
269268
io_err!(InvalidInput, "Invalid protocol or address")
270-
));
269+
)?;
271270

272271
if proto != "tcp" {
273272
return res!(io_err!(InvalidInput, format!("Unsupported protocol: {}", proto)));
@@ -278,18 +277,18 @@ pub fn srv<Fs: Filesystem>(filesystem: Fs, addr: &str) -> Result<()> {
278277
sigaction(Signal::SIGCHLD, &SigAction::new(SigHandler::SigIgn, SaFlags::empty(), SigSet::empty()))?;
279278
}
280279

281-
let listener = try!(TcpListener::bind(&sockaddr[..]));
280+
let listener = TcpListener::bind(&sockaddr[..])?;
282281

283282
loop {
284-
let (stream, remote) = try!(listener.accept());
283+
let (stream, remote) = listener.accept()?;
285284

286-
match try!(nix::unistd::fork()) {
285+
match nix::unistd::fork()? {
287286
nix::unistd::ForkResult::Parent { .. } => {},
288287
nix::unistd::ForkResult::Child => {
289288
info!("ServerProcess={} starts", remote);
290289

291-
try!(utils::setup_tcp_stream(&stream));
292-
let result = try!(ServerInstance::new(filesystem, stream)).dispatch();
290+
utils::setup_tcp_stream(&stream)?;
291+
let result = ServerInstance::new(filesystem, stream)?.dispatch();
293292

294293
info!("ServerProcess={} finished: {:?}", remote, result);
295294
process::exit(1);
@@ -303,26 +302,26 @@ pub fn srv<Fs: Filesystem>(filesystem: Fs, addr: &str) -> Result<()> {
303302
/// This function spawns a new thread to handle its 9P messages
304303
/// when a client connects to the server.
305304
pub fn srv_spawn<Fs: Filesystem + Send + 'static>(filesystem: Fs, addr: &str) -> Result<()> {
306-
let (proto, sockaddr) = try!(utils::parse_proto(addr).ok_or(
305+
let (proto, sockaddr) = utils::parse_proto(addr).ok_or(
307306
io_err!(InvalidInput, "Invalid protocol or address")
308-
));
307+
)?;
309308

310309
if proto != "tcp" {
311310
return res!(io_err!(InvalidInput, format!("Unsupported protocol: {}", proto)));
312311
}
313312

314313
let arc_fs = Arc::new(Mutex::new(filesystem));
315-
let listener = try!(TcpListener::bind(&sockaddr[..]));
314+
let listener = TcpListener::bind(&sockaddr[..])?;
316315

317316
loop {
318-
let (stream, remote) = try!(listener.accept());
317+
let (stream, remote) = listener.accept()?;
319318
let (fs, thread_name) = (arc_fs.clone(), format!("{}", remote));
320319

321320
let _ = thread::Builder::new().name(thread_name.clone()).spawn(move || {
322321
info!("ServerThread={:?} started", thread_name);
323322
let result = {|| {
324-
try!(utils::setup_tcp_stream(&stream));
325-
try!(SpawnServerInstance::new(fs, stream)).dispatch()
323+
utils::setup_tcp_stream(&stream)?;
324+
SpawnServerInstance::new(fs, stream)?.dispatch()
326325
}}();
327326
info!("ServerThread={:?} finished: {:?}", thread_name, result);
328327
});

‎src/utils.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ pub fn respond<WExt: WriteBytesExt>(stream: &mut WExt, tag: u16, body: Fcall) ->
4444
};
4545

4646
let msg = Msg { tag: tag, body: body };
47-
try!(serialize::write_msg(stream, &msg));
47+
serialize::write_msg(stream, &msg)?;
4848

4949
debug!("\t← {:?}", msg);
5050

0 commit comments

Comments
 (0)