Skip to content

Commit

Permalink
reformat/general: replace try! with ?
Browse files Browse the repository at this point in the history
  • Loading branch information
@dhardy
dhardy committed Dec 28, 2016
1 parent 5713943 commit 98fa749
Show file tree
Hide file tree
Showing 20 changed files with 330 additions and 330 deletions.
38 changes: 19 additions & 19 deletions app_tests/examples/sequences.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -117,58 +117,58 @@ fn run(path: &Path, part_num: Option<u64>,
// On creation we need a number; 0 here means "default":
let part_id = PartId::from_num(if pn == 0 { 1 } else { pn });
let io = Box::new(fileio::PartFileIO::new_empty(part_id, path.join("seqdb")));
try!(Partition::<Sequence>::create(io, "sequences db", None, None))
Partition::<Sequence>::create(io, "sequences db", None, None)?
} else {
// — Open partition —
let part_id = if pn != 0 { Some(PartId::from_num(pn)) } else { None };
let io = Box::new(try!(discover::part_from_path(path, part_id)));
let mut part = try!(Partition::<Sequence>::open(io));
try!(part.load_latest(None, None));
let io = Box::new(discover::part_from_path(path, part_id)?);
let mut part = Partition::<Sequence>::open(io)?;
part.load_latest(None, None)?;
part
};

if part.merge_required() {
try!(part.merge(&merge_solver, true, None));
part.merge(&merge_solver, true, None)?;
}

if let Some(num) = list_n {
let tip = try!(part.tip());
let tip = part.tip()?;
for (id, ref elt) in tip.elts_iter().take(num) {
println!("Element {}: {:?}" , id, *elt);
}
}

for _ in 0..repetitions {
let mut state = {
let tip = try!(part.tip());
let tip = part.tip()?;
println!("Found state {}; have {} elements", tip.statesum(), tip.num_avail());
tip.clone_mut()
};
generate(&mut state);
println!("Done modifying state");
try!(part.push_state(state, None));
try!(part.write(false, None));
part.push_state(state, None)?;
part.write(false, None)?;
}

if snapshot {
try!(part.write_snapshot(None));
part.write_snapshot(None)?;
}
} else {
let discover = try!(discover::repo_from_path(path));
let discover = discover::repo_from_path(path)?;
let rt = SeqRepo::new(discover);

let mut repo = if create {
// — Create repository —
try!(Repository::create(rt, "sequences db", None))
Repository::create(rt, "sequences db", None)?
} else {
// — Open repository —
let mut repo = try!(Repository::open(rt));
try!(repo.load_latest(None));
let mut repo = Repository::open(rt)?;
repo.load_latest(None)?;
repo
};

if repo.merge_required() {
try!(repo.merge(&merge_solver, true, None));
repo.merge(&merge_solver, true, None)?;
}

if let Some(_num) = list_n {
Expand All @@ -177,16 +177,16 @@ fn run(path: &Path, part_num: Option<u64>,
}

for _ in 0..repetitions {
let mut state = try!(repo.clone_state());
let mut state = repo.clone_state()?;
println!("Found {} partitions with {} elements", state.num_parts(), state.num_avail());
generate(&mut state);
println!("Done modifying state");
try!(repo.merge_in(state, None));
try!(repo.write_all(false));
repo.merge_in(state, None)?;
repo.write_all(false)?;
}

if snapshot {
try!(repo.write_snapshot_all());
repo.write_snapshot_all()?;
}
}

Expand Down
22 changes: 11 additions & 11 deletions app_tests/src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -70,18 +70,18 @@ pub mod util {

/// Test whether two files are the same. Returns true if they are.
pub fn files_are_eq<P1: AsRef<Path>, P2: AsRef<Path>>(p1: P1, p2: P2) -> io::Result<bool> {
let mut f1 = try!(File::open(p1));
let mut f2 = try!(File::open(p2));
let mut f1 = File::open(p1)?;
let mut f2 = File::open(p2)?;

const BUF_SIZE: usize = 4096; // common page size on Linux
let mut buf1 = [0u8; BUF_SIZE];
let mut buf2 = [0u8; BUF_SIZE];

loop {
let len = try!(f1.read(&mut buf1));
let len = f1.read(&mut buf1)?;
if len == 0 {
// EOF of f1; is f2 also at EOF?
let l2 = try!(f2.read(&mut buf2[0..1]));
let l2 = f2.read(&mut buf2[0..1])?;
return Ok(l2 == 0);
}
match f2.read_exact(&mut buf2[0..len]) {
Expand Down Expand Up @@ -116,8 +116,8 @@ pub mod util {
Err(io::Error::new(io::ErrorKind::NotFound, "broken symlink or unknown object"))
}
};
let cat1 = try!(classify(p1.as_ref()));
let cat2 = try!(classify(p2.as_ref()));
let cat1 = classify(p1.as_ref())?;
let cat2 = classify(p2.as_ref())?;
if cat1 != cat2 {
return Ok(false);
}
Expand All @@ -128,14 +128,14 @@ pub mod util {
},
Cat::Dir => {
let mut entries = HashMap::new();
for entry in try!(fs::read_dir(p1)) {
let entry = try!(entry);
for entry in fs::read_dir(p1)? {
let entry = entry?;
let name = entry.file_name();
assert!(!entries.contains_key(&name));
entries.insert(name, (entry.path(), None));
}
for dir_entry in try!(fs::read_dir(p2)) {
let dir_entry = try!(dir_entry);
for dir_entry in fs::read_dir(p2)? {
let dir_entry = dir_entry?;
match entries.entry(dir_entry.file_name()) {
Entry::Occupied(mut e) => {
assert!(e.get().1 == None); // not already set
Expand All @@ -155,7 +155,7 @@ pub mod util {
for ref v in entries.values() {
let pe1 = &v.0;
if let &Some(ref pe2) = &v.1 {
if !try!(paths_are_eq(&pe1, &pe2)) {
if !paths_are_eq(&pe1, &pe2)? {
return Ok(false);
}
} else { assert!(false); }
Expand Down
6 changes: 3 additions & 3 deletions app_tests/src/seq.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -46,7 +46,7 @@ impl From<Vec<R>> for Sequence {
impl ElementT for Sequence {
fn write_buf(&self, writer: &mut Write) -> Result<()> {
for x in &self.v {
try!(writer.write_f64::<LittleEndian>(*x));
writer.write_f64::<LittleEndian>(*x)?;
}
Ok(())
}
Expand All @@ -58,7 +58,7 @@ impl ElementT for Sequence {
let n = buf.len() / size_of::<R>();
let mut v = Vec::with_capacity(n);
for _ in 0..n {
v.push(try!(r.read_f64::<LittleEndian>()));
v.push(r.read_f64::<LittleEndian>()?);
}
Ok(Sequence{ v: v })
}
Expand Down Expand Up @@ -347,7 +347,7 @@ impl<IO: RepoIO> RepoT<SeqClassifier> for SeqRepo<IO> {
fn divide(&mut self, part: &Partition<Sequence>) ->
Result<(Vec<PartId>, Vec<PartId>), RepoDivideError>
{
let tip = try!(part.tip().map_err(|e| RepoDivideError::Other(Box::new(e))));
let tip = part.tip().map_err(|e| RepoDivideError::Other(Box::new(e)))?;
// 1: choose new lengths to use for partitioning
// Algorithm: sample up to 999 lengths, find the median
if tip.num_avail() < 1 { return Err(RepoDivideError::NotSubdivisible); }
Expand Down
16 changes: 8 additions & 8 deletions examples/hello.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,11 +13,11 @@ fn inner() -> Result<()> {
match discover::part_from_path(".", None) {
Ok(io) => {
// Read the found files:
let mut part = try!(Partition::<String>::open(Box::new(io)));
try!(part.load_latest(None, None));
let mut part = Partition::<String>::open(Box::new(io))?;
part.load_latest(None, None)?;

// Get access to the latest state:
let tip = try!(part.tip());
let tip = part.tip()?;
println!("Found {} element(s)", tip.num_avail());

// Read the elements (API may change here):
Expand All @@ -31,15 +31,15 @@ fn inner() -> Result<()> {

// Create a new partition, using PartFileIO:
let io = Box::new(fileio::PartFileIO::new_default("hello"));
let mut part = try!(Partition::create(io, "hello world", None, None));
let mut part = Partition::create(io, "hello world", None, None)?;

// Create a new state derived from the tip:
let mut state = try!(part.tip()).clone_mut();
try!(state.insert("Hello, world!".to_string()));
try!(part.push_state(state, None));
let mut state = part.tip()?.clone_mut();
state.insert("Hello, world!".to_string())?;
part.push_state(state, None)?;

// Write our changes:
try!(part.write_full(None));
part.write_full(None)?;
}
}
Ok(())
Expand Down
60 changes: 30 additions & 30 deletions examples/pippincmd.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -191,18 +191,18 @@ fn inner(path: PathBuf, op: Operation, args: Rest) -> Result<()>
name[0..len].to_string()
});
let part_id = PartId::from_num(match part_num {
Some(n) => try!(n.parse()),
Some(n) => n.parse()?,
None => 1,
});

let prefix = path.join(name);
let io = fileio::PartFileIO::new_empty(part_id, prefix);
try!(Partition::<DataElt>::create(Box::new(io), &repo_name, None, None));
Partition::<DataElt>::create(Box::new(io), &repo_name, None, None)?;
Ok(())
},
Operation::Header => {
println!("Reading header from: {}", path.display());
let head = try!(read_head(&mut try!(fs::File::open(path))));
let head = read_head(&mut fs::File::open(path)?)?;
println!("{} file, version: {}",
match head.ftype { FileType::Snapshot(_) => "Snapshot", FileType::CommitLog(_) => "Commit log" },
head.ftype.ver());
Expand All @@ -226,7 +226,7 @@ fn inner(path: PathBuf, op: Operation, args: Rest) -> Result<()>
assert_eq!(args.commit, None);
println!("Scanning files ...");
// #0017: this should print warnings generated in discover::*
let repo_files = try!(discover::repo_from_path(&path));
let repo_files = discover::repo_from_path(&path)?;
for part in repo_files.partitions() {
println!("Partition {}: {}*", part.part_id(), part.prefix().display());
let ss_len = part.ss_len();
Expand All @@ -249,8 +249,8 @@ fn inner(path: PathBuf, op: Operation, args: Rest) -> Result<()>
}
}
if list_commits {
let mut part = try!(Partition::<DataElt>::open(Box::new(part.clone())));
try!(part.load_all(None, None));
let mut part = Partition::<DataElt>::open(Box::new(part.clone()))?;
part.load_all(None, None)?;
let mut states: Vec<_> = part.states_iter().collect();
states.sort_by_key(|s| s.meta().number());
for state in states {
Expand All @@ -267,17 +267,17 @@ fn inner(path: PathBuf, op: Operation, args: Rest) -> Result<()>
panic!("No support for -p / --partition option");
}
println!("Scanning files ...");
let part_files = try!(discover::part_from_path(&path, None));
let part_files = discover::part_from_path(&path, None)?;

let mut part = try!(Partition::<DataElt>::open(Box::new(part_files)));
let mut part = Partition::<DataElt>::open(Box::new(part_files))?;
{
let (is_tip, mut state) = if let Some(ss) = args.commit {
try!(part.load_all(None, None));
let state = try!(part.state_from_string(ss));
part.load_all(None, None)?;
let state = part.state_from_string(ss)?;
(part.tip_key().map(|k| k == state.statesum()).unwrap_or(false), state.clone_mut())
} else {
try!(part.load_latest(None, None));
(true, try!(part.tip()).clone_mut())
part.load_latest(None, None)?;
(true, part.tip()?.clone_mut())
};
match part_op {
PartitionOp::ListElts => {
Expand All @@ -288,7 +288,7 @@ fn inner(path: PathBuf, op: Operation, args: Rest) -> Result<()>
}
},
PartitionOp::EltGet(elt) => {
let id: u64 = try!(elt.parse());
let id: u64 = elt.parse()?;
match state.get(id.into()) {
Ok(d) => {
println!("Element {}:", id);
Expand All @@ -301,9 +301,9 @@ fn inner(path: PathBuf, op: Operation, args: Rest) -> Result<()>
if !is_tip && !args.force {
panic!("Do you really want to make an edit from a historical state? If so specify '--force'.");
}
let output = try!(Command::new("mktemp")
let output = Command::new("mktemp")
.arg("--tmpdir")
.arg("pippin-element.XXXXXXXX").output());
.arg("pippin-element.XXXXXXXX").output()?;
if !output.status.success() {
return CmdFailed::err("mktemp", output.status.code());
}
Expand All @@ -312,45 +312,45 @@ fn inner(path: PathBuf, op: Operation, args: Rest) -> Result<()>
return PathError::err("temporary file created but not found", tmp_path);
}

let id: u64 = try!(elt.parse());
let id: u64 = elt.parse()?;
{
let elt_data: &DataElt = if let Ok(d) = state.get(id.into()) {
&d
} else {
panic!("element not found");
};
let mut file = try!(fs::OpenOptions::new().write(true).open(&tmp_path));
try!(file.write(elt_data.bytes()));
let mut file = fs::OpenOptions::new().write(true).open(&tmp_path)?;
file.write(elt_data.bytes())?;
}
println!("Written to temporary file: {}", tmp_path.display());

let editor_cmd = try!(env::var(match editor {
let editor_cmd = env::var(match editor {
Editor::Cmd => "EDITOR",
Editor::Visual => "VISUAL",
}));
let status = try!(Command::new(&editor_cmd).arg(&tmp_path).status());
})?;
let status = Command::new(&editor_cmd).arg(&tmp_path).status()?;
if !status.success() {
return CmdFailed::err(editor_cmd, status.code());
}
let mut file = try!(fs::File::open(&tmp_path));
let mut file = fs::File::open(&tmp_path)?;
let mut buf = Vec::new();
try!(file.read_to_end(&mut buf));
try!(state.replace(id.into(), DataElt::from(buf)));
try!(fs::remove_file(tmp_path));
file.read_to_end(&mut buf)?;
state.replace(id.into(), DataElt::from(buf))?;
fs::remove_file(tmp_path)?;
},
PartitionOp::EltDelete(elt) => {
if !is_tip && !args.force {
panic!("Do you really want to make an edit from a historical state? If so specify '--force'.");
}
let id: u64 = try!(elt.parse());
try!(state.remove(id.into()));
let id: u64 = elt.parse()?;
state.remove(id.into())?;
},
}
} // destroy reference `state`

let has_changes = try!(part.write_fast(None));
let has_changes = part.write_fast(None)?;
if has_changes && args.snapshot {
try!(part.write_snapshot(None));
part.write_snapshot(None)?;
}
Ok(())
},
Expand Down Expand Up @@ -385,7 +385,7 @@ impl From<Vec<u8>> for DataElt {
}
impl ElementT for DataElt {
fn write_buf(&self, writer: &mut Write) -> Result<()> {
try!(writer.write(self.bytes()));
writer.write(self.bytes())?;
Ok(())
}
fn read_buf(buf: &[u8]) -> Result<Self> {
Expand Down
8 changes: 4 additions & 4 deletions src/commit.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -418,16 +418,16 @@ impl<E: ElementT> Commit<E> {
for (id, ref change) in self.changes.iter() {
match *change {
&EltChange::Deletion => {
try!(mut_state.remove(*id));
mut_state.remove(*id)?;
},
&EltChange::Insertion(ref elt) => {
try!(mut_state.insert_with_id(*id, elt.clone()));
mut_state.insert_with_id(*id, elt.clone())?;
}
&EltChange::Replacement(ref elt) => {
try!(mut_state.replace_rc(*id, elt.clone()));
mut_state.replace_rc(*id, elt.clone())?;
}
&EltChange::MoveOut(new_id) => {
try!(mut_state.remove(*id));
mut_state.remove(*id)?;
mut_state.set_move(*id, new_id);
}
&EltChange::Moved(new_id) => {
Expand Down
Loading

0 comments on commit 98fa749

Please sign in to comment.