file_name
large_stringlengths
4
69
prefix
large_stringlengths
0
26.7k
suffix
large_stringlengths
0
24.8k
middle
large_stringlengths
0
2.12k
fim_type
large_stringclasses
4 values
specialization-no-default.rs
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![feature(specialization)] // Check a number of scenarios in which one impl tries to override another, // without correctly using `default`. //////////////////////////////////////////////////////////////////////////////// // Test 1: one layer of specialization, multiple methods, missing `default` //////////////////////////////////////////////////////////////////////////////// trait Foo { fn foo(&self); fn bar(&self); } impl<T> Foo for T { fn
(&self) {} fn bar(&self) {} } impl Foo for u8 {} impl Foo for u16 { fn foo(&self) {} //~ ERROR E0520 } impl Foo for u32 { fn bar(&self) {} //~ ERROR E0520 } //////////////////////////////////////////////////////////////////////////////// // Test 2: one layer of specialization, missing `default` on associated type //////////////////////////////////////////////////////////////////////////////// trait Bar { type T; } impl<T> Bar for T { type T = u8; } impl Bar for u8 { type T = (); //~ ERROR E0520 } //////////////////////////////////////////////////////////////////////////////// // Test 3a: multiple layers of specialization, missing interior `default` //////////////////////////////////////////////////////////////////////////////// trait Baz { fn baz(&self); } impl<T> Baz for T { default fn baz(&self) {} } impl<T: Clone> Baz for T { fn baz(&self) {} } impl Baz for i32 { fn baz(&self) {} //~ ERROR E0520 } //////////////////////////////////////////////////////////////////////////////// // Test 3b: multiple layers of specialization, missing interior `default`, // redundant `default` in bottom layer. //////////////////////////////////////////////////////////////////////////////// trait Redundant { fn redundant(&self); } impl<T> Redundant for T { default fn redundant(&self) {} } impl<T: Clone> Redundant for T { fn redundant(&self) {} } impl Redundant for i32 { default fn redundant(&self) {} //~ ERROR E0520 } fn main() {}
foo
identifier_name
specialization-no-default.rs
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![feature(specialization)] // Check a number of scenarios in which one impl tries to override another, // without correctly using `default`. //////////////////////////////////////////////////////////////////////////////// // Test 1: one layer of specialization, multiple methods, missing `default` //////////////////////////////////////////////////////////////////////////////// trait Foo { fn foo(&self); fn bar(&self); } impl<T> Foo for T { fn foo(&self) {} fn bar(&self) {} } impl Foo for u8 {} impl Foo for u16 { fn foo(&self) {} //~ ERROR E0520 } impl Foo for u32 { fn bar(&self) {} //~ ERROR E0520 } //////////////////////////////////////////////////////////////////////////////// // Test 2: one layer of specialization, missing `default` on associated type //////////////////////////////////////////////////////////////////////////////// trait Bar { type T; } impl<T> Bar for T { type T = u8; } impl Bar for u8 { type T = (); //~ ERROR E0520 } //////////////////////////////////////////////////////////////////////////////// // Test 3a: multiple layers of specialization, missing interior `default` //////////////////////////////////////////////////////////////////////////////// trait Baz { fn baz(&self); } impl<T> Baz for T {
} impl<T: Clone> Baz for T { fn baz(&self) {} } impl Baz for i32 { fn baz(&self) {} //~ ERROR E0520 } //////////////////////////////////////////////////////////////////////////////// // Test 3b: multiple layers of specialization, missing interior `default`, // redundant `default` in bottom layer. //////////////////////////////////////////////////////////////////////////////// trait Redundant { fn redundant(&self); } impl<T> Redundant for T { default fn redundant(&self) {} } impl<T: Clone> Redundant for T { fn redundant(&self) {} } impl Redundant for i32 { default fn redundant(&self) {} //~ ERROR E0520 } fn main() {}
default fn baz(&self) {}
random_line_split
specialization-no-default.rs
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![feature(specialization)] // Check a number of scenarios in which one impl tries to override another, // without correctly using `default`. //////////////////////////////////////////////////////////////////////////////// // Test 1: one layer of specialization, multiple methods, missing `default` //////////////////////////////////////////////////////////////////////////////// trait Foo { fn foo(&self); fn bar(&self); } impl<T> Foo for T { fn foo(&self) {} fn bar(&self)
} impl Foo for u8 {} impl Foo for u16 { fn foo(&self) {} //~ ERROR E0520 } impl Foo for u32 { fn bar(&self) {} //~ ERROR E0520 } //////////////////////////////////////////////////////////////////////////////// // Test 2: one layer of specialization, missing `default` on associated type //////////////////////////////////////////////////////////////////////////////// trait Bar { type T; } impl<T> Bar for T { type T = u8; } impl Bar for u8 { type T = (); //~ ERROR E0520 } //////////////////////////////////////////////////////////////////////////////// // Test 3a: multiple layers of specialization, missing interior `default` //////////////////////////////////////////////////////////////////////////////// trait Baz { fn baz(&self); } impl<T> Baz for T { default fn baz(&self) {} } impl<T: Clone> Baz for T { fn baz(&self) {} } impl Baz for i32 { fn baz(&self) {} //~ ERROR E0520 } //////////////////////////////////////////////////////////////////////////////// // Test 3b: multiple layers of specialization, missing interior `default`, // redundant `default` in bottom layer. //////////////////////////////////////////////////////////////////////////////// trait Redundant { fn redundant(&self); } impl<T> Redundant for T { default fn redundant(&self) {} } impl<T: Clone> Redundant for T { fn redundant(&self) {} } impl Redundant for i32 { default fn redundant(&self) {} //~ ERROR E0520 } fn main() {}
{}
identifier_body
main.rs
// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. extern crate zip; use std::fs; fn
() { println!("Hello, world!"); let args: Vec<_> = std::env::args().collect(); if args.len() < 2 { println!("Usage: {} ", args[0]); return; } let fname = std::path::Path::new(&*args[1]); let file = fs::File::open(&fname).unwrap(); let mut archive = zip::ZipArchive::new(file).unwrap(); for i in 0..archive.len() { let mut file = archive.by_index(i); print_file(file); } } fn print_file<'a>( in_file: zip::result::ZipResult<zip::read::ZipFile>, ) -> zip::result::ZipResult<()> { let file = in_file?; println!("read file: {:?}", file.sanitized_name()); return Ok(()); }
main
identifier_name
main.rs
// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. extern crate zip; use std::fs; fn main() {
return; } let fname = std::path::Path::new(&*args[1]); let file = fs::File::open(&fname).unwrap(); let mut archive = zip::ZipArchive::new(file).unwrap(); for i in 0..archive.len() { let mut file = archive.by_index(i); print_file(file); } } fn print_file<'a>( in_file: zip::result::ZipResult<zip::read::ZipFile>, ) -> zip::result::ZipResult<()> { let file = in_file?; println!("read file: {:?}", file.sanitized_name()); return Ok(()); }
println!("Hello, world!"); let args: Vec<_> = std::env::args().collect(); if args.len() < 2 { println!("Usage: {} <filename>", args[0]);
random_line_split
main.rs
// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. extern crate zip; use std::fs; fn main() { println!("Hello, world!"); let args: Vec<_> = std::env::args().collect(); if args.len() < 2
let fname = std::path::Path::new(&*args[1]); let file = fs::File::open(&fname).unwrap(); let mut archive = zip::ZipArchive::new(file).unwrap(); for i in 0..archive.len() { let mut file = archive.by_index(i); print_file(file); } } fn print_file<'a>( in_file: zip::result::ZipResult<zip::read::ZipFile>, ) -> zip::result::ZipResult<()> { let file = in_file?; println!("read file: {:?}", file.sanitized_name()); return Ok(()); }
{ println!("Usage: {} <filename>", args[0]); return; }
conditional_block
main.rs
// Copyright 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. extern crate zip; use std::fs; fn main()
fn print_file<'a>( in_file: zip::result::ZipResult<zip::read::ZipFile>, ) -> zip::result::ZipResult<()> { let file = in_file?; println!("read file: {:?}", file.sanitized_name()); return Ok(()); }
{ println!("Hello, world!"); let args: Vec<_> = std::env::args().collect(); if args.len() < 2 { println!("Usage: {} <filename>", args[0]); return; } let fname = std::path::Path::new(&*args[1]); let file = fs::File::open(&fname).unwrap(); let mut archive = zip::ZipArchive::new(file).unwrap(); for i in 0..archive.len() { let mut file = archive.by_index(i); print_file(file); } }
identifier_body
task-comm-16.rs
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. use std::cmp; // Tests of ports and channels on various types fn test_rec() { struct R {val0: int, val1: u8, val2: char} let (tx, rx) = channel(); let r0: R = R {val0: 0, val1: 1u8, val2: '2'}; tx.send(r0); let mut r1: R; r1 = rx.recv(); assert_eq!(r1.val0, 0); assert_eq!(r1.val1, 1u8); assert_eq!(r1.val2, '2'); } fn test_vec()
fn test_str() { let (tx, rx) = channel(); let s0 = ~"test"; tx.send(s0); let s1 = rx.recv(); assert_eq!(s1[0], 't' as u8); assert_eq!(s1[1], 'e' as u8); assert_eq!(s1[2],'s' as u8); assert_eq!(s1[3], 't' as u8); } #[deriving(Show)] enum t { tag1, tag2(int), tag3(int, u8, char) } impl cmp::Eq for t { fn eq(&self, other: &t) -> bool { match *self { tag1 => { match (*other) { tag1 => true, _ => false } } tag2(e0a) => { match (*other) { tag2(e0b) => e0a == e0b, _ => false } } tag3(e0a, e1a, e2a) => { match (*other) { tag3(e0b, e1b, e2b) => e0a == e0b && e1a == e1b && e2a == e2b, _ => false } } } } fn ne(&self, other: &t) -> bool {!(*self).eq(other) } } fn test_tag() { let (tx, rx) = channel(); tx.send(tag1); tx.send(tag2(10)); tx.send(tag3(10, 11u8, 'A')); let mut t1: t; t1 = rx.recv(); assert_eq!(t1, tag1); t1 = rx.recv(); assert_eq!(t1, tag2(10)); t1 = rx.recv(); assert_eq!(t1, tag3(10, 11u8, 'A')); } fn test_chan() { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); tx1.send(tx2); let tx2 = rx1.recv(); // Does the transmitted channel still work? tx2.send(10); let mut i: int; i = rx2.recv(); assert_eq!(i, 10); } pub fn main() { test_rec(); test_vec(); test_str(); test_tag(); test_chan(); }
{ let (tx, rx) = channel(); let v0: Vec<int> = vec!(0, 1, 2); tx.send(v0); let v1 = rx.recv(); assert_eq!(*v1.get(0), 0); assert_eq!(*v1.get(1), 1); assert_eq!(*v1.get(2), 2); }
identifier_body
task-comm-16.rs
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. use std::cmp; // Tests of ports and channels on various types fn test_rec() { struct
{val0: int, val1: u8, val2: char} let (tx, rx) = channel(); let r0: R = R {val0: 0, val1: 1u8, val2: '2'}; tx.send(r0); let mut r1: R; r1 = rx.recv(); assert_eq!(r1.val0, 0); assert_eq!(r1.val1, 1u8); assert_eq!(r1.val2, '2'); } fn test_vec() { let (tx, rx) = channel(); let v0: Vec<int> = vec!(0, 1, 2); tx.send(v0); let v1 = rx.recv(); assert_eq!(*v1.get(0), 0); assert_eq!(*v1.get(1), 1); assert_eq!(*v1.get(2), 2); } fn test_str() { let (tx, rx) = channel(); let s0 = ~"test"; tx.send(s0); let s1 = rx.recv(); assert_eq!(s1[0], 't' as u8); assert_eq!(s1[1], 'e' as u8); assert_eq!(s1[2],'s' as u8); assert_eq!(s1[3], 't' as u8); } #[deriving(Show)] enum t { tag1, tag2(int), tag3(int, u8, char) } impl cmp::Eq for t { fn eq(&self, other: &t) -> bool { match *self { tag1 => { match (*other) { tag1 => true, _ => false } } tag2(e0a) => { match (*other) { tag2(e0b) => e0a == e0b, _ => false } } tag3(e0a, e1a, e2a) => { match (*other) { tag3(e0b, e1b, e2b) => e0a == e0b && e1a == e1b && e2a == e2b, _ => false } } } } fn ne(&self, other: &t) -> bool {!(*self).eq(other) } } fn test_tag() { let (tx, rx) = channel(); tx.send(tag1); tx.send(tag2(10)); tx.send(tag3(10, 11u8, 'A')); let mut t1: t; t1 = rx.recv(); assert_eq!(t1, tag1); t1 = rx.recv(); assert_eq!(t1, tag2(10)); t1 = rx.recv(); assert_eq!(t1, tag3(10, 11u8, 'A')); } fn test_chan() { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); tx1.send(tx2); let tx2 = rx1.recv(); // Does the transmitted channel still work? tx2.send(10); let mut i: int; i = rx2.recv(); assert_eq!(i, 10); } pub fn main() { test_rec(); test_vec(); test_str(); test_tag(); test_chan(); }
R
identifier_name
task-comm-16.rs
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. use std::cmp; // Tests of ports and channels on various types fn test_rec() { struct R {val0: int, val1: u8, val2: char} let (tx, rx) = channel(); let r0: R = R {val0: 0, val1: 1u8, val2: '2'}; tx.send(r0); let mut r1: R; r1 = rx.recv(); assert_eq!(r1.val0, 0); assert_eq!(r1.val1, 1u8); assert_eq!(r1.val2, '2'); } fn test_vec() { let (tx, rx) = channel(); let v0: Vec<int> = vec!(0, 1, 2); tx.send(v0); let v1 = rx.recv(); assert_eq!(*v1.get(0), 0); assert_eq!(*v1.get(1), 1); assert_eq!(*v1.get(2), 2); } fn test_str() { let (tx, rx) = channel(); let s0 = ~"test"; tx.send(s0); let s1 = rx.recv(); assert_eq!(s1[0], 't' as u8); assert_eq!(s1[1], 'e' as u8); assert_eq!(s1[2],'s' as u8); assert_eq!(s1[3], 't' as u8); } #[deriving(Show)] enum t { tag1,
fn eq(&self, other: &t) -> bool { match *self { tag1 => { match (*other) { tag1 => true, _ => false } } tag2(e0a) => { match (*other) { tag2(e0b) => e0a == e0b, _ => false } } tag3(e0a, e1a, e2a) => { match (*other) { tag3(e0b, e1b, e2b) => e0a == e0b && e1a == e1b && e2a == e2b, _ => false } } } } fn ne(&self, other: &t) -> bool {!(*self).eq(other) } } fn test_tag() { let (tx, rx) = channel(); tx.send(tag1); tx.send(tag2(10)); tx.send(tag3(10, 11u8, 'A')); let mut t1: t; t1 = rx.recv(); assert_eq!(t1, tag1); t1 = rx.recv(); assert_eq!(t1, tag2(10)); t1 = rx.recv(); assert_eq!(t1, tag3(10, 11u8, 'A')); } fn test_chan() { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); tx1.send(tx2); let tx2 = rx1.recv(); // Does the transmitted channel still work? tx2.send(10); let mut i: int; i = rx2.recv(); assert_eq!(i, 10); } pub fn main() { test_rec(); test_vec(); test_str(); test_tag(); test_chan(); }
tag2(int), tag3(int, u8, char) } impl cmp::Eq for t {
random_line_split
lib.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ //! Calculate [specified][specified] and [computed values][computed] from a //! tree of DOM nodes and a set of stylesheets. //! //! [computed]: https://drafts.csswg.org/css-cascade/#computed //! [specified]: https://drafts.csswg.org/css-cascade/#specified //! //! In particular, this crate contains the definitions of supported properties, //! the code to parse them into specified values and calculate the computed //! values based on the specified values, as well as the code to serialize both //! specified and computed values. //! //! The main entry point is [`recalc_style_at`][recalc_style_at]. //! //! [recalc_style_at]: traversal/fn.recalc_style_at.html //! //! Major dependencies are the [cssparser][cssparser] and [selectors][selectors] //! crates. //! //! [cssparser]:../cssparser/index.html //! [selectors]:../selectors/index.html // FIXME: replace discriminant_value with per-enum methods that use `match`? #![feature(core_intrinsics)] #![cfg_attr(feature = "servo", feature(custom_attribute))] #![cfg_attr(feature = "servo", feature(custom_derive))] #![cfg_attr(feature = "servo", feature(plugin))] #![cfg_attr(feature = "servo", plugin(heapsize_plugin))] #![cfg_attr(feature = "servo", plugin(serde_macros))] #![deny(unsafe_code)] #![recursion_limit = "500"] // For match_ignore_ascii_case in PropertyDeclaration::parse extern crate app_units; #[allow(unused_extern_crates)] #[macro_use] extern crate bitflags; extern crate core; #[macro_use] extern crate cssparser; extern crate encoding; extern crate euclid; extern crate fnv; #[cfg(feature = "gecko")] extern crate gecko_bindings; #[cfg(feature = "servo")] extern crate heapsize; #[allow(unused_extern_crates)] #[macro_use] extern crate lazy_static; #[macro_use] extern crate log; #[allow(unused_extern_crates)] #[macro_use] extern crate matches; extern crate num_traits; extern crate rustc_serialize; extern crate selectors; #[cfg(feature = "servo")] extern crate serde; extern crate smallvec; #[macro_use(atom, ns)] extern crate string_cache; #[macro_use] extern crate style_traits; extern crate time; extern crate url; extern crate util; pub mod animation; pub mod attr; pub mod bezier; pub mod context; pub mod custom_properties; pub mod data; pub mod dom; pub mod element_state; pub mod error_reporting; pub mod font_face; pub mod logical_geometry; pub mod matching; pub mod media_queries; pub mod parallel; pub mod parser; pub mod refcell; pub mod restyle_hints; pub mod selector_impl; pub mod selector_matching; pub mod sequential; pub mod servo; pub mod stylesheets; pub mod traversal; #[macro_use] #[allow(non_camel_case_types)] pub mod values; pub mod viewport; /// The CSS properties supported by the style system. // Generated from the properties.mako.rs template by build.rs #[macro_use]
} macro_rules! reexport_computed_values { ( $( $name: ident )+ ) => { /// Types for [computed values][computed]. /// /// [computed]: https://drafts.csswg.org/css-cascade/#computed pub mod computed_values { $( pub use properties::longhands::$name::computed_value as $name; )+ // Don't use a side-specific name needlessly: pub use properties::longhands::border_top_style::computed_value as border_style; } } } longhand_properties_idents!(reexport_computed_values);
#[allow(unsafe_code)] pub mod properties { include!(concat!(env!("OUT_DIR"), "/properties.rs"));
random_line_split
resto_druid_mastery.rs
extern crate wow_combat_log; extern crate chrono; extern crate clap; use std::fs::File; use std::io::BufReader; use std::collections::{HashMap, HashSet}; use std::fmt; use chrono::Duration; use clap::{Arg, App}; use wow_combat_log::Entry; static MASTERY_AURAS: &'static [u32] = &[ 33763, // Lifebloom 774, // Rejuv 155777, // Rejuv (Germ) 8936, // Regrowth, 48438, // WG 207386, // Spring Blossoms 200389, // Cultivation 102352, // Cenarion Ward 22842, // Frenzied Regen (no really, it counts) ]; static MASTERY_NAMES: &'static [(u32, &'static str)] = &[ (33763, "LB"), (774, "Rejuv"), (155777, "Germ"), (8936, "Regrowth"), (48438, "WG"), (207386, "SB"), (200389, "Cult"), (102352, "CW"), (22842, "Frenzied"), ]; // not renewal(108238), not ysera's gift(145109/10), not trinkets // // Living seed is not itself affected by mastery, but the heal its // strength is based on _is_. The ideal computation would be to use // the mastery stacks (and rating) from when the heal was created, but // to use the overheal/etc values that we only know when it goes off. static OTHER_HEALS: &'static [u32] = &[ 157982, // Tranq 18562, // Swiftmend 33778, // Lifebloom bloom 5185, // HT 81269, // Efflo 189800, // Nature's Essence (WG insta heal) 189853, // Dreamwalker 48503, // Living seed ]; static REJUV_AURAS: &'static [u32] = &[ 774, // Rejuv 155777, // Rejuv (Germ) ]; static LIVING_SEED_HEALS: &'static [u32] = &[5185, 8936, 18562]; const AURA_2PC: u32 = 232378; const SPELL_REGROWTH: u32 = 8936; const SPELL_TRANQ: u32 = 157982; const MASTERY_2PC: u32 = 4000; pub fn find_init_mastery<'a, I: Iterator<Item=Entry<'a>>>(iter: I, player: &str) -> Option<(&'a str, u32)> { let mut map = HashMap::new(); let mut player_id = None; for log in iter { if player_id.is_none() { if let Some(base) = log.base() { let id; if base.src.name == player { id = base.src.id; } else if base.dst.name == player { id = base.dst.id; } else { continue; } if let Some(v) = map.get(id) { return Some((id, *v)); } player_id = Some(id); } } match log { wow_combat_log::Entry::Info { id, mastery,.. } => { if let Some(pid) = player_id { if pid == id { return Some((pid, mastery)); } else { continue } } map.entry(id).or_insert(mastery); }, _ => (), } } //None Some((player_id.unwrap(), 8773)) } #[derive(Default, Debug, Clone)] pub struct RestoComputation<'a> { map: HashMap<&'a str, (HashSet<u32>, Duration)>, total_healing: u64, total_unmastery_healing: u64, total_uncrit_healing: u64, mastery_healing: u64, living_seed_healing: u64, regrowth_healing: u64, tranq_healing: u64, rejuv_healing: u64, healing_2pc: u64, healing_2pc_added: u64, under_2pc: bool, player_id: &'a str, cur_mastery: u32, total_healing_per: [u64; 14], total_healing_per_unmast: [u64; 14], hot_mastery_healing_added: HashMap<u32, u64>, } impl<'a> RestoComputation<'a> { pub fn new(player_id: &'a str, starting_mastery: u32) -> Self { RestoComputation { player_id: player_id, cur_mastery: starting_mastery, ..Default::default() } } pub fn reset_stats(&mut self) { let prev = std::mem::replace(self, Default::default()); *self = RestoComputation { player_id: prev.player_id, cur_mastery: prev.cur_mastery, map: prev.map, under_2pc: prev.under_2pc, ..Default::default() } } pub fn parse_entry(&mut self, log: &wow_combat_log::Entry<'a>, filter_start_time: Duration) { use wow_combat_log::Entry::*; use wow_combat_log::AuraType::*; if let Info { id, mastery, ref auras,.. } = *log { let entry = self.map.entry(id).or_insert((HashSet::new(), log.timestamp())); let player_id = self.player_id; if player_id == id { self.cur_mastery = mastery; if auras.contains(&(self.player_id, AURA_2PC)) { self.cur_mastery -= MASTERY_2PC; self.under_2pc = true; } } entry.0 = auras.iter() .filter(|&&(src, aura)| src == player_id && MASTERY_AURAS.contains(&aura)) .map(|&(_, aura)| aura).collect(); entry.1 = log.timestamp(); } if log.base().is_none() { return; } let base = log.base().unwrap(); if base.src.id!= self.player_id { return; } let entry = self.map.entry(log.base().unwrap().dst.id).or_insert((HashSet::new(), log.timestamp())); let diff = log.timestamp() - entry.1; // If we haven't seen anything from them for 10 seconds, // assume they left the zone and may have lost all their buffs if diff > Duration::seconds(10) { entry.0.clear(); } else { entry.1 = log.timestamp(); } match *log { Aura { ty, id,.. } if MASTERY_AURAS.contains(&id) => { match ty { Apply | Refresh => { entry.0.insert(id); }, Remove => { entry.0.remove(&id); }, _ => (), } entry.1 = log.timestamp(); }, Aura { ty, id: AURA_2PC,.. } => { self.under_2pc = ty!= Remove; }, Heal { id, heal: total_heal, overheal, crit, ty,.. } => { if log.timestamp() < filter_start_time { return; } let heal = total_heal - overheal; let stacks = entry.0.len(); let mastery = self.cur_mastery + if self.under_2pc { MASTERY_2PC } else { 0 }; let mastery = (mastery as f64 /666.6+4.8)/100.; let unmast = ((heal as f64) / (1. + stacks as f64 * mastery)) as u64; let uncrit_heal = if crit { total_heal / 2 } else { total_heal }; // TODO /2 ignores drape and tauren let uncrit_heal = std::cmp::min(uncrit_heal, heal); self.total_healing += heal; if REJUV_AURAS.contains(&id) { self.rejuv_healing += heal; } if MASTERY_AURAS.contains(&id) || OTHER_HEALS.contains(&id) { self.total_healing_per[stacks] += heal; self.total_healing_per_unmast[stacks] += unmast; self.mastery_healing += (stacks as u64) * unmast; self.total_unmastery_healing += unmast;
// Only measure the contribution to other heals if aura!= id { let added = (unmast as f64 * mastery) as u64; *self.hot_mastery_healing_added.entry(aura).or_insert(0) += added; } } if self.under_2pc { let added = (stacks as f64 * unmast as f64 * MASTERY_2PC as f64 /666.6 / 100.) as u64; self.healing_2pc += heal; self.healing_2pc_added += added; } } self.total_uncrit_healing += uncrit_heal; if ty == wow_combat_log::HealType::Heal { if LIVING_SEED_HEALS.contains(&id) { self.living_seed_healing += uncrit_heal; } if id == SPELL_REGROWTH { self.regrowth_healing += uncrit_heal; } } if id == SPELL_TRANQ { self.tranq_healing += heal; } }, _ => () } } } impl<'a> fmt::Display for RestoComputation<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "scale_mastery_frac: {:.6}; scale_living_seed: {:.6}; scale_regrowth: {:.6}; scale_tranq: {:.6}; scale_rejuv: {:.6};\n scale_2pc: {:.6}; scale_2pc_added: {:.6};\n", self.mastery_healing as f64 / self.total_unmastery_healing as f64, self.living_seed_healing as f64 / self.total_uncrit_healing as f64, self.regrowth_healing as f64 / self.total_uncrit_healing as f64, self.tranq_healing as f64 / self.total_healing as f64, self.rejuv_healing as f64 / self.total_healing as f64, self.healing_2pc as f64/self.total_healing as f64, self.healing_2pc_added as f64/self.total_healing as f64, )?; writeln!(f, "Mastery stack healing on other heals: ")?; for &(aura, name) in MASTERY_NAMES { let added = self.hot_mastery_healing_added.get(&aura).map(|x| *x).unwrap_or(0); if added!= 0 { write!(f, "{}: {:.6}, ", name, added as f64 / self.total_healing as f64)?; } } Ok(()) } } impl<'a, 'b, 'c> std::ops::SubAssign<&'b RestoComputation<'c>> for RestoComputation<'a> { fn sub_assign(&mut self, rhs: &'b RestoComputation<'c>) { self.total_healing -= rhs.total_healing; self.total_unmastery_healing -= rhs.total_unmastery_healing; self.total_uncrit_healing -= rhs.total_uncrit_healing; self.mastery_healing -= rhs.mastery_healing; self.living_seed_healing -= rhs.living_seed_healing; self.regrowth_healing -= rhs.regrowth_healing; self.tranq_healing -= rhs.tranq_healing; self.rejuv_healing -= rhs.rejuv_healing; self.healing_2pc -= rhs.healing_2pc; self.healing_2pc_added -= rhs.healing_2pc_added; for (i, &j) in self.total_healing_per.iter_mut().zip(rhs.total_healing_per.iter()) { *i -= j; } for (i, &j) in self.total_healing_per_unmast.iter_mut().zip(rhs.total_healing_per_unmast.iter()) { *i -= j; } for (aura, &heal) in rhs.hot_mastery_healing_added.iter() { *self.hot_mastery_healing_added.get_mut(aura).unwrap() -= heal; } } } fn run<'a, I: Iterator<Item=Entry<'a>>, F: Fn(Option<&str>) -> I>(player: &str, start: Duration, end: Duration, get_iter: F) { let (pid, cur_mastery) = find_init_mastery(get_iter(None), player).unwrap(); let iter = get_iter(Some(player)); let iter = iter.take_while(|x| x.timestamp() < end); let mut encounter_start = None; let mut total = RestoComputation::new(pid, cur_mastery); let mut encounter = total.clone(); let mut kills = total.clone(); let mut bosses = total.clone(); for log in iter { use wow_combat_log::Entry::*; match log { EncounterStart {..} => { encounter_start = Some(log.timestamp()); bosses -= &encounter; kills -= &encounter; encounter.reset_stats(); }, EncounterEnd {name, kill, difficulty,..} => { if let Some(s) = encounter_start { println!("duration: {}, start: {}, {} ({}), kill: {}", (log.timestamp() - s).num_seconds(), s.num_seconds(), name, difficulty, kill); println!("{}", encounter); println!(""); encounter_start = None; } if!kill { kills -= &encounter; } encounter.reset_stats(); }, _ => () } encounter.parse_entry(&log, start); total.parse_entry(&log, start); kills.parse_entry(&log, start); bosses.parse_entry(&log, start); } bosses -= &encounter; kills -= &encounter; println!("-------"); println!(""); println!("Log total:"); println!("{}", total); println!(""); println!("Boss total:"); println!("{}", bosses); println!(""); println!("Kill total:"); println!("{}", kills); } #[cfg(feature = "wcl")] pub fn wcl_iter<'a>(intern: &'a wow_combat_log::Interner, log: &str, api_key: &str, skip: bool, name: Option<&str>) -> wow_combat_log::wcl::Iter<'a> { wow_combat_log::wcl::iter(intern, log, api_key, skip, name) } #[cfg(not(feature = "wcl"))] pub fn wcl_iter<'a>(_: &'a wow_combat_log::Interner, _: &str, _: &str, _: bool, _: Option<&str>) -> wow_combat_log::Iter<'a, BufReader<File>> { unreachable!() } fn main() { let app = App::new("resto druid mastery"); let app = if cfg!(feature = "wcl") { app.arg(Arg::with_name("API key").long("wcl").takes_value(true).help("warcraftlogs API key")) } else { app }; let matches = app .arg(Arg::with_name("File/WCL ID").required(true).help("Log file or WCL log ID")) .arg(Arg::with_name("Player").required(true).help("Player name (as reported in log)")) .arg(Arg::with_name("Start").help("Start time in seconds from start of log")) .arg(Arg::with_name("End").help("End time in seconds from start of log")) .get_matches(); let player = matches.value_of("Player").unwrap(); let intern = wow_combat_log::Interner::default(); let start = matches.value_of("Start").map(|x| Duration::seconds(x.parse().unwrap())).unwrap_or(Duration::zero()); let end = matches.value_of("End").map(|x| Duration::seconds(x.parse().unwrap())).unwrap_or(Duration::max_value()); let input = matches.value_of("File/WCL ID").unwrap(); if let Some(api) = matches.value_of("API key") { run(player, start, end, |player| wcl_iter(&intern, input, api, player.is_none(), player) ); } else { run(player, start, end, |_| wow_combat_log::iter(&intern, BufReader::new(File::open(input).unwrap())) ); } }
for &aura in &entry.0 {
random_line_split
resto_druid_mastery.rs
extern crate wow_combat_log; extern crate chrono; extern crate clap; use std::fs::File; use std::io::BufReader; use std::collections::{HashMap, HashSet}; use std::fmt; use chrono::Duration; use clap::{Arg, App}; use wow_combat_log::Entry; static MASTERY_AURAS: &'static [u32] = &[ 33763, // Lifebloom 774, // Rejuv 155777, // Rejuv (Germ) 8936, // Regrowth, 48438, // WG 207386, // Spring Blossoms 200389, // Cultivation 102352, // Cenarion Ward 22842, // Frenzied Regen (no really, it counts) ]; static MASTERY_NAMES: &'static [(u32, &'static str)] = &[ (33763, "LB"), (774, "Rejuv"), (155777, "Germ"), (8936, "Regrowth"), (48438, "WG"), (207386, "SB"), (200389, "Cult"), (102352, "CW"), (22842, "Frenzied"), ]; // not renewal(108238), not ysera's gift(145109/10), not trinkets // // Living seed is not itself affected by mastery, but the heal its // strength is based on _is_. The ideal computation would be to use // the mastery stacks (and rating) from when the heal was created, but // to use the overheal/etc values that we only know when it goes off. static OTHER_HEALS: &'static [u32] = &[ 157982, // Tranq 18562, // Swiftmend 33778, // Lifebloom bloom 5185, // HT 81269, // Efflo 189800, // Nature's Essence (WG insta heal) 189853, // Dreamwalker 48503, // Living seed ]; static REJUV_AURAS: &'static [u32] = &[ 774, // Rejuv 155777, // Rejuv (Germ) ]; static LIVING_SEED_HEALS: &'static [u32] = &[5185, 8936, 18562]; const AURA_2PC: u32 = 232378; const SPELL_REGROWTH: u32 = 8936; const SPELL_TRANQ: u32 = 157982; const MASTERY_2PC: u32 = 4000; pub fn find_init_mastery<'a, I: Iterator<Item=Entry<'a>>>(iter: I, player: &str) -> Option<(&'a str, u32)> { let mut map = HashMap::new(); let mut player_id = None; for log in iter { if player_id.is_none() { if let Some(base) = log.base() { let id; if base.src.name == player { id = base.src.id; } else if base.dst.name == player { id = base.dst.id; } else { continue; } if let Some(v) = map.get(id) { return Some((id, *v)); } player_id = Some(id); } } match log { wow_combat_log::Entry::Info { id, mastery,.. } => { if let Some(pid) = player_id { if pid == id { return Some((pid, mastery)); } else { continue } } map.entry(id).or_insert(mastery); }, _ => (), } } //None Some((player_id.unwrap(), 8773)) } #[derive(Default, Debug, Clone)] pub struct RestoComputation<'a> { map: HashMap<&'a str, (HashSet<u32>, Duration)>, total_healing: u64, total_unmastery_healing: u64, total_uncrit_healing: u64, mastery_healing: u64, living_seed_healing: u64, regrowth_healing: u64, tranq_healing: u64, rejuv_healing: u64, healing_2pc: u64, healing_2pc_added: u64, under_2pc: bool, player_id: &'a str, cur_mastery: u32, total_healing_per: [u64; 14], total_healing_per_unmast: [u64; 14], hot_mastery_healing_added: HashMap<u32, u64>, } impl<'a> RestoComputation<'a> { pub fn new(player_id: &'a str, starting_mastery: u32) -> Self { RestoComputation { player_id: player_id, cur_mastery: starting_mastery, ..Default::default() } } pub fn reset_stats(&mut self) { let prev = std::mem::replace(self, Default::default()); *self = RestoComputation { player_id: prev.player_id, cur_mastery: prev.cur_mastery, map: prev.map, under_2pc: prev.under_2pc, ..Default::default() } } pub fn parse_entry(&mut self, log: &wow_combat_log::Entry<'a>, filter_start_time: Duration)
if log.base().is_none() { return; } let base = log.base().unwrap(); if base.src.id!= self.player_id { return; } let entry = self.map.entry(log.base().unwrap().dst.id).or_insert((HashSet::new(), log.timestamp())); let diff = log.timestamp() - entry.1; // If we haven't seen anything from them for 10 seconds, // assume they left the zone and may have lost all their buffs if diff > Duration::seconds(10) { entry.0.clear(); } else { entry.1 = log.timestamp(); } match *log { Aura { ty, id,.. } if MASTERY_AURAS.contains(&id) => { match ty { Apply | Refresh => { entry.0.insert(id); }, Remove => { entry.0.remove(&id); }, _ => (), } entry.1 = log.timestamp(); }, Aura { ty, id: AURA_2PC,.. } => { self.under_2pc = ty!= Remove; }, Heal { id, heal: total_heal, overheal, crit, ty,.. } => { if log.timestamp() < filter_start_time { return; } let heal = total_heal - overheal; let stacks = entry.0.len(); let mastery = self.cur_mastery + if self.under_2pc { MASTERY_2PC } else { 0 }; let mastery = (mastery as f64 /666.6+4.8)/100.; let unmast = ((heal as f64) / (1. + stacks as f64 * mastery)) as u64; let uncrit_heal = if crit { total_heal / 2 } else { total_heal }; // TODO /2 ignores drape and tauren let uncrit_heal = std::cmp::min(uncrit_heal, heal); self.total_healing += heal; if REJUV_AURAS.contains(&id) { self.rejuv_healing += heal; } if MASTERY_AURAS.contains(&id) || OTHER_HEALS.contains(&id) { self.total_healing_per[stacks] += heal; self.total_healing_per_unmast[stacks] += unmast; self.mastery_healing += (stacks as u64) * unmast; self.total_unmastery_healing += unmast; for &aura in &entry.0 { // Only measure the contribution to other heals if aura!= id { let added = (unmast as f64 * mastery) as u64; *self.hot_mastery_healing_added.entry(aura).or_insert(0) += added; } } if self.under_2pc { let added = (stacks as f64 * unmast as f64 * MASTERY_2PC as f64 /666.6 / 100.) as u64; self.healing_2pc += heal; self.healing_2pc_added += added; } } self.total_uncrit_healing += uncrit_heal; if ty == wow_combat_log::HealType::Heal { if LIVING_SEED_HEALS.contains(&id) { self.living_seed_healing += uncrit_heal; } if id == SPELL_REGROWTH { self.regrowth_healing += uncrit_heal; } } if id == SPELL_TRANQ { self.tranq_healing += heal; } }, _ => () } } } impl<'a> fmt::Display for RestoComputation<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "scale_mastery_frac: {:.6}; scale_living_seed: {:.6}; scale_regrowth: {:.6}; scale_tranq: {:.6}; scale_rejuv: {:.6};\n scale_2pc: {:.6}; scale_2pc_added: {:.6};\n", self.mastery_healing as f64 / self.total_unmastery_healing as f64, self.living_seed_healing as f64 / self.total_uncrit_healing as f64, self.regrowth_healing as f64 / self.total_uncrit_healing as f64, self.tranq_healing as f64 / self.total_healing as f64, self.rejuv_healing as f64 / self.total_healing as f64, self.healing_2pc as f64/self.total_healing as f64, self.healing_2pc_added as f64/self.total_healing as f64, )?; writeln!(f, "Mastery stack healing on other heals: ")?; for &(aura, name) in MASTERY_NAMES { let added = self.hot_mastery_healing_added.get(&aura).map(|x| *x).unwrap_or(0); if added!= 0 { write!(f, "{}: {:.6}, ", name, added as f64 / self.total_healing as f64)?; } } Ok(()) } } impl<'a, 'b, 'c> std::ops::SubAssign<&'b RestoComputation<'c>> for RestoComputation<'a> { fn sub_assign(&mut self, rhs: &'b RestoComputation<'c>) { self.total_healing -= rhs.total_healing; self.total_unmastery_healing -= rhs.total_unmastery_healing; self.total_uncrit_healing -= rhs.total_uncrit_healing; self.mastery_healing -= rhs.mastery_healing; self.living_seed_healing -= rhs.living_seed_healing; self.regrowth_healing -= rhs.regrowth_healing; self.tranq_healing -= rhs.tranq_healing; self.rejuv_healing -= rhs.rejuv_healing; self.healing_2pc -= rhs.healing_2pc; self.healing_2pc_added -= rhs.healing_2pc_added; for (i, &j) in self.total_healing_per.iter_mut().zip(rhs.total_healing_per.iter()) { *i -= j; } for (i, &j) in self.total_healing_per_unmast.iter_mut().zip(rhs.total_healing_per_unmast.iter()) { *i -= j; } for (aura, &heal) in rhs.hot_mastery_healing_added.iter() { *self.hot_mastery_healing_added.get_mut(aura).unwrap() -= heal; } } } fn run<'a, I: Iterator<Item=Entry<'a>>, F: Fn(Option<&str>) -> I>(player: &str, start: Duration, end: Duration, get_iter: F) { let (pid, cur_mastery) = find_init_mastery(get_iter(None), player).unwrap(); let iter = get_iter(Some(player)); let iter = iter.take_while(|x| x.timestamp() < end); let mut encounter_start = None; let mut total = RestoComputation::new(pid, cur_mastery); let mut encounter = total.clone(); let mut kills = total.clone(); let mut bosses = total.clone(); for log in iter { use wow_combat_log::Entry::*; match log { EncounterStart {..} => { encounter_start = Some(log.timestamp()); bosses -= &encounter; kills -= &encounter; encounter.reset_stats(); }, EncounterEnd {name, kill, difficulty,..} => { if let Some(s) = encounter_start { println!("duration: {}, start: {}, {} ({}), kill: {}", (log.timestamp() - s).num_seconds(), s.num_seconds(), name, difficulty, kill); println!("{}", encounter); println!(""); encounter_start = None; } if!kill { kills -= &encounter; } encounter.reset_stats(); }, _ => () } encounter.parse_entry(&log, start); total.parse_entry(&log, start); kills.parse_entry(&log, start); bosses.parse_entry(&log, start); } bosses -= &encounter; kills -= &encounter; println!("-------"); println!(""); println!("Log total:"); println!("{}", total); println!(""); println!("Boss total:"); println!("{}", bosses); println!(""); println!("Kill total:"); println!("{}", kills); } #[cfg(feature = "wcl")] pub fn wcl_iter<'a>(intern: &'a wow_combat_log::Interner, log: &str, api_key: &str, skip: bool, name: Option<&str>) -> wow_combat_log::wcl::Iter<'a> { wow_combat_log::wcl::iter(intern, log, api_key, skip, name) } #[cfg(not(feature = "wcl"))] pub fn wcl_iter<'a>(_: &'a wow_combat_log::Interner, _: &str, _: &str, _: bool, _: Option<&str>) -> wow_combat_log::Iter<'a, BufReader<File>> { unreachable!() } fn main() { let app = App::new("resto druid mastery"); let app = if cfg!(feature = "wcl") { app.arg(Arg::with_name("API key").long("wcl").takes_value(true).help("warcraftlogs API key")) } else { app }; let matches = app .arg(Arg::with_name("File/WCL ID").required(true).help("Log file or WCL log ID")) .arg(Arg::with_name("Player").required(true).help("Player name (as reported in log)")) .arg(Arg::with_name("Start").help("Start time in seconds from start of log")) .arg(Arg::with_name("End").help("End time in seconds from start of log")) .get_matches(); let player = matches.value_of("Player").unwrap(); let intern = wow_combat_log::Interner::default(); let start = matches.value_of("Start").map(|x| Duration::seconds(x.parse().unwrap())).unwrap_or(Duration::zero()); let end = matches.value_of("End").map(|x| Duration::seconds(x.parse().unwrap())).unwrap_or(Duration::max_value()); let input = matches.value_of("File/WCL ID").unwrap(); if let Some(api) = matches.value_of("API key") { run(player, start, end, |player| wcl_iter(&intern, input, api, player.is_none(), player) ); } else { run(player, start, end, |_| wow_combat_log::iter(&intern, BufReader::new(File::open(input).unwrap())) ); } }
{ use wow_combat_log::Entry::*; use wow_combat_log::AuraType::*; if let Info { id, mastery, ref auras, .. } = *log { let entry = self.map.entry(id).or_insert((HashSet::new(), log.timestamp())); let player_id = self.player_id; if player_id == id { self.cur_mastery = mastery; if auras.contains(&(self.player_id, AURA_2PC)) { self.cur_mastery -= MASTERY_2PC; self.under_2pc = true; } } entry.0 = auras.iter() .filter(|&&(src, aura)| src == player_id && MASTERY_AURAS.contains(&aura)) .map(|&(_, aura)| aura).collect(); entry.1 = log.timestamp(); }
identifier_body
resto_druid_mastery.rs
extern crate wow_combat_log; extern crate chrono; extern crate clap; use std::fs::File; use std::io::BufReader; use std::collections::{HashMap, HashSet}; use std::fmt; use chrono::Duration; use clap::{Arg, App}; use wow_combat_log::Entry; static MASTERY_AURAS: &'static [u32] = &[ 33763, // Lifebloom 774, // Rejuv 155777, // Rejuv (Germ) 8936, // Regrowth, 48438, // WG 207386, // Spring Blossoms 200389, // Cultivation 102352, // Cenarion Ward 22842, // Frenzied Regen (no really, it counts) ]; static MASTERY_NAMES: &'static [(u32, &'static str)] = &[ (33763, "LB"), (774, "Rejuv"), (155777, "Germ"), (8936, "Regrowth"), (48438, "WG"), (207386, "SB"), (200389, "Cult"), (102352, "CW"), (22842, "Frenzied"), ]; // not renewal(108238), not ysera's gift(145109/10), not trinkets // // Living seed is not itself affected by mastery, but the heal its // strength is based on _is_. The ideal computation would be to use // the mastery stacks (and rating) from when the heal was created, but // to use the overheal/etc values that we only know when it goes off. static OTHER_HEALS: &'static [u32] = &[ 157982, // Tranq 18562, // Swiftmend 33778, // Lifebloom bloom 5185, // HT 81269, // Efflo 189800, // Nature's Essence (WG insta heal) 189853, // Dreamwalker 48503, // Living seed ]; static REJUV_AURAS: &'static [u32] = &[ 774, // Rejuv 155777, // Rejuv (Germ) ]; static LIVING_SEED_HEALS: &'static [u32] = &[5185, 8936, 18562]; const AURA_2PC: u32 = 232378; const SPELL_REGROWTH: u32 = 8936; const SPELL_TRANQ: u32 = 157982; const MASTERY_2PC: u32 = 4000; pub fn
<'a, I: Iterator<Item=Entry<'a>>>(iter: I, player: &str) -> Option<(&'a str, u32)> { let mut map = HashMap::new(); let mut player_id = None; for log in iter { if player_id.is_none() { if let Some(base) = log.base() { let id; if base.src.name == player { id = base.src.id; } else if base.dst.name == player { id = base.dst.id; } else { continue; } if let Some(v) = map.get(id) { return Some((id, *v)); } player_id = Some(id); } } match log { wow_combat_log::Entry::Info { id, mastery,.. } => { if let Some(pid) = player_id { if pid == id { return Some((pid, mastery)); } else { continue } } map.entry(id).or_insert(mastery); }, _ => (), } } //None Some((player_id.unwrap(), 8773)) } #[derive(Default, Debug, Clone)] pub struct RestoComputation<'a> { map: HashMap<&'a str, (HashSet<u32>, Duration)>, total_healing: u64, total_unmastery_healing: u64, total_uncrit_healing: u64, mastery_healing: u64, living_seed_healing: u64, regrowth_healing: u64, tranq_healing: u64, rejuv_healing: u64, healing_2pc: u64, healing_2pc_added: u64, under_2pc: bool, player_id: &'a str, cur_mastery: u32, total_healing_per: [u64; 14], total_healing_per_unmast: [u64; 14], hot_mastery_healing_added: HashMap<u32, u64>, } impl<'a> RestoComputation<'a> { pub fn new(player_id: &'a str, starting_mastery: u32) -> Self { RestoComputation { player_id: player_id, cur_mastery: starting_mastery, ..Default::default() } } pub fn reset_stats(&mut self) { let prev = std::mem::replace(self, Default::default()); *self = RestoComputation { player_id: prev.player_id, cur_mastery: prev.cur_mastery, map: prev.map, under_2pc: prev.under_2pc, ..Default::default() } } pub fn parse_entry(&mut self, log: &wow_combat_log::Entry<'a>, filter_start_time: Duration) { use wow_combat_log::Entry::*; use wow_combat_log::AuraType::*; if let Info { id, mastery, ref auras,.. } = *log { let entry = self.map.entry(id).or_insert((HashSet::new(), log.timestamp())); let player_id = self.player_id; if player_id == id { self.cur_mastery = mastery; if auras.contains(&(self.player_id, AURA_2PC)) { self.cur_mastery -= MASTERY_2PC; self.under_2pc = true; } } entry.0 = auras.iter() .filter(|&&(src, aura)| src == player_id && MASTERY_AURAS.contains(&aura)) .map(|&(_, aura)| aura).collect(); entry.1 = log.timestamp(); } if log.base().is_none() { return; } let base = log.base().unwrap(); if base.src.id!= self.player_id { return; } let entry = self.map.entry(log.base().unwrap().dst.id).or_insert((HashSet::new(), log.timestamp())); let diff = log.timestamp() - entry.1; // If we haven't seen anything from them for 10 seconds, // assume they left the zone and may have lost all their buffs if diff > Duration::seconds(10) { entry.0.clear(); } else { entry.1 = log.timestamp(); } match *log { Aura { ty, id,.. } if MASTERY_AURAS.contains(&id) => { match ty { Apply | Refresh => { entry.0.insert(id); }, Remove => { entry.0.remove(&id); }, _ => (), } entry.1 = log.timestamp(); }, Aura { ty, id: AURA_2PC,.. } => { self.under_2pc = ty!= Remove; }, Heal { id, heal: total_heal, overheal, crit, ty,.. } => { if log.timestamp() < filter_start_time { return; } let heal = total_heal - overheal; let stacks = entry.0.len(); let mastery = self.cur_mastery + if self.under_2pc { MASTERY_2PC } else { 0 }; let mastery = (mastery as f64 /666.6+4.8)/100.; let unmast = ((heal as f64) / (1. + stacks as f64 * mastery)) as u64; let uncrit_heal = if crit { total_heal / 2 } else { total_heal }; // TODO /2 ignores drape and tauren let uncrit_heal = std::cmp::min(uncrit_heal, heal); self.total_healing += heal; if REJUV_AURAS.contains(&id) { self.rejuv_healing += heal; } if MASTERY_AURAS.contains(&id) || OTHER_HEALS.contains(&id) { self.total_healing_per[stacks] += heal; self.total_healing_per_unmast[stacks] += unmast; self.mastery_healing += (stacks as u64) * unmast; self.total_unmastery_healing += unmast; for &aura in &entry.0 { // Only measure the contribution to other heals if aura!= id { let added = (unmast as f64 * mastery) as u64; *self.hot_mastery_healing_added.entry(aura).or_insert(0) += added; } } if self.under_2pc { let added = (stacks as f64 * unmast as f64 * MASTERY_2PC as f64 /666.6 / 100.) as u64; self.healing_2pc += heal; self.healing_2pc_added += added; } } self.total_uncrit_healing += uncrit_heal; if ty == wow_combat_log::HealType::Heal { if LIVING_SEED_HEALS.contains(&id) { self.living_seed_healing += uncrit_heal; } if id == SPELL_REGROWTH { self.regrowth_healing += uncrit_heal; } } if id == SPELL_TRANQ { self.tranq_healing += heal; } }, _ => () } } } impl<'a> fmt::Display for RestoComputation<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "scale_mastery_frac: {:.6}; scale_living_seed: {:.6}; scale_regrowth: {:.6}; scale_tranq: {:.6}; scale_rejuv: {:.6};\n scale_2pc: {:.6}; scale_2pc_added: {:.6};\n", self.mastery_healing as f64 / self.total_unmastery_healing as f64, self.living_seed_healing as f64 / self.total_uncrit_healing as f64, self.regrowth_healing as f64 / self.total_uncrit_healing as f64, self.tranq_healing as f64 / self.total_healing as f64, self.rejuv_healing as f64 / self.total_healing as f64, self.healing_2pc as f64/self.total_healing as f64, self.healing_2pc_added as f64/self.total_healing as f64, )?; writeln!(f, "Mastery stack healing on other heals: ")?; for &(aura, name) in MASTERY_NAMES { let added = self.hot_mastery_healing_added.get(&aura).map(|x| *x).unwrap_or(0); if added!= 0 { write!(f, "{}: {:.6}, ", name, added as f64 / self.total_healing as f64)?; } } Ok(()) } } impl<'a, 'b, 'c> std::ops::SubAssign<&'b RestoComputation<'c>> for RestoComputation<'a> { fn sub_assign(&mut self, rhs: &'b RestoComputation<'c>) { self.total_healing -= rhs.total_healing; self.total_unmastery_healing -= rhs.total_unmastery_healing; self.total_uncrit_healing -= rhs.total_uncrit_healing; self.mastery_healing -= rhs.mastery_healing; self.living_seed_healing -= rhs.living_seed_healing; self.regrowth_healing -= rhs.regrowth_healing; self.tranq_healing -= rhs.tranq_healing; self.rejuv_healing -= rhs.rejuv_healing; self.healing_2pc -= rhs.healing_2pc; self.healing_2pc_added -= rhs.healing_2pc_added; for (i, &j) in self.total_healing_per.iter_mut().zip(rhs.total_healing_per.iter()) { *i -= j; } for (i, &j) in self.total_healing_per_unmast.iter_mut().zip(rhs.total_healing_per_unmast.iter()) { *i -= j; } for (aura, &heal) in rhs.hot_mastery_healing_added.iter() { *self.hot_mastery_healing_added.get_mut(aura).unwrap() -= heal; } } } fn run<'a, I: Iterator<Item=Entry<'a>>, F: Fn(Option<&str>) -> I>(player: &str, start: Duration, end: Duration, get_iter: F) { let (pid, cur_mastery) = find_init_mastery(get_iter(None), player).unwrap(); let iter = get_iter(Some(player)); let iter = iter.take_while(|x| x.timestamp() < end); let mut encounter_start = None; let mut total = RestoComputation::new(pid, cur_mastery); let mut encounter = total.clone(); let mut kills = total.clone(); let mut bosses = total.clone(); for log in iter { use wow_combat_log::Entry::*; match log { EncounterStart {..} => { encounter_start = Some(log.timestamp()); bosses -= &encounter; kills -= &encounter; encounter.reset_stats(); }, EncounterEnd {name, kill, difficulty,..} => { if let Some(s) = encounter_start { println!("duration: {}, start: {}, {} ({}), kill: {}", (log.timestamp() - s).num_seconds(), s.num_seconds(), name, difficulty, kill); println!("{}", encounter); println!(""); encounter_start = None; } if!kill { kills -= &encounter; } encounter.reset_stats(); }, _ => () } encounter.parse_entry(&log, start); total.parse_entry(&log, start); kills.parse_entry(&log, start); bosses.parse_entry(&log, start); } bosses -= &encounter; kills -= &encounter; println!("-------"); println!(""); println!("Log total:"); println!("{}", total); println!(""); println!("Boss total:"); println!("{}", bosses); println!(""); println!("Kill total:"); println!("{}", kills); } #[cfg(feature = "wcl")] pub fn wcl_iter<'a>(intern: &'a wow_combat_log::Interner, log: &str, api_key: &str, skip: bool, name: Option<&str>) -> wow_combat_log::wcl::Iter<'a> { wow_combat_log::wcl::iter(intern, log, api_key, skip, name) } #[cfg(not(feature = "wcl"))] pub fn wcl_iter<'a>(_: &'a wow_combat_log::Interner, _: &str, _: &str, _: bool, _: Option<&str>) -> wow_combat_log::Iter<'a, BufReader<File>> { unreachable!() } fn main() { let app = App::new("resto druid mastery"); let app = if cfg!(feature = "wcl") { app.arg(Arg::with_name("API key").long("wcl").takes_value(true).help("warcraftlogs API key")) } else { app }; let matches = app .arg(Arg::with_name("File/WCL ID").required(true).help("Log file or WCL log ID")) .arg(Arg::with_name("Player").required(true).help("Player name (as reported in log)")) .arg(Arg::with_name("Start").help("Start time in seconds from start of log")) .arg(Arg::with_name("End").help("End time in seconds from start of log")) .get_matches(); let player = matches.value_of("Player").unwrap(); let intern = wow_combat_log::Interner::default(); let start = matches.value_of("Start").map(|x| Duration::seconds(x.parse().unwrap())).unwrap_or(Duration::zero()); let end = matches.value_of("End").map(|x| Duration::seconds(x.parse().unwrap())).unwrap_or(Duration::max_value()); let input = matches.value_of("File/WCL ID").unwrap(); if let Some(api) = matches.value_of("API key") { run(player, start, end, |player| wcl_iter(&intern, input, api, player.is_none(), player) ); } else { run(player, start, end, |_| wow_combat_log::iter(&intern, BufReader::new(File::open(input).unwrap())) ); } }
find_init_mastery
identifier_name
type_names.rs
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // Type Names for Debug Info. use super::namespace::crate_root_namespace; use trans::common::CrateContext; use middle::subst::{self, Substs}; use middle::ty::{self, Ty, ClosureTyper}; use syntax::ast; use syntax::parse::token; // Compute the name of the type as it should be stored in debuginfo. Does not do // any caching, i.e. calling the function twice with the same type will also do // the work twice. The `qualified` parameter only affects the first level of the // type name, further levels (i.e. type parameters) are always fully qualified. pub fn compute_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, qualified: bool) -> String { let mut result = String::with_capacity(64); push_debuginfo_type_name(cx, t, qualified, &mut result); result } // Pushes the name of the type as it should be stored in debuginfo on the // `output` String. See also compute_debuginfo_type_name(). pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, qualified: bool, output: &mut String)
push_type_params(cx, substs, output); }, ty::TyTuple(ref component_types) => { output.push('('); for &component_type in component_types { push_debuginfo_type_name(cx, component_type, true, output); output.push_str(", "); } if!component_types.is_empty() { output.pop(); output.pop(); } output.push(')'); }, ty::TyBox(inner_type) => { output.push_str("Box<"); push_debuginfo_type_name(cx, inner_type, true, output); output.push('>'); }, ty::TyRawPtr(ty::mt { ty: inner_type, mutbl } ) => { output.push('*'); match mutbl { ast::MutImmutable => output.push_str("const "), ast::MutMutable => output.push_str("mut "), } push_debuginfo_type_name(cx, inner_type, true, output); }, ty::TyRef(_, ty::mt { ty: inner_type, mutbl }) => { output.push('&'); if mutbl == ast::MutMutable { output.push_str("mut "); } push_debuginfo_type_name(cx, inner_type, true, output); }, ty::TyArray(inner_type, len) => { output.push('['); push_debuginfo_type_name(cx, inner_type, true, output); output.push_str(&format!("; {}", len)); output.push(']'); }, ty::TySlice(inner_type) => { output.push('['); push_debuginfo_type_name(cx, inner_type, true, output); output.push(']'); }, ty::TyTrait(ref trait_data) => { let principal = cx.tcx().erase_late_bound_regions(&trait_data.principal); push_item_name(cx, principal.def_id, false, output); push_type_params(cx, principal.substs, output); }, ty::TyBareFn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => { if unsafety == ast::Unsafety::Unsafe { output.push_str("unsafe "); } if abi!= ::syntax::abi::Rust { output.push_str("extern \""); output.push_str(abi.name()); output.push_str("\" "); } output.push_str("fn("); let sig = cx.tcx().erase_late_bound_regions(sig); if!sig.inputs.is_empty() { for &parameter_type in &sig.inputs { push_debuginfo_type_name(cx, parameter_type, true, output); output.push_str(", "); } output.pop(); output.pop(); } if sig.variadic { if!sig.inputs.is_empty() { output.push_str(",..."); } else { output.push_str("..."); } } output.push(')'); match sig.output { ty::FnConverging(result_type) if result_type.is_nil() => {} ty::FnConverging(result_type) => { output.push_str(" -> "); push_debuginfo_type_name(cx, result_type, true, output); } ty::FnDiverging => { output.push_str(" ->!"); } } }, ty::TyClosure(..) => { output.push_str("closure"); } ty::TyError | ty::TyInfer(_) | ty::TyProjection(..) | ty::TyParam(_) => { cx.sess().bug(&format!("debuginfo: Trying to create type name for \ unexpected type: {:?}", t)); } } fn push_item_name(cx: &CrateContext, def_id: ast::DefId, qualified: bool, output: &mut String) { cx.tcx().with_path(def_id, |path| { if qualified { if def_id.krate == ast::LOCAL_CRATE { output.push_str(crate_root_namespace(cx)); output.push_str("::"); } let mut path_element_count = 0; for path_element in path { let name = token::get_name(path_element.name()); output.push_str(&name); output.push_str("::"); path_element_count += 1; } if path_element_count == 0 { cx.sess().bug("debuginfo: Encountered empty item path!"); } output.pop(); output.pop(); } else { let name = token::get_name(path.last() .expect("debuginfo: Empty item path?") .name()); output.push_str(&name); } }); } // Pushes the type parameters in the given `Substs` to the output string. // This ignores region parameters, since they can't reliably be // reconstructed for items from non-local crates. For local crates, this // would be possible but with inlining and LTO we have to use the least // common denominator - otherwise we would run into conflicts. fn push_type_params<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, substs: &subst::Substs<'tcx>, output: &mut String) { if substs.types.is_empty() { return; } output.push('<'); for &type_parameter in &substs.types { push_debuginfo_type_name(cx, type_parameter, true, output); output.push_str(", "); } output.pop(); output.pop(); output.push('>'); } }
{ match t.sty { ty::TyBool => output.push_str("bool"), ty::TyChar => output.push_str("char"), ty::TyStr => output.push_str("str"), ty::TyInt(ast::TyIs) => output.push_str("isize"), ty::TyInt(ast::TyI8) => output.push_str("i8"), ty::TyInt(ast::TyI16) => output.push_str("i16"), ty::TyInt(ast::TyI32) => output.push_str("i32"), ty::TyInt(ast::TyI64) => output.push_str("i64"), ty::TyUint(ast::TyUs) => output.push_str("usize"), ty::TyUint(ast::TyU8) => output.push_str("u8"), ty::TyUint(ast::TyU16) => output.push_str("u16"), ty::TyUint(ast::TyU32) => output.push_str("u32"), ty::TyUint(ast::TyU64) => output.push_str("u64"), ty::TyFloat(ast::TyF32) => output.push_str("f32"), ty::TyFloat(ast::TyF64) => output.push_str("f64"), ty::TyStruct(def_id, substs) | ty::TyEnum(def_id, substs) => { push_item_name(cx, def_id, qualified, output);
identifier_body
type_names.rs
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // Type Names for Debug Info. use super::namespace::crate_root_namespace; use trans::common::CrateContext; use middle::subst::{self, Substs}; use middle::ty::{self, Ty, ClosureTyper}; use syntax::ast; use syntax::parse::token; // Compute the name of the type as it should be stored in debuginfo. Does not do // any caching, i.e. calling the function twice with the same type will also do // the work twice. The `qualified` parameter only affects the first level of the // type name, further levels (i.e. type parameters) are always fully qualified. pub fn compute_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, qualified: bool) -> String { let mut result = String::with_capacity(64); push_debuginfo_type_name(cx, t, qualified, &mut result); result } // Pushes the name of the type as it should be stored in debuginfo on the // `output` String. See also compute_debuginfo_type_name(). pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, qualified: bool, output: &mut String) { match t.sty { ty::TyBool => output.push_str("bool"), ty::TyChar => output.push_str("char"), ty::TyStr => output.push_str("str"), ty::TyInt(ast::TyIs) => output.push_str("isize"), ty::TyInt(ast::TyI8) => output.push_str("i8"), ty::TyInt(ast::TyI16) => output.push_str("i16"), ty::TyInt(ast::TyI32) => output.push_str("i32"), ty::TyInt(ast::TyI64) => output.push_str("i64"), ty::TyUint(ast::TyUs) => output.push_str("usize"), ty::TyUint(ast::TyU8) => output.push_str("u8"), ty::TyUint(ast::TyU16) => output.push_str("u16"), ty::TyUint(ast::TyU32) => output.push_str("u32"),
ty::TyFloat(ast::TyF64) => output.push_str("f64"), ty::TyStruct(def_id, substs) | ty::TyEnum(def_id, substs) => { push_item_name(cx, def_id, qualified, output); push_type_params(cx, substs, output); }, ty::TyTuple(ref component_types) => { output.push('('); for &component_type in component_types { push_debuginfo_type_name(cx, component_type, true, output); output.push_str(", "); } if!component_types.is_empty() { output.pop(); output.pop(); } output.push(')'); }, ty::TyBox(inner_type) => { output.push_str("Box<"); push_debuginfo_type_name(cx, inner_type, true, output); output.push('>'); }, ty::TyRawPtr(ty::mt { ty: inner_type, mutbl } ) => { output.push('*'); match mutbl { ast::MutImmutable => output.push_str("const "), ast::MutMutable => output.push_str("mut "), } push_debuginfo_type_name(cx, inner_type, true, output); }, ty::TyRef(_, ty::mt { ty: inner_type, mutbl }) => { output.push('&'); if mutbl == ast::MutMutable { output.push_str("mut "); } push_debuginfo_type_name(cx, inner_type, true, output); }, ty::TyArray(inner_type, len) => { output.push('['); push_debuginfo_type_name(cx, inner_type, true, output); output.push_str(&format!("; {}", len)); output.push(']'); }, ty::TySlice(inner_type) => { output.push('['); push_debuginfo_type_name(cx, inner_type, true, output); output.push(']'); }, ty::TyTrait(ref trait_data) => { let principal = cx.tcx().erase_late_bound_regions(&trait_data.principal); push_item_name(cx, principal.def_id, false, output); push_type_params(cx, principal.substs, output); }, ty::TyBareFn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => { if unsafety == ast::Unsafety::Unsafe { output.push_str("unsafe "); } if abi!= ::syntax::abi::Rust { output.push_str("extern \""); output.push_str(abi.name()); output.push_str("\" "); } output.push_str("fn("); let sig = cx.tcx().erase_late_bound_regions(sig); if!sig.inputs.is_empty() { for &parameter_type in &sig.inputs { push_debuginfo_type_name(cx, parameter_type, true, output); output.push_str(", "); } output.pop(); output.pop(); } if sig.variadic { if!sig.inputs.is_empty() { output.push_str(",..."); } else { output.push_str("..."); } } output.push(')'); match sig.output { ty::FnConverging(result_type) if result_type.is_nil() => {} ty::FnConverging(result_type) => { output.push_str(" -> "); push_debuginfo_type_name(cx, result_type, true, output); } ty::FnDiverging => { output.push_str(" ->!"); } } }, ty::TyClosure(..) => { output.push_str("closure"); } ty::TyError | ty::TyInfer(_) | ty::TyProjection(..) | ty::TyParam(_) => { cx.sess().bug(&format!("debuginfo: Trying to create type name for \ unexpected type: {:?}", t)); } } fn push_item_name(cx: &CrateContext, def_id: ast::DefId, qualified: bool, output: &mut String) { cx.tcx().with_path(def_id, |path| { if qualified { if def_id.krate == ast::LOCAL_CRATE { output.push_str(crate_root_namespace(cx)); output.push_str("::"); } let mut path_element_count = 0; for path_element in path { let name = token::get_name(path_element.name()); output.push_str(&name); output.push_str("::"); path_element_count += 1; } if path_element_count == 0 { cx.sess().bug("debuginfo: Encountered empty item path!"); } output.pop(); output.pop(); } else { let name = token::get_name(path.last() .expect("debuginfo: Empty item path?") .name()); output.push_str(&name); } }); } // Pushes the type parameters in the given `Substs` to the output string. // This ignores region parameters, since they can't reliably be // reconstructed for items from non-local crates. For local crates, this // would be possible but with inlining and LTO we have to use the least // common denominator - otherwise we would run into conflicts. fn push_type_params<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, substs: &subst::Substs<'tcx>, output: &mut String) { if substs.types.is_empty() { return; } output.push('<'); for &type_parameter in &substs.types { push_debuginfo_type_name(cx, type_parameter, true, output); output.push_str(", "); } output.pop(); output.pop(); output.push('>'); } }
ty::TyUint(ast::TyU64) => output.push_str("u64"), ty::TyFloat(ast::TyF32) => output.push_str("f32"),
random_line_split
type_names.rs
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // Type Names for Debug Info. use super::namespace::crate_root_namespace; use trans::common::CrateContext; use middle::subst::{self, Substs}; use middle::ty::{self, Ty, ClosureTyper}; use syntax::ast; use syntax::parse::token; // Compute the name of the type as it should be stored in debuginfo. Does not do // any caching, i.e. calling the function twice with the same type will also do // the work twice. The `qualified` parameter only affects the first level of the // type name, further levels (i.e. type parameters) are always fully qualified. pub fn
<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, qualified: bool) -> String { let mut result = String::with_capacity(64); push_debuginfo_type_name(cx, t, qualified, &mut result); result } // Pushes the name of the type as it should be stored in debuginfo on the // `output` String. See also compute_debuginfo_type_name(). pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, qualified: bool, output: &mut String) { match t.sty { ty::TyBool => output.push_str("bool"), ty::TyChar => output.push_str("char"), ty::TyStr => output.push_str("str"), ty::TyInt(ast::TyIs) => output.push_str("isize"), ty::TyInt(ast::TyI8) => output.push_str("i8"), ty::TyInt(ast::TyI16) => output.push_str("i16"), ty::TyInt(ast::TyI32) => output.push_str("i32"), ty::TyInt(ast::TyI64) => output.push_str("i64"), ty::TyUint(ast::TyUs) => output.push_str("usize"), ty::TyUint(ast::TyU8) => output.push_str("u8"), ty::TyUint(ast::TyU16) => output.push_str("u16"), ty::TyUint(ast::TyU32) => output.push_str("u32"), ty::TyUint(ast::TyU64) => output.push_str("u64"), ty::TyFloat(ast::TyF32) => output.push_str("f32"), ty::TyFloat(ast::TyF64) => output.push_str("f64"), ty::TyStruct(def_id, substs) | ty::TyEnum(def_id, substs) => { push_item_name(cx, def_id, qualified, output); push_type_params(cx, substs, output); }, ty::TyTuple(ref component_types) => { output.push('('); for &component_type in component_types { push_debuginfo_type_name(cx, component_type, true, output); output.push_str(", "); } if!component_types.is_empty() { output.pop(); output.pop(); } output.push(')'); }, ty::TyBox(inner_type) => { output.push_str("Box<"); push_debuginfo_type_name(cx, inner_type, true, output); output.push('>'); }, ty::TyRawPtr(ty::mt { ty: inner_type, mutbl } ) => { output.push('*'); match mutbl { ast::MutImmutable => output.push_str("const "), ast::MutMutable => output.push_str("mut "), } push_debuginfo_type_name(cx, inner_type, true, output); }, ty::TyRef(_, ty::mt { ty: inner_type, mutbl }) => { output.push('&'); if mutbl == ast::MutMutable { output.push_str("mut "); } push_debuginfo_type_name(cx, inner_type, true, output); }, ty::TyArray(inner_type, len) => { output.push('['); push_debuginfo_type_name(cx, inner_type, true, output); output.push_str(&format!("; {}", len)); output.push(']'); }, ty::TySlice(inner_type) => { output.push('['); push_debuginfo_type_name(cx, inner_type, true, output); output.push(']'); }, ty::TyTrait(ref trait_data) => { let principal = cx.tcx().erase_late_bound_regions(&trait_data.principal); push_item_name(cx, principal.def_id, false, output); push_type_params(cx, principal.substs, output); }, ty::TyBareFn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => { if unsafety == ast::Unsafety::Unsafe { output.push_str("unsafe "); } if abi!= ::syntax::abi::Rust { output.push_str("extern \""); output.push_str(abi.name()); output.push_str("\" "); } output.push_str("fn("); let sig = cx.tcx().erase_late_bound_regions(sig); if!sig.inputs.is_empty() { for &parameter_type in &sig.inputs { push_debuginfo_type_name(cx, parameter_type, true, output); output.push_str(", "); } output.pop(); output.pop(); } if sig.variadic { if!sig.inputs.is_empty() { output.push_str(",..."); } else { output.push_str("..."); } } output.push(')'); match sig.output { ty::FnConverging(result_type) if result_type.is_nil() => {} ty::FnConverging(result_type) => { output.push_str(" -> "); push_debuginfo_type_name(cx, result_type, true, output); } ty::FnDiverging => { output.push_str(" ->!"); } } }, ty::TyClosure(..) => { output.push_str("closure"); } ty::TyError | ty::TyInfer(_) | ty::TyProjection(..) | ty::TyParam(_) => { cx.sess().bug(&format!("debuginfo: Trying to create type name for \ unexpected type: {:?}", t)); } } fn push_item_name(cx: &CrateContext, def_id: ast::DefId, qualified: bool, output: &mut String) { cx.tcx().with_path(def_id, |path| { if qualified { if def_id.krate == ast::LOCAL_CRATE { output.push_str(crate_root_namespace(cx)); output.push_str("::"); } let mut path_element_count = 0; for path_element in path { let name = token::get_name(path_element.name()); output.push_str(&name); output.push_str("::"); path_element_count += 1; } if path_element_count == 0 { cx.sess().bug("debuginfo: Encountered empty item path!"); } output.pop(); output.pop(); } else { let name = token::get_name(path.last() .expect("debuginfo: Empty item path?") .name()); output.push_str(&name); } }); } // Pushes the type parameters in the given `Substs` to the output string. // This ignores region parameters, since they can't reliably be // reconstructed for items from non-local crates. For local crates, this // would be possible but with inlining and LTO we have to use the least // common denominator - otherwise we would run into conflicts. fn push_type_params<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, substs: &subst::Substs<'tcx>, output: &mut String) { if substs.types.is_empty() { return; } output.push('<'); for &type_parameter in &substs.types { push_debuginfo_type_name(cx, type_parameter, true, output); output.push_str(", "); } output.pop(); output.pop(); output.push('>'); } }
compute_debuginfo_type_name
identifier_name
type_names.rs
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // Type Names for Debug Info. use super::namespace::crate_root_namespace; use trans::common::CrateContext; use middle::subst::{self, Substs}; use middle::ty::{self, Ty, ClosureTyper}; use syntax::ast; use syntax::parse::token; // Compute the name of the type as it should be stored in debuginfo. Does not do // any caching, i.e. calling the function twice with the same type will also do // the work twice. The `qualified` parameter only affects the first level of the // type name, further levels (i.e. type parameters) are always fully qualified. pub fn compute_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, qualified: bool) -> String { let mut result = String::with_capacity(64); push_debuginfo_type_name(cx, t, qualified, &mut result); result } // Pushes the name of the type as it should be stored in debuginfo on the // `output` String. See also compute_debuginfo_type_name(). pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, qualified: bool, output: &mut String) { match t.sty { ty::TyBool => output.push_str("bool"), ty::TyChar => output.push_str("char"), ty::TyStr => output.push_str("str"), ty::TyInt(ast::TyIs) => output.push_str("isize"), ty::TyInt(ast::TyI8) => output.push_str("i8"), ty::TyInt(ast::TyI16) => output.push_str("i16"), ty::TyInt(ast::TyI32) => output.push_str("i32"), ty::TyInt(ast::TyI64) => output.push_str("i64"), ty::TyUint(ast::TyUs) => output.push_str("usize"), ty::TyUint(ast::TyU8) => output.push_str("u8"), ty::TyUint(ast::TyU16) => output.push_str("u16"), ty::TyUint(ast::TyU32) => output.push_str("u32"), ty::TyUint(ast::TyU64) => output.push_str("u64"), ty::TyFloat(ast::TyF32) => output.push_str("f32"), ty::TyFloat(ast::TyF64) => output.push_str("f64"), ty::TyStruct(def_id, substs) | ty::TyEnum(def_id, substs) => { push_item_name(cx, def_id, qualified, output); push_type_params(cx, substs, output); }, ty::TyTuple(ref component_types) => { output.push('('); for &component_type in component_types { push_debuginfo_type_name(cx, component_type, true, output); output.push_str(", "); } if!component_types.is_empty() { output.pop(); output.pop(); } output.push(')'); }, ty::TyBox(inner_type) => { output.push_str("Box<"); push_debuginfo_type_name(cx, inner_type, true, output); output.push('>'); }, ty::TyRawPtr(ty::mt { ty: inner_type, mutbl } ) => { output.push('*'); match mutbl { ast::MutImmutable => output.push_str("const "), ast::MutMutable => output.push_str("mut "), } push_debuginfo_type_name(cx, inner_type, true, output); }, ty::TyRef(_, ty::mt { ty: inner_type, mutbl }) => { output.push('&'); if mutbl == ast::MutMutable { output.push_str("mut "); } push_debuginfo_type_name(cx, inner_type, true, output); }, ty::TyArray(inner_type, len) => { output.push('['); push_debuginfo_type_name(cx, inner_type, true, output); output.push_str(&format!("; {}", len)); output.push(']'); }, ty::TySlice(inner_type) => { output.push('['); push_debuginfo_type_name(cx, inner_type, true, output); output.push(']'); }, ty::TyTrait(ref trait_data) => { let principal = cx.tcx().erase_late_bound_regions(&trait_data.principal); push_item_name(cx, principal.def_id, false, output); push_type_params(cx, principal.substs, output); }, ty::TyBareFn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => { if unsafety == ast::Unsafety::Unsafe { output.push_str("unsafe "); } if abi!= ::syntax::abi::Rust { output.push_str("extern \""); output.push_str(abi.name()); output.push_str("\" "); } output.push_str("fn("); let sig = cx.tcx().erase_late_bound_regions(sig); if!sig.inputs.is_empty() { for &parameter_type in &sig.inputs { push_debuginfo_type_name(cx, parameter_type, true, output); output.push_str(", "); } output.pop(); output.pop(); } if sig.variadic { if!sig.inputs.is_empty() { output.push_str(",..."); } else { output.push_str("..."); } } output.push(')'); match sig.output { ty::FnConverging(result_type) if result_type.is_nil() => {} ty::FnConverging(result_type) => { output.push_str(" -> "); push_debuginfo_type_name(cx, result_type, true, output); } ty::FnDiverging => { output.push_str(" ->!"); } } }, ty::TyClosure(..) => { output.push_str("closure"); } ty::TyError | ty::TyInfer(_) | ty::TyProjection(..) | ty::TyParam(_) => { cx.sess().bug(&format!("debuginfo: Trying to create type name for \ unexpected type: {:?}", t)); } } fn push_item_name(cx: &CrateContext, def_id: ast::DefId, qualified: bool, output: &mut String) { cx.tcx().with_path(def_id, |path| { if qualified { if def_id.krate == ast::LOCAL_CRATE
let mut path_element_count = 0; for path_element in path { let name = token::get_name(path_element.name()); output.push_str(&name); output.push_str("::"); path_element_count += 1; } if path_element_count == 0 { cx.sess().bug("debuginfo: Encountered empty item path!"); } output.pop(); output.pop(); } else { let name = token::get_name(path.last() .expect("debuginfo: Empty item path?") .name()); output.push_str(&name); } }); } // Pushes the type parameters in the given `Substs` to the output string. // This ignores region parameters, since they can't reliably be // reconstructed for items from non-local crates. For local crates, this // would be possible but with inlining and LTO we have to use the least // common denominator - otherwise we would run into conflicts. fn push_type_params<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, substs: &subst::Substs<'tcx>, output: &mut String) { if substs.types.is_empty() { return; } output.push('<'); for &type_parameter in &substs.types { push_debuginfo_type_name(cx, type_parameter, true, output); output.push_str(", "); } output.pop(); output.pop(); output.push('>'); } }
{ output.push_str(crate_root_namespace(cx)); output.push_str("::"); }
conditional_block
lib.rs
// Copyright 2015, 2016 Ethcore (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. //! General IO module. //! //! Example usage for creating a network service and adding an IO handler: //! //! ```rust //! extern crate ethcore_io; //! use ethcore_io::*; //! use std::sync::Arc; //! //! struct MyHandler; //! //! #[derive(Clone)] //! struct MyMessage { //! data: u32 //! } //! //! impl IoHandler<MyMessage> for MyHandler { //! fn initialize(&self, io: &IoContext<MyMessage>) { //! io.register_timer(0, 1000).unwrap(); //! } //! //! fn timeout(&self, _io: &IoContext<MyMessage>, timer: TimerToken) { //! println!("Timeout {}", timer); //! } //! //! fn message(&self, _io: &IoContext<MyMessage>, message: &MyMessage) { //! println!("Message {}", message.data); //! } //! } //! //! fn main () { //! let mut service = IoService::<MyMessage>::start().expect("Error creating network service"); //! service.register_handler(Arc::new(MyHandler)).unwrap(); //! //! // Wait for quit condition //! //... //! // Drop the service //! } //! ``` extern crate mio; #[macro_use] extern crate log as rlog; extern crate slab; extern crate crossbeam; extern crate parking_lot; mod service; mod worker; mod panics; use mio::{EventLoop, Token}; use std::fmt; pub use worker::LOCAL_STACK_SIZE; #[derive(Debug)] /// IO Error pub enum IoError { /// Low level error from mio crate Mio(::std::io::Error), /// Error concerning the Rust standard library's IO subsystem. StdIo(::std::io::Error), } impl fmt::Display for IoError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // just defer to the std implementation for now. // we can refine the formatting when more variants are added. match *self { IoError::Mio(ref std_err) => std_err.fmt(f), IoError::StdIo(ref std_err) => std_err.fmt(f), } } } impl From<::std::io::Error> for IoError { fn from(err: ::std::io::Error) -> IoError { IoError::StdIo(err) } } impl<Message> From<::mio::NotifyError<service::IoMessage<Message>>> for IoError where Message: Send + Clone { fn from(_err: ::mio::NotifyError<service::IoMessage<Message>>) -> IoError { IoError::Mio(::std::io::Error::new(::std::io::ErrorKind::ConnectionAborted, "Network IO notification error")) } } /// Generic IO handler. /// All the handler function are called from within IO event loop. /// `Message` type is used as notification data pub trait IoHandler<Message>: Send + Sync where Message: Send + Sync + Clone +'static { /// Initialize the handler fn initialize(&self, _io: &IoContext<Message>) {} /// Timer function called after a timeout created with `HandlerIo::timeout`. fn timeout(&self, _io: &IoContext<Message>, _timer: TimerToken) {} /// Called when a broadcasted message is received. The message can only be sent from a different IO handler. fn message(&self, _io: &IoContext<Message>, _message: &Message) {} /// Called when an IO stream gets closed fn stream_hup(&self, _io: &IoContext<Message>, _stream: StreamToken) {} /// Called when an IO stream can be read from fn stream_readable(&self, _io: &IoContext<Message>, _stream: StreamToken) {} /// Called when an IO stream can be written to fn stream_writable(&self, _io: &IoContext<Message>, _stream: StreamToken) {} /// Register a new stream with the event loop fn register_stream(&self, _stream: StreamToken, _reg: Token, _event_loop: &mut EventLoop<IoManager<Message>>) {} /// Re-register a stream with the event loop fn update_stream(&self, _stream: StreamToken, _reg: Token, _event_loop: &mut EventLoop<IoManager<Message>>) {} /// Deregister a stream. Called whenstream is removed from event loop fn deregister_stream(&self, _stream: StreamToken, _event_loop: &mut EventLoop<IoManager<Message>>) {} } pub use service::TimerToken; pub use service::StreamToken; pub use service::IoContext; pub use service::IoService; pub use service::IoChannel; pub use service::IoManager; pub use service::TOKENS_PER_HANDLER; pub use panics::{PanicHandler, MayPanic, OnPanicListener, ForwardPanic}; #[cfg(test)] mod tests { use std::sync::Arc; use super::*; struct MyHandler; #[derive(Clone)] struct MyMessage { data: u32 } impl IoHandler<MyMessage> for MyHandler { fn initialize(&self, io: &IoContext<MyMessage>) { io.register_timer(0, 1000).unwrap(); } fn timeout(&self, _io: &IoContext<MyMessage>, timer: TimerToken) { println!("Timeout {}", timer); } fn message(&self, _io: &IoContext<MyMessage>, message: &MyMessage) { println!("Message {}", message.data); } } #[test] fn
() { let service = IoService::<MyMessage>::start().expect("Error creating network service"); service.register_handler(Arc::new(MyHandler)).unwrap(); } }
test_service_register_handler
identifier_name
lib.rs
// Copyright 2015, 2016 Ethcore (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. //! General IO module. //! //! Example usage for creating a network service and adding an IO handler: //! //! ```rust //! extern crate ethcore_io; //! use ethcore_io::*; //! use std::sync::Arc; //! //! struct MyHandler; //! //! #[derive(Clone)] //! struct MyMessage { //! data: u32 //! } //! //! impl IoHandler<MyMessage> for MyHandler { //! fn initialize(&self, io: &IoContext<MyMessage>) { //! io.register_timer(0, 1000).unwrap(); //! } //! //! fn timeout(&self, _io: &IoContext<MyMessage>, timer: TimerToken) { //! println!("Timeout {}", timer); //! } //! //! fn message(&self, _io: &IoContext<MyMessage>, message: &MyMessage) { //! println!("Message {}", message.data);
//! //! fn main () { //! let mut service = IoService::<MyMessage>::start().expect("Error creating network service"); //! service.register_handler(Arc::new(MyHandler)).unwrap(); //! //! // Wait for quit condition //! //... //! // Drop the service //! } //! ``` extern crate mio; #[macro_use] extern crate log as rlog; extern crate slab; extern crate crossbeam; extern crate parking_lot; mod service; mod worker; mod panics; use mio::{EventLoop, Token}; use std::fmt; pub use worker::LOCAL_STACK_SIZE; #[derive(Debug)] /// IO Error pub enum IoError { /// Low level error from mio crate Mio(::std::io::Error), /// Error concerning the Rust standard library's IO subsystem. StdIo(::std::io::Error), } impl fmt::Display for IoError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // just defer to the std implementation for now. // we can refine the formatting when more variants are added. match *self { IoError::Mio(ref std_err) => std_err.fmt(f), IoError::StdIo(ref std_err) => std_err.fmt(f), } } } impl From<::std::io::Error> for IoError { fn from(err: ::std::io::Error) -> IoError { IoError::StdIo(err) } } impl<Message> From<::mio::NotifyError<service::IoMessage<Message>>> for IoError where Message: Send + Clone { fn from(_err: ::mio::NotifyError<service::IoMessage<Message>>) -> IoError { IoError::Mio(::std::io::Error::new(::std::io::ErrorKind::ConnectionAborted, "Network IO notification error")) } } /// Generic IO handler. /// All the handler function are called from within IO event loop. /// `Message` type is used as notification data pub trait IoHandler<Message>: Send + Sync where Message: Send + Sync + Clone +'static { /// Initialize the handler fn initialize(&self, _io: &IoContext<Message>) {} /// Timer function called after a timeout created with `HandlerIo::timeout`. fn timeout(&self, _io: &IoContext<Message>, _timer: TimerToken) {} /// Called when a broadcasted message is received. The message can only be sent from a different IO handler. fn message(&self, _io: &IoContext<Message>, _message: &Message) {} /// Called when an IO stream gets closed fn stream_hup(&self, _io: &IoContext<Message>, _stream: StreamToken) {} /// Called when an IO stream can be read from fn stream_readable(&self, _io: &IoContext<Message>, _stream: StreamToken) {} /// Called when an IO stream can be written to fn stream_writable(&self, _io: &IoContext<Message>, _stream: StreamToken) {} /// Register a new stream with the event loop fn register_stream(&self, _stream: StreamToken, _reg: Token, _event_loop: &mut EventLoop<IoManager<Message>>) {} /// Re-register a stream with the event loop fn update_stream(&self, _stream: StreamToken, _reg: Token, _event_loop: &mut EventLoop<IoManager<Message>>) {} /// Deregister a stream. Called whenstream is removed from event loop fn deregister_stream(&self, _stream: StreamToken, _event_loop: &mut EventLoop<IoManager<Message>>) {} } pub use service::TimerToken; pub use service::StreamToken; pub use service::IoContext; pub use service::IoService; pub use service::IoChannel; pub use service::IoManager; pub use service::TOKENS_PER_HANDLER; pub use panics::{PanicHandler, MayPanic, OnPanicListener, ForwardPanic}; #[cfg(test)] mod tests { use std::sync::Arc; use super::*; struct MyHandler; #[derive(Clone)] struct MyMessage { data: u32 } impl IoHandler<MyMessage> for MyHandler { fn initialize(&self, io: &IoContext<MyMessage>) { io.register_timer(0, 1000).unwrap(); } fn timeout(&self, _io: &IoContext<MyMessage>, timer: TimerToken) { println!("Timeout {}", timer); } fn message(&self, _io: &IoContext<MyMessage>, message: &MyMessage) { println!("Message {}", message.data); } } #[test] fn test_service_register_handler () { let service = IoService::<MyMessage>::start().expect("Error creating network service"); service.register_handler(Arc::new(MyHandler)).unwrap(); } }
//! } //! }
random_line_split
lib.rs
// Copyright 2015, 2016 Ethcore (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. //! General IO module. //! //! Example usage for creating a network service and adding an IO handler: //! //! ```rust //! extern crate ethcore_io; //! use ethcore_io::*; //! use std::sync::Arc; //! //! struct MyHandler; //! //! #[derive(Clone)] //! struct MyMessage { //! data: u32 //! } //! //! impl IoHandler<MyMessage> for MyHandler { //! fn initialize(&self, io: &IoContext<MyMessage>) { //! io.register_timer(0, 1000).unwrap(); //! } //! //! fn timeout(&self, _io: &IoContext<MyMessage>, timer: TimerToken) { //! println!("Timeout {}", timer); //! } //! //! fn message(&self, _io: &IoContext<MyMessage>, message: &MyMessage) { //! println!("Message {}", message.data); //! } //! } //! //! fn main () { //! let mut service = IoService::<MyMessage>::start().expect("Error creating network service"); //! service.register_handler(Arc::new(MyHandler)).unwrap(); //! //! // Wait for quit condition //! //... //! // Drop the service //! } //! ``` extern crate mio; #[macro_use] extern crate log as rlog; extern crate slab; extern crate crossbeam; extern crate parking_lot; mod service; mod worker; mod panics; use mio::{EventLoop, Token}; use std::fmt; pub use worker::LOCAL_STACK_SIZE; #[derive(Debug)] /// IO Error pub enum IoError { /// Low level error from mio crate Mio(::std::io::Error), /// Error concerning the Rust standard library's IO subsystem. StdIo(::std::io::Error), } impl fmt::Display for IoError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // just defer to the std implementation for now. // we can refine the formatting when more variants are added. match *self { IoError::Mio(ref std_err) => std_err.fmt(f), IoError::StdIo(ref std_err) => std_err.fmt(f), } } } impl From<::std::io::Error> for IoError { fn from(err: ::std::io::Error) -> IoError { IoError::StdIo(err) } } impl<Message> From<::mio::NotifyError<service::IoMessage<Message>>> for IoError where Message: Send + Clone { fn from(_err: ::mio::NotifyError<service::IoMessage<Message>>) -> IoError { IoError::Mio(::std::io::Error::new(::std::io::ErrorKind::ConnectionAborted, "Network IO notification error")) } } /// Generic IO handler. /// All the handler function are called from within IO event loop. /// `Message` type is used as notification data pub trait IoHandler<Message>: Send + Sync where Message: Send + Sync + Clone +'static { /// Initialize the handler fn initialize(&self, _io: &IoContext<Message>) {} /// Timer function called after a timeout created with `HandlerIo::timeout`. fn timeout(&self, _io: &IoContext<Message>, _timer: TimerToken) {} /// Called when a broadcasted message is received. The message can only be sent from a different IO handler. fn message(&self, _io: &IoContext<Message>, _message: &Message) {} /// Called when an IO stream gets closed fn stream_hup(&self, _io: &IoContext<Message>, _stream: StreamToken) {} /// Called when an IO stream can be read from fn stream_readable(&self, _io: &IoContext<Message>, _stream: StreamToken) {} /// Called when an IO stream can be written to fn stream_writable(&self, _io: &IoContext<Message>, _stream: StreamToken)
/// Register a new stream with the event loop fn register_stream(&self, _stream: StreamToken, _reg: Token, _event_loop: &mut EventLoop<IoManager<Message>>) {} /// Re-register a stream with the event loop fn update_stream(&self, _stream: StreamToken, _reg: Token, _event_loop: &mut EventLoop<IoManager<Message>>) {} /// Deregister a stream. Called whenstream is removed from event loop fn deregister_stream(&self, _stream: StreamToken, _event_loop: &mut EventLoop<IoManager<Message>>) {} } pub use service::TimerToken; pub use service::StreamToken; pub use service::IoContext; pub use service::IoService; pub use service::IoChannel; pub use service::IoManager; pub use service::TOKENS_PER_HANDLER; pub use panics::{PanicHandler, MayPanic, OnPanicListener, ForwardPanic}; #[cfg(test)] mod tests { use std::sync::Arc; use super::*; struct MyHandler; #[derive(Clone)] struct MyMessage { data: u32 } impl IoHandler<MyMessage> for MyHandler { fn initialize(&self, io: &IoContext<MyMessage>) { io.register_timer(0, 1000).unwrap(); } fn timeout(&self, _io: &IoContext<MyMessage>, timer: TimerToken) { println!("Timeout {}", timer); } fn message(&self, _io: &IoContext<MyMessage>, message: &MyMessage) { println!("Message {}", message.data); } } #[test] fn test_service_register_handler () { let service = IoService::<MyMessage>::start().expect("Error creating network service"); service.register_handler(Arc::new(MyHandler)).unwrap(); } }
{}
identifier_body
buf.rs
use alloc::heap::{Heap, Alloc, Layout}; use std::{cmp, io, mem, ops, ptr, slice}; use std::io::Write; /// Default buffer size. Perhaps this should be tunable. const BUF_SIZE: usize = 4096; /// A reference counted slab allocator. /// /// `MutBuf` keeps an internal byte buffer to which it allows bytes to be /// written. The buffer is fixed size, and append only. The bytes may be shared /// as owned `Buf` instances. /// /// The reference counting mechanism of `MutBuf` is not threadsafe, so instances /// may not be shared or sent across thread boundaries. pub struct MutBuf { raw: RawBuf, offset: usize, } impl io::Write for MutBuf { fn write(&mut self, buf: &[u8]) -> io::Result<usize> { unsafe { let count = cmp::min(buf.len(), self.raw.len() - self.offset); ptr::copy_nonoverlapping(buf.as_ptr(), self.raw.buf().offset(self.offset as isize), count); self.offset += count; Ok(count) } } fn flush(&mut self) -> io::Result<()> { Ok(()) } } impl MutBuf { pub fn new() -> MutBuf { MutBuf::with_capacity(BUF_SIZE) } pub fn with_capacity(cap: usize) -> MutBuf { MutBuf { raw: RawBuf::new(cap), offset: 0, } } pub fn buf(&self, offset: usize, len: usize) -> Buf { unsafe { assert!(offset + len <= self.offset); Buf { raw: self.raw.clone(), ptr: self.raw.buf().offset(offset as isize), len: len, } } } /// Attempts to fill the buffer with at least `amount` bytes from `read`. /// The remaining capacity of the buffer must exceed `amount`. fn fill<R>(&mut self, read: &mut R, amount: usize) -> io::Result<()> where R: io::Read { unsafe { let remaining_capacity = self.raw.len() - self.offset; assert!(remaining_capacity >= amount); let mut buf = slice::from_raw_parts_mut(self.raw.buf().offset(self.offset as isize), remaining_capacity); let target_offset = self.offset + amount; while self.offset < target_offset { match try!(read.read(&mut buf)) { 0 => return Result::Err(io::Error::new(io::ErrorKind::UnexpectedEof, "failed to fill whole buffer")), n => { self.offset += n; let tmp = buf; buf = &mut tmp[n..]; }, } } } Ok(()) } /// Attemps to fill the buffer with at least `amount` bytes after the offset /// `from`. /// /// If the buffer does not have enough capacity it is replaced with a new /// one, and `from` is reset to the corresponding offset in the new buffer. pub fn fill_or_replace<R>(&mut self, read: &mut R, from: &mut usize, amount: usize) -> io::Result<()> where R: io::Read { assert!(*from <= self.offset); let buffered_amount = self.offset - *from; if buffered_amount >= amount { return Ok(()); } let remaining_amount = amount - buffered_amount; if remaining_amount > self.raw.len() - self.offset { // Replace self with a new buffer with sufficient capacity. Copy // over all bytes between `from` and the current write offset, and // reset `from` to 0. let old_buf = mem::replace(self, MutBuf::with_capacity(cmp::max(BUF_SIZE, amount + 8))); try!(self.write(&old_buf[*from..])); *from = 0; } self.fill(read, remaining_amount) } } impl ops::Deref for MutBuf { type Target = [u8]; fn deref(&self) -> &[u8] { unsafe { slice::from_raw_parts(self.raw.buf(), self.offset) } } } /// A view into a `MutBuf`. /// /// A `Buf` increments the reference count of the `MutBuf`, so that a `Buf` can /// outlive the `MutBuf` from which it was created. /// /// The reference counting mechanism of `MutBuf` is not threadsafe, so `Buf` /// instances may not be shared or sent across thread boundaries. pub struct Buf { raw: RawBuf, ptr: *const u8, len: usize, } impl ops::Deref for Buf { type Target = [u8]; fn deref(&self) -> &[u8] { unsafe { slice::from_raw_parts(self.ptr, self.len) } } } impl Clone for Buf { fn clone(&self) -> Buf { Buf { raw: self.raw.clone(), ptr: self.ptr, len: self.len } } } /// A reference counted byte buffer. /// /// The reference count is the first 8 bytes of the buffer. /// The buffer is not initialized. /// /// It is left to the user to ensure that data races do not occur and /// unitialized data is not read. /// /// `RawBuf` is not threadsafe, and may not be sent or shared across thread /// boundaries. struct RawBuf { bytes: *mut u8, len: usize, } impl RawBuf { /// Creates a new `RawBuf` instance with approximately the provided /// length. fn new(len: usize) -> RawBuf { unsafe { let refcount_len = mem::size_of::<u64>(); let len = cmp::max(refcount_len, len); // The buffer is aligned to a u64. This is necessary for storing the // refcount, as well as required by Cap'n Proto. This requirement is // the primary reason that the raw allocation APIs are used instead // of something like RawVec. let bytes = match Heap.alloc(Layout::from_size_align(len, refcount_len).unwrap()) { Result::Ok(val) => val, Result::Err(err) => Heap.oom(err), }; *(bytes as *mut u64) = 1; RawBuf { bytes: bytes.offset(refcount_len as isize), len: len - refcount_len, } } } fn buf(&self) -> *mut u8 { self.bytes } fn len(&self) -> usize { self.len } } impl Clone for RawBuf { fn clone(&self) -> RawBuf { unsafe { *(self.bytes.offset(-(mem::size_of::<u64>() as isize)) as *mut u64) += 1; RawBuf { bytes: self.bytes, len: self.len, } } } } impl Drop for RawBuf { fn drop(&mut self) { unsafe { let refcount_len = mem::size_of::<u64>(); let allocation = self.bytes.offset(-(refcount_len as isize)); let refcount = allocation as *mut u64; *refcount -= 1; if *refcount == 0 { Heap.dealloc(allocation, Layout::from_size_align(self.len + refcount_len, refcount_len).unwrap()); } } } } #[cfg(test)] mod test { use std::io::{Cursor, Write}; use super::{MutBuf, RawBuf}; use quickcheck::{quickcheck, TestResult}; #[test] fn test_create_raw_buf() { let raw = RawBuf::new(128 * 1024); assert_eq!(128 * 1024 - 8, raw.len()); } #[test] fn raw_buf_is_cloneable() { let raw = RawBuf::new(0); let clone = raw.clone(); assert_eq!(0, clone.len()); } #[test] fn mut_buf_write() { let mut buf = MutBuf::with_capacity(16); assert_eq!(8, buf.write(b"abcdefghijk").unwrap()); assert_eq!(0, buf.write(b"abcdefghijk").unwrap()); } #[test] fn buf() { let mut buf = MutBuf::with_capacity(16); buf.write_all(b"abcdefgh").unwrap(); assert_eq!(b"", &*buf.buf(0, 0)); assert_eq!(b"a", &*buf.buf(0, 1)); assert_eq!(b"ab", &*buf.buf(0, 2)); assert_eq!(b"abc", &*buf.buf(0, 3)); assert_eq!(b"abcd", &*buf.buf(0, 4)); assert_eq!(b"abcde", &*buf.buf(0, 5)); assert_eq!(b"abcdef", &*buf.buf(0, 6)); assert_eq!(b"abcdefg", &*buf.buf(0, 7)); assert_eq!(b"abcdefgh", &*buf.buf(0, 8)); } #[test] fn fill_or_replace() { let mut buf = MutBuf::with_capacity(14); buf.write_all(b"abcdef").unwrap(); let mut offset = 3; buf.fill_or_replace(&mut Cursor::new("ghi"), &mut offset, 6).unwrap(); assert_eq!(b"defghi", &*buf.buf(offset, 6)); } #[test] fn check_buf() { fn buf(segments: Vec<Vec<u8>>) -> TestResult { let total_len: usize = segments.iter().fold(0, |acc, segment| acc + segment.len()); let mut buf = MutBuf::with_capacity(total_len + 8); for segment in &segments { buf.write_all(&*segment).unwrap(); } let mut offset = 0; for segment in &segments { if &segment[..]!= &*buf.buf(offset, segment.len()) { return TestResult::failed(); } assert_eq!(&segment[..], &*buf.buf(offset, segment.len())); offset += segment.len(); } TestResult::passed() } quickcheck(buf as fn(Vec<Vec<u8>>) -> TestResult); } #[test] fn check_fill() { fn fill(segments: Vec<Vec<u8>>) -> TestResult { let total_len: usize = segments.iter().fold(0, |acc, segment| acc + segment.len()); let mut buf = MutBuf::with_capacity(total_len + 8); for segment in &segments { buf.fill(&mut Cursor::new(segment), segment.len()).unwrap(); } let mut offset = 0; for segment in &segments { if &segment[..]!= &*buf.buf(offset, segment.len()) { return TestResult::failed(); } assert_eq!(&segment[..], &*buf.buf(offset, segment.len())); offset += segment.len(); } TestResult::passed() } quickcheck(fill as fn(Vec<Vec<u8>>) -> TestResult); } #[test] fn check_fill_or_replace() { fn fill(a: Vec<u8>, b: Vec<u8>, c: Vec<u8>) -> TestResult { let mut buf = MutBuf::with_capacity(8 + a.len() + b.len()); buf.write_all(&a).unwrap(); buf.write_all(&b).unwrap(); let mut offset = a.len(); buf.fill_or_replace(&mut Cursor::new(&c), &mut offset, b.len() + c.len()).unwrap(); if &b[..]!= &*buf.buf(offset, b.len()) { return TestResult::failed(); } if &c[..]!= &*buf.buf(offset + b.len(), c.len())
TestResult::passed() } quickcheck(fill as fn(Vec<u8>, Vec<u8>, Vec<u8>) -> TestResult); } }
{ return TestResult::failed(); }
conditional_block
buf.rs
use alloc::heap::{Heap, Alloc, Layout}; use std::{cmp, io, mem, ops, ptr, slice}; use std::io::Write; /// Default buffer size. Perhaps this should be tunable. const BUF_SIZE: usize = 4096; /// A reference counted slab allocator. /// /// `MutBuf` keeps an internal byte buffer to which it allows bytes to be /// written. The buffer is fixed size, and append only. The bytes may be shared /// as owned `Buf` instances. /// /// The reference counting mechanism of `MutBuf` is not threadsafe, so instances /// may not be shared or sent across thread boundaries. pub struct MutBuf { raw: RawBuf, offset: usize, } impl io::Write for MutBuf { fn write(&mut self, buf: &[u8]) -> io::Result<usize> { unsafe { let count = cmp::min(buf.len(), self.raw.len() - self.offset); ptr::copy_nonoverlapping(buf.as_ptr(), self.raw.buf().offset(self.offset as isize), count); self.offset += count; Ok(count) } } fn flush(&mut self) -> io::Result<()> { Ok(()) } } impl MutBuf { pub fn new() -> MutBuf { MutBuf::with_capacity(BUF_SIZE) } pub fn with_capacity(cap: usize) -> MutBuf { MutBuf { raw: RawBuf::new(cap), offset: 0, } } pub fn buf(&self, offset: usize, len: usize) -> Buf { unsafe { assert!(offset + len <= self.offset); Buf { raw: self.raw.clone(), ptr: self.raw.buf().offset(offset as isize), len: len, } } } /// Attempts to fill the buffer with at least `amount` bytes from `read`. /// The remaining capacity of the buffer must exceed `amount`. fn fill<R>(&mut self, read: &mut R, amount: usize) -> io::Result<()> where R: io::Read { unsafe { let remaining_capacity = self.raw.len() - self.offset; assert!(remaining_capacity >= amount); let mut buf = slice::from_raw_parts_mut(self.raw.buf().offset(self.offset as isize), remaining_capacity); let target_offset = self.offset + amount; while self.offset < target_offset { match try!(read.read(&mut buf)) { 0 => return Result::Err(io::Error::new(io::ErrorKind::UnexpectedEof, "failed to fill whole buffer")), n => { self.offset += n; let tmp = buf; buf = &mut tmp[n..]; }, } } } Ok(()) } /// Attemps to fill the buffer with at least `amount` bytes after the offset /// `from`. /// /// If the buffer does not have enough capacity it is replaced with a new /// one, and `from` is reset to the corresponding offset in the new buffer. pub fn fill_or_replace<R>(&mut self, read: &mut R, from: &mut usize, amount: usize) -> io::Result<()> where R: io::Read { assert!(*from <= self.offset); let buffered_amount = self.offset - *from; if buffered_amount >= amount { return Ok(()); } let remaining_amount = amount - buffered_amount; if remaining_amount > self.raw.len() - self.offset { // Replace self with a new buffer with sufficient capacity. Copy // over all bytes between `from` and the current write offset, and // reset `from` to 0. let old_buf = mem::replace(self, MutBuf::with_capacity(cmp::max(BUF_SIZE, amount + 8))); try!(self.write(&old_buf[*from..])); *from = 0; } self.fill(read, remaining_amount) } } impl ops::Deref for MutBuf { type Target = [u8]; fn deref(&self) -> &[u8] { unsafe { slice::from_raw_parts(self.raw.buf(), self.offset) } } } /// A view into a `MutBuf`. /// /// A `Buf` increments the reference count of the `MutBuf`, so that a `Buf` can /// outlive the `MutBuf` from which it was created. /// /// The reference counting mechanism of `MutBuf` is not threadsafe, so `Buf` /// instances may not be shared or sent across thread boundaries. pub struct Buf { raw: RawBuf, ptr: *const u8, len: usize, } impl ops::Deref for Buf { type Target = [u8]; fn deref(&self) -> &[u8] { unsafe { slice::from_raw_parts(self.ptr, self.len) } } } impl Clone for Buf { fn clone(&self) -> Buf { Buf { raw: self.raw.clone(), ptr: self.ptr, len: self.len } } } /// A reference counted byte buffer. /// /// The reference count is the first 8 bytes of the buffer. /// The buffer is not initialized. ///
/// /// `RawBuf` is not threadsafe, and may not be sent or shared across thread /// boundaries. struct RawBuf { bytes: *mut u8, len: usize, } impl RawBuf { /// Creates a new `RawBuf` instance with approximately the provided /// length. fn new(len: usize) -> RawBuf { unsafe { let refcount_len = mem::size_of::<u64>(); let len = cmp::max(refcount_len, len); // The buffer is aligned to a u64. This is necessary for storing the // refcount, as well as required by Cap'n Proto. This requirement is // the primary reason that the raw allocation APIs are used instead // of something like RawVec. let bytes = match Heap.alloc(Layout::from_size_align(len, refcount_len).unwrap()) { Result::Ok(val) => val, Result::Err(err) => Heap.oom(err), }; *(bytes as *mut u64) = 1; RawBuf { bytes: bytes.offset(refcount_len as isize), len: len - refcount_len, } } } fn buf(&self) -> *mut u8 { self.bytes } fn len(&self) -> usize { self.len } } impl Clone for RawBuf { fn clone(&self) -> RawBuf { unsafe { *(self.bytes.offset(-(mem::size_of::<u64>() as isize)) as *mut u64) += 1; RawBuf { bytes: self.bytes, len: self.len, } } } } impl Drop for RawBuf { fn drop(&mut self) { unsafe { let refcount_len = mem::size_of::<u64>(); let allocation = self.bytes.offset(-(refcount_len as isize)); let refcount = allocation as *mut u64; *refcount -= 1; if *refcount == 0 { Heap.dealloc(allocation, Layout::from_size_align(self.len + refcount_len, refcount_len).unwrap()); } } } } #[cfg(test)] mod test { use std::io::{Cursor, Write}; use super::{MutBuf, RawBuf}; use quickcheck::{quickcheck, TestResult}; #[test] fn test_create_raw_buf() { let raw = RawBuf::new(128 * 1024); assert_eq!(128 * 1024 - 8, raw.len()); } #[test] fn raw_buf_is_cloneable() { let raw = RawBuf::new(0); let clone = raw.clone(); assert_eq!(0, clone.len()); } #[test] fn mut_buf_write() { let mut buf = MutBuf::with_capacity(16); assert_eq!(8, buf.write(b"abcdefghijk").unwrap()); assert_eq!(0, buf.write(b"abcdefghijk").unwrap()); } #[test] fn buf() { let mut buf = MutBuf::with_capacity(16); buf.write_all(b"abcdefgh").unwrap(); assert_eq!(b"", &*buf.buf(0, 0)); assert_eq!(b"a", &*buf.buf(0, 1)); assert_eq!(b"ab", &*buf.buf(0, 2)); assert_eq!(b"abc", &*buf.buf(0, 3)); assert_eq!(b"abcd", &*buf.buf(0, 4)); assert_eq!(b"abcde", &*buf.buf(0, 5)); assert_eq!(b"abcdef", &*buf.buf(0, 6)); assert_eq!(b"abcdefg", &*buf.buf(0, 7)); assert_eq!(b"abcdefgh", &*buf.buf(0, 8)); } #[test] fn fill_or_replace() { let mut buf = MutBuf::with_capacity(14); buf.write_all(b"abcdef").unwrap(); let mut offset = 3; buf.fill_or_replace(&mut Cursor::new("ghi"), &mut offset, 6).unwrap(); assert_eq!(b"defghi", &*buf.buf(offset, 6)); } #[test] fn check_buf() { fn buf(segments: Vec<Vec<u8>>) -> TestResult { let total_len: usize = segments.iter().fold(0, |acc, segment| acc + segment.len()); let mut buf = MutBuf::with_capacity(total_len + 8); for segment in &segments { buf.write_all(&*segment).unwrap(); } let mut offset = 0; for segment in &segments { if &segment[..]!= &*buf.buf(offset, segment.len()) { return TestResult::failed(); } assert_eq!(&segment[..], &*buf.buf(offset, segment.len())); offset += segment.len(); } TestResult::passed() } quickcheck(buf as fn(Vec<Vec<u8>>) -> TestResult); } #[test] fn check_fill() { fn fill(segments: Vec<Vec<u8>>) -> TestResult { let total_len: usize = segments.iter().fold(0, |acc, segment| acc + segment.len()); let mut buf = MutBuf::with_capacity(total_len + 8); for segment in &segments { buf.fill(&mut Cursor::new(segment), segment.len()).unwrap(); } let mut offset = 0; for segment in &segments { if &segment[..]!= &*buf.buf(offset, segment.len()) { return TestResult::failed(); } assert_eq!(&segment[..], &*buf.buf(offset, segment.len())); offset += segment.len(); } TestResult::passed() } quickcheck(fill as fn(Vec<Vec<u8>>) -> TestResult); } #[test] fn check_fill_or_replace() { fn fill(a: Vec<u8>, b: Vec<u8>, c: Vec<u8>) -> TestResult { let mut buf = MutBuf::with_capacity(8 + a.len() + b.len()); buf.write_all(&a).unwrap(); buf.write_all(&b).unwrap(); let mut offset = a.len(); buf.fill_or_replace(&mut Cursor::new(&c), &mut offset, b.len() + c.len()).unwrap(); if &b[..]!= &*buf.buf(offset, b.len()) { return TestResult::failed(); } if &c[..]!= &*buf.buf(offset + b.len(), c.len()) { return TestResult::failed(); } TestResult::passed() } quickcheck(fill as fn(Vec<u8>, Vec<u8>, Vec<u8>) -> TestResult); } }
/// It is left to the user to ensure that data races do not occur and /// unitialized data is not read.
random_line_split
buf.rs
use alloc::heap::{Heap, Alloc, Layout}; use std::{cmp, io, mem, ops, ptr, slice}; use std::io::Write; /// Default buffer size. Perhaps this should be tunable. const BUF_SIZE: usize = 4096; /// A reference counted slab allocator. /// /// `MutBuf` keeps an internal byte buffer to which it allows bytes to be /// written. The buffer is fixed size, and append only. The bytes may be shared /// as owned `Buf` instances. /// /// The reference counting mechanism of `MutBuf` is not threadsafe, so instances /// may not be shared or sent across thread boundaries. pub struct MutBuf { raw: RawBuf, offset: usize, } impl io::Write for MutBuf { fn write(&mut self, buf: &[u8]) -> io::Result<usize> { unsafe { let count = cmp::min(buf.len(), self.raw.len() - self.offset); ptr::copy_nonoverlapping(buf.as_ptr(), self.raw.buf().offset(self.offset as isize), count); self.offset += count; Ok(count) } } fn flush(&mut self) -> io::Result<()> { Ok(()) } } impl MutBuf { pub fn new() -> MutBuf { MutBuf::with_capacity(BUF_SIZE) } pub fn with_capacity(cap: usize) -> MutBuf { MutBuf { raw: RawBuf::new(cap), offset: 0, } } pub fn buf(&self, offset: usize, len: usize) -> Buf { unsafe { assert!(offset + len <= self.offset); Buf { raw: self.raw.clone(), ptr: self.raw.buf().offset(offset as isize), len: len, } } } /// Attempts to fill the buffer with at least `amount` bytes from `read`. /// The remaining capacity of the buffer must exceed `amount`. fn fill<R>(&mut self, read: &mut R, amount: usize) -> io::Result<()> where R: io::Read { unsafe { let remaining_capacity = self.raw.len() - self.offset; assert!(remaining_capacity >= amount); let mut buf = slice::from_raw_parts_mut(self.raw.buf().offset(self.offset as isize), remaining_capacity); let target_offset = self.offset + amount; while self.offset < target_offset { match try!(read.read(&mut buf)) { 0 => return Result::Err(io::Error::new(io::ErrorKind::UnexpectedEof, "failed to fill whole buffer")), n => { self.offset += n; let tmp = buf; buf = &mut tmp[n..]; }, } } } Ok(()) } /// Attemps to fill the buffer with at least `amount` bytes after the offset /// `from`. /// /// If the buffer does not have enough capacity it is replaced with a new /// one, and `from` is reset to the corresponding offset in the new buffer. pub fn fill_or_replace<R>(&mut self, read: &mut R, from: &mut usize, amount: usize) -> io::Result<()> where R: io::Read { assert!(*from <= self.offset); let buffered_amount = self.offset - *from; if buffered_amount >= amount { return Ok(()); } let remaining_amount = amount - buffered_amount; if remaining_amount > self.raw.len() - self.offset { // Replace self with a new buffer with sufficient capacity. Copy // over all bytes between `from` and the current write offset, and // reset `from` to 0. let old_buf = mem::replace(self, MutBuf::with_capacity(cmp::max(BUF_SIZE, amount + 8))); try!(self.write(&old_buf[*from..])); *from = 0; } self.fill(read, remaining_amount) } } impl ops::Deref for MutBuf { type Target = [u8]; fn deref(&self) -> &[u8] { unsafe { slice::from_raw_parts(self.raw.buf(), self.offset) } } } /// A view into a `MutBuf`. /// /// A `Buf` increments the reference count of the `MutBuf`, so that a `Buf` can /// outlive the `MutBuf` from which it was created. /// /// The reference counting mechanism of `MutBuf` is not threadsafe, so `Buf` /// instances may not be shared or sent across thread boundaries. pub struct Buf { raw: RawBuf, ptr: *const u8, len: usize, } impl ops::Deref for Buf { type Target = [u8]; fn deref(&self) -> &[u8] { unsafe { slice::from_raw_parts(self.ptr, self.len) } } } impl Clone for Buf { fn clone(&self) -> Buf { Buf { raw: self.raw.clone(), ptr: self.ptr, len: self.len } } } /// A reference counted byte buffer. /// /// The reference count is the first 8 bytes of the buffer. /// The buffer is not initialized. /// /// It is left to the user to ensure that data races do not occur and /// unitialized data is not read. /// /// `RawBuf` is not threadsafe, and may not be sent or shared across thread /// boundaries. struct RawBuf { bytes: *mut u8, len: usize, } impl RawBuf { /// Creates a new `RawBuf` instance with approximately the provided /// length. fn new(len: usize) -> RawBuf { unsafe { let refcount_len = mem::size_of::<u64>(); let len = cmp::max(refcount_len, len); // The buffer is aligned to a u64. This is necessary for storing the // refcount, as well as required by Cap'n Proto. This requirement is // the primary reason that the raw allocation APIs are used instead // of something like RawVec. let bytes = match Heap.alloc(Layout::from_size_align(len, refcount_len).unwrap()) { Result::Ok(val) => val, Result::Err(err) => Heap.oom(err), }; *(bytes as *mut u64) = 1; RawBuf { bytes: bytes.offset(refcount_len as isize), len: len - refcount_len, } } } fn buf(&self) -> *mut u8 { self.bytes } fn len(&self) -> usize { self.len } } impl Clone for RawBuf { fn clone(&self) -> RawBuf { unsafe { *(self.bytes.offset(-(mem::size_of::<u64>() as isize)) as *mut u64) += 1; RawBuf { bytes: self.bytes, len: self.len, } } } } impl Drop for RawBuf { fn drop(&mut self) { unsafe { let refcount_len = mem::size_of::<u64>(); let allocation = self.bytes.offset(-(refcount_len as isize)); let refcount = allocation as *mut u64; *refcount -= 1; if *refcount == 0 { Heap.dealloc(allocation, Layout::from_size_align(self.len + refcount_len, refcount_len).unwrap()); } } } } #[cfg(test)] mod test { use std::io::{Cursor, Write}; use super::{MutBuf, RawBuf}; use quickcheck::{quickcheck, TestResult}; #[test] fn test_create_raw_buf() { let raw = RawBuf::new(128 * 1024); assert_eq!(128 * 1024 - 8, raw.len()); } #[test] fn raw_buf_is_cloneable() { let raw = RawBuf::new(0); let clone = raw.clone(); assert_eq!(0, clone.len()); } #[test] fn mut_buf_write() { let mut buf = MutBuf::with_capacity(16); assert_eq!(8, buf.write(b"abcdefghijk").unwrap()); assert_eq!(0, buf.write(b"abcdefghijk").unwrap()); } #[test] fn buf() { let mut buf = MutBuf::with_capacity(16); buf.write_all(b"abcdefgh").unwrap(); assert_eq!(b"", &*buf.buf(0, 0)); assert_eq!(b"a", &*buf.buf(0, 1)); assert_eq!(b"ab", &*buf.buf(0, 2)); assert_eq!(b"abc", &*buf.buf(0, 3)); assert_eq!(b"abcd", &*buf.buf(0, 4)); assert_eq!(b"abcde", &*buf.buf(0, 5)); assert_eq!(b"abcdef", &*buf.buf(0, 6)); assert_eq!(b"abcdefg", &*buf.buf(0, 7)); assert_eq!(b"abcdefgh", &*buf.buf(0, 8)); } #[test] fn fill_or_replace() { let mut buf = MutBuf::with_capacity(14); buf.write_all(b"abcdef").unwrap(); let mut offset = 3; buf.fill_or_replace(&mut Cursor::new("ghi"), &mut offset, 6).unwrap(); assert_eq!(b"defghi", &*buf.buf(offset, 6)); } #[test] fn check_buf()
quickcheck(buf as fn(Vec<Vec<u8>>) -> TestResult); } #[test] fn check_fill() { fn fill(segments: Vec<Vec<u8>>) -> TestResult { let total_len: usize = segments.iter().fold(0, |acc, segment| acc + segment.len()); let mut buf = MutBuf::with_capacity(total_len + 8); for segment in &segments { buf.fill(&mut Cursor::new(segment), segment.len()).unwrap(); } let mut offset = 0; for segment in &segments { if &segment[..]!= &*buf.buf(offset, segment.len()) { return TestResult::failed(); } assert_eq!(&segment[..], &*buf.buf(offset, segment.len())); offset += segment.len(); } TestResult::passed() } quickcheck(fill as fn(Vec<Vec<u8>>) -> TestResult); } #[test] fn check_fill_or_replace() { fn fill(a: Vec<u8>, b: Vec<u8>, c: Vec<u8>) -> TestResult { let mut buf = MutBuf::with_capacity(8 + a.len() + b.len()); buf.write_all(&a).unwrap(); buf.write_all(&b).unwrap(); let mut offset = a.len(); buf.fill_or_replace(&mut Cursor::new(&c), &mut offset, b.len() + c.len()).unwrap(); if &b[..]!= &*buf.buf(offset, b.len()) { return TestResult::failed(); } if &c[..]!= &*buf.buf(offset + b.len(), c.len()) { return TestResult::failed(); } TestResult::passed() } quickcheck(fill as fn(Vec<u8>, Vec<u8>, Vec<u8>) -> TestResult); } }
{ fn buf(segments: Vec<Vec<u8>>) -> TestResult { let total_len: usize = segments.iter().fold(0, |acc, segment| acc + segment.len()); let mut buf = MutBuf::with_capacity(total_len + 8); for segment in &segments { buf.write_all(&*segment).unwrap(); } let mut offset = 0; for segment in &segments { if &segment[..] != &*buf.buf(offset, segment.len()) { return TestResult::failed(); } assert_eq!(&segment[..], &*buf.buf(offset, segment.len())); offset += segment.len(); } TestResult::passed() }
identifier_body
buf.rs
use alloc::heap::{Heap, Alloc, Layout}; use std::{cmp, io, mem, ops, ptr, slice}; use std::io::Write; /// Default buffer size. Perhaps this should be tunable. const BUF_SIZE: usize = 4096; /// A reference counted slab allocator. /// /// `MutBuf` keeps an internal byte buffer to which it allows bytes to be /// written. The buffer is fixed size, and append only. The bytes may be shared /// as owned `Buf` instances. /// /// The reference counting mechanism of `MutBuf` is not threadsafe, so instances /// may not be shared or sent across thread boundaries. pub struct MutBuf { raw: RawBuf, offset: usize, } impl io::Write for MutBuf { fn write(&mut self, buf: &[u8]) -> io::Result<usize> { unsafe { let count = cmp::min(buf.len(), self.raw.len() - self.offset); ptr::copy_nonoverlapping(buf.as_ptr(), self.raw.buf().offset(self.offset as isize), count); self.offset += count; Ok(count) } } fn flush(&mut self) -> io::Result<()> { Ok(()) } } impl MutBuf { pub fn new() -> MutBuf { MutBuf::with_capacity(BUF_SIZE) } pub fn with_capacity(cap: usize) -> MutBuf { MutBuf { raw: RawBuf::new(cap), offset: 0, } } pub fn
(&self, offset: usize, len: usize) -> Buf { unsafe { assert!(offset + len <= self.offset); Buf { raw: self.raw.clone(), ptr: self.raw.buf().offset(offset as isize), len: len, } } } /// Attempts to fill the buffer with at least `amount` bytes from `read`. /// The remaining capacity of the buffer must exceed `amount`. fn fill<R>(&mut self, read: &mut R, amount: usize) -> io::Result<()> where R: io::Read { unsafe { let remaining_capacity = self.raw.len() - self.offset; assert!(remaining_capacity >= amount); let mut buf = slice::from_raw_parts_mut(self.raw.buf().offset(self.offset as isize), remaining_capacity); let target_offset = self.offset + amount; while self.offset < target_offset { match try!(read.read(&mut buf)) { 0 => return Result::Err(io::Error::new(io::ErrorKind::UnexpectedEof, "failed to fill whole buffer")), n => { self.offset += n; let tmp = buf; buf = &mut tmp[n..]; }, } } } Ok(()) } /// Attemps to fill the buffer with at least `amount` bytes after the offset /// `from`. /// /// If the buffer does not have enough capacity it is replaced with a new /// one, and `from` is reset to the corresponding offset in the new buffer. pub fn fill_or_replace<R>(&mut self, read: &mut R, from: &mut usize, amount: usize) -> io::Result<()> where R: io::Read { assert!(*from <= self.offset); let buffered_amount = self.offset - *from; if buffered_amount >= amount { return Ok(()); } let remaining_amount = amount - buffered_amount; if remaining_amount > self.raw.len() - self.offset { // Replace self with a new buffer with sufficient capacity. Copy // over all bytes between `from` and the current write offset, and // reset `from` to 0. let old_buf = mem::replace(self, MutBuf::with_capacity(cmp::max(BUF_SIZE, amount + 8))); try!(self.write(&old_buf[*from..])); *from = 0; } self.fill(read, remaining_amount) } } impl ops::Deref for MutBuf { type Target = [u8]; fn deref(&self) -> &[u8] { unsafe { slice::from_raw_parts(self.raw.buf(), self.offset) } } } /// A view into a `MutBuf`. /// /// A `Buf` increments the reference count of the `MutBuf`, so that a `Buf` can /// outlive the `MutBuf` from which it was created. /// /// The reference counting mechanism of `MutBuf` is not threadsafe, so `Buf` /// instances may not be shared or sent across thread boundaries. pub struct Buf { raw: RawBuf, ptr: *const u8, len: usize, } impl ops::Deref for Buf { type Target = [u8]; fn deref(&self) -> &[u8] { unsafe { slice::from_raw_parts(self.ptr, self.len) } } } impl Clone for Buf { fn clone(&self) -> Buf { Buf { raw: self.raw.clone(), ptr: self.ptr, len: self.len } } } /// A reference counted byte buffer. /// /// The reference count is the first 8 bytes of the buffer. /// The buffer is not initialized. /// /// It is left to the user to ensure that data races do not occur and /// unitialized data is not read. /// /// `RawBuf` is not threadsafe, and may not be sent or shared across thread /// boundaries. struct RawBuf { bytes: *mut u8, len: usize, } impl RawBuf { /// Creates a new `RawBuf` instance with approximately the provided /// length. fn new(len: usize) -> RawBuf { unsafe { let refcount_len = mem::size_of::<u64>(); let len = cmp::max(refcount_len, len); // The buffer is aligned to a u64. This is necessary for storing the // refcount, as well as required by Cap'n Proto. This requirement is // the primary reason that the raw allocation APIs are used instead // of something like RawVec. let bytes = match Heap.alloc(Layout::from_size_align(len, refcount_len).unwrap()) { Result::Ok(val) => val, Result::Err(err) => Heap.oom(err), }; *(bytes as *mut u64) = 1; RawBuf { bytes: bytes.offset(refcount_len as isize), len: len - refcount_len, } } } fn buf(&self) -> *mut u8 { self.bytes } fn len(&self) -> usize { self.len } } impl Clone for RawBuf { fn clone(&self) -> RawBuf { unsafe { *(self.bytes.offset(-(mem::size_of::<u64>() as isize)) as *mut u64) += 1; RawBuf { bytes: self.bytes, len: self.len, } } } } impl Drop for RawBuf { fn drop(&mut self) { unsafe { let refcount_len = mem::size_of::<u64>(); let allocation = self.bytes.offset(-(refcount_len as isize)); let refcount = allocation as *mut u64; *refcount -= 1; if *refcount == 0 { Heap.dealloc(allocation, Layout::from_size_align(self.len + refcount_len, refcount_len).unwrap()); } } } } #[cfg(test)] mod test { use std::io::{Cursor, Write}; use super::{MutBuf, RawBuf}; use quickcheck::{quickcheck, TestResult}; #[test] fn test_create_raw_buf() { let raw = RawBuf::new(128 * 1024); assert_eq!(128 * 1024 - 8, raw.len()); } #[test] fn raw_buf_is_cloneable() { let raw = RawBuf::new(0); let clone = raw.clone(); assert_eq!(0, clone.len()); } #[test] fn mut_buf_write() { let mut buf = MutBuf::with_capacity(16); assert_eq!(8, buf.write(b"abcdefghijk").unwrap()); assert_eq!(0, buf.write(b"abcdefghijk").unwrap()); } #[test] fn buf() { let mut buf = MutBuf::with_capacity(16); buf.write_all(b"abcdefgh").unwrap(); assert_eq!(b"", &*buf.buf(0, 0)); assert_eq!(b"a", &*buf.buf(0, 1)); assert_eq!(b"ab", &*buf.buf(0, 2)); assert_eq!(b"abc", &*buf.buf(0, 3)); assert_eq!(b"abcd", &*buf.buf(0, 4)); assert_eq!(b"abcde", &*buf.buf(0, 5)); assert_eq!(b"abcdef", &*buf.buf(0, 6)); assert_eq!(b"abcdefg", &*buf.buf(0, 7)); assert_eq!(b"abcdefgh", &*buf.buf(0, 8)); } #[test] fn fill_or_replace() { let mut buf = MutBuf::with_capacity(14); buf.write_all(b"abcdef").unwrap(); let mut offset = 3; buf.fill_or_replace(&mut Cursor::new("ghi"), &mut offset, 6).unwrap(); assert_eq!(b"defghi", &*buf.buf(offset, 6)); } #[test] fn check_buf() { fn buf(segments: Vec<Vec<u8>>) -> TestResult { let total_len: usize = segments.iter().fold(0, |acc, segment| acc + segment.len()); let mut buf = MutBuf::with_capacity(total_len + 8); for segment in &segments { buf.write_all(&*segment).unwrap(); } let mut offset = 0; for segment in &segments { if &segment[..]!= &*buf.buf(offset, segment.len()) { return TestResult::failed(); } assert_eq!(&segment[..], &*buf.buf(offset, segment.len())); offset += segment.len(); } TestResult::passed() } quickcheck(buf as fn(Vec<Vec<u8>>) -> TestResult); } #[test] fn check_fill() { fn fill(segments: Vec<Vec<u8>>) -> TestResult { let total_len: usize = segments.iter().fold(0, |acc, segment| acc + segment.len()); let mut buf = MutBuf::with_capacity(total_len + 8); for segment in &segments { buf.fill(&mut Cursor::new(segment), segment.len()).unwrap(); } let mut offset = 0; for segment in &segments { if &segment[..]!= &*buf.buf(offset, segment.len()) { return TestResult::failed(); } assert_eq!(&segment[..], &*buf.buf(offset, segment.len())); offset += segment.len(); } TestResult::passed() } quickcheck(fill as fn(Vec<Vec<u8>>) -> TestResult); } #[test] fn check_fill_or_replace() { fn fill(a: Vec<u8>, b: Vec<u8>, c: Vec<u8>) -> TestResult { let mut buf = MutBuf::with_capacity(8 + a.len() + b.len()); buf.write_all(&a).unwrap(); buf.write_all(&b).unwrap(); let mut offset = a.len(); buf.fill_or_replace(&mut Cursor::new(&c), &mut offset, b.len() + c.len()).unwrap(); if &b[..]!= &*buf.buf(offset, b.len()) { return TestResult::failed(); } if &c[..]!= &*buf.buf(offset + b.len(), c.len()) { return TestResult::failed(); } TestResult::passed() } quickcheck(fill as fn(Vec<u8>, Vec<u8>, Vec<u8>) -> TestResult); } }
buf
identifier_name
offlineaudiocompletionevent.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ use crate::dom::audiobuffer::AudioBuffer; use crate::dom::bindings::codegen::Bindings::EventBinding::EventMethods; use crate::dom::bindings::codegen::Bindings::OfflineAudioCompletionEventBinding; use crate::dom::bindings::codegen::Bindings::OfflineAudioCompletionEventBinding::OfflineAudioCompletionEventInit; use crate::dom::bindings::codegen::Bindings::OfflineAudioCompletionEventBinding::OfflineAudioCompletionEventMethods; use crate::dom::bindings::error::Fallible; use crate::dom::bindings::inheritance::Castable; use crate::dom::bindings::reflector::reflect_dom_object; use crate::dom::bindings::root::{Dom, DomRoot}; use crate::dom::bindings::str::DOMString; use crate::dom::event::{Event, EventBubbles, EventCancelable}; use crate::dom::window::Window; use dom_struct::dom_struct; use servo_atoms::Atom; #[dom_struct] pub struct OfflineAudioCompletionEvent { event: Event, rendered_buffer: Dom<AudioBuffer>, } impl OfflineAudioCompletionEvent { pub fn new_inherited(rendered_buffer: &AudioBuffer) -> OfflineAudioCompletionEvent { OfflineAudioCompletionEvent { event: Event::new_inherited(), rendered_buffer: Dom::from_ref(rendered_buffer), } } pub fn new( window: &Window, type_: Atom, bubbles: EventBubbles, cancelable: EventCancelable, rendered_buffer: &AudioBuffer, ) -> DomRoot<OfflineAudioCompletionEvent>
#[allow(non_snake_case)] pub fn Constructor( window: &Window, type_: DOMString, init: &OfflineAudioCompletionEventInit, ) -> Fallible<DomRoot<OfflineAudioCompletionEvent>> { let bubbles = EventBubbles::from(init.parent.bubbles); let cancelable = EventCancelable::from(init.parent.cancelable); Ok(OfflineAudioCompletionEvent::new( window, Atom::from(type_), bubbles, cancelable, &init.renderedBuffer, )) } } impl OfflineAudioCompletionEventMethods for OfflineAudioCompletionEvent { // https://webaudio.github.io/web-audio-api/#dom-offlineaudiocompletionevent-renderedbuffer fn RenderedBuffer(&self) -> DomRoot<AudioBuffer> { DomRoot::from_ref(&*self.rendered_buffer) } // https://dom.spec.whatwg.org/#dom-event-istrusted fn IsTrusted(&self) -> bool { self.event.IsTrusted() } }
{ let event = Box::new(OfflineAudioCompletionEvent::new_inherited(rendered_buffer)); let ev = reflect_dom_object(event, window, OfflineAudioCompletionEventBinding::Wrap); { let event = ev.upcast::<Event>(); event.init_event(type_, bool::from(bubbles), bool::from(cancelable)); } ev }
identifier_body
offlineaudiocompletionevent.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ use crate::dom::audiobuffer::AudioBuffer; use crate::dom::bindings::codegen::Bindings::EventBinding::EventMethods; use crate::dom::bindings::codegen::Bindings::OfflineAudioCompletionEventBinding; use crate::dom::bindings::codegen::Bindings::OfflineAudioCompletionEventBinding::OfflineAudioCompletionEventInit; use crate::dom::bindings::codegen::Bindings::OfflineAudioCompletionEventBinding::OfflineAudioCompletionEventMethods; use crate::dom::bindings::error::Fallible; use crate::dom::bindings::inheritance::Castable; use crate::dom::bindings::reflector::reflect_dom_object; use crate::dom::bindings::root::{Dom, DomRoot}; use crate::dom::bindings::str::DOMString; use crate::dom::event::{Event, EventBubbles, EventCancelable}; use crate::dom::window::Window; use dom_struct::dom_struct; use servo_atoms::Atom; #[dom_struct] pub struct OfflineAudioCompletionEvent { event: Event, rendered_buffer: Dom<AudioBuffer>, } impl OfflineAudioCompletionEvent { pub fn new_inherited(rendered_buffer: &AudioBuffer) -> OfflineAudioCompletionEvent { OfflineAudioCompletionEvent { event: Event::new_inherited(), rendered_buffer: Dom::from_ref(rendered_buffer), } } pub fn new( window: &Window, type_: Atom, bubbles: EventBubbles, cancelable: EventCancelable, rendered_buffer: &AudioBuffer, ) -> DomRoot<OfflineAudioCompletionEvent> { let event = Box::new(OfflineAudioCompletionEvent::new_inherited(rendered_buffer)); let ev = reflect_dom_object(event, window, OfflineAudioCompletionEventBinding::Wrap); { let event = ev.upcast::<Event>(); event.init_event(type_, bool::from(bubbles), bool::from(cancelable)); } ev } #[allow(non_snake_case)] pub fn Constructor( window: &Window, type_: DOMString, init: &OfflineAudioCompletionEventInit, ) -> Fallible<DomRoot<OfflineAudioCompletionEvent>> { let bubbles = EventBubbles::from(init.parent.bubbles); let cancelable = EventCancelable::from(init.parent.cancelable); Ok(OfflineAudioCompletionEvent::new( window, Atom::from(type_), bubbles, cancelable, &init.renderedBuffer, )) } } impl OfflineAudioCompletionEventMethods for OfflineAudioCompletionEvent { // https://webaudio.github.io/web-audio-api/#dom-offlineaudiocompletionevent-renderedbuffer fn
(&self) -> DomRoot<AudioBuffer> { DomRoot::from_ref(&*self.rendered_buffer) } // https://dom.spec.whatwg.org/#dom-event-istrusted fn IsTrusted(&self) -> bool { self.event.IsTrusted() } }
RenderedBuffer
identifier_name
offlineaudiocompletionevent.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ use crate::dom::audiobuffer::AudioBuffer; use crate::dom::bindings::codegen::Bindings::EventBinding::EventMethods; use crate::dom::bindings::codegen::Bindings::OfflineAudioCompletionEventBinding; use crate::dom::bindings::codegen::Bindings::OfflineAudioCompletionEventBinding::OfflineAudioCompletionEventInit; use crate::dom::bindings::codegen::Bindings::OfflineAudioCompletionEventBinding::OfflineAudioCompletionEventMethods; use crate::dom::bindings::error::Fallible; use crate::dom::bindings::inheritance::Castable; use crate::dom::bindings::reflector::reflect_dom_object; use crate::dom::bindings::root::{Dom, DomRoot}; use crate::dom::bindings::str::DOMString; use crate::dom::event::{Event, EventBubbles, EventCancelable}; use crate::dom::window::Window; use dom_struct::dom_struct; use servo_atoms::Atom; #[dom_struct] pub struct OfflineAudioCompletionEvent { event: Event, rendered_buffer: Dom<AudioBuffer>, } impl OfflineAudioCompletionEvent { pub fn new_inherited(rendered_buffer: &AudioBuffer) -> OfflineAudioCompletionEvent { OfflineAudioCompletionEvent { event: Event::new_inherited(), rendered_buffer: Dom::from_ref(rendered_buffer), } } pub fn new( window: &Window, type_: Atom, bubbles: EventBubbles, cancelable: EventCancelable, rendered_buffer: &AudioBuffer, ) -> DomRoot<OfflineAudioCompletionEvent> { let event = Box::new(OfflineAudioCompletionEvent::new_inherited(rendered_buffer)); let ev = reflect_dom_object(event, window, OfflineAudioCompletionEventBinding::Wrap); { let event = ev.upcast::<Event>(); event.init_event(type_, bool::from(bubbles), bool::from(cancelable)); } ev } #[allow(non_snake_case)] pub fn Constructor( window: &Window, type_: DOMString, init: &OfflineAudioCompletionEventInit, ) -> Fallible<DomRoot<OfflineAudioCompletionEvent>> { let bubbles = EventBubbles::from(init.parent.bubbles); let cancelable = EventCancelable::from(init.parent.cancelable); Ok(OfflineAudioCompletionEvent::new( window, Atom::from(type_), bubbles, cancelable, &init.renderedBuffer, )) } } impl OfflineAudioCompletionEventMethods for OfflineAudioCompletionEvent { // https://webaudio.github.io/web-audio-api/#dom-offlineaudiocompletionevent-renderedbuffer fn RenderedBuffer(&self) -> DomRoot<AudioBuffer> { DomRoot::from_ref(&*self.rendered_buffer) } // https://dom.spec.whatwg.org/#dom-event-istrusted fn IsTrusted(&self) -> bool { self.event.IsTrusted() }
}
random_line_split
once.rs
use core; use Poll; use stream; use stream::Stream; /// A stream which emits single element and then EOF. /// /// This stream will never block and is always ready. #[must_use = "streams do nothing unless polled"] pub struct Once<T, E>(stream::IterStream<core::iter::Once<Result<T, E>>>); /// Creates a stream of single element /// /// ```rust /// use futures::*; /// /// let mut stream = stream::once::<(), _>(Err(17)); /// assert_eq!(Err(17), stream.poll()); /// assert_eq!(Ok(Async::Ready(None)), stream.poll()); /// ``` pub fn
<T, E>(item: Result<T, E>) -> Once<T, E> { Once(stream::iter(core::iter::once(item))) } impl<T, E> Stream for Once<T, E> { type Item = T; type Error = E; fn poll(&mut self) -> Poll<Option<T>, E> { self.0.poll() } }
once
identifier_name
once.rs
use core; use Poll; use stream; use stream::Stream; /// A stream which emits single element and then EOF. /// /// This stream will never block and is always ready. #[must_use = "streams do nothing unless polled"] pub struct Once<T, E>(stream::IterStream<core::iter::Once<Result<T, E>>>); /// Creates a stream of single element /// /// ```rust /// use futures::*; /// /// let mut stream = stream::once::<(), _>(Err(17)); /// assert_eq!(Err(17), stream.poll()); /// assert_eq!(Ok(Async::Ready(None)), stream.poll()); /// ``` pub fn once<T, E>(item: Result<T, E>) -> Once<T, E> { Once(stream::iter(core::iter::once(item))) } impl<T, E> Stream for Once<T, E> { type Item = T;
fn poll(&mut self) -> Poll<Option<T>, E> { self.0.poll() } }
type Error = E;
random_line_split
must_use-in-stdlib-traits.rs
#![deny(unused_must_use)] #![feature(futures_api, pin, arbitrary_self_types)] use std::iter::Iterator; use std::future::Future; use std::task::{Poll, LocalWaker}; use std::pin::Pin; use std::unimplemented; struct MyFuture; impl Future for MyFuture { type Output = u32; fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<u32> { Poll::Pending } } fn iterator() -> impl Iterator { std::iter::empty::<u32>() } fn future() -> impl Future { MyFuture } fn square_fn_once() -> impl FnOnce(u32) -> u32 { |x| x * x } fn square_fn_mut() -> impl FnMut(u32) -> u32 { |x| x * x } fn square_fn() -> impl Fn(u32) -> u32 { |x| x * x } fn
() { iterator(); //~ ERROR unused implementer of `std::iter::Iterator` that must be used future(); //~ ERROR unused implementer of `std::future::Future` that must be used square_fn_once(); //~ ERROR unused implementer of `std::ops::FnOnce` that must be used square_fn_mut(); //~ ERROR unused implementer of `std::ops::FnMut` that must be used square_fn(); //~ ERROR unused implementer of `std::ops::Fn` that must be used }
main
identifier_name
must_use-in-stdlib-traits.rs
#![deny(unused_must_use)] #![feature(futures_api, pin, arbitrary_self_types)] use std::iter::Iterator; use std::future::Future; use std::task::{Poll, LocalWaker}; use std::pin::Pin; use std::unimplemented; struct MyFuture; impl Future for MyFuture { type Output = u32; fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<u32> { Poll::Pending } } fn iterator() -> impl Iterator { std::iter::empty::<u32>() } fn future() -> impl Future {
fn square_fn_once() -> impl FnOnce(u32) -> u32 { |x| x * x } fn square_fn_mut() -> impl FnMut(u32) -> u32 { |x| x * x } fn square_fn() -> impl Fn(u32) -> u32 { |x| x * x } fn main() { iterator(); //~ ERROR unused implementer of `std::iter::Iterator` that must be used future(); //~ ERROR unused implementer of `std::future::Future` that must be used square_fn_once(); //~ ERROR unused implementer of `std::ops::FnOnce` that must be used square_fn_mut(); //~ ERROR unused implementer of `std::ops::FnMut` that must be used square_fn(); //~ ERROR unused implementer of `std::ops::Fn` that must be used }
MyFuture }
random_line_split
must_use-in-stdlib-traits.rs
#![deny(unused_must_use)] #![feature(futures_api, pin, arbitrary_self_types)] use std::iter::Iterator; use std::future::Future; use std::task::{Poll, LocalWaker}; use std::pin::Pin; use std::unimplemented; struct MyFuture; impl Future for MyFuture { type Output = u32; fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<u32> { Poll::Pending } } fn iterator() -> impl Iterator
fn future() -> impl Future { MyFuture } fn square_fn_once() -> impl FnOnce(u32) -> u32 { |x| x * x } fn square_fn_mut() -> impl FnMut(u32) -> u32 { |x| x * x } fn square_fn() -> impl Fn(u32) -> u32 { |x| x * x } fn main() { iterator(); //~ ERROR unused implementer of `std::iter::Iterator` that must be used future(); //~ ERROR unused implementer of `std::future::Future` that must be used square_fn_once(); //~ ERROR unused implementer of `std::ops::FnOnce` that must be used square_fn_mut(); //~ ERROR unused implementer of `std::ops::FnMut` that must be used square_fn(); //~ ERROR unused implementer of `std::ops::Fn` that must be used }
{ std::iter::empty::<u32>() }
identifier_body
install.rs
use crate::paths; use std::env::consts::EXE_SUFFIX; use std::path::{Path, PathBuf}; /// Used by `cargo install` tests to assert an executable binary /// has been installed. Example usage: /// /// assert_has_installed_exe(cargo_home(), "foo"); pub fn assert_has_installed_exe<P: AsRef<Path>>(path: P, name: &'static str) { assert!(check_has_installed_exe(path, name)); } pub fn assert_has_not_installed_exe<P: AsRef<Path>>(path: P, name: &'static str) { assert!(!check_has_installed_exe(path, name)); } fn check_has_installed_exe<P: AsRef<Path>>(path: P, name: &'static str) -> bool { path.as_ref().join("bin").join(exe(name)).is_file() } pub fn cargo_home() -> PathBuf { paths::home().join(".cargo") } pub fn
(name: &str) -> String { format!("{}{}", name, EXE_SUFFIX) }
exe
identifier_name
install.rs
use crate::paths; use std::env::consts::EXE_SUFFIX; use std::path::{Path, PathBuf}; /// Used by `cargo install` tests to assert an executable binary /// has been installed. Example usage: /// /// assert_has_installed_exe(cargo_home(), "foo"); pub fn assert_has_installed_exe<P: AsRef<Path>>(path: P, name: &'static str)
pub fn assert_has_not_installed_exe<P: AsRef<Path>>(path: P, name: &'static str) { assert!(!check_has_installed_exe(path, name)); } fn check_has_installed_exe<P: AsRef<Path>>(path: P, name: &'static str) -> bool { path.as_ref().join("bin").join(exe(name)).is_file() } pub fn cargo_home() -> PathBuf { paths::home().join(".cargo") } pub fn exe(name: &str) -> String { format!("{}{}", name, EXE_SUFFIX) }
{ assert!(check_has_installed_exe(path, name)); }
identifier_body
install.rs
use crate::paths; use std::env::consts::EXE_SUFFIX; use std::path::{Path, PathBuf};
/// assert_has_installed_exe(cargo_home(), "foo"); pub fn assert_has_installed_exe<P: AsRef<Path>>(path: P, name: &'static str) { assert!(check_has_installed_exe(path, name)); } pub fn assert_has_not_installed_exe<P: AsRef<Path>>(path: P, name: &'static str) { assert!(!check_has_installed_exe(path, name)); } fn check_has_installed_exe<P: AsRef<Path>>(path: P, name: &'static str) -> bool { path.as_ref().join("bin").join(exe(name)).is_file() } pub fn cargo_home() -> PathBuf { paths::home().join(".cargo") } pub fn exe(name: &str) -> String { format!("{}{}", name, EXE_SUFFIX) }
/// Used by `cargo install` tests to assert an executable binary /// has been installed. Example usage: ///
random_line_split
config_env.rs
use envconfig::Envconfig; use crate::domain::key_derivation::KeyDerivationFunction; lazy_static! { static ref APP_ENV_CONFIG: AppEnvConfig = AppEnvConfig::init().unwrap(); } pub fn get_app_env_config() -> &'static AppEnvConfig { return &APP_ENV_CONFIG } #[derive(Envconfig, Debug)] pub struct AppEnvConfig { #[envconfig(from = "NEW_AGENT_KDF", default = "RAW")] pub new_agent_kdf: KeyDerivationFunction, #[envconfig(from = "RESTORE_ON_DEMAND", default = "false")] pub restore_on_demand: bool, } #[cfg(test)] mod tests { use super::*; use std::env; #[test] fn should_construct_app_env_config_with_correct_kdf()
}
{ env::remove_var("NEW_AGENT_KDF"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Raw, "Default new_agent_kdf should be Raw"); env::set_var("NEW_AGENT_KDF", "RAW"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Raw, "Expected new_agent_kdf to be Raw."); env::set_var("NEW_AGENT_KDF", "ARGON2I_INT"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Argon2iInt, "Expected new_agent_kdf to be Argon2iInt."); env::set_var("NEW_AGENT_KDF", "ARGON2I_MOD"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Argon2iMod, "Expected new_agent_kdf to be Argon2iMod."); env::set_var("NEW_AGENT_KDF", "FOOBAR"); assert!(AppEnvConfig::init().is_err()) }
identifier_body
config_env.rs
use envconfig::Envconfig; use crate::domain::key_derivation::KeyDerivationFunction; lazy_static! { static ref APP_ENV_CONFIG: AppEnvConfig = AppEnvConfig::init().unwrap(); } pub fn get_app_env_config() -> &'static AppEnvConfig { return &APP_ENV_CONFIG } #[derive(Envconfig, Debug)] pub struct
{ #[envconfig(from = "NEW_AGENT_KDF", default = "RAW")] pub new_agent_kdf: KeyDerivationFunction, #[envconfig(from = "RESTORE_ON_DEMAND", default = "false")] pub restore_on_demand: bool, } #[cfg(test)] mod tests { use super::*; use std::env; #[test] fn should_construct_app_env_config_with_correct_kdf() { env::remove_var("NEW_AGENT_KDF"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Raw, "Default new_agent_kdf should be Raw"); env::set_var("NEW_AGENT_KDF", "RAW"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Raw, "Expected new_agent_kdf to be Raw."); env::set_var("NEW_AGENT_KDF", "ARGON2I_INT"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Argon2iInt, "Expected new_agent_kdf to be Argon2iInt."); env::set_var("NEW_AGENT_KDF", "ARGON2I_MOD"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Argon2iMod, "Expected new_agent_kdf to be Argon2iMod."); env::set_var("NEW_AGENT_KDF", "FOOBAR"); assert!(AppEnvConfig::init().is_err()) } }
AppEnvConfig
identifier_name
config_env.rs
use envconfig::Envconfig; use crate::domain::key_derivation::KeyDerivationFunction; lazy_static! { static ref APP_ENV_CONFIG: AppEnvConfig = AppEnvConfig::init().unwrap(); } pub fn get_app_env_config() -> &'static AppEnvConfig { return &APP_ENV_CONFIG } #[derive(Envconfig, Debug)] pub struct AppEnvConfig { #[envconfig(from = "NEW_AGENT_KDF", default = "RAW")] pub new_agent_kdf: KeyDerivationFunction, #[envconfig(from = "RESTORE_ON_DEMAND", default = "false")] pub restore_on_demand: bool, } #[cfg(test)] mod tests { use super::*; use std::env; #[test]
env::set_var("NEW_AGENT_KDF", "RAW"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Raw, "Expected new_agent_kdf to be Raw."); env::set_var("NEW_AGENT_KDF", "ARGON2I_INT"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Argon2iInt, "Expected new_agent_kdf to be Argon2iInt."); env::set_var("NEW_AGENT_KDF", "ARGON2I_MOD"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Argon2iMod, "Expected new_agent_kdf to be Argon2iMod."); env::set_var("NEW_AGENT_KDF", "FOOBAR"); assert!(AppEnvConfig::init().is_err()) } }
fn should_construct_app_env_config_with_correct_kdf() { env::remove_var("NEW_AGENT_KDF"); let app_config = AppEnvConfig::init().unwrap(); assert_eq!(app_config.new_agent_kdf, KeyDerivationFunction::Raw, "Default new_agent_kdf should be Raw");
random_line_split
tx_processor.rs
// Copyright 2018 Mozilla // // Licensed under the Apache License, Version 2.0 (the "License"); you may not use // this file except in compliance with the License. You may obtain a copy of the // License at http://www.apache.org/licenses/LICENSE-2.0 // Unless required by applicable law or agreed to in writing, software distributed // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR // CONDITIONS OF ANY KIND, either express or implied. See the License for the // specific language governing permissions and limitations under the License. use std::iter::Peekable; use rusqlite; use mentat_db::{ TypedSQLValue, }; use core_traits::{ Entid, TypedValue, }; use public_traits::errors::{ Result, }; use types::{ TxPart, }; /// Implementors must specify type of the "receiver report" which /// they will produce once processor is finished. pub trait TxReceiver<RR> { /// Called for each transaction, with an iterator over its datoms. fn tx<T: Iterator<Item=TxPart>>(&mut self, tx_id: Entid, d: &mut T) -> Result<()>; /// Called once processor is finished, consuming this receiver and producing a report. fn done(self) -> RR; } pub struct
{} pub struct DatomsIterator<'dbtx, 't, T> where T: Sized + Iterator<Item=Result<TxPart>> + 't { at_first: bool, at_last: bool, first: &'dbtx TxPart, rows: &'t mut Peekable<T>, } impl<'dbtx, 't, T> DatomsIterator<'dbtx, 't, T> where T: Sized + Iterator<Item=Result<TxPart>> + 't { fn new(first: &'dbtx TxPart, rows: &'t mut Peekable<T>) -> DatomsIterator<'dbtx, 't, T> { DatomsIterator { at_first: true, at_last: false, first: first, rows: rows, } } } impl<'dbtx, 't, T> Iterator for DatomsIterator<'dbtx, 't, T> where T: Sized + Iterator<Item=Result<TxPart>> + 't { type Item = TxPart; fn next(&mut self) -> Option<Self::Item> { if self.at_last { return None; } if self.at_first { self.at_first = false; return Some(self.first.clone()); } // Look ahead to see if we're about to cross into // the next partition. { let next_option = self.rows.peek(); match next_option { Some(&Ok(ref next)) => { if next.tx!= self.first.tx { self.at_last = true; return None; } }, // Empty, or error. Either way, this iterator's done. _ => { self.at_last = true; return None; } } } // We're in the correct partition, return a TxPart. if let Some(result) = self.rows.next() { match result { Err(_) => None, Ok(datom) => { Some(TxPart { partitions: None, e: datom.e, a: datom.a, v: datom.v.clone(), tx: datom.tx, added: datom.added, }) }, } } else { self.at_last = true; None } } } fn to_tx_part(row: &rusqlite::Row) -> Result<TxPart> { Ok(TxPart { partitions: None, e: row.get_checked(0)?, a: row.get_checked(1)?, v: TypedValue::from_sql_value_pair(row.get_checked(2)?, row.get_checked(3)?)?, tx: row.get_checked(4)?, added: row.get_checked(5)?, }) } impl Processor { pub fn process<RR, R: TxReceiver<RR>> (sqlite: &rusqlite::Transaction, from_tx: Option<Entid>, mut receiver: R) -> Result<RR> { let tx_filter = match from_tx { Some(tx) => format!(" WHERE timeline = 0 AND tx > {} ", tx), None => format!("WHERE timeline = 0") }; let select_query = format!("SELECT e, a, v, value_type_tag, tx, added FROM timelined_transactions {} ORDER BY tx", tx_filter); let mut stmt = sqlite.prepare(&select_query)?; let mut rows = stmt.query_and_then(&[], to_tx_part)?.peekable(); // Walk the transaction table, keeping track of the current "tx". // Whenever "tx" changes, construct a datoms iterator and pass it to the receiver. // NB: this logic depends on data coming out of the rows iterator to be sorted by "tx". let mut current_tx = None; while let Some(row) = rows.next() { let datom = row?; match current_tx { Some(tx) => { if tx!= datom.tx { current_tx = Some(datom.tx); receiver.tx( datom.tx, &mut DatomsIterator::new(&datom, &mut rows) )?; } }, None => { current_tx = Some(datom.tx); receiver.tx( datom.tx, &mut DatomsIterator::new(&datom, &mut rows) )?; } } } // Consume the receiver, letting it produce a "receiver report" // as defined by generic type RR. Ok(receiver.done()) } }
Processor
identifier_name
tx_processor.rs
// Copyright 2018 Mozilla // // Licensed under the Apache License, Version 2.0 (the "License"); you may not use // this file except in compliance with the License. You may obtain a copy of the // License at http://www.apache.org/licenses/LICENSE-2.0 // Unless required by applicable law or agreed to in writing, software distributed // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR // CONDITIONS OF ANY KIND, either express or implied. See the License for the // specific language governing permissions and limitations under the License. use std::iter::Peekable; use rusqlite; use mentat_db::{ TypedSQLValue, }; use core_traits::{ Entid, TypedValue, }; use public_traits::errors::{ Result, }; use types::{
/// Implementors must specify type of the "receiver report" which /// they will produce once processor is finished. pub trait TxReceiver<RR> { /// Called for each transaction, with an iterator over its datoms. fn tx<T: Iterator<Item=TxPart>>(&mut self, tx_id: Entid, d: &mut T) -> Result<()>; /// Called once processor is finished, consuming this receiver and producing a report. fn done(self) -> RR; } pub struct Processor {} pub struct DatomsIterator<'dbtx, 't, T> where T: Sized + Iterator<Item=Result<TxPart>> + 't { at_first: bool, at_last: bool, first: &'dbtx TxPart, rows: &'t mut Peekable<T>, } impl<'dbtx, 't, T> DatomsIterator<'dbtx, 't, T> where T: Sized + Iterator<Item=Result<TxPart>> + 't { fn new(first: &'dbtx TxPart, rows: &'t mut Peekable<T>) -> DatomsIterator<'dbtx, 't, T> { DatomsIterator { at_first: true, at_last: false, first: first, rows: rows, } } } impl<'dbtx, 't, T> Iterator for DatomsIterator<'dbtx, 't, T> where T: Sized + Iterator<Item=Result<TxPart>> + 't { type Item = TxPart; fn next(&mut self) -> Option<Self::Item> { if self.at_last { return None; } if self.at_first { self.at_first = false; return Some(self.first.clone()); } // Look ahead to see if we're about to cross into // the next partition. { let next_option = self.rows.peek(); match next_option { Some(&Ok(ref next)) => { if next.tx!= self.first.tx { self.at_last = true; return None; } }, // Empty, or error. Either way, this iterator's done. _ => { self.at_last = true; return None; } } } // We're in the correct partition, return a TxPart. if let Some(result) = self.rows.next() { match result { Err(_) => None, Ok(datom) => { Some(TxPart { partitions: None, e: datom.e, a: datom.a, v: datom.v.clone(), tx: datom.tx, added: datom.added, }) }, } } else { self.at_last = true; None } } } fn to_tx_part(row: &rusqlite::Row) -> Result<TxPart> { Ok(TxPart { partitions: None, e: row.get_checked(0)?, a: row.get_checked(1)?, v: TypedValue::from_sql_value_pair(row.get_checked(2)?, row.get_checked(3)?)?, tx: row.get_checked(4)?, added: row.get_checked(5)?, }) } impl Processor { pub fn process<RR, R: TxReceiver<RR>> (sqlite: &rusqlite::Transaction, from_tx: Option<Entid>, mut receiver: R) -> Result<RR> { let tx_filter = match from_tx { Some(tx) => format!(" WHERE timeline = 0 AND tx > {} ", tx), None => format!("WHERE timeline = 0") }; let select_query = format!("SELECT e, a, v, value_type_tag, tx, added FROM timelined_transactions {} ORDER BY tx", tx_filter); let mut stmt = sqlite.prepare(&select_query)?; let mut rows = stmt.query_and_then(&[], to_tx_part)?.peekable(); // Walk the transaction table, keeping track of the current "tx". // Whenever "tx" changes, construct a datoms iterator and pass it to the receiver. // NB: this logic depends on data coming out of the rows iterator to be sorted by "tx". let mut current_tx = None; while let Some(row) = rows.next() { let datom = row?; match current_tx { Some(tx) => { if tx!= datom.tx { current_tx = Some(datom.tx); receiver.tx( datom.tx, &mut DatomsIterator::new(&datom, &mut rows) )?; } }, None => { current_tx = Some(datom.tx); receiver.tx( datom.tx, &mut DatomsIterator::new(&datom, &mut rows) )?; } } } // Consume the receiver, letting it produce a "receiver report" // as defined by generic type RR. Ok(receiver.done()) } }
TxPart, };
random_line_split
tx_processor.rs
// Copyright 2018 Mozilla // // Licensed under the Apache License, Version 2.0 (the "License"); you may not use // this file except in compliance with the License. You may obtain a copy of the // License at http://www.apache.org/licenses/LICENSE-2.0 // Unless required by applicable law or agreed to in writing, software distributed // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR // CONDITIONS OF ANY KIND, either express or implied. See the License for the // specific language governing permissions and limitations under the License. use std::iter::Peekable; use rusqlite; use mentat_db::{ TypedSQLValue, }; use core_traits::{ Entid, TypedValue, }; use public_traits::errors::{ Result, }; use types::{ TxPart, }; /// Implementors must specify type of the "receiver report" which /// they will produce once processor is finished. pub trait TxReceiver<RR> { /// Called for each transaction, with an iterator over its datoms. fn tx<T: Iterator<Item=TxPart>>(&mut self, tx_id: Entid, d: &mut T) -> Result<()>; /// Called once processor is finished, consuming this receiver and producing a report. fn done(self) -> RR; } pub struct Processor {} pub struct DatomsIterator<'dbtx, 't, T> where T: Sized + Iterator<Item=Result<TxPart>> + 't { at_first: bool, at_last: bool, first: &'dbtx TxPart, rows: &'t mut Peekable<T>, } impl<'dbtx, 't, T> DatomsIterator<'dbtx, 't, T> where T: Sized + Iterator<Item=Result<TxPart>> + 't { fn new(first: &'dbtx TxPart, rows: &'t mut Peekable<T>) -> DatomsIterator<'dbtx, 't, T>
} impl<'dbtx, 't, T> Iterator for DatomsIterator<'dbtx, 't, T> where T: Sized + Iterator<Item=Result<TxPart>> + 't { type Item = TxPart; fn next(&mut self) -> Option<Self::Item> { if self.at_last { return None; } if self.at_first { self.at_first = false; return Some(self.first.clone()); } // Look ahead to see if we're about to cross into // the next partition. { let next_option = self.rows.peek(); match next_option { Some(&Ok(ref next)) => { if next.tx!= self.first.tx { self.at_last = true; return None; } }, // Empty, or error. Either way, this iterator's done. _ => { self.at_last = true; return None; } } } // We're in the correct partition, return a TxPart. if let Some(result) = self.rows.next() { match result { Err(_) => None, Ok(datom) => { Some(TxPart { partitions: None, e: datom.e, a: datom.a, v: datom.v.clone(), tx: datom.tx, added: datom.added, }) }, } } else { self.at_last = true; None } } } fn to_tx_part(row: &rusqlite::Row) -> Result<TxPart> { Ok(TxPart { partitions: None, e: row.get_checked(0)?, a: row.get_checked(1)?, v: TypedValue::from_sql_value_pair(row.get_checked(2)?, row.get_checked(3)?)?, tx: row.get_checked(4)?, added: row.get_checked(5)?, }) } impl Processor { pub fn process<RR, R: TxReceiver<RR>> (sqlite: &rusqlite::Transaction, from_tx: Option<Entid>, mut receiver: R) -> Result<RR> { let tx_filter = match from_tx { Some(tx) => format!(" WHERE timeline = 0 AND tx > {} ", tx), None => format!("WHERE timeline = 0") }; let select_query = format!("SELECT e, a, v, value_type_tag, tx, added FROM timelined_transactions {} ORDER BY tx", tx_filter); let mut stmt = sqlite.prepare(&select_query)?; let mut rows = stmt.query_and_then(&[], to_tx_part)?.peekable(); // Walk the transaction table, keeping track of the current "tx". // Whenever "tx" changes, construct a datoms iterator and pass it to the receiver. // NB: this logic depends on data coming out of the rows iterator to be sorted by "tx". let mut current_tx = None; while let Some(row) = rows.next() { let datom = row?; match current_tx { Some(tx) => { if tx!= datom.tx { current_tx = Some(datom.tx); receiver.tx( datom.tx, &mut DatomsIterator::new(&datom, &mut rows) )?; } }, None => { current_tx = Some(datom.tx); receiver.tx( datom.tx, &mut DatomsIterator::new(&datom, &mut rows) )?; } } } // Consume the receiver, letting it produce a "receiver report" // as defined by generic type RR. Ok(receiver.done()) } }
{ DatomsIterator { at_first: true, at_last: false, first: first, rows: rows, } }
identifier_body
extern-crate-referenced-by-self-path.rs
// Copyright 2018 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // run-pass // aux-build:edition-lint-paths.rs // run-rustfix // Oddball: `edition_lint_paths` is accessed via this `self` path // rather than being accessed directly. Unless we rewrite that path, // we can't drop the extern crate. #![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] extern crate edition_lint_paths; use self::edition_lint_paths::foo; fn
() { foo(); }
main
identifier_name
extern-crate-referenced-by-self-path.rs
// Copyright 2018 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // run-pass // aux-build:edition-lint-paths.rs // run-rustfix // Oddball: `edition_lint_paths` is accessed via this `self` path // rather than being accessed directly. Unless we rewrite that path, // we can't drop the extern crate. #![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] extern crate edition_lint_paths; use self::edition_lint_paths::foo; fn main()
{ foo(); }
identifier_body
extern-crate-referenced-by-self-path.rs
// Copyright 2018 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // run-pass // aux-build:edition-lint-paths.rs // run-rustfix // Oddball: `edition_lint_paths` is accessed via this `self` path // rather than being accessed directly. Unless we rewrite that path, // we can't drop the extern crate. #![feature(rust_2018_preview)] #![deny(absolute_paths_not_starting_with_crate)] extern crate edition_lint_paths; use self::edition_lint_paths::foo; fn main() {
foo(); }
random_line_split
lib.rs
extern crate num; use num::traits::identities::Zero; use std::cmp::PartialOrd; pub struct Triangle<T: Zero + PartialOrd + Copy>([T; 3]); impl<T: Zero + PartialOrd + Copy> Triangle<T> { pub fn build(lengths: [T; 3]) -> Result<Triangle<T>, &'static str> { if lengths[0] <= T::zero() || lengths[1] <= T::zero() || lengths[2] <= T::zero() { Err("Zero sized sides are illegal") } else if!(lengths[0] + lengths[1] > lengths[2] && lengths[1] + lengths[2] > lengths[0] && lengths[2] + lengths[0] > lengths[1]) { Err("Triangle inequality does not hold") } else { Ok(Triangle(lengths)) } } pub fn is_equilateral(&self) -> bool { // all three sides equal self.0[0] == self.0[1] && self.0[1] == self.0[2] }
// two sides are equal, but not all three !self.is_equilateral() && (self.0[0] == self.0[1] || self.0[1] == self.0[2] || self.0[2] == self.0[0]) } pub fn is_scalene(&self) -> bool { // all sides differently, no two sides equal self.0[0]!= self.0[1] && self.0[1]!= self.0[2] && self.0[2]!= self.0[0] } }
pub fn is_isosceles(&self) -> bool {
random_line_split
lib.rs
extern crate num; use num::traits::identities::Zero; use std::cmp::PartialOrd; pub struct
<T: Zero + PartialOrd + Copy>([T; 3]); impl<T: Zero + PartialOrd + Copy> Triangle<T> { pub fn build(lengths: [T; 3]) -> Result<Triangle<T>, &'static str> { if lengths[0] <= T::zero() || lengths[1] <= T::zero() || lengths[2] <= T::zero() { Err("Zero sized sides are illegal") } else if!(lengths[0] + lengths[1] > lengths[2] && lengths[1] + lengths[2] > lengths[0] && lengths[2] + lengths[0] > lengths[1]) { Err("Triangle inequality does not hold") } else { Ok(Triangle(lengths)) } } pub fn is_equilateral(&self) -> bool { // all three sides equal self.0[0] == self.0[1] && self.0[1] == self.0[2] } pub fn is_isosceles(&self) -> bool { // two sides are equal, but not all three !self.is_equilateral() && (self.0[0] == self.0[1] || self.0[1] == self.0[2] || self.0[2] == self.0[0]) } pub fn is_scalene(&self) -> bool { // all sides differently, no two sides equal self.0[0]!= self.0[1] && self.0[1]!= self.0[2] && self.0[2]!= self.0[0] } }
Triangle
identifier_name
lib.rs
extern crate num; use num::traits::identities::Zero; use std::cmp::PartialOrd; pub struct Triangle<T: Zero + PartialOrd + Copy>([T; 3]); impl<T: Zero + PartialOrd + Copy> Triangle<T> { pub fn build(lengths: [T; 3]) -> Result<Triangle<T>, &'static str> { if lengths[0] <= T::zero() || lengths[1] <= T::zero() || lengths[2] <= T::zero()
else if!(lengths[0] + lengths[1] > lengths[2] && lengths[1] + lengths[2] > lengths[0] && lengths[2] + lengths[0] > lengths[1]) { Err("Triangle inequality does not hold") } else { Ok(Triangle(lengths)) } } pub fn is_equilateral(&self) -> bool { // all three sides equal self.0[0] == self.0[1] && self.0[1] == self.0[2] } pub fn is_isosceles(&self) -> bool { // two sides are equal, but not all three !self.is_equilateral() && (self.0[0] == self.0[1] || self.0[1] == self.0[2] || self.0[2] == self.0[0]) } pub fn is_scalene(&self) -> bool { // all sides differently, no two sides equal self.0[0]!= self.0[1] && self.0[1]!= self.0[2] && self.0[2]!= self.0[0] } }
{ Err("Zero sized sides are illegal") }
conditional_block
lib.rs
extern crate num; use num::traits::identities::Zero; use std::cmp::PartialOrd; pub struct Triangle<T: Zero + PartialOrd + Copy>([T; 3]); impl<T: Zero + PartialOrd + Copy> Triangle<T> { pub fn build(lengths: [T; 3]) -> Result<Triangle<T>, &'static str> { if lengths[0] <= T::zero() || lengths[1] <= T::zero() || lengths[2] <= T::zero() { Err("Zero sized sides are illegal") } else if!(lengths[0] + lengths[1] > lengths[2] && lengths[1] + lengths[2] > lengths[0] && lengths[2] + lengths[0] > lengths[1]) { Err("Triangle inequality does not hold") } else { Ok(Triangle(lengths)) } } pub fn is_equilateral(&self) -> bool { // all three sides equal self.0[0] == self.0[1] && self.0[1] == self.0[2] } pub fn is_isosceles(&self) -> bool
pub fn is_scalene(&self) -> bool { // all sides differently, no two sides equal self.0[0]!= self.0[1] && self.0[1]!= self.0[2] && self.0[2]!= self.0[0] } }
{ // two sides are equal, but not all three !self.is_equilateral() && (self.0[0] == self.0[1] || self.0[1] == self.0[2] || self.0[2] == self.0[0]) }
identifier_body
fnv.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ //! This file stolen wholesale from rustc/src/librustc/util/nodemap.rs use std::default::Default; use std::hash::{Hasher, Writer}; /// A speedy hash algorithm for node ids and def ids. The hashmap in /// libcollections by default uses SipHash which isn't quite as speedy as we /// want. In the compiler we're not really worried about DOS attempts, so we /// just default to a non-cryptographic hash. /// /// This uses FNV hashing, as described here: /// http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function #[allow(missing_copy_implementations)] pub struct FnvHasher(u64); impl Default for FnvHasher { fn
() -> FnvHasher { FnvHasher(0xcbf29ce484222325) } } impl Hasher for FnvHasher { type Output = u64; fn reset(&mut self) { *self = Default::default(); } fn finish(&self) -> u64 { self.0 } } impl Writer for FnvHasher { fn write(&mut self, bytes: &[u8]) { let FnvHasher(mut hash) = *self; for byte in bytes.iter() { hash = hash ^ (*byte as u64); hash = hash * 0x100000001b3; } *self = FnvHasher(hash); } }
default
identifier_name
fnv.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ //! This file stolen wholesale from rustc/src/librustc/util/nodemap.rs use std::default::Default; use std::hash::{Hasher, Writer}; /// A speedy hash algorithm for node ids and def ids. The hashmap in /// libcollections by default uses SipHash which isn't quite as speedy as we /// want. In the compiler we're not really worried about DOS attempts, so we /// just default to a non-cryptographic hash. /// /// This uses FNV hashing, as described here: /// http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function #[allow(missing_copy_implementations)] pub struct FnvHasher(u64); impl Default for FnvHasher { fn default() -> FnvHasher
} impl Hasher for FnvHasher { type Output = u64; fn reset(&mut self) { *self = Default::default(); } fn finish(&self) -> u64 { self.0 } } impl Writer for FnvHasher { fn write(&mut self, bytes: &[u8]) { let FnvHasher(mut hash) = *self; for byte in bytes.iter() { hash = hash ^ (*byte as u64); hash = hash * 0x100000001b3; } *self = FnvHasher(hash); } }
{ FnvHasher(0xcbf29ce484222325) }
identifier_body
fnv.rs
/* This Source Code Form is subject to the terms of the Mozilla Public
//! This file stolen wholesale from rustc/src/librustc/util/nodemap.rs use std::default::Default; use std::hash::{Hasher, Writer}; /// A speedy hash algorithm for node ids and def ids. The hashmap in /// libcollections by default uses SipHash which isn't quite as speedy as we /// want. In the compiler we're not really worried about DOS attempts, so we /// just default to a non-cryptographic hash. /// /// This uses FNV hashing, as described here: /// http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function #[allow(missing_copy_implementations)] pub struct FnvHasher(u64); impl Default for FnvHasher { fn default() -> FnvHasher { FnvHasher(0xcbf29ce484222325) } } impl Hasher for FnvHasher { type Output = u64; fn reset(&mut self) { *self = Default::default(); } fn finish(&self) -> u64 { self.0 } } impl Writer for FnvHasher { fn write(&mut self, bytes: &[u8]) { let FnvHasher(mut hash) = *self; for byte in bytes.iter() { hash = hash ^ (*byte as u64); hash = hash * 0x100000001b3; } *self = FnvHasher(hash); } }
* License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
random_line_split
lib.rs
/// Main library module for merging coverage files. use std::collections::BTreeSet; use std::env; use std::str; extern crate clap; extern crate chrono; #[macro_use] extern crate error_chain; /// This crate's error-related code, generated by `error-chain`. mod errors { // Create the Error, ErrorKind, ResultExt, and Result types error_chain! {} } pub use errors::*; extern crate shlex; #[macro_use] extern crate slog; use slog::Logger; extern crate rust_htslib; use rust_htslib::bcf; use rust_htslib::bcf::record::Numeric; extern crate lib_shared; use lib_shared::bcf_utils; mod options; pub use options::*; /// Obtain all field names of the given field type. fn
(header: &bcf::header::HeaderView, field_type: &str) -> BTreeSet<String> { let mut result: BTreeSet<String> = BTreeSet::new(); for record in header.header_records() { match record { bcf::HeaderRecord::Format { key: _, values } => match values.get("Type") { Some(this_type) => { if this_type == field_type { result.insert( values .get("ID") .expect("FILTER entry does not have an ID!") .clone(), ); } } _ => (), }, _ => (), } } result } /// Build BCF writer. fn build_writer( logger: &mut Logger, header: &bcf::header::HeaderView, samples: &Vec<&[u8]>, options: &MergeCovOptions, ) -> Result<bcf::Writer> { debug!(logger, "Opening output file..."); // Construct extended header. let mut header = bcf::Header::from_template_subset(header, &[]) .chain_err(|| "Problem constructing header from template and no samples")?; // TODO: version should come from one central place header.push_record(format!("##cnvetti_cmdMergeCovVersion={}", "0.1.0").as_bytes()); header.push_record( format!( "##cnvetti_cmdMergeCovCommand={}", env::args() .map(|s| shlex::quote(&s).to_string()) .collect::<Vec<String>>() .join(" ") ) .as_bytes(), ); for sample in samples { header.push_sample(&sample); } let uncompressed =!options.output.ends_with(".bcf") &&!options.output.ends_with(".vcf.gz"); let vcf = options.output.ends_with(".vcf") || options.output.ends_with(".vcf.gz"); Ok( bcf::Writer::from_path(&options.output, &header, uncompressed, vcf) .chain_err(|| format!("Could not open output BCF file {}", options.output))?, ) } /// Merge the coverage BCF files in `reader` to the writer. pub fn merge_files( format_string: &BTreeSet<String>, format_float: &BTreeSet<String>, reader: &mut bcf::synced::SyncedReader, writer: &mut bcf::Writer, ) -> Result<()> { while reader .read_next() .chain_err(|| "Problem reading from input BCF files")? != 0 { // TODO: also merge INFO values? // Locate first record; will copy INFO from there; FORMAT comes later. let mut first: Option<bcf::Record> = None; let num_samples = writer.header().sample_count(); for i in 0..num_samples { match (reader.has_line(i), &first) { (true, None) => { let mut record = reader.record(i).expect("Could not retrieve record"); writer.translate(&mut record); first = Some(record); // break; } _ => (), } } assert!(first.is_some()); let record = first.as_mut().unwrap(); // Push GT, always no-call for coverage records. let values = (0..(1 * num_samples)) .map(|_| bcf::GT_MISSING) .collect::<Vec<i32>>(); record .push_format_integer(b"GT", values.as_slice()) .chain_err(|| "Could not write FORMAT/GT")?; // Collect input FORMAT String fields and push to output FORMAT. for key in format_string { if key == "GT" { continue; // already handled above } let key_b = key.as_bytes(); let mut values_v: Vec<Vec<u8>> = Vec::new(); for i in 0..reader.reader_count() { if reader.has_line(i) { let mut rec_in = reader .record(i) .expect("We just checked that the record should be there!"); let mut tmp_v = rec_in .format(&key_b) .string() .unwrap_or_else(|_| Vec::new()) .iter() .map(|v| Vec::from(*v)) .collect::<Vec<Vec<u8>>>(); if tmp_v.iter().any(|ref x|!x.is_empty()) { values_v.append(&mut tmp_v); } } else { let num_samples = reader.header(i).sample_count(); for _j in 0..num_samples { values_v.push(b"".to_vec()); } } } let values: Vec<&[u8]> = values_v .iter() .map(|v| v.as_slice()) .collect::<Vec<&[u8]>>(); record .push_format_string(key_b, values.as_slice()) .chain_err(|| format!("Could not write FORMAT/{}", key))?; } // Collect input FORMAT Float fields and push to output FORMAT. for key in format_float { let key_b = key.as_bytes(); // First, get dimension of individual arrays. let dim = (0..reader.reader_count()) .filter(|i| reader.has_line(*i)) .map(|i| { reader .record(i) .expect("Could not get get record") .format(&key_b) .float() .unwrap_or_else(|_| Vec::new()) .len() }) .max() .expect("Could not compute maximum"); if dim == 0 { continue; } // Then, build the array. let mut values: Vec<f32> = Vec::new(); for i in 0..reader.reader_count() { if!reader.has_line(i) { let header = reader.header(i); let n = dim * header.sample_count() as usize; values.append(&mut (0..n).map(|_| f32::missing()).collect::<Vec<f32>>()); continue; } match reader.record(i).unwrap().format(&key_b).float() { Ok(ref vec) => { for arr in vec { values.append(&mut arr.to_vec()); } } Err(_) => { let header = reader.header(i); let n = dim * header.sample_count() as usize; values.append(&mut (0..n).map(|_| f32::missing()).collect::<Vec<f32>>()); } } } // Finally, push array into record. record .push_format_float(key_b, values.as_slice()) .chain_err(|| format!("Could not write FORMAT/{}", key))?; } writer .write(&record) .chain_err(|| "Problem writing BCF record")?; } Ok(()) } /// Main entry point for the "cmd build-model-wis" command. pub fn run(logger: &mut Logger, options: &MergeCovOptions) -> Result<()> { info!(logger, "Running: cnvetti cmd merge-cov"); info!(logger, "Options: {:?}", options); // Open reader. info!(logger, "Opening input files..."); let mut reader = bcf::synced::SyncedReader::new().chain_err(|| "Could not allocated synced reader")?; reader.set_require_index(true); reader.set_pairing(bcf::synced::pairing::EXACT); for input in &options.input { info!(logger, "- {}", input); reader .add_reader(&input) .chain_err(|| format!("Could not open file {} for reading", input))?; } info!(logger, "=> done"); // Get all Format fields of type String and Float; "GT" will get special handling. Also, get // all sample names. let mut format_string = BTreeSet::new(); let mut format_float = BTreeSet::new(); let mut samples_v: Vec<Vec<u8>> = Vec::new(); for i in 0..reader.reader_count() { format_float.append(&mut get_field_names(&reader.header(i), "Float")); format_string.append(&mut get_field_names(&reader.header(i), "String")); let mut other = reader .header(i) .samples() .iter() .map(|s| s.to_vec()) .collect::<Vec<Vec<u8>>>(); samples_v.append(&mut other); } let samples = samples_v .iter() .map(|v| v.as_slice()) .collect::<Vec<&[u8]>>(); // Open output file; construct writer. // TODO: do something fancier than taking just the first header { let mut writer = build_writer(logger, &reader.header(0), &samples, &options)?; merge_files(&format_string, &format_float, &mut reader, &mut writer)?; } // Finally, create index on created output file. info!(logger, "Building index for output file..."); bcf_utils::build_index(logger, &options.output).chain_err(|| "Could not build index")?; info!(logger, "All done. Have a nice day!"); Ok(()) }
get_field_names
identifier_name
lib.rs
/// Main library module for merging coverage files. use std::collections::BTreeSet; use std::env; use std::str; extern crate clap; extern crate chrono; #[macro_use] extern crate error_chain; /// This crate's error-related code, generated by `error-chain`. mod errors { // Create the Error, ErrorKind, ResultExt, and Result types error_chain! {} } pub use errors::*; extern crate shlex; #[macro_use] extern crate slog; use slog::Logger; extern crate rust_htslib; use rust_htslib::bcf; use rust_htslib::bcf::record::Numeric; extern crate lib_shared; use lib_shared::bcf_utils; mod options; pub use options::*; /// Obtain all field names of the given field type. fn get_field_names(header: &bcf::header::HeaderView, field_type: &str) -> BTreeSet<String> { let mut result: BTreeSet<String> = BTreeSet::new(); for record in header.header_records() { match record { bcf::HeaderRecord::Format { key: _, values } => match values.get("Type") { Some(this_type) => { if this_type == field_type { result.insert( values .get("ID") .expect("FILTER entry does not have an ID!") .clone(), ); } } _ => (), }, _ => (), } } result } /// Build BCF writer. fn build_writer( logger: &mut Logger, header: &bcf::header::HeaderView, samples: &Vec<&[u8]>, options: &MergeCovOptions, ) -> Result<bcf::Writer> { debug!(logger, "Opening output file..."); // Construct extended header. let mut header = bcf::Header::from_template_subset(header, &[]) .chain_err(|| "Problem constructing header from template and no samples")?; // TODO: version should come from one central place header.push_record(format!("##cnvetti_cmdMergeCovVersion={}", "0.1.0").as_bytes()); header.push_record( format!( "##cnvetti_cmdMergeCovCommand={}", env::args() .map(|s| shlex::quote(&s).to_string()) .collect::<Vec<String>>() .join(" ") ) .as_bytes(), ); for sample in samples { header.push_sample(&sample); } let uncompressed =!options.output.ends_with(".bcf") &&!options.output.ends_with(".vcf.gz"); let vcf = options.output.ends_with(".vcf") || options.output.ends_with(".vcf.gz"); Ok( bcf::Writer::from_path(&options.output, &header, uncompressed, vcf) .chain_err(|| format!("Could not open output BCF file {}", options.output))?, ) } /// Merge the coverage BCF files in `reader` to the writer. pub fn merge_files( format_string: &BTreeSet<String>, format_float: &BTreeSet<String>, reader: &mut bcf::synced::SyncedReader, writer: &mut bcf::Writer, ) -> Result<()> { while reader .read_next() .chain_err(|| "Problem reading from input BCF files")? != 0 { // TODO: also merge INFO values? // Locate first record; will copy INFO from there; FORMAT comes later. let mut first: Option<bcf::Record> = None; let num_samples = writer.header().sample_count(); for i in 0..num_samples { match (reader.has_line(i), &first) { (true, None) => { let mut record = reader.record(i).expect("Could not retrieve record"); writer.translate(&mut record); first = Some(record); // break; } _ => (), } } assert!(first.is_some()); let record = first.as_mut().unwrap(); // Push GT, always no-call for coverage records. let values = (0..(1 * num_samples)) .map(|_| bcf::GT_MISSING) .collect::<Vec<i32>>(); record .push_format_integer(b"GT", values.as_slice()) .chain_err(|| "Could not write FORMAT/GT")?; // Collect input FORMAT String fields and push to output FORMAT. for key in format_string { if key == "GT" { continue; // already handled above } let key_b = key.as_bytes(); let mut values_v: Vec<Vec<u8>> = Vec::new(); for i in 0..reader.reader_count() { if reader.has_line(i)
else { let num_samples = reader.header(i).sample_count(); for _j in 0..num_samples { values_v.push(b"".to_vec()); } } } let values: Vec<&[u8]> = values_v .iter() .map(|v| v.as_slice()) .collect::<Vec<&[u8]>>(); record .push_format_string(key_b, values.as_slice()) .chain_err(|| format!("Could not write FORMAT/{}", key))?; } // Collect input FORMAT Float fields and push to output FORMAT. for key in format_float { let key_b = key.as_bytes(); // First, get dimension of individual arrays. let dim = (0..reader.reader_count()) .filter(|i| reader.has_line(*i)) .map(|i| { reader .record(i) .expect("Could not get get record") .format(&key_b) .float() .unwrap_or_else(|_| Vec::new()) .len() }) .max() .expect("Could not compute maximum"); if dim == 0 { continue; } // Then, build the array. let mut values: Vec<f32> = Vec::new(); for i in 0..reader.reader_count() { if!reader.has_line(i) { let header = reader.header(i); let n = dim * header.sample_count() as usize; values.append(&mut (0..n).map(|_| f32::missing()).collect::<Vec<f32>>()); continue; } match reader.record(i).unwrap().format(&key_b).float() { Ok(ref vec) => { for arr in vec { values.append(&mut arr.to_vec()); } } Err(_) => { let header = reader.header(i); let n = dim * header.sample_count() as usize; values.append(&mut (0..n).map(|_| f32::missing()).collect::<Vec<f32>>()); } } } // Finally, push array into record. record .push_format_float(key_b, values.as_slice()) .chain_err(|| format!("Could not write FORMAT/{}", key))?; } writer .write(&record) .chain_err(|| "Problem writing BCF record")?; } Ok(()) } /// Main entry point for the "cmd build-model-wis" command. pub fn run(logger: &mut Logger, options: &MergeCovOptions) -> Result<()> { info!(logger, "Running: cnvetti cmd merge-cov"); info!(logger, "Options: {:?}", options); // Open reader. info!(logger, "Opening input files..."); let mut reader = bcf::synced::SyncedReader::new().chain_err(|| "Could not allocated synced reader")?; reader.set_require_index(true); reader.set_pairing(bcf::synced::pairing::EXACT); for input in &options.input { info!(logger, "- {}", input); reader .add_reader(&input) .chain_err(|| format!("Could not open file {} for reading", input))?; } info!(logger, "=> done"); // Get all Format fields of type String and Float; "GT" will get special handling. Also, get // all sample names. let mut format_string = BTreeSet::new(); let mut format_float = BTreeSet::new(); let mut samples_v: Vec<Vec<u8>> = Vec::new(); for i in 0..reader.reader_count() { format_float.append(&mut get_field_names(&reader.header(i), "Float")); format_string.append(&mut get_field_names(&reader.header(i), "String")); let mut other = reader .header(i) .samples() .iter() .map(|s| s.to_vec()) .collect::<Vec<Vec<u8>>>(); samples_v.append(&mut other); } let samples = samples_v .iter() .map(|v| v.as_slice()) .collect::<Vec<&[u8]>>(); // Open output file; construct writer. // TODO: do something fancier than taking just the first header { let mut writer = build_writer(logger, &reader.header(0), &samples, &options)?; merge_files(&format_string, &format_float, &mut reader, &mut writer)?; } // Finally, create index on created output file. info!(logger, "Building index for output file..."); bcf_utils::build_index(logger, &options.output).chain_err(|| "Could not build index")?; info!(logger, "All done. Have a nice day!"); Ok(()) }
{ let mut rec_in = reader .record(i) .expect("We just checked that the record should be there!"); let mut tmp_v = rec_in .format(&key_b) .string() .unwrap_or_else(|_| Vec::new()) .iter() .map(|v| Vec::from(*v)) .collect::<Vec<Vec<u8>>>(); if tmp_v.iter().any(|ref x| !x.is_empty()) { values_v.append(&mut tmp_v); } }
conditional_block
lib.rs
/// Main library module for merging coverage files. use std::collections::BTreeSet; use std::env; use std::str; extern crate clap; extern crate chrono; #[macro_use] extern crate error_chain; /// This crate's error-related code, generated by `error-chain`. mod errors { // Create the Error, ErrorKind, ResultExt, and Result types error_chain! {} } pub use errors::*; extern crate shlex; #[macro_use] extern crate slog; use slog::Logger; extern crate rust_htslib; use rust_htslib::bcf; use rust_htslib::bcf::record::Numeric; extern crate lib_shared; use lib_shared::bcf_utils; mod options; pub use options::*; /// Obtain all field names of the given field type. fn get_field_names(header: &bcf::header::HeaderView, field_type: &str) -> BTreeSet<String> { let mut result: BTreeSet<String> = BTreeSet::new(); for record in header.header_records() { match record { bcf::HeaderRecord::Format { key: _, values } => match values.get("Type") { Some(this_type) => { if this_type == field_type { result.insert( values .get("ID") .expect("FILTER entry does not have an ID!") .clone(), ); } } _ => (), }, _ => (), } } result } /// Build BCF writer. fn build_writer( logger: &mut Logger, header: &bcf::header::HeaderView, samples: &Vec<&[u8]>, options: &MergeCovOptions, ) -> Result<bcf::Writer> { debug!(logger, "Opening output file..."); // Construct extended header. let mut header = bcf::Header::from_template_subset(header, &[]) .chain_err(|| "Problem constructing header from template and no samples")?; // TODO: version should come from one central place header.push_record(format!("##cnvetti_cmdMergeCovVersion={}", "0.1.0").as_bytes()); header.push_record( format!( "##cnvetti_cmdMergeCovCommand={}", env::args() .map(|s| shlex::quote(&s).to_string()) .collect::<Vec<String>>() .join(" ") ) .as_bytes(), ); for sample in samples { header.push_sample(&sample); } let uncompressed =!options.output.ends_with(".bcf") &&!options.output.ends_with(".vcf.gz"); let vcf = options.output.ends_with(".vcf") || options.output.ends_with(".vcf.gz"); Ok( bcf::Writer::from_path(&options.output, &header, uncompressed, vcf) .chain_err(|| format!("Could not open output BCF file {}", options.output))?, ) } /// Merge the coverage BCF files in `reader` to the writer. pub fn merge_files( format_string: &BTreeSet<String>, format_float: &BTreeSet<String>, reader: &mut bcf::synced::SyncedReader, writer: &mut bcf::Writer, ) -> Result<()>
} assert!(first.is_some()); let record = first.as_mut().unwrap(); // Push GT, always no-call for coverage records. let values = (0..(1 * num_samples)) .map(|_| bcf::GT_MISSING) .collect::<Vec<i32>>(); record .push_format_integer(b"GT", values.as_slice()) .chain_err(|| "Could not write FORMAT/GT")?; // Collect input FORMAT String fields and push to output FORMAT. for key in format_string { if key == "GT" { continue; // already handled above } let key_b = key.as_bytes(); let mut values_v: Vec<Vec<u8>> = Vec::new(); for i in 0..reader.reader_count() { if reader.has_line(i) { let mut rec_in = reader .record(i) .expect("We just checked that the record should be there!"); let mut tmp_v = rec_in .format(&key_b) .string() .unwrap_or_else(|_| Vec::new()) .iter() .map(|v| Vec::from(*v)) .collect::<Vec<Vec<u8>>>(); if tmp_v.iter().any(|ref x|!x.is_empty()) { values_v.append(&mut tmp_v); } } else { let num_samples = reader.header(i).sample_count(); for _j in 0..num_samples { values_v.push(b"".to_vec()); } } } let values: Vec<&[u8]> = values_v .iter() .map(|v| v.as_slice()) .collect::<Vec<&[u8]>>(); record .push_format_string(key_b, values.as_slice()) .chain_err(|| format!("Could not write FORMAT/{}", key))?; } // Collect input FORMAT Float fields and push to output FORMAT. for key in format_float { let key_b = key.as_bytes(); // First, get dimension of individual arrays. let dim = (0..reader.reader_count()) .filter(|i| reader.has_line(*i)) .map(|i| { reader .record(i) .expect("Could not get get record") .format(&key_b) .float() .unwrap_or_else(|_| Vec::new()) .len() }) .max() .expect("Could not compute maximum"); if dim == 0 { continue; } // Then, build the array. let mut values: Vec<f32> = Vec::new(); for i in 0..reader.reader_count() { if!reader.has_line(i) { let header = reader.header(i); let n = dim * header.sample_count() as usize; values.append(&mut (0..n).map(|_| f32::missing()).collect::<Vec<f32>>()); continue; } match reader.record(i).unwrap().format(&key_b).float() { Ok(ref vec) => { for arr in vec { values.append(&mut arr.to_vec()); } } Err(_) => { let header = reader.header(i); let n = dim * header.sample_count() as usize; values.append(&mut (0..n).map(|_| f32::missing()).collect::<Vec<f32>>()); } } } // Finally, push array into record. record .push_format_float(key_b, values.as_slice()) .chain_err(|| format!("Could not write FORMAT/{}", key))?; } writer .write(&record) .chain_err(|| "Problem writing BCF record")?; } Ok(()) } /// Main entry point for the "cmd build-model-wis" command. pub fn run(logger: &mut Logger, options: &MergeCovOptions) -> Result<()> { info!(logger, "Running: cnvetti cmd merge-cov"); info!(logger, "Options: {:?}", options); // Open reader. info!(logger, "Opening input files..."); let mut reader = bcf::synced::SyncedReader::new().chain_err(|| "Could not allocated synced reader")?; reader.set_require_index(true); reader.set_pairing(bcf::synced::pairing::EXACT); for input in &options.input { info!(logger, "- {}", input); reader .add_reader(&input) .chain_err(|| format!("Could not open file {} for reading", input))?; } info!(logger, "=> done"); // Get all Format fields of type String and Float; "GT" will get special handling. Also, get // all sample names. let mut format_string = BTreeSet::new(); let mut format_float = BTreeSet::new(); let mut samples_v: Vec<Vec<u8>> = Vec::new(); for i in 0..reader.reader_count() { format_float.append(&mut get_field_names(&reader.header(i), "Float")); format_string.append(&mut get_field_names(&reader.header(i), "String")); let mut other = reader .header(i) .samples() .iter() .map(|s| s.to_vec()) .collect::<Vec<Vec<u8>>>(); samples_v.append(&mut other); } let samples = samples_v .iter() .map(|v| v.as_slice()) .collect::<Vec<&[u8]>>(); // Open output file; construct writer. // TODO: do something fancier than taking just the first header { let mut writer = build_writer(logger, &reader.header(0), &samples, &options)?; merge_files(&format_string, &format_float, &mut reader, &mut writer)?; } // Finally, create index on created output file. info!(logger, "Building index for output file..."); bcf_utils::build_index(logger, &options.output).chain_err(|| "Could not build index")?; info!(logger, "All done. Have a nice day!"); Ok(()) }
{ while reader .read_next() .chain_err(|| "Problem reading from input BCF files")? != 0 { // TODO: also merge INFO values? // Locate first record; will copy INFO from there; FORMAT comes later. let mut first: Option<bcf::Record> = None; let num_samples = writer.header().sample_count(); for i in 0..num_samples { match (reader.has_line(i), &first) { (true, None) => { let mut record = reader.record(i).expect("Could not retrieve record"); writer.translate(&mut record); first = Some(record); // break; } _ => (), }
identifier_body
lib.rs
/// Main library module for merging coverage files. use std::collections::BTreeSet; use std::env; use std::str; extern crate clap; extern crate chrono; #[macro_use] extern crate error_chain; /// This crate's error-related code, generated by `error-chain`. mod errors { // Create the Error, ErrorKind, ResultExt, and Result types error_chain! {} } pub use errors::*; extern crate shlex; #[macro_use] extern crate slog; use slog::Logger; extern crate rust_htslib; use rust_htslib::bcf; use rust_htslib::bcf::record::Numeric; extern crate lib_shared; use lib_shared::bcf_utils; mod options; pub use options::*; /// Obtain all field names of the given field type. fn get_field_names(header: &bcf::header::HeaderView, field_type: &str) -> BTreeSet<String> { let mut result: BTreeSet<String> = BTreeSet::new(); for record in header.header_records() { match record { bcf::HeaderRecord::Format { key: _, values } => match values.get("Type") { Some(this_type) => { if this_type == field_type { result.insert( values .get("ID") .expect("FILTER entry does not have an ID!") .clone(), ); } } _ => (), }, _ => (), } } result } /// Build BCF writer. fn build_writer( logger: &mut Logger, header: &bcf::header::HeaderView, samples: &Vec<&[u8]>, options: &MergeCovOptions, ) -> Result<bcf::Writer> { debug!(logger, "Opening output file..."); // Construct extended header. let mut header = bcf::Header::from_template_subset(header, &[]) .chain_err(|| "Problem constructing header from template and no samples")?; // TODO: version should come from one central place header.push_record(format!("##cnvetti_cmdMergeCovVersion={}", "0.1.0").as_bytes()); header.push_record( format!( "##cnvetti_cmdMergeCovCommand={}", env::args() .map(|s| shlex::quote(&s).to_string()) .collect::<Vec<String>>() .join(" ") ) .as_bytes(), ); for sample in samples { header.push_sample(&sample); } let uncompressed =!options.output.ends_with(".bcf") &&!options.output.ends_with(".vcf.gz"); let vcf = options.output.ends_with(".vcf") || options.output.ends_with(".vcf.gz"); Ok( bcf::Writer::from_path(&options.output, &header, uncompressed, vcf) .chain_err(|| format!("Could not open output BCF file {}", options.output))?, ) } /// Merge the coverage BCF files in `reader` to the writer. pub fn merge_files( format_string: &BTreeSet<String>, format_float: &BTreeSet<String>, reader: &mut bcf::synced::SyncedReader, writer: &mut bcf::Writer, ) -> Result<()> { while reader .read_next() .chain_err(|| "Problem reading from input BCF files")? != 0 { // TODO: also merge INFO values? // Locate first record; will copy INFO from there; FORMAT comes later. let mut first: Option<bcf::Record> = None; let num_samples = writer.header().sample_count(); for i in 0..num_samples { match (reader.has_line(i), &first) { (true, None) => { let mut record = reader.record(i).expect("Could not retrieve record"); writer.translate(&mut record); first = Some(record); // break; } _ => (), } } assert!(first.is_some()); let record = first.as_mut().unwrap(); // Push GT, always no-call for coverage records. let values = (0..(1 * num_samples)) .map(|_| bcf::GT_MISSING) .collect::<Vec<i32>>(); record .push_format_integer(b"GT", values.as_slice()) .chain_err(|| "Could not write FORMAT/GT")?; // Collect input FORMAT String fields and push to output FORMAT. for key in format_string { if key == "GT" { continue; // already handled above } let key_b = key.as_bytes(); let mut values_v: Vec<Vec<u8>> = Vec::new(); for i in 0..reader.reader_count() { if reader.has_line(i) { let mut rec_in = reader .record(i) .expect("We just checked that the record should be there!"); let mut tmp_v = rec_in .format(&key_b) .string() .unwrap_or_else(|_| Vec::new()) .iter() .map(|v| Vec::from(*v)) .collect::<Vec<Vec<u8>>>(); if tmp_v.iter().any(|ref x|!x.is_empty()) { values_v.append(&mut tmp_v); } } else { let num_samples = reader.header(i).sample_count(); for _j in 0..num_samples {
.iter() .map(|v| v.as_slice()) .collect::<Vec<&[u8]>>(); record .push_format_string(key_b, values.as_slice()) .chain_err(|| format!("Could not write FORMAT/{}", key))?; } // Collect input FORMAT Float fields and push to output FORMAT. for key in format_float { let key_b = key.as_bytes(); // First, get dimension of individual arrays. let dim = (0..reader.reader_count()) .filter(|i| reader.has_line(*i)) .map(|i| { reader .record(i) .expect("Could not get get record") .format(&key_b) .float() .unwrap_or_else(|_| Vec::new()) .len() }) .max() .expect("Could not compute maximum"); if dim == 0 { continue; } // Then, build the array. let mut values: Vec<f32> = Vec::new(); for i in 0..reader.reader_count() { if!reader.has_line(i) { let header = reader.header(i); let n = dim * header.sample_count() as usize; values.append(&mut (0..n).map(|_| f32::missing()).collect::<Vec<f32>>()); continue; } match reader.record(i).unwrap().format(&key_b).float() { Ok(ref vec) => { for arr in vec { values.append(&mut arr.to_vec()); } } Err(_) => { let header = reader.header(i); let n = dim * header.sample_count() as usize; values.append(&mut (0..n).map(|_| f32::missing()).collect::<Vec<f32>>()); } } } // Finally, push array into record. record .push_format_float(key_b, values.as_slice()) .chain_err(|| format!("Could not write FORMAT/{}", key))?; } writer .write(&record) .chain_err(|| "Problem writing BCF record")?; } Ok(()) } /// Main entry point for the "cmd build-model-wis" command. pub fn run(logger: &mut Logger, options: &MergeCovOptions) -> Result<()> { info!(logger, "Running: cnvetti cmd merge-cov"); info!(logger, "Options: {:?}", options); // Open reader. info!(logger, "Opening input files..."); let mut reader = bcf::synced::SyncedReader::new().chain_err(|| "Could not allocated synced reader")?; reader.set_require_index(true); reader.set_pairing(bcf::synced::pairing::EXACT); for input in &options.input { info!(logger, "- {}", input); reader .add_reader(&input) .chain_err(|| format!("Could not open file {} for reading", input))?; } info!(logger, "=> done"); // Get all Format fields of type String and Float; "GT" will get special handling. Also, get // all sample names. let mut format_string = BTreeSet::new(); let mut format_float = BTreeSet::new(); let mut samples_v: Vec<Vec<u8>> = Vec::new(); for i in 0..reader.reader_count() { format_float.append(&mut get_field_names(&reader.header(i), "Float")); format_string.append(&mut get_field_names(&reader.header(i), "String")); let mut other = reader .header(i) .samples() .iter() .map(|s| s.to_vec()) .collect::<Vec<Vec<u8>>>(); samples_v.append(&mut other); } let samples = samples_v .iter() .map(|v| v.as_slice()) .collect::<Vec<&[u8]>>(); // Open output file; construct writer. // TODO: do something fancier than taking just the first header { let mut writer = build_writer(logger, &reader.header(0), &samples, &options)?; merge_files(&format_string, &format_float, &mut reader, &mut writer)?; } // Finally, create index on created output file. info!(logger, "Building index for output file..."); bcf_utils::build_index(logger, &options.output).chain_err(|| "Could not build index")?; info!(logger, "All done. Have a nice day!"); Ok(()) }
values_v.push(b"".to_vec()); } } } let values: Vec<&[u8]> = values_v
random_line_split
udev.rs
//! `udev` related functionality for automated device scanning //! //! This module mainly provides the [`UdevBackend`], which monitors available DRM devices and acts as //! an event source to be inserted in [`calloop`], generating events whenever these devices change. //! //! *Note:* Once inserted into the event loop, the [`UdevBackend`] will only notify you about *changes* //! in the device list. To get an initial snapshot of the state during your initialization, you need to //! call its `device_list` method. //! //! ```no_run //! use smithay::backend::udev::{UdevBackend, UdevEvent}; //! //! let udev = UdevBackend::new("seat0", None).expect("Failed to monitor udev."); //! //! for (dev_id, node_path) in udev.device_list() { //! // process the initial list of devices //! } //! //! # let event_loop = smithay::reexports::calloop::EventLoop::<()>::try_new().unwrap(); //! # let loop_handle = event_loop.handle(); //! // setup the event source for long-term monitoring //! loop_handle.insert_source(udev, |event, _, _dispatch_data| match event { //! UdevEvent::Added { device_id, path } => { //! // a new device has been added //! }, //! UdevEvent::Changed { device_id } => { //! // a device has been changed //! }, //! UdevEvent::Removed { device_id } => { //! // a device has been removed //! } //! }).expect("Failed to insert the udev source into the event loop"); //! ``` //! //! Additionally this contains some utility functions related to scanning. //! //! See also `anvil/src/udev.rs` for pure hardware backed example of a compositor utilizing this //! backend. use nix::sys::stat::{dev_t, stat}; use std::{ collections::HashMap, ffi::OsString, fmt, io::Result as IoResult, os::unix::io::{AsRawFd, RawFd}, path::{Path, PathBuf}, }; use udev::{Enumerator, EventType, MonitorBuilder, MonitorSocket}; use calloop::{EventSource, Interest, Mode, Poll, PostAction, Readiness, Token, TokenFactory}; use slog::{debug, info, o, warn}; /// Backend to monitor available drm devices. /// /// Provides a way to automatically scan for available gpus and notifies the /// given handler of any changes. Can be used to provide hot-plug functionality for gpus and /// attached monitors. pub struct UdevBackend { devices: HashMap<dev_t, PathBuf>, monitor: MonitorSocket, token: Token, logger: ::slog::Logger, } // MonitorSocket does not implement debug, so we have to impl Debug manually impl fmt::Debug for UdevBackend { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { use udev::AsRaw; f.debug_struct("UdevBackend") .field("devices", &self.devices) .field("monitor", &format!("MonitorSocket ({:?})", self.monitor.as_raw())) .field("logger", &self.logger) .finish() } } impl AsRawFd for UdevBackend { fn as_raw_fd(&self) -> RawFd { self.monitor.as_raw_fd() } }
/// ## Arguments /// `seat` - system seat which should be bound /// `logger` - slog Logger to be used by the backend and its `DrmDevices`. pub fn new<L, S: AsRef<str>>(seat: S, logger: L) -> IoResult<UdevBackend> where L: Into<Option<::slog::Logger>>, { let log = crate::slog_or_fallback(logger).new(o!("smithay_module" => "backend_udev")); let devices = all_gpus(seat)? .into_iter() // Create devices .flat_map(|path| match stat(&path) { Ok(stat) => Some((stat.st_rdev, path)), Err(err) => { warn!(log, "Unable to get id of {:?}, Error: {:?}. Skipping", path, err); None } }) .collect(); let monitor = MonitorBuilder::new()?.match_subsystem("drm")?.listen()?; Ok(UdevBackend { devices, monitor, token: Token::invalid(), logger: log, }) } /// Get a list of DRM devices currently known to the backend /// /// You should call this once before inserting the event source into your /// event loop, to get an initial snapshot of the device state. pub fn device_list(&self) -> impl Iterator<Item = (dev_t, &Path)> { self.devices.iter().map(|(&id, path)| (id, path.as_ref())) } } impl EventSource for UdevBackend { type Event = UdevEvent; type Metadata = (); type Ret = (); fn process_events<F>( &mut self, _: Readiness, token: Token, mut callback: F, ) -> std::io::Result<PostAction> where F: FnMut(UdevEvent, &mut ()), { if token!= self.token { return Ok(PostAction::Continue); } let monitor = self.monitor.clone(); for event in monitor { debug!( self.logger, "Udev event: type={}, devnum={:?} devnode={:?}", event.event_type(), event.devnum(), event.devnode() ); match event.event_type() { // New device EventType::Add => { if let (Some(path), Some(devnum)) = (event.devnode(), event.devnum()) { info!(self.logger, "New device: #{} at {}", devnum, path.display()); if self.devices.insert(devnum, path.to_path_buf()).is_none() { callback( UdevEvent::Added { device_id: devnum, path: path.to_path_buf(), }, &mut (), ); } } } // Device removed EventType::Remove => { if let Some(devnum) = event.devnum() { info!(self.logger, "Device removed: #{}", devnum); if self.devices.remove(&devnum).is_some() { callback(UdevEvent::Removed { device_id: devnum }, &mut ()); } } } // New connector EventType::Change => { if let Some(devnum) = event.devnum() { info!(self.logger, "Device changed: #{}", devnum); if self.devices.contains_key(&devnum) { callback(UdevEvent::Changed { device_id: devnum }, &mut ()); } } } _ => {} } } Ok(PostAction::Continue) } fn register(&mut self, poll: &mut Poll, factory: &mut TokenFactory) -> std::io::Result<()> { self.token = factory.token(); poll.register(self.as_raw_fd(), Interest::READ, Mode::Level, self.token) } fn reregister(&mut self, poll: &mut Poll, factory: &mut TokenFactory) -> std::io::Result<()> { self.token = factory.token(); poll.reregister(self.as_raw_fd(), Interest::READ, Mode::Level, self.token) } fn unregister(&mut self, poll: &mut Poll) -> std::io::Result<()> { self.token = Token::invalid(); poll.unregister(self.as_raw_fd()) } } /// Events generated by the [`UdevBackend`], notifying you of changes in system devices #[derive(Debug)] pub enum UdevEvent { /// A new device has been detected Added { /// ID of the new device device_id: dev_t, /// Path of the new device path: PathBuf, }, /// A device has changed Changed { /// ID of the changed device device_id: dev_t, }, /// A device has been removed Removed { /// ID of the removed device device_id: dev_t, }, } /// Returns the path of the primary GPU device if any /// /// Might be used for filtering of [`UdevEvent::Added`] or for manual /// [`DrmDevice`](crate::backend::drm::DrmDevice) initialization. pub fn primary_gpu<S: AsRef<str>>(seat: S) -> IoResult<Option<PathBuf>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; if let Some(path) = enumerator .scan_devices()? .filter(|device| { let seat_name = device .property_value("ID_SEAT") .map(|x| x.to_os_string()) .unwrap_or_else(|| OsString::from("seat0")); if seat_name == *seat.as_ref() { if let Ok(Some(pci)) = device.parent_with_subsystem(Path::new("pci")) { if let Some(id) = pci.attribute_value("boot_vga") { return id == "1"; } } } false }) .flat_map(|device| device.devnode().map(PathBuf::from)) .next() { Ok(Some(path)) } else { all_gpus(seat).map(|all| all.into_iter().next()) } } /// Returns the paths of all available GPU devices /// /// Might be used for manual [`DrmDevice`](crate::backend::drm::DrmDevice) /// initialization. pub fn all_gpus<S: AsRef<str>>(seat: S) -> IoResult<Vec<PathBuf>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; Ok(enumerator .scan_devices()? .filter(|device| { device .property_value("ID_SEAT") .map(|x| x.to_os_string()) .unwrap_or_else(|| OsString::from("seat0")) == *seat.as_ref() }) .flat_map(|device| device.devnode().map(PathBuf::from)) .collect()) } /// Returns the loaded driver for a device named by it's [`dev_t`](::nix::sys::stat::dev_t). pub fn driver(dev: dev_t) -> IoResult<Option<OsString>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; Ok(enumerator .scan_devices()? .filter(|device| device.devnum() == Some(dev)) .flat_map(|dev| { let mut device = Some(dev); while let Some(dev) = device { if dev.driver().is_some() { return dev.driver().map(std::ffi::OsStr::to_os_string); } device = dev.parent(); } None }) .next()) }
impl UdevBackend { /// Creates a new [`UdevBackend`] ///
random_line_split
udev.rs
//! `udev` related functionality for automated device scanning //! //! This module mainly provides the [`UdevBackend`], which monitors available DRM devices and acts as //! an event source to be inserted in [`calloop`], generating events whenever these devices change. //! //! *Note:* Once inserted into the event loop, the [`UdevBackend`] will only notify you about *changes* //! in the device list. To get an initial snapshot of the state during your initialization, you need to //! call its `device_list` method. //! //! ```no_run //! use smithay::backend::udev::{UdevBackend, UdevEvent}; //! //! let udev = UdevBackend::new("seat0", None).expect("Failed to monitor udev."); //! //! for (dev_id, node_path) in udev.device_list() { //! // process the initial list of devices //! } //! //! # let event_loop = smithay::reexports::calloop::EventLoop::<()>::try_new().unwrap(); //! # let loop_handle = event_loop.handle(); //! // setup the event source for long-term monitoring //! loop_handle.insert_source(udev, |event, _, _dispatch_data| match event { //! UdevEvent::Added { device_id, path } => { //! // a new device has been added //! }, //! UdevEvent::Changed { device_id } => { //! // a device has been changed //! }, //! UdevEvent::Removed { device_id } => { //! // a device has been removed //! } //! }).expect("Failed to insert the udev source into the event loop"); //! ``` //! //! Additionally this contains some utility functions related to scanning. //! //! See also `anvil/src/udev.rs` for pure hardware backed example of a compositor utilizing this //! backend. use nix::sys::stat::{dev_t, stat}; use std::{ collections::HashMap, ffi::OsString, fmt, io::Result as IoResult, os::unix::io::{AsRawFd, RawFd}, path::{Path, PathBuf}, }; use udev::{Enumerator, EventType, MonitorBuilder, MonitorSocket}; use calloop::{EventSource, Interest, Mode, Poll, PostAction, Readiness, Token, TokenFactory}; use slog::{debug, info, o, warn}; /// Backend to monitor available drm devices. /// /// Provides a way to automatically scan for available gpus and notifies the /// given handler of any changes. Can be used to provide hot-plug functionality for gpus and /// attached monitors. pub struct UdevBackend { devices: HashMap<dev_t, PathBuf>, monitor: MonitorSocket, token: Token, logger: ::slog::Logger, } // MonitorSocket does not implement debug, so we have to impl Debug manually impl fmt::Debug for UdevBackend { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { use udev::AsRaw; f.debug_struct("UdevBackend") .field("devices", &self.devices) .field("monitor", &format!("MonitorSocket ({:?})", self.monitor.as_raw())) .field("logger", &self.logger) .finish() } } impl AsRawFd for UdevBackend { fn as_raw_fd(&self) -> RawFd { self.monitor.as_raw_fd() } } impl UdevBackend { /// Creates a new [`UdevBackend`] /// /// ## Arguments /// `seat` - system seat which should be bound /// `logger` - slog Logger to be used by the backend and its `DrmDevices`. pub fn new<L, S: AsRef<str>>(seat: S, logger: L) -> IoResult<UdevBackend> where L: Into<Option<::slog::Logger>>, { let log = crate::slog_or_fallback(logger).new(o!("smithay_module" => "backend_udev")); let devices = all_gpus(seat)? .into_iter() // Create devices .flat_map(|path| match stat(&path) { Ok(stat) => Some((stat.st_rdev, path)), Err(err) => { warn!(log, "Unable to get id of {:?}, Error: {:?}. Skipping", path, err); None } }) .collect(); let monitor = MonitorBuilder::new()?.match_subsystem("drm")?.listen()?; Ok(UdevBackend { devices, monitor, token: Token::invalid(), logger: log, }) } /// Get a list of DRM devices currently known to the backend /// /// You should call this once before inserting the event source into your /// event loop, to get an initial snapshot of the device state. pub fn device_list(&self) -> impl Iterator<Item = (dev_t, &Path)> { self.devices.iter().map(|(&id, path)| (id, path.as_ref())) } } impl EventSource for UdevBackend { type Event = UdevEvent; type Metadata = (); type Ret = (); fn process_events<F>( &mut self, _: Readiness, token: Token, mut callback: F, ) -> std::io::Result<PostAction> where F: FnMut(UdevEvent, &mut ()), { if token!= self.token { return Ok(PostAction::Continue); } let monitor = self.monitor.clone(); for event in monitor { debug!( self.logger, "Udev event: type={}, devnum={:?} devnode={:?}", event.event_type(), event.devnum(), event.devnode() ); match event.event_type() { // New device EventType::Add => { if let (Some(path), Some(devnum)) = (event.devnode(), event.devnum()) { info!(self.logger, "New device: #{} at {}", devnum, path.display()); if self.devices.insert(devnum, path.to_path_buf()).is_none() { callback( UdevEvent::Added { device_id: devnum, path: path.to_path_buf(), }, &mut (), ); } } } // Device removed EventType::Remove => { if let Some(devnum) = event.devnum() { info!(self.logger, "Device removed: #{}", devnum); if self.devices.remove(&devnum).is_some() { callback(UdevEvent::Removed { device_id: devnum }, &mut ()); } } } // New connector EventType::Change => { if let Some(devnum) = event.devnum() { info!(self.logger, "Device changed: #{}", devnum); if self.devices.contains_key(&devnum) { callback(UdevEvent::Changed { device_id: devnum }, &mut ()); } } } _ => {} } } Ok(PostAction::Continue) } fn register(&mut self, poll: &mut Poll, factory: &mut TokenFactory) -> std::io::Result<()> { self.token = factory.token(); poll.register(self.as_raw_fd(), Interest::READ, Mode::Level, self.token) } fn reregister(&mut self, poll: &mut Poll, factory: &mut TokenFactory) -> std::io::Result<()> { self.token = factory.token(); poll.reregister(self.as_raw_fd(), Interest::READ, Mode::Level, self.token) } fn unregister(&mut self, poll: &mut Poll) -> std::io::Result<()>
} /// Events generated by the [`UdevBackend`], notifying you of changes in system devices #[derive(Debug)] pub enum UdevEvent { /// A new device has been detected Added { /// ID of the new device device_id: dev_t, /// Path of the new device path: PathBuf, }, /// A device has changed Changed { /// ID of the changed device device_id: dev_t, }, /// A device has been removed Removed { /// ID of the removed device device_id: dev_t, }, } /// Returns the path of the primary GPU device if any /// /// Might be used for filtering of [`UdevEvent::Added`] or for manual /// [`DrmDevice`](crate::backend::drm::DrmDevice) initialization. pub fn primary_gpu<S: AsRef<str>>(seat: S) -> IoResult<Option<PathBuf>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; if let Some(path) = enumerator .scan_devices()? .filter(|device| { let seat_name = device .property_value("ID_SEAT") .map(|x| x.to_os_string()) .unwrap_or_else(|| OsString::from("seat0")); if seat_name == *seat.as_ref() { if let Ok(Some(pci)) = device.parent_with_subsystem(Path::new("pci")) { if let Some(id) = pci.attribute_value("boot_vga") { return id == "1"; } } } false }) .flat_map(|device| device.devnode().map(PathBuf::from)) .next() { Ok(Some(path)) } else { all_gpus(seat).map(|all| all.into_iter().next()) } } /// Returns the paths of all available GPU devices /// /// Might be used for manual [`DrmDevice`](crate::backend::drm::DrmDevice) /// initialization. pub fn all_gpus<S: AsRef<str>>(seat: S) -> IoResult<Vec<PathBuf>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; Ok(enumerator .scan_devices()? .filter(|device| { device .property_value("ID_SEAT") .map(|x| x.to_os_string()) .unwrap_or_else(|| OsString::from("seat0")) == *seat.as_ref() }) .flat_map(|device| device.devnode().map(PathBuf::from)) .collect()) } /// Returns the loaded driver for a device named by it's [`dev_t`](::nix::sys::stat::dev_t). pub fn driver(dev: dev_t) -> IoResult<Option<OsString>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; Ok(enumerator .scan_devices()? .filter(|device| device.devnum() == Some(dev)) .flat_map(|dev| { let mut device = Some(dev); while let Some(dev) = device { if dev.driver().is_some() { return dev.driver().map(std::ffi::OsStr::to_os_string); } device = dev.parent(); } None }) .next()) }
{ self.token = Token::invalid(); poll.unregister(self.as_raw_fd()) }
identifier_body
udev.rs
//! `udev` related functionality for automated device scanning //! //! This module mainly provides the [`UdevBackend`], which monitors available DRM devices and acts as //! an event source to be inserted in [`calloop`], generating events whenever these devices change. //! //! *Note:* Once inserted into the event loop, the [`UdevBackend`] will only notify you about *changes* //! in the device list. To get an initial snapshot of the state during your initialization, you need to //! call its `device_list` method. //! //! ```no_run //! use smithay::backend::udev::{UdevBackend, UdevEvent}; //! //! let udev = UdevBackend::new("seat0", None).expect("Failed to monitor udev."); //! //! for (dev_id, node_path) in udev.device_list() { //! // process the initial list of devices //! } //! //! # let event_loop = smithay::reexports::calloop::EventLoop::<()>::try_new().unwrap(); //! # let loop_handle = event_loop.handle(); //! // setup the event source for long-term monitoring //! loop_handle.insert_source(udev, |event, _, _dispatch_data| match event { //! UdevEvent::Added { device_id, path } => { //! // a new device has been added //! }, //! UdevEvent::Changed { device_id } => { //! // a device has been changed //! }, //! UdevEvent::Removed { device_id } => { //! // a device has been removed //! } //! }).expect("Failed to insert the udev source into the event loop"); //! ``` //! //! Additionally this contains some utility functions related to scanning. //! //! See also `anvil/src/udev.rs` for pure hardware backed example of a compositor utilizing this //! backend. use nix::sys::stat::{dev_t, stat}; use std::{ collections::HashMap, ffi::OsString, fmt, io::Result as IoResult, os::unix::io::{AsRawFd, RawFd}, path::{Path, PathBuf}, }; use udev::{Enumerator, EventType, MonitorBuilder, MonitorSocket}; use calloop::{EventSource, Interest, Mode, Poll, PostAction, Readiness, Token, TokenFactory}; use slog::{debug, info, o, warn}; /// Backend to monitor available drm devices. /// /// Provides a way to automatically scan for available gpus and notifies the /// given handler of any changes. Can be used to provide hot-plug functionality for gpus and /// attached monitors. pub struct UdevBackend { devices: HashMap<dev_t, PathBuf>, monitor: MonitorSocket, token: Token, logger: ::slog::Logger, } // MonitorSocket does not implement debug, so we have to impl Debug manually impl fmt::Debug for UdevBackend { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { use udev::AsRaw; f.debug_struct("UdevBackend") .field("devices", &self.devices) .field("monitor", &format!("MonitorSocket ({:?})", self.monitor.as_raw())) .field("logger", &self.logger) .finish() } } impl AsRawFd for UdevBackend { fn as_raw_fd(&self) -> RawFd { self.monitor.as_raw_fd() } } impl UdevBackend { /// Creates a new [`UdevBackend`] /// /// ## Arguments /// `seat` - system seat which should be bound /// `logger` - slog Logger to be used by the backend and its `DrmDevices`. pub fn new<L, S: AsRef<str>>(seat: S, logger: L) -> IoResult<UdevBackend> where L: Into<Option<::slog::Logger>>, { let log = crate::slog_or_fallback(logger).new(o!("smithay_module" => "backend_udev")); let devices = all_gpus(seat)? .into_iter() // Create devices .flat_map(|path| match stat(&path) { Ok(stat) => Some((stat.st_rdev, path)), Err(err) => { warn!(log, "Unable to get id of {:?}, Error: {:?}. Skipping", path, err); None } }) .collect(); let monitor = MonitorBuilder::new()?.match_subsystem("drm")?.listen()?; Ok(UdevBackend { devices, monitor, token: Token::invalid(), logger: log, }) } /// Get a list of DRM devices currently known to the backend /// /// You should call this once before inserting the event source into your /// event loop, to get an initial snapshot of the device state. pub fn device_list(&self) -> impl Iterator<Item = (dev_t, &Path)> { self.devices.iter().map(|(&id, path)| (id, path.as_ref())) } } impl EventSource for UdevBackend { type Event = UdevEvent; type Metadata = (); type Ret = (); fn process_events<F>( &mut self, _: Readiness, token: Token, mut callback: F, ) -> std::io::Result<PostAction> where F: FnMut(UdevEvent, &mut ()), { if token!= self.token { return Ok(PostAction::Continue); } let monitor = self.monitor.clone(); for event in monitor { debug!( self.logger, "Udev event: type={}, devnum={:?} devnode={:?}", event.event_type(), event.devnum(), event.devnode() ); match event.event_type() { // New device EventType::Add => { if let (Some(path), Some(devnum)) = (event.devnode(), event.devnum()) { info!(self.logger, "New device: #{} at {}", devnum, path.display()); if self.devices.insert(devnum, path.to_path_buf()).is_none() { callback( UdevEvent::Added { device_id: devnum, path: path.to_path_buf(), }, &mut (), ); } } } // Device removed EventType::Remove => { if let Some(devnum) = event.devnum() { info!(self.logger, "Device removed: #{}", devnum); if self.devices.remove(&devnum).is_some()
} } // New connector EventType::Change => { if let Some(devnum) = event.devnum() { info!(self.logger, "Device changed: #{}", devnum); if self.devices.contains_key(&devnum) { callback(UdevEvent::Changed { device_id: devnum }, &mut ()); } } } _ => {} } } Ok(PostAction::Continue) } fn register(&mut self, poll: &mut Poll, factory: &mut TokenFactory) -> std::io::Result<()> { self.token = factory.token(); poll.register(self.as_raw_fd(), Interest::READ, Mode::Level, self.token) } fn reregister(&mut self, poll: &mut Poll, factory: &mut TokenFactory) -> std::io::Result<()> { self.token = factory.token(); poll.reregister(self.as_raw_fd(), Interest::READ, Mode::Level, self.token) } fn unregister(&mut self, poll: &mut Poll) -> std::io::Result<()> { self.token = Token::invalid(); poll.unregister(self.as_raw_fd()) } } /// Events generated by the [`UdevBackend`], notifying you of changes in system devices #[derive(Debug)] pub enum UdevEvent { /// A new device has been detected Added { /// ID of the new device device_id: dev_t, /// Path of the new device path: PathBuf, }, /// A device has changed Changed { /// ID of the changed device device_id: dev_t, }, /// A device has been removed Removed { /// ID of the removed device device_id: dev_t, }, } /// Returns the path of the primary GPU device if any /// /// Might be used for filtering of [`UdevEvent::Added`] or for manual /// [`DrmDevice`](crate::backend::drm::DrmDevice) initialization. pub fn primary_gpu<S: AsRef<str>>(seat: S) -> IoResult<Option<PathBuf>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; if let Some(path) = enumerator .scan_devices()? .filter(|device| { let seat_name = device .property_value("ID_SEAT") .map(|x| x.to_os_string()) .unwrap_or_else(|| OsString::from("seat0")); if seat_name == *seat.as_ref() { if let Ok(Some(pci)) = device.parent_with_subsystem(Path::new("pci")) { if let Some(id) = pci.attribute_value("boot_vga") { return id == "1"; } } } false }) .flat_map(|device| device.devnode().map(PathBuf::from)) .next() { Ok(Some(path)) } else { all_gpus(seat).map(|all| all.into_iter().next()) } } /// Returns the paths of all available GPU devices /// /// Might be used for manual [`DrmDevice`](crate::backend::drm::DrmDevice) /// initialization. pub fn all_gpus<S: AsRef<str>>(seat: S) -> IoResult<Vec<PathBuf>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; Ok(enumerator .scan_devices()? .filter(|device| { device .property_value("ID_SEAT") .map(|x| x.to_os_string()) .unwrap_or_else(|| OsString::from("seat0")) == *seat.as_ref() }) .flat_map(|device| device.devnode().map(PathBuf::from)) .collect()) } /// Returns the loaded driver for a device named by it's [`dev_t`](::nix::sys::stat::dev_t). pub fn driver(dev: dev_t) -> IoResult<Option<OsString>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; Ok(enumerator .scan_devices()? .filter(|device| device.devnum() == Some(dev)) .flat_map(|dev| { let mut device = Some(dev); while let Some(dev) = device { if dev.driver().is_some() { return dev.driver().map(std::ffi::OsStr::to_os_string); } device = dev.parent(); } None }) .next()) }
{ callback(UdevEvent::Removed { device_id: devnum }, &mut ()); }
conditional_block
udev.rs
//! `udev` related functionality for automated device scanning //! //! This module mainly provides the [`UdevBackend`], which monitors available DRM devices and acts as //! an event source to be inserted in [`calloop`], generating events whenever these devices change. //! //! *Note:* Once inserted into the event loop, the [`UdevBackend`] will only notify you about *changes* //! in the device list. To get an initial snapshot of the state during your initialization, you need to //! call its `device_list` method. //! //! ```no_run //! use smithay::backend::udev::{UdevBackend, UdevEvent}; //! //! let udev = UdevBackend::new("seat0", None).expect("Failed to monitor udev."); //! //! for (dev_id, node_path) in udev.device_list() { //! // process the initial list of devices //! } //! //! # let event_loop = smithay::reexports::calloop::EventLoop::<()>::try_new().unwrap(); //! # let loop_handle = event_loop.handle(); //! // setup the event source for long-term monitoring //! loop_handle.insert_source(udev, |event, _, _dispatch_data| match event { //! UdevEvent::Added { device_id, path } => { //! // a new device has been added //! }, //! UdevEvent::Changed { device_id } => { //! // a device has been changed //! }, //! UdevEvent::Removed { device_id } => { //! // a device has been removed //! } //! }).expect("Failed to insert the udev source into the event loop"); //! ``` //! //! Additionally this contains some utility functions related to scanning. //! //! See also `anvil/src/udev.rs` for pure hardware backed example of a compositor utilizing this //! backend. use nix::sys::stat::{dev_t, stat}; use std::{ collections::HashMap, ffi::OsString, fmt, io::Result as IoResult, os::unix::io::{AsRawFd, RawFd}, path::{Path, PathBuf}, }; use udev::{Enumerator, EventType, MonitorBuilder, MonitorSocket}; use calloop::{EventSource, Interest, Mode, Poll, PostAction, Readiness, Token, TokenFactory}; use slog::{debug, info, o, warn}; /// Backend to monitor available drm devices. /// /// Provides a way to automatically scan for available gpus and notifies the /// given handler of any changes. Can be used to provide hot-plug functionality for gpus and /// attached monitors. pub struct UdevBackend { devices: HashMap<dev_t, PathBuf>, monitor: MonitorSocket, token: Token, logger: ::slog::Logger, } // MonitorSocket does not implement debug, so we have to impl Debug manually impl fmt::Debug for UdevBackend { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { use udev::AsRaw; f.debug_struct("UdevBackend") .field("devices", &self.devices) .field("monitor", &format!("MonitorSocket ({:?})", self.monitor.as_raw())) .field("logger", &self.logger) .finish() } } impl AsRawFd for UdevBackend { fn as_raw_fd(&self) -> RawFd { self.monitor.as_raw_fd() } } impl UdevBackend { /// Creates a new [`UdevBackend`] /// /// ## Arguments /// `seat` - system seat which should be bound /// `logger` - slog Logger to be used by the backend and its `DrmDevices`. pub fn new<L, S: AsRef<str>>(seat: S, logger: L) -> IoResult<UdevBackend> where L: Into<Option<::slog::Logger>>, { let log = crate::slog_or_fallback(logger).new(o!("smithay_module" => "backend_udev")); let devices = all_gpus(seat)? .into_iter() // Create devices .flat_map(|path| match stat(&path) { Ok(stat) => Some((stat.st_rdev, path)), Err(err) => { warn!(log, "Unable to get id of {:?}, Error: {:?}. Skipping", path, err); None } }) .collect(); let monitor = MonitorBuilder::new()?.match_subsystem("drm")?.listen()?; Ok(UdevBackend { devices, monitor, token: Token::invalid(), logger: log, }) } /// Get a list of DRM devices currently known to the backend /// /// You should call this once before inserting the event source into your /// event loop, to get an initial snapshot of the device state. pub fn device_list(&self) -> impl Iterator<Item = (dev_t, &Path)> { self.devices.iter().map(|(&id, path)| (id, path.as_ref())) } } impl EventSource for UdevBackend { type Event = UdevEvent; type Metadata = (); type Ret = (); fn process_events<F>( &mut self, _: Readiness, token: Token, mut callback: F, ) -> std::io::Result<PostAction> where F: FnMut(UdevEvent, &mut ()), { if token!= self.token { return Ok(PostAction::Continue); } let monitor = self.monitor.clone(); for event in monitor { debug!( self.logger, "Udev event: type={}, devnum={:?} devnode={:?}", event.event_type(), event.devnum(), event.devnode() ); match event.event_type() { // New device EventType::Add => { if let (Some(path), Some(devnum)) = (event.devnode(), event.devnum()) { info!(self.logger, "New device: #{} at {}", devnum, path.display()); if self.devices.insert(devnum, path.to_path_buf()).is_none() { callback( UdevEvent::Added { device_id: devnum, path: path.to_path_buf(), }, &mut (), ); } } } // Device removed EventType::Remove => { if let Some(devnum) = event.devnum() { info!(self.logger, "Device removed: #{}", devnum); if self.devices.remove(&devnum).is_some() { callback(UdevEvent::Removed { device_id: devnum }, &mut ()); } } } // New connector EventType::Change => { if let Some(devnum) = event.devnum() { info!(self.logger, "Device changed: #{}", devnum); if self.devices.contains_key(&devnum) { callback(UdevEvent::Changed { device_id: devnum }, &mut ()); } } } _ => {} } } Ok(PostAction::Continue) } fn register(&mut self, poll: &mut Poll, factory: &mut TokenFactory) -> std::io::Result<()> { self.token = factory.token(); poll.register(self.as_raw_fd(), Interest::READ, Mode::Level, self.token) } fn reregister(&mut self, poll: &mut Poll, factory: &mut TokenFactory) -> std::io::Result<()> { self.token = factory.token(); poll.reregister(self.as_raw_fd(), Interest::READ, Mode::Level, self.token) } fn unregister(&mut self, poll: &mut Poll) -> std::io::Result<()> { self.token = Token::invalid(); poll.unregister(self.as_raw_fd()) } } /// Events generated by the [`UdevBackend`], notifying you of changes in system devices #[derive(Debug)] pub enum UdevEvent { /// A new device has been detected Added { /// ID of the new device device_id: dev_t, /// Path of the new device path: PathBuf, }, /// A device has changed Changed { /// ID of the changed device device_id: dev_t, }, /// A device has been removed Removed { /// ID of the removed device device_id: dev_t, }, } /// Returns the path of the primary GPU device if any /// /// Might be used for filtering of [`UdevEvent::Added`] or for manual /// [`DrmDevice`](crate::backend::drm::DrmDevice) initialization. pub fn primary_gpu<S: AsRef<str>>(seat: S) -> IoResult<Option<PathBuf>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; if let Some(path) = enumerator .scan_devices()? .filter(|device| { let seat_name = device .property_value("ID_SEAT") .map(|x| x.to_os_string()) .unwrap_or_else(|| OsString::from("seat0")); if seat_name == *seat.as_ref() { if let Ok(Some(pci)) = device.parent_with_subsystem(Path::new("pci")) { if let Some(id) = pci.attribute_value("boot_vga") { return id == "1"; } } } false }) .flat_map(|device| device.devnode().map(PathBuf::from)) .next() { Ok(Some(path)) } else { all_gpus(seat).map(|all| all.into_iter().next()) } } /// Returns the paths of all available GPU devices /// /// Might be used for manual [`DrmDevice`](crate::backend::drm::DrmDevice) /// initialization. pub fn all_gpus<S: AsRef<str>>(seat: S) -> IoResult<Vec<PathBuf>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; Ok(enumerator .scan_devices()? .filter(|device| { device .property_value("ID_SEAT") .map(|x| x.to_os_string()) .unwrap_or_else(|| OsString::from("seat0")) == *seat.as_ref() }) .flat_map(|device| device.devnode().map(PathBuf::from)) .collect()) } /// Returns the loaded driver for a device named by it's [`dev_t`](::nix::sys::stat::dev_t). pub fn
(dev: dev_t) -> IoResult<Option<OsString>> { let mut enumerator = Enumerator::new()?; enumerator.match_subsystem("drm")?; enumerator.match_sysname("card[0-9]*")?; Ok(enumerator .scan_devices()? .filter(|device| device.devnum() == Some(dev)) .flat_map(|dev| { let mut device = Some(dev); while let Some(dev) = device { if dev.driver().is_some() { return dev.driver().map(std::ffi::OsStr::to_os_string); } device = dev.parent(); } None }) .next()) }
driver
identifier_name
instr_extractps.rs
use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; use ::RegType::*; use ::instruction_def::*; use ::Operand::*; use ::Reg::*; use ::RegScale::*; use ::test::run_test; #[test] fn extractps_1() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(Direct(EBP)), operand2: Some(Direct(XMM6)), operand3: Some(Literal8(70)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 245, 70], OperandSize::Dword) } #[test] fn extractps_2() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(IndirectScaledDisplaced(EAX, Four, 630659303, Some(OperandSize::Dword), None)), operand2: Some(Direct(XMM7)), operand3: Some(Literal8(106)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 60, 133, 231, 24, 151, 37, 106], OperandSize::Dword)
} #[test] fn extractps_4() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(Indirect(RDX, Some(OperandSize::Dword), None)), operand2: Some(Direct(XMM1)), operand3: Some(Literal8(62)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 10, 62], OperandSize::Qword) }
} #[test] fn extractps_3() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(Direct(EDI)), operand2: Some(Direct(XMM3)), operand3: Some(Literal8(85)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 223, 85], OperandSize::Qword)
random_line_split
instr_extractps.rs
use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; use ::RegType::*; use ::instruction_def::*; use ::Operand::*; use ::Reg::*; use ::RegScale::*; use ::test::run_test; #[test] fn extractps_1()
#[test] fn extractps_2() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(IndirectScaledDisplaced(EAX, Four, 630659303, Some(OperandSize::Dword), None)), operand2: Some(Direct(XMM7)), operand3: Some(Literal8(106)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 60, 133, 231, 24, 151, 37, 106], OperandSize::Dword) } #[test] fn extractps_3() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(Direct(EDI)), operand2: Some(Direct(XMM3)), operand3: Some(Literal8(85)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 223, 85], OperandSize::Qword) } #[test] fn extractps_4() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(Indirect(RDX, Some(OperandSize::Dword), None)), operand2: Some(Direct(XMM1)), operand3: Some(Literal8(62)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 10, 62], OperandSize::Qword) }
{ run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(Direct(EBP)), operand2: Some(Direct(XMM6)), operand3: Some(Literal8(70)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 245, 70], OperandSize::Dword) }
identifier_body
instr_extractps.rs
use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; use ::RegType::*; use ::instruction_def::*; use ::Operand::*; use ::Reg::*; use ::RegScale::*; use ::test::run_test; #[test] fn
() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(Direct(EBP)), operand2: Some(Direct(XMM6)), operand3: Some(Literal8(70)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 245, 70], OperandSize::Dword) } #[test] fn extractps_2() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(IndirectScaledDisplaced(EAX, Four, 630659303, Some(OperandSize::Dword), None)), operand2: Some(Direct(XMM7)), operand3: Some(Literal8(106)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 60, 133, 231, 24, 151, 37, 106], OperandSize::Dword) } #[test] fn extractps_3() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(Direct(EDI)), operand2: Some(Direct(XMM3)), operand3: Some(Literal8(85)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 223, 85], OperandSize::Qword) } #[test] fn extractps_4() { run_test(&Instruction { mnemonic: Mnemonic::EXTRACTPS, operand1: Some(Indirect(RDX, Some(OperandSize::Dword), None)), operand2: Some(Direct(XMM1)), operand3: Some(Literal8(62)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 58, 23, 10, 62], OperandSize::Qword) }
extractps_1
identifier_name
deriving-cmp-generic-enum.rs
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms.
#[derive(PartialEq, Eq, PartialOrd, Ord)] enum E<T> { E0, E1(T), E2(T,T) } pub fn main() { let e0 = E::E0; let e11 = E::E1(1i); let e12 = E::E1(2i); let e21 = E::E2(1i, 1i); let e22 = E::E2(1i, 2i); // in order for both PartialOrd and Ord let es = [e0, e11, e12, e21, e22]; for (i, e1) in es.iter().enumerate() { for (j, e2) in es.iter().enumerate() { let ord = i.cmp(&j); let eq = i == j; let lt = i < j; let le = i <= j; let gt = i > j; let ge = i >= j; // PartialEq assert_eq!(*e1 == *e2, eq); assert_eq!(*e1!= *e2,!eq); // PartialOrd assert_eq!(*e1 < *e2, lt); assert_eq!(*e1 > *e2, gt); assert_eq!(*e1 <= *e2, le); assert_eq!(*e1 >= *e2, ge); // Ord assert_eq!(e1.cmp(e2), ord); } } }
// no-pretty-expanded FIXME #15189
random_line_split
deriving-cmp-generic-enum.rs
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // no-pretty-expanded FIXME #15189 #[derive(PartialEq, Eq, PartialOrd, Ord)] enum E<T> { E0, E1(T), E2(T,T) } pub fn main()
// PartialEq assert_eq!(*e1 == *e2, eq); assert_eq!(*e1!= *e2,!eq); // PartialOrd assert_eq!(*e1 < *e2, lt); assert_eq!(*e1 > *e2, gt); assert_eq!(*e1 <= *e2, le); assert_eq!(*e1 >= *e2, ge); // Ord assert_eq!(e1.cmp(e2), ord); } } }
{ let e0 = E::E0; let e11 = E::E1(1i); let e12 = E::E1(2i); let e21 = E::E2(1i, 1i); let e22 = E::E2(1i, 2i); // in order for both PartialOrd and Ord let es = [e0, e11, e12, e21, e22]; for (i, e1) in es.iter().enumerate() { for (j, e2) in es.iter().enumerate() { let ord = i.cmp(&j); let eq = i == j; let lt = i < j; let le = i <= j; let gt = i > j; let ge = i >= j;
identifier_body
deriving-cmp-generic-enum.rs
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // no-pretty-expanded FIXME #15189 #[derive(PartialEq, Eq, PartialOrd, Ord)] enum
<T> { E0, E1(T), E2(T,T) } pub fn main() { let e0 = E::E0; let e11 = E::E1(1i); let e12 = E::E1(2i); let e21 = E::E2(1i, 1i); let e22 = E::E2(1i, 2i); // in order for both PartialOrd and Ord let es = [e0, e11, e12, e21, e22]; for (i, e1) in es.iter().enumerate() { for (j, e2) in es.iter().enumerate() { let ord = i.cmp(&j); let eq = i == j; let lt = i < j; let le = i <= j; let gt = i > j; let ge = i >= j; // PartialEq assert_eq!(*e1 == *e2, eq); assert_eq!(*e1!= *e2,!eq); // PartialOrd assert_eq!(*e1 < *e2, lt); assert_eq!(*e1 > *e2, gt); assert_eq!(*e1 <= *e2, le); assert_eq!(*e1 >= *e2, ge); // Ord assert_eq!(e1.cmp(e2), ord); } } }
E
identifier_name
receipt.rs
// Copyright 2015, 2016 Ethcore (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. //! Receipt use util::{H256, U256, Address}; use util::HeapSizeOf; use rlp::*; use basic_types::LogBloom; use header::BlockNumber; use log_entry::{LogEntry, LocalizedLogEntry}; /// Information describing execution of a transaction. #[derive(Default, Debug, Clone, Binary)] pub struct Receipt { /// The state root after executing the transaction. pub state_root: H256, /// The total gas used in the block following execution of the transaction. pub gas_used: U256, /// The OR-wide combination of all logs' blooms for this transaction. pub log_bloom: LogBloom, /// The logs stemming from this transaction. pub logs: Vec<LogEntry>, } impl Receipt { /// Create a new receipt. pub fn new(state_root: H256, gas_used: U256, logs: Vec<LogEntry>) -> Receipt { Receipt { state_root: state_root, gas_used: gas_used, log_bloom: logs.iter().fold(LogBloom::default(), |mut b, l| { b = &b | &l.bloom(); b }), //TODO: use |= operator logs: logs, } } } impl Encodable for Receipt { fn rlp_append(&self, s: &mut RlpStream) { s.begin_list(4); s.append(&self.state_root); s.append(&self.gas_used); s.append(&self.log_bloom); s.append(&self.logs); } } impl Decodable for Receipt { fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder { let d = decoder.as_rlp(); let receipt = Receipt { state_root: try!(d.val_at(0)), gas_used: try!(d.val_at(1)), log_bloom: try!(d.val_at(2)), logs: try!(d.val_at(3)), }; Ok(receipt) } } impl HeapSizeOf for Receipt { fn heap_size_of_children(&self) -> usize { self.logs.heap_size_of_children() } } /// Receipt with additional info. #[derive(Debug, Clone, PartialEq, Binary)] pub struct RichReceipt { /// Transaction hash. pub transaction_hash: H256, /// Transaction index. pub transaction_index: usize, /// The total gas used in the block following execution of the transaction. pub cumulative_gas_used: U256, /// The gas used in the execution of the transaction. Note the difference of meaning to `Receipt::gas_used`. pub gas_used: U256, /// Contract address. pub contract_address: Option<Address>, /// Logs pub logs: Vec<LogEntry>, /// Logs bloom pub log_bloom: LogBloom, /// State root pub state_root: H256, } /// Receipt with additional info. #[derive(Debug, Clone, PartialEq, Binary)] pub struct LocalizedReceipt { /// Transaction hash. pub transaction_hash: H256, /// Transaction index. pub transaction_index: usize, /// Block hash. pub block_hash: H256, /// Block number. pub block_number: BlockNumber, /// The total gas used in the block following execution of the transaction. pub cumulative_gas_used: U256, /// The gas used in the execution of the transaction. Note the difference of meaning to `Receipt::gas_used`. pub gas_used: U256, /// Contract address. pub contract_address: Option<Address>, /// Logs pub logs: Vec<LocalizedLogEntry>, /// Logs bloom pub log_bloom: LogBloom, /// State root pub state_root: H256, } #[test] fn
() { let expected = ::rustc_serialize::hex::FromHex::from_hex("f90162a02f697d671e9ae4ee24a43c4b0d7e15f1cb4ba6de1561120d43b9a4e8c4a8a6ee83040caeb9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000f838f794dcf421d093428b096ca501a7cd1a740855a7976fc0a00000000000000000000000000000000000000000000000000000000000000000").unwrap(); let r = Receipt::new( "2f697d671e9ae4ee24a43c4b0d7e15f1cb4ba6de1561120d43b9a4e8c4a8a6ee".into(), 0x40cae.into(), vec![LogEntry { address: "dcf421d093428b096ca501a7cd1a740855a7976f".into(), topics: vec![], data: vec![0u8; 32] }] ); assert_eq!(&encode(&r)[..], &expected[..]); }
test_basic
identifier_name
receipt.rs
// Copyright 2015, 2016 Ethcore (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. //! Receipt use util::{H256, U256, Address}; use util::HeapSizeOf; use rlp::*; use basic_types::LogBloom; use header::BlockNumber; use log_entry::{LogEntry, LocalizedLogEntry}; /// Information describing execution of a transaction. #[derive(Default, Debug, Clone, Binary)] pub struct Receipt { /// The state root after executing the transaction. pub state_root: H256, /// The total gas used in the block following execution of the transaction. pub gas_used: U256, /// The OR-wide combination of all logs' blooms for this transaction. pub log_bloom: LogBloom, /// The logs stemming from this transaction. pub logs: Vec<LogEntry>, } impl Receipt { /// Create a new receipt. pub fn new(state_root: H256, gas_used: U256, logs: Vec<LogEntry>) -> Receipt { Receipt { state_root: state_root, gas_used: gas_used, log_bloom: logs.iter().fold(LogBloom::default(), |mut b, l| { b = &b | &l.bloom(); b }), //TODO: use |= operator logs: logs, } } } impl Encodable for Receipt { fn rlp_append(&self, s: &mut RlpStream)
} impl Decodable for Receipt { fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder { let d = decoder.as_rlp(); let receipt = Receipt { state_root: try!(d.val_at(0)), gas_used: try!(d.val_at(1)), log_bloom: try!(d.val_at(2)), logs: try!(d.val_at(3)), }; Ok(receipt) } } impl HeapSizeOf for Receipt { fn heap_size_of_children(&self) -> usize { self.logs.heap_size_of_children() } } /// Receipt with additional info. #[derive(Debug, Clone, PartialEq, Binary)] pub struct RichReceipt { /// Transaction hash. pub transaction_hash: H256, /// Transaction index. pub transaction_index: usize, /// The total gas used in the block following execution of the transaction. pub cumulative_gas_used: U256, /// The gas used in the execution of the transaction. Note the difference of meaning to `Receipt::gas_used`. pub gas_used: U256, /// Contract address. pub contract_address: Option<Address>, /// Logs pub logs: Vec<LogEntry>, /// Logs bloom pub log_bloom: LogBloom, /// State root pub state_root: H256, } /// Receipt with additional info. #[derive(Debug, Clone, PartialEq, Binary)] pub struct LocalizedReceipt { /// Transaction hash. pub transaction_hash: H256, /// Transaction index. pub transaction_index: usize, /// Block hash. pub block_hash: H256, /// Block number. pub block_number: BlockNumber, /// The total gas used in the block following execution of the transaction. pub cumulative_gas_used: U256, /// The gas used in the execution of the transaction. Note the difference of meaning to `Receipt::gas_used`. pub gas_used: U256, /// Contract address. pub contract_address: Option<Address>, /// Logs pub logs: Vec<LocalizedLogEntry>, /// Logs bloom pub log_bloom: LogBloom, /// State root pub state_root: H256, } #[test] fn test_basic() { let expected = ::rustc_serialize::hex::FromHex::from_hex("f90162a02f697d671e9ae4ee24a43c4b0d7e15f1cb4ba6de1561120d43b9a4e8c4a8a6ee83040caeb9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000f838f794dcf421d093428b096ca501a7cd1a740855a7976fc0a00000000000000000000000000000000000000000000000000000000000000000").unwrap(); let r = Receipt::new( "2f697d671e9ae4ee24a43c4b0d7e15f1cb4ba6de1561120d43b9a4e8c4a8a6ee".into(), 0x40cae.into(), vec![LogEntry { address: "dcf421d093428b096ca501a7cd1a740855a7976f".into(), topics: vec![], data: vec![0u8; 32] }] ); assert_eq!(&encode(&r)[..], &expected[..]); }
{ s.begin_list(4); s.append(&self.state_root); s.append(&self.gas_used); s.append(&self.log_bloom); s.append(&self.logs); }
identifier_body
receipt.rs
// Copyright 2015, 2016 Ethcore (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. //! Receipt use util::{H256, U256, Address}; use util::HeapSizeOf; use rlp::*; use basic_types::LogBloom; use header::BlockNumber; use log_entry::{LogEntry, LocalizedLogEntry}; /// Information describing execution of a transaction. #[derive(Default, Debug, Clone, Binary)] pub struct Receipt { /// The state root after executing the transaction. pub state_root: H256, /// The total gas used in the block following execution of the transaction. pub gas_used: U256, /// The OR-wide combination of all logs' blooms for this transaction. pub log_bloom: LogBloom, /// The logs stemming from this transaction. pub logs: Vec<LogEntry>, } impl Receipt { /// Create a new receipt. pub fn new(state_root: H256, gas_used: U256, logs: Vec<LogEntry>) -> Receipt { Receipt { state_root: state_root, gas_used: gas_used, log_bloom: logs.iter().fold(LogBloom::default(), |mut b, l| { b = &b | &l.bloom(); b }), //TODO: use |= operator logs: logs, } } } impl Encodable for Receipt { fn rlp_append(&self, s: &mut RlpStream) { s.begin_list(4); s.append(&self.state_root); s.append(&self.gas_used); s.append(&self.log_bloom); s.append(&self.logs); } } impl Decodable for Receipt {
state_root: try!(d.val_at(0)), gas_used: try!(d.val_at(1)), log_bloom: try!(d.val_at(2)), logs: try!(d.val_at(3)), }; Ok(receipt) } } impl HeapSizeOf for Receipt { fn heap_size_of_children(&self) -> usize { self.logs.heap_size_of_children() } } /// Receipt with additional info. #[derive(Debug, Clone, PartialEq, Binary)] pub struct RichReceipt { /// Transaction hash. pub transaction_hash: H256, /// Transaction index. pub transaction_index: usize, /// The total gas used in the block following execution of the transaction. pub cumulative_gas_used: U256, /// The gas used in the execution of the transaction. Note the difference of meaning to `Receipt::gas_used`. pub gas_used: U256, /// Contract address. pub contract_address: Option<Address>, /// Logs pub logs: Vec<LogEntry>, /// Logs bloom pub log_bloom: LogBloom, /// State root pub state_root: H256, } /// Receipt with additional info. #[derive(Debug, Clone, PartialEq, Binary)] pub struct LocalizedReceipt { /// Transaction hash. pub transaction_hash: H256, /// Transaction index. pub transaction_index: usize, /// Block hash. pub block_hash: H256, /// Block number. pub block_number: BlockNumber, /// The total gas used in the block following execution of the transaction. pub cumulative_gas_used: U256, /// The gas used in the execution of the transaction. Note the difference of meaning to `Receipt::gas_used`. pub gas_used: U256, /// Contract address. pub contract_address: Option<Address>, /// Logs pub logs: Vec<LocalizedLogEntry>, /// Logs bloom pub log_bloom: LogBloom, /// State root pub state_root: H256, } #[test] fn test_basic() { let expected = ::rustc_serialize::hex::FromHex::from_hex("f90162a02f697d671e9ae4ee24a43c4b0d7e15f1cb4ba6de1561120d43b9a4e8c4a8a6ee83040caeb9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000f838f794dcf421d093428b096ca501a7cd1a740855a7976fc0a00000000000000000000000000000000000000000000000000000000000000000").unwrap(); let r = Receipt::new( "2f697d671e9ae4ee24a43c4b0d7e15f1cb4ba6de1561120d43b9a4e8c4a8a6ee".into(), 0x40cae.into(), vec![LogEntry { address: "dcf421d093428b096ca501a7cd1a740855a7976f".into(), topics: vec![], data: vec![0u8; 32] }] ); assert_eq!(&encode(&r)[..], &expected[..]); }
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder { let d = decoder.as_rlp(); let receipt = Receipt {
random_line_split
mod.rs
//! ===================================================================================== //! //! Filename: movement/mod.rs //! //! Description: Components to update actor's movement. //! //! Version: 1.0 //! Created: 13/06/16 22:43:05
//! //! Author: Anicka Burova //! //! ===================================================================================== extern crate rand; use rand::Rng; use collision::{Aabb}; use tcod::input::KeyCode; use component::Component; use util::{Offset}; use actor::Actor; use game::Game; use world::World; pub struct RandomMovement; impl Component for RandomMovement { fn update(&mut self, actor: &mut Actor, game: &Game, _: &mut World) { let offset_x = rand::thread_rng().gen_range(-1,2); let new_pos = actor.position + Offset::new(offset_x, 0); let mut res = actor.position; if game.window_bounds.contains(new_pos) { res = new_pos; } let offset_y = rand::thread_rng().gen_range(-1,2); let new_pos = res + Offset::new(0, offset_y); if game.window_bounds.contains(new_pos) { res = new_pos; } actor.position = res; } } pub struct InputMovement; impl Component for InputMovement { fn update(&mut self, actor: &mut Actor, game: &Game, _: &mut World) { let mut offset = Offset::new(0,0); let key = game.last_key; match key { KeyCode::Up => offset.y = -1, KeyCode::Down => offset.y = 1, KeyCode::Left => offset.x = -1, KeyCode::Right => offset.x = 1, _ => {} } let new_pos = actor.position + offset; if game.window_bounds.contains(new_pos) { actor.position = new_pos; } } } pub struct ChaseMovement { pub target: char, } impl Component for ChaseMovement { fn update(&mut self, actor: &mut Actor, _: &Game, world: &mut World) { // find character to chase let target = world.find(self.target); match target { Some(ref t) => { // start moving toward the target let target = t.borrow(); let x_delta = target.position.x - actor.position.x; let y_delta = target.position.y - actor.position.y; let mut offset = Offset::new(0,0); if x_delta.abs() > y_delta.abs() { offset.x = x_delta.signum(); } else { offset.y = y_delta.signum(); } actor.position = actor.position + offset; } _ => {},// do nothing if we dont have a target } } }
//! Revision: none //! Compiler: rust
random_line_split
mod.rs
//! ===================================================================================== //! //! Filename: movement/mod.rs //! //! Description: Components to update actor's movement. //! //! Version: 1.0 //! Created: 13/06/16 22:43:05 //! Revision: none //! Compiler: rust //! //! Author: Anicka Burova //! //! ===================================================================================== extern crate rand; use rand::Rng; use collision::{Aabb}; use tcod::input::KeyCode; use component::Component; use util::{Offset}; use actor::Actor; use game::Game; use world::World; pub struct RandomMovement; impl Component for RandomMovement { fn update(&mut self, actor: &mut Actor, game: &Game, _: &mut World)
} pub struct InputMovement; impl Component for InputMovement { fn update(&mut self, actor: &mut Actor, game: &Game, _: &mut World) { let mut offset = Offset::new(0,0); let key = game.last_key; match key { KeyCode::Up => offset.y = -1, KeyCode::Down => offset.y = 1, KeyCode::Left => offset.x = -1, KeyCode::Right => offset.x = 1, _ => {} } let new_pos = actor.position + offset; if game.window_bounds.contains(new_pos) { actor.position = new_pos; } } } pub struct ChaseMovement { pub target: char, } impl Component for ChaseMovement { fn update(&mut self, actor: &mut Actor, _: &Game, world: &mut World) { // find character to chase let target = world.find(self.target); match target { Some(ref t) => { // start moving toward the target let target = t.borrow(); let x_delta = target.position.x - actor.position.x; let y_delta = target.position.y - actor.position.y; let mut offset = Offset::new(0,0); if x_delta.abs() > y_delta.abs() { offset.x = x_delta.signum(); } else { offset.y = y_delta.signum(); } actor.position = actor.position + offset; } _ => {},// do nothing if we dont have a target } } }
{ let offset_x = rand::thread_rng().gen_range(-1,2); let new_pos = actor.position + Offset::new(offset_x, 0); let mut res = actor.position; if game.window_bounds.contains(new_pos) { res = new_pos; } let offset_y = rand::thread_rng().gen_range(-1,2); let new_pos = res + Offset::new(0, offset_y); if game.window_bounds.contains(new_pos) { res = new_pos; } actor.position = res; }
identifier_body
mod.rs
//! ===================================================================================== //! //! Filename: movement/mod.rs //! //! Description: Components to update actor's movement. //! //! Version: 1.0 //! Created: 13/06/16 22:43:05 //! Revision: none //! Compiler: rust //! //! Author: Anicka Burova //! //! ===================================================================================== extern crate rand; use rand::Rng; use collision::{Aabb}; use tcod::input::KeyCode; use component::Component; use util::{Offset}; use actor::Actor; use game::Game; use world::World; pub struct RandomMovement; impl Component for RandomMovement { fn update(&mut self, actor: &mut Actor, game: &Game, _: &mut World) { let offset_x = rand::thread_rng().gen_range(-1,2); let new_pos = actor.position + Offset::new(offset_x, 0); let mut res = actor.position; if game.window_bounds.contains(new_pos) { res = new_pos; } let offset_y = rand::thread_rng().gen_range(-1,2); let new_pos = res + Offset::new(0, offset_y); if game.window_bounds.contains(new_pos) { res = new_pos; } actor.position = res; } } pub struct
; impl Component for InputMovement { fn update(&mut self, actor: &mut Actor, game: &Game, _: &mut World) { let mut offset = Offset::new(0,0); let key = game.last_key; match key { KeyCode::Up => offset.y = -1, KeyCode::Down => offset.y = 1, KeyCode::Left => offset.x = -1, KeyCode::Right => offset.x = 1, _ => {} } let new_pos = actor.position + offset; if game.window_bounds.contains(new_pos) { actor.position = new_pos; } } } pub struct ChaseMovement { pub target: char, } impl Component for ChaseMovement { fn update(&mut self, actor: &mut Actor, _: &Game, world: &mut World) { // find character to chase let target = world.find(self.target); match target { Some(ref t) => { // start moving toward the target let target = t.borrow(); let x_delta = target.position.x - actor.position.x; let y_delta = target.position.y - actor.position.y; let mut offset = Offset::new(0,0); if x_delta.abs() > y_delta.abs() { offset.x = x_delta.signum(); } else { offset.y = y_delta.signum(); } actor.position = actor.position + offset; } _ => {},// do nothing if we dont have a target } } }
InputMovement
identifier_name
mod.rs
//! ===================================================================================== //! //! Filename: movement/mod.rs //! //! Description: Components to update actor's movement. //! //! Version: 1.0 //! Created: 13/06/16 22:43:05 //! Revision: none //! Compiler: rust //! //! Author: Anicka Burova //! //! ===================================================================================== extern crate rand; use rand::Rng; use collision::{Aabb}; use tcod::input::KeyCode; use component::Component; use util::{Offset}; use actor::Actor; use game::Game; use world::World; pub struct RandomMovement; impl Component for RandomMovement { fn update(&mut self, actor: &mut Actor, game: &Game, _: &mut World) { let offset_x = rand::thread_rng().gen_range(-1,2); let new_pos = actor.position + Offset::new(offset_x, 0); let mut res = actor.position; if game.window_bounds.contains(new_pos) { res = new_pos; } let offset_y = rand::thread_rng().gen_range(-1,2); let new_pos = res + Offset::new(0, offset_y); if game.window_bounds.contains(new_pos)
actor.position = res; } } pub struct InputMovement; impl Component for InputMovement { fn update(&mut self, actor: &mut Actor, game: &Game, _: &mut World) { let mut offset = Offset::new(0,0); let key = game.last_key; match key { KeyCode::Up => offset.y = -1, KeyCode::Down => offset.y = 1, KeyCode::Left => offset.x = -1, KeyCode::Right => offset.x = 1, _ => {} } let new_pos = actor.position + offset; if game.window_bounds.contains(new_pos) { actor.position = new_pos; } } } pub struct ChaseMovement { pub target: char, } impl Component for ChaseMovement { fn update(&mut self, actor: &mut Actor, _: &Game, world: &mut World) { // find character to chase let target = world.find(self.target); match target { Some(ref t) => { // start moving toward the target let target = t.borrow(); let x_delta = target.position.x - actor.position.x; let y_delta = target.position.y - actor.position.y; let mut offset = Offset::new(0,0); if x_delta.abs() > y_delta.abs() { offset.x = x_delta.signum(); } else { offset.y = y_delta.signum(); } actor.position = actor.position + offset; } _ => {},// do nothing if we dont have a target } } }
{ res = new_pos; }
conditional_block
api.rs
//! The Api system is responsible for talking to our Turtl server, and manages //! our user authentication. use ::std::io::Read; use ::std::time::Duration; use ::config; use ::reqwest::{Method, blocking::RequestBuilder, blocking::Client, Url, Proxy}; use ::reqwest::header::{HeaderMap, HeaderValue}; pub use ::reqwest::StatusCode; use ::jedi::{self, Value, DeserializeOwned}; use ::error::{MResult, MError}; use ::crypto; /// Holds our Api configuration. This consists of any mutable fields the Api /// needs to build URLs or make decisions. struct ApiConfig { auth: Option<String>, } impl ApiConfig { /// Create a new, blank config fn new() -> ApiConfig { ApiConfig { auth: None, } } } /// A struct used for building API requests pub struct ApiReq { headers: HeaderMap, timeout: Duration, data: Value, } impl ApiReq { /// Create a new builder pub fn new() -> Self { ApiReq { headers: HeaderMap::new(), timeout: Duration::new(10, 0), data: Value::Null, } } /// Set a header #[allow(dead_code)] pub fn header<'a>(mut self, name: &'static str, val: &String) -> Self { self.headers.insert(name, HeaderValue::from_str(val.as_str()).expect("ApiReq.header() -- bad header value given")); self } /// Set (override) the timeout for this request pub fn timeout<'a>(mut self, secs: u64) -> Self { self.timeout = Duration::new(secs, 0); self } /// Set this request's data #[allow(dead_code)] pub fn data<'a>(mut self, data: Value) -> Self { self.data = data; self } } /// Used to store some info we want when we send a response to call_end() pub struct CallInfo { method: Method, resource: String, } impl CallInfo { /// Create a new call info object fn new(method: Method, resource: String) -> Self { Self { method: method, resource: resource, } } } /// Our Api object. Responsible for making outbound calls to our Turtl server. pub struct Api { config: ApiConfig, } impl Api { /// Create an Api pub fn new() -> Api { Api { config: ApiConfig::new(), } } /// Set the API's authentication pub fn set_auth(&mut self, auth: String) -> MResult<()> { let auth_str = String::from("user:") + &auth; let base_auth = crypto::to_base64(&Vec::from(auth_str.as_bytes()))?; self.config.auth = Some(String::from("Basic ") + &base_auth); Ok(()) } /// Grab the auth our of the API object pub fn get_auth(&self) -> Option<String> { self.config.auth.as_ref().map(|x| x.clone()) } /// Write our auth headers into a header collection pub fn
(&self, req: RequestBuilder) -> RequestBuilder { match self.config.auth.as_ref() { Some(x) => req.header("Authorization", x.clone()), None => req, } } /// Set our standard auth header into a Headers set fn set_standard_headers(&self, req: RequestBuilder) -> RequestBuilder { self.set_auth_headers(req) .header("Content-Type", "application/json") } /// Build a full URL given a resource fn build_url(&self, resource: &str) -> MResult<String> { let endpoint = config::get::<String>(&["api", "v6", "endpoint"])?; let mut url = String::with_capacity(endpoint.len() + resource.len()); url.push_str(endpoint.trim_end_matches('/')); url.push_str(resource); Ok(url) } /// Send out an API request pub fn call<T: DeserializeOwned>(&self, method: Method, resource: &str, builder: ApiReq) -> MResult<T> { debug!("api::call() -- req: {} {}", method, resource); let ApiReq {headers, timeout, data} = builder; let url = self.build_url(resource)?; let mut client_builder = Client::builder() .timeout(timeout); match config::get::<Option<String>>(&["api", "proxy"]) { Ok(x) => { if let Some(proxy_cfg) = x { client_builder = client_builder.proxy(Proxy::http(format!("http://{}", proxy_cfg).as_str())?); } } Err(_) => {} } let client = client_builder.build()?; let req = client.request(method, Url::parse(url.as_str())?); let req = self.set_standard_headers(req) .headers(headers) .json(&data) .build()?; let callinfo = CallInfo::new(req.method().clone(), String::from(req.url().as_str())); let res = client.execute(req); res .map_err(|e| { tomerr!(e) }) .and_then(|mut res| { let mut out = String::new(); let str_res = res.read_to_string(&mut out) .map_err(|e| tomerr!(e)) .and_then(move |_| Ok(out)); if!res.status().is_success() { let errstr = match str_res { Ok(x) => x, Err(e) => { error!("api::call() -- problem grabbing error message: {}", e); String::from("<unknown>") } }; return Err(MError::Api(res.status(), errstr)); } str_res.map(move |x| (x, res)) }) .map(|(out, res)| { info!("api::call() -- res({}): {:?} {} {}", out.len(), res.status().as_u16(), &callinfo.method, &callinfo.resource); trace!(" api::call() -- body: {}", out); out }) .and_then(|out| jedi::parse(&out).map_err(|e| tomerr!(e))) } /// Convenience function for api.call(GET) pub fn get<T: DeserializeOwned>(&self, resource: &str, builder: ApiReq) -> MResult<T> { self.call(Method::GET, resource, builder) } /// Convenience function for api.call(POST) pub fn post<T: DeserializeOwned>(&self, resource: &str, builder: ApiReq) -> MResult<T> { self.call(Method::POST, resource, builder) } /// Convenience function for api.call(PUT) #[allow(dead_code)] pub fn put<T: DeserializeOwned>(&self, resource: &str, builder: ApiReq) -> MResult<T> { self.call(Method::PUT, resource, builder) } /// Convenience function for api.call(DELETE) #[allow(dead_code)] pub fn delete<T: DeserializeOwned>(&self, resource: &str, builder: ApiReq) -> MResult<T> { self.call(Method::DELETE, resource, builder) } }
set_auth_headers
identifier_name
api.rs
//! The Api system is responsible for talking to our Turtl server, and manages //! our user authentication. use ::std::io::Read; use ::std::time::Duration; use ::config; use ::reqwest::{Method, blocking::RequestBuilder, blocking::Client, Url, Proxy}; use ::reqwest::header::{HeaderMap, HeaderValue}; pub use ::reqwest::StatusCode; use ::jedi::{self, Value, DeserializeOwned}; use ::error::{MResult, MError}; use ::crypto; /// Holds our Api configuration. This consists of any mutable fields the Api /// needs to build URLs or make decisions. struct ApiConfig { auth: Option<String>, } impl ApiConfig { /// Create a new, blank config fn new() -> ApiConfig { ApiConfig { auth: None, } } } /// A struct used for building API requests pub struct ApiReq { headers: HeaderMap, timeout: Duration, data: Value, } impl ApiReq { /// Create a new builder pub fn new() -> Self { ApiReq { headers: HeaderMap::new(), timeout: Duration::new(10, 0), data: Value::Null, } } /// Set a header #[allow(dead_code)] pub fn header<'a>(mut self, name: &'static str, val: &String) -> Self { self.headers.insert(name, HeaderValue::from_str(val.as_str()).expect("ApiReq.header() -- bad header value given")); self } /// Set (override) the timeout for this request pub fn timeout<'a>(mut self, secs: u64) -> Self { self.timeout = Duration::new(secs, 0); self } /// Set this request's data #[allow(dead_code)] pub fn data<'a>(mut self, data: Value) -> Self { self.data = data; self } } /// Used to store some info we want when we send a response to call_end() pub struct CallInfo { method: Method, resource: String, } impl CallInfo { /// Create a new call info object fn new(method: Method, resource: String) -> Self { Self { method: method, resource: resource, } } } /// Our Api object. Responsible for making outbound calls to our Turtl server. pub struct Api { config: ApiConfig, }
pub fn new() -> Api { Api { config: ApiConfig::new(), } } /// Set the API's authentication pub fn set_auth(&mut self, auth: String) -> MResult<()> { let auth_str = String::from("user:") + &auth; let base_auth = crypto::to_base64(&Vec::from(auth_str.as_bytes()))?; self.config.auth = Some(String::from("Basic ") + &base_auth); Ok(()) } /// Grab the auth our of the API object pub fn get_auth(&self) -> Option<String> { self.config.auth.as_ref().map(|x| x.clone()) } /// Write our auth headers into a header collection pub fn set_auth_headers(&self, req: RequestBuilder) -> RequestBuilder { match self.config.auth.as_ref() { Some(x) => req.header("Authorization", x.clone()), None => req, } } /// Set our standard auth header into a Headers set fn set_standard_headers(&self, req: RequestBuilder) -> RequestBuilder { self.set_auth_headers(req) .header("Content-Type", "application/json") } /// Build a full URL given a resource fn build_url(&self, resource: &str) -> MResult<String> { let endpoint = config::get::<String>(&["api", "v6", "endpoint"])?; let mut url = String::with_capacity(endpoint.len() + resource.len()); url.push_str(endpoint.trim_end_matches('/')); url.push_str(resource); Ok(url) } /// Send out an API request pub fn call<T: DeserializeOwned>(&self, method: Method, resource: &str, builder: ApiReq) -> MResult<T> { debug!("api::call() -- req: {} {}", method, resource); let ApiReq {headers, timeout, data} = builder; let url = self.build_url(resource)?; let mut client_builder = Client::builder() .timeout(timeout); match config::get::<Option<String>>(&["api", "proxy"]) { Ok(x) => { if let Some(proxy_cfg) = x { client_builder = client_builder.proxy(Proxy::http(format!("http://{}", proxy_cfg).as_str())?); } } Err(_) => {} } let client = client_builder.build()?; let req = client.request(method, Url::parse(url.as_str())?); let req = self.set_standard_headers(req) .headers(headers) .json(&data) .build()?; let callinfo = CallInfo::new(req.method().clone(), String::from(req.url().as_str())); let res = client.execute(req); res .map_err(|e| { tomerr!(e) }) .and_then(|mut res| { let mut out = String::new(); let str_res = res.read_to_string(&mut out) .map_err(|e| tomerr!(e)) .and_then(move |_| Ok(out)); if!res.status().is_success() { let errstr = match str_res { Ok(x) => x, Err(e) => { error!("api::call() -- problem grabbing error message: {}", e); String::from("<unknown>") } }; return Err(MError::Api(res.status(), errstr)); } str_res.map(move |x| (x, res)) }) .map(|(out, res)| { info!("api::call() -- res({}): {:?} {} {}", out.len(), res.status().as_u16(), &callinfo.method, &callinfo.resource); trace!(" api::call() -- body: {}", out); out }) .and_then(|out| jedi::parse(&out).map_err(|e| tomerr!(e))) } /// Convenience function for api.call(GET) pub fn get<T: DeserializeOwned>(&self, resource: &str, builder: ApiReq) -> MResult<T> { self.call(Method::GET, resource, builder) } /// Convenience function for api.call(POST) pub fn post<T: DeserializeOwned>(&self, resource: &str, builder: ApiReq) -> MResult<T> { self.call(Method::POST, resource, builder) } /// Convenience function for api.call(PUT) #[allow(dead_code)] pub fn put<T: DeserializeOwned>(&self, resource: &str, builder: ApiReq) -> MResult<T> { self.call(Method::PUT, resource, builder) } /// Convenience function for api.call(DELETE) #[allow(dead_code)] pub fn delete<T: DeserializeOwned>(&self, resource: &str, builder: ApiReq) -> MResult<T> { self.call(Method::DELETE, resource, builder) } }
impl Api { /// Create an Api
random_line_split
loader.rs
_library_crate() { Some(t) => t, None => { self.report_load_errs(); unreachable!() } } } pub fn report_load_errs(&mut self) { let message = if self.rejected_via_hash.len() > 0 { format!("found possibly newer version of crate `{}`", self.ident) } else if self.rejected_via_triple.len() > 0 { format!("found incorrect triple for crate `{}`", self.ident) } else { format!("can't find crate for `{}`", self.ident) }; let message = match self.root { &None => message, &Some(ref r) => format!("{} which `{}` depends on", message, r.ident) }; self.sess.span_err(self.span, message.as_slice()); let mismatches = self.rejected_via_triple.iter(); if self.rejected_via_triple.len() > 0 { self.sess.span_note(self.span, format!("expected triple of {}", self.triple).as_slice()); for (i, &CrateMismatch{ ref path, ref got }) in mismatches.enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path \\#{}, triple {}: {}", self.ident, i+1, got, path.display()).as_slice()); } } if self.rejected_via_hash.len() > 0 { self.sess.span_note(self.span, "perhaps this crate needs \ to be recompiled?"); let mismatches = self.rejected_via_hash.iter(); for (i, &CrateMismatch{ ref path,.. }) in mismatches.enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path \\#{}: {}", self.ident, i+1, path.display()).as_slice()); } match self.root { &None => {} &Some(ref r) => { for (i, path) in r.paths().iter().enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path \\#{}: {}", r.ident, i+1, path.display()).as_slice()); } } } } self.sess.abort_if_errors(); } fn find_library_crate(&mut self) -> Option<Library> { let (dyprefix, dysuffix) = self.dylibname(); // want: crate_name.dir_part() + prefix + crate_name.file_part + "-" let dylib_prefix = format!("{}{}-", dyprefix, self.crate_id.name); let rlib_prefix = format!("lib{}-", self.crate_id.name); let mut candidates = HashMap::new(); // First, find all possible candidate rlibs and dylibs purely based on // the name of the files themselves. We're trying to match against an // exact crate_id and a possibly an exact hash. // // During this step, we can filter all found libraries based on the // name and id found in the crate id (we ignore the path portion for // filename matching), as well as the exact hash (if specified). If we // end up having many candidates, we must look at the metadata to // perform exact matches against hashes/crate ids. Note that opening up // the metadata is where we do an exact match against the full contents // of the crate id (path/name/id). // // The goal of this step is to look at as little metadata as possible. self.filesearch.search(|path| { let file = match path.filename_str() { None => return FileDoesntMatch, Some(file) => file, }; if file.starts_with(rlib_prefix.as_slice()) && file.ends_with(".rlib") { info!("rlib candidate: {}", path.display()); match self.try_match(file, rlib_prefix.as_slice(), ".rlib") { Some(hash) => { info!("rlib accepted, hash: {}", hash); let slot = candidates.find_or_insert_with(hash, |_| { (HashSet::new(), HashSet::new()) }); let (ref mut rlibs, _) = *slot; rlibs.insert(fs::realpath(path).unwrap()); FileMatches } None => { info!("rlib rejected"); FileDoesntMatch } } } else if file.starts_with(dylib_prefix.as_slice()) && file.ends_with(dysuffix){ info!("dylib candidate: {}", path.display()); match self.try_match(file, dylib_prefix.as_slice(), dysuffix) { Some(hash) => { info!("dylib accepted, hash: {}", hash); let slot = candidates.find_or_insert_with(hash, |_| { (HashSet::new(), HashSet::new()) }); let (_, ref mut dylibs) = *slot; dylibs.insert(fs::realpath(path).unwrap()); FileMatches } None => { info!("dylib rejected"); FileDoesntMatch } } } else { FileDoesntMatch } }); // We have now collected all known libraries into a set of candidates // keyed of the filename hash listed. For each filename, we also have a // list of rlibs/dylibs that apply. Here, we map each of these lists // (per hash), to a Library candidate for returning. // // A Library candidate is created if the metadata for the set of // libraries corresponds to the crate id and hash criteria that this // search is being performed for. let mut libraries = Vec::new(); for (_hash, (rlibs, dylibs)) in candidates.move_iter() { let mut metadata = None; let rlib = self.extract_one(rlibs, "rlib", &mut metadata); let dylib = self.extract_one(dylibs, "dylib", &mut metadata); match metadata { Some(metadata) => { libraries.push(Library { dylib: dylib, rlib: rlib, metadata: metadata, }) } None => {} } } // Having now translated all relevant found hashes into libraries, see // what we've got and figure out if we found multiple candidates for // libraries or not. match libraries.len() { 0 => None, 1 => Some(libraries.move_iter().next().unwrap()), _ => { self.sess.span_err(self.span, format!("multiple matching crates for `{}`", self.crate_id.name).as_slice()); self.sess.note("candidates:"); for lib in libraries.iter() { match lib.dylib { Some(ref p) => { self.sess.note(format!("path: {}", p.display()).as_slice()); } None => {} } match lib.rlib { Some(ref p) => { self.sess.note(format!("path: {}", p.display()).as_slice()); } None => {} } let data = lib.metadata.as_slice(); let crate_id = decoder::get_crate_id(data); note_crateid_attr(self.sess.diagnostic(), &crate_id); } None } } } // Attempts to match the requested version of a library against the file // specified. The prefix/suffix are specified (disambiguates between // rlib/dylib). // // The return value is `None` if `file` doesn't look like a rust-generated // library, or if a specific version was requested and it doesn't match the // apparent file's version. // // If everything checks out, then `Some(hash)` is returned where `hash` is // the listed hash in the filename itself. fn try_match(&self, file: &str, prefix: &str, suffix: &str) -> Option<String>{ let middle = file.slice(prefix.len(), file.len() - suffix.len()); debug!("matching -- {}, middle: {}", file, middle); let mut parts = middle.splitn('-', 1); let hash = match parts.next() { Some(h) => h, None => return None }; debug!("matching -- {}, hash: {} (want {})", file, hash, self.id_hash); let vers = match parts.next() { Some(v) => v, None => return None }; debug!("matching -- {}, vers: {} (want {})", file, vers, self.crate_id.version); match self.crate_id.version { Some(ref version) if version.as_slice()!= vers => return None, Some(..) => {} // check the hash // hash is irrelevant, no version specified None => return Some(hash.to_string()) } debug!("matching -- {}, vers ok", file); // hashes in filenames are prefixes of the "true hash" if self.id_hash == hash.as_slice() { debug!("matching -- {}, hash ok", file); Some(hash.to_string()) } else { None } } // Attempts to extract *one* library from the set `m`. If the set has no // elements, `None` is returned. If the set has more than one element, then // the errors and notes are emitted about the set of libraries. // // With only one library in the set, this function will extract it, and then // read the metadata from it if `*slot` is `None`. If the metadata couldn't // be read, it is assumed that the file isn't a valid rust library (no // errors are emitted). fn extract_one(&mut self, m: HashSet<Path>, flavor: &str, slot: &mut Option<MetadataBlob>) -> Option<Path> { let mut ret = None::<Path>; let mut error = 0; if slot.is_some() { // FIXME(#10786): for an optimization, we only read one of the // library's metadata sections. In theory we should // read both, but reading dylib metadata is quite // slow. if m.len() == 0 { return None } else if m.len() == 1 { return Some(m.move_iter().next().unwrap()) } } for lib in m.move_iter() { info!("{} reading metadata from: {}", flavor, lib.display()); let metadata = match get_metadata_section(self.os, &lib) { Ok(blob) => { if self.crate_matches(blob.as_slice(), &lib) { blob } else { info!("metadata mismatch"); continue } } Err(_) => { info!("no metadata found"); continue } }; if ret.is_some() { self.sess.span_err(self.span, format!("multiple {} candidates for `{}` \ found", flavor, self.crate_id.name).as_slice()); self.sess.span_note(self.span, format!(r"candidate \#1: {}", ret.get_ref() .display()).as_slice()); error = 1; ret = None; } if error > 0 { error += 1; self.sess.span_note(self.span, format!(r"candidate \#{}: {}", error, lib.display()).as_slice()); continue } *slot = Some(metadata); ret = Some(lib); } return if error > 0 {None} else {ret} } fn crate_matches(&mut self, crate_data: &[u8], libpath: &Path) -> bool { match decoder::maybe_get_crate_id(crate_data) { Some(ref id) if self.crate_id.matches(id) => {} _ => { info!("Rejecting via crate_id"); return false } } let hash = match decoder::maybe_get_crate_hash(crate_data) { Some(hash) => hash, None => { info!("Rejecting via lack of crate hash"); return false; } }; let triple = decoder::get_crate_triple(crate_data); if triple.as_slice()!= self.triple { info!("Rejecting via crate triple: expected {} got {}", self.triple, triple); self.rejected_via_triple.push(CrateMismatch { path: libpath.clone(), got: triple.to_string() }); return false; } match self.hash { None => true, Some(myhash) => { if *myhash!= hash { info!("Rejecting via hash: expected {} got {}", *myhash, hash); self.rejected_via_hash.push(CrateMismatch { path: libpath.clone(), got: myhash.as_str().to_string() }); false } else { true } } } } // Returns the corresponding (prefix, suffix) that files need to have for // dynamic libraries fn dylibname(&self) -> (&'static str, &'static str) { match self.os { OsWin32 => (WIN32_DLL_PREFIX, WIN32_DLL_SUFFIX), OsMacos => (MACOS_DLL_PREFIX, MACOS_DLL_SUFFIX), OsLinux => (LINUX_DLL_PREFIX, LINUX_DLL_SUFFIX), OsAndroid => (ANDROID_DLL_PREFIX, ANDROID_DLL_SUFFIX), OsFreebsd => (FREEBSD_DLL_PREFIX, FREEBSD_DLL_SUFFIX), } } } pub fn note_crateid_attr(diag: &SpanHandler, crateid: &CrateId) { diag.handler().note(format!("crate_id: {}", crateid.to_str()).as_slice()); } impl ArchiveMetadata { fn new(ar: ArchiveRO) -> Option<ArchiveMetadata> { let data: &'static [u8] = { let data = match ar.read(METADATA_FILENAME) { Some(data) => data, None => { debug!("didn't find '{}' in the archive", METADATA_FILENAME); return None; } }; // This data is actually a pointer inside of the archive itself, but // we essentially want to cache it because the lookup inside the // archive is a fairly expensive operation (and it's queried for // *very* frequently). For this reason, we transmute it to the // static lifetime to put into the struct. Note that the buffer is // never actually handed out with a static lifetime, but rather the // buffer is loaned with the lifetime of this containing object. // Hence, we're guaranteed that the buffer will never be used after // this object is dead, so this is a safe operation to transmute and
// store the data as a static buffer.
random_line_split
loader.rs
{ archive: ArchiveRO, // See comments in ArchiveMetadata::new for why this is static data: &'static [u8], } pub struct CratePaths { pub ident: String, pub dylib: Option<Path>, pub rlib: Option<Path> } impl CratePaths { fn paths(&self) -> Vec<Path> { match (&self.dylib, &self.rlib) { (&None, &None) => vec!(), (&Some(ref p), &None) | (&None, &Some(ref p)) => vec!(p.clone()), (&Some(ref p1), &Some(ref p2)) => vec!(p1.clone(), p2.clone()), } } } impl<'a> Context<'a> { pub fn maybe_load_library_crate(&mut self) -> Option<Library> { self.find_library_crate() } pub fn load_library_crate(&mut self) -> Library { match self.find_library_crate() { Some(t) => t, None => { self.report_load_errs(); unreachable!() } } } pub fn report_load_errs(&mut self) { let message = if self.rejected_via_hash.len() > 0 { format!("found possibly newer version of crate `{}`", self.ident) } else if self.rejected_via_triple.len() > 0 { format!("found incorrect triple for crate `{}`", self.ident) } else { format!("can't find crate for `{}`", self.ident) }; let message = match self.root { &None => message, &Some(ref r) => format!("{} which `{}` depends on", message, r.ident) }; self.sess.span_err(self.span, message.as_slice()); let mismatches = self.rejected_via_triple.iter(); if self.rejected_via_triple.len() > 0 { self.sess.span_note(self.span, format!("expected triple of {}", self.triple).as_slice()); for (i, &CrateMismatch{ ref path, ref got }) in mismatches.enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path \\#{}, triple {}: {}", self.ident, i+1, got, path.display()).as_slice()); } } if self.rejected_via_hash.len() > 0 { self.sess.span_note(self.span, "perhaps this crate needs \ to be recompiled?"); let mismatches = self.rejected_via_hash.iter(); for (i, &CrateMismatch{ ref path,.. }) in mismatches.enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path \\#{}: {}", self.ident, i+1, path.display()).as_slice()); } match self.root { &None => {} &Some(ref r) => { for (i, path) in r.paths().iter().enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path \\#{}: {}", r.ident, i+1, path.display()).as_slice()); } } } } self.sess.abort_if_errors(); } fn find_library_crate(&mut self) -> Option<Library> { let (dyprefix, dysuffix) = self.dylibname(); // want: crate_name.dir_part() + prefix + crate_name.file_part + "-" let dylib_prefix = format!("{}{}-", dyprefix, self.crate_id.name); let rlib_prefix = format!("lib{}-", self.crate_id.name); let mut candidates = HashMap::new(); // First, find all possible candidate rlibs and dylibs purely based on // the name of the files themselves. We're trying to match against an // exact crate_id and a possibly an exact hash. // // During this step, we can filter all found libraries based on the // name and id found in the crate id (we ignore the path portion for // filename matching), as well as the exact hash (if specified). If we // end up having many candidates, we must look at the metadata to // perform exact matches against hashes/crate ids. Note that opening up // the metadata is where we do an exact match against the full contents // of the crate id (path/name/id). // // The goal of this step is to look at as little metadata as possible. self.filesearch.search(|path| { let file = match path.filename_str() { None => return FileDoesntMatch, Some(file) => file, }; if file.starts_with(rlib_prefix.as_slice()) && file.ends_with(".rlib") { info!("rlib candidate: {}", path.display()); match self.try_match(file, rlib_prefix.as_slice(), ".rlib") { Some(hash) => { info!("rlib accepted, hash: {}", hash); let slot = candidates.find_or_insert_with(hash, |_| { (HashSet::new(), HashSet::new()) }); let (ref mut rlibs, _) = *slot; rlibs.insert(fs::realpath(path).unwrap()); FileMatches } None => { info!("rlib rejected"); FileDoesntMatch } } } else if file.starts_with(dylib_prefix.as_slice()) && file.ends_with(dysuffix){ info!("dylib candidate: {}", path.display()); match self.try_match(file, dylib_prefix.as_slice(), dysuffix) { Some(hash) => { info!("dylib accepted, hash: {}", hash); let slot = candidates.find_or_insert_with(hash, |_| { (HashSet::new(), HashSet::new()) }); let (_, ref mut dylibs) = *slot; dylibs.insert(fs::realpath(path).unwrap()); FileMatches } None => { info!("dylib rejected"); FileDoesntMatch } } } else { FileDoesntMatch } }); // We have now collected all known libraries into a set of candidates // keyed of the filename hash listed. For each filename, we also have a // list of rlibs/dylibs that apply. Here, we map each of these lists // (per hash), to a Library candidate for returning. // // A Library candidate is created if the metadata for the set of // libraries corresponds to the crate id and hash criteria that this // search is being performed for. let mut libraries = Vec::new(); for (_hash, (rlibs, dylibs)) in candidates.move_iter() { let mut metadata = None; let rlib = self.extract_one(rlibs, "rlib", &mut metadata); let dylib = self.extract_one(dylibs, "dylib", &mut metadata); match metadata { Some(metadata) => { libraries.push(Library { dylib: dylib, rlib: rlib, metadata: metadata, }) } None => {} } } // Having now translated all relevant found hashes into libraries, see // what we've got and figure out if we found multiple candidates for // libraries or not. match libraries.len() { 0 => None, 1 => Some(libraries.move_iter().next().unwrap()), _ => { self.sess.span_err(self.span, format!("multiple matching crates for `{}`", self.crate_id.name).as_slice()); self.sess.note("candidates:"); for lib in libraries.iter() { match lib.dylib { Some(ref p) => { self.sess.note(format!("path: {}", p.display()).as_slice()); } None => {} } match lib.rlib { Some(ref p) => { self.sess.note(format!("path: {}", p.display()).as_slice()); } None => {} } let data = lib.metadata.as_slice(); let crate_id = decoder::get_crate_id(data); note_crateid_attr(self.sess.diagnostic(), &crate_id); } None } } } // Attempts to match the requested version of a library against the file // specified. The prefix/suffix are specified (disambiguates between // rlib/dylib). // // The return value is `None` if `file` doesn't look like a rust-generated // library, or if a specific version was requested and it doesn't match the // apparent file's version. // // If everything checks out, then `Some(hash)` is returned where `hash` is // the listed hash in the filename itself. fn try_match(&self, file: &str, prefix: &str, suffix: &str) -> Option<String>{ let middle = file.slice(prefix.len(), file.len() - suffix.len()); debug!("matching -- {}, middle: {}", file, middle); let mut parts = middle.splitn('-', 1); let hash = match parts.next() { Some(h) => h, None => return None }; debug!("matching -- {}, hash: {} (want {})", file, hash, self.id_hash); let vers = match parts.next() { Some(v) => v, None => return None }; debug!("matching -- {}, vers: {} (want {})", file, vers, self.crate_id.version); match self.crate_id.version { Some(ref version) if version.as_slice()!= vers => return None, Some(..) => {} // check the hash // hash is irrelevant, no version specified None => return Some(hash.to_string()) } debug!("matching -- {}, vers ok", file); // hashes in filenames are prefixes of the "true hash" if self.id_hash == hash.as_slice() { debug!("matching -- {}, hash ok", file); Some(hash.to_string()) } else { None } } // Attempts to extract *one* library from the set `m`. If the set has no // elements, `None` is returned. If the set has more than one element, then // the errors and notes are emitted about the set of libraries. // // With only one library in the set, this function will extract it, and then // read the metadata from it if `*slot` is `None`. If the metadata couldn't // be read, it is assumed that the file isn't a valid rust library (no // errors are emitted). fn extract_one(&mut self, m: HashSet<Path>, flavor: &str, slot: &mut Option<MetadataBlob>) -> Option<Path> { let mut ret = None::<Path>; let mut error = 0; if slot.is_some() { // FIXME(#10786): for an optimization, we only read one of the // library's metadata sections. In theory we should // read both, but reading dylib metadata is quite // slow. if m.len() == 0 { return None } else if m.len() == 1 { return Some(m.move_iter().next().unwrap()) } } for lib in m.move_iter() { info!("{} reading metadata from: {}", flavor, lib.display()); let metadata = match get_metadata_section(self.os, &lib) { Ok(blob) => { if self.crate_matches(blob.as_slice(), &lib) { blob } else { info!("metadata mismatch"); continue } } Err(_) => { info!("no metadata found"); continue } }; if ret.is_some() { self.sess.span_err(self.span, format!("multiple {} candidates for `{}` \ found", flavor, self.crate_id.name).as_slice()); self.sess.span_note(self.span, format!(r"candidate \#1: {}", ret.get_ref() .display()).as_slice()); error = 1; ret = None; } if error > 0 { error += 1; self.sess.span_note(self.span, format!(r"candidate \#{}: {}", error, lib.display()).as_slice()); continue } *slot = Some(metadata); ret = Some(lib); } return if error > 0 {None} else {ret} } fn crate_matches(&mut self, crate_data: &[u8], libpath: &Path) -> bool { match decoder::maybe_get_crate_id(crate_data) { Some(ref id) if self.crate_id.matches(id) => {} _ => { info!("Rejecting via crate_id"); return false } } let hash = match decoder::maybe_get_crate_hash(crate_data) { Some(hash) => hash, None => { info!("Rejecting via lack of crate hash"); return false; } }; let triple = decoder::get_crate_triple(crate_data); if triple.as_slice()!= self.triple { info!("Rejecting via crate triple: expected {} got {}", self.triple, triple); self.rejected_via_triple.push(CrateMismatch { path: libpath.clone(), got: triple.to_string() }); return false; } match self.hash { None => true, Some(myhash) => { if *myhash!= hash { info!("Rejecting via hash: expected {} got {}", *myhash, hash); self.rejected_via_hash.push(CrateMismatch { path: libpath.clone(), got: myhash.as_str().to_string() }); false } else { true } } } } // Returns the corresponding (prefix, suffix) that files need to have for // dynamic libraries fn dylibname(&self) -> (&'static str, &'static str) { match self.os { OsWin32 => (WIN32_DLL_PREFIX, WIN32_DLL_SUFFIX), OsMacos => (MACOS_DLL_PREFIX, MACOS_DLL_SUFFIX), OsLinux => (LINUX_DLL_PREFIX, LINUX_DLL_SUFFIX), OsAndroid => (ANDROID_DLL_PREFIX, ANDROID_DLL_SUFFIX), OsFreebsd => (FREEBSD_DLL_PREFIX, FREEBSD_DLL_SUFFIX), } } } pub fn note_crateid_attr(diag: &SpanHandler, crateid: &CrateId) { diag.handler().note(format!("crate_id: {}", crateid.to_str()).as_slice()); } impl ArchiveMetadata { fn new(ar: ArchiveRO) -> Option<ArchiveMetadata> { let data: &'static [u8] = { let data = match ar.read(METADATA_FILENAME) { Some(data) => data,
ArchiveMetadata
identifier_name
loader.rs
(HashSet::new(), HashSet::new()) }); let (_, ref mut dylibs) = *slot; dylibs.insert(fs::realpath(path).unwrap()); FileMatches } None => { info!("dylib rejected"); FileDoesntMatch } } } else { FileDoesntMatch } }); // We have now collected all known libraries into a set of candidates // keyed of the filename hash listed. For each filename, we also have a // list of rlibs/dylibs that apply. Here, we map each of these lists // (per hash), to a Library candidate for returning. // // A Library candidate is created if the metadata for the set of // libraries corresponds to the crate id and hash criteria that this // search is being performed for. let mut libraries = Vec::new(); for (_hash, (rlibs, dylibs)) in candidates.move_iter() { let mut metadata = None; let rlib = self.extract_one(rlibs, "rlib", &mut metadata); let dylib = self.extract_one(dylibs, "dylib", &mut metadata); match metadata { Some(metadata) => { libraries.push(Library { dylib: dylib, rlib: rlib, metadata: metadata, }) } None => {} } } // Having now translated all relevant found hashes into libraries, see // what we've got and figure out if we found multiple candidates for // libraries or not. match libraries.len() { 0 => None, 1 => Some(libraries.move_iter().next().unwrap()), _ => { self.sess.span_err(self.span, format!("multiple matching crates for `{}`", self.crate_id.name).as_slice()); self.sess.note("candidates:"); for lib in libraries.iter() { match lib.dylib { Some(ref p) => { self.sess.note(format!("path: {}", p.display()).as_slice()); } None => {} } match lib.rlib { Some(ref p) => { self.sess.note(format!("path: {}", p.display()).as_slice()); } None => {} } let data = lib.metadata.as_slice(); let crate_id = decoder::get_crate_id(data); note_crateid_attr(self.sess.diagnostic(), &crate_id); } None } } } // Attempts to match the requested version of a library against the file // specified. The prefix/suffix are specified (disambiguates between // rlib/dylib). // // The return value is `None` if `file` doesn't look like a rust-generated // library, or if a specific version was requested and it doesn't match the // apparent file's version. // // If everything checks out, then `Some(hash)` is returned where `hash` is // the listed hash in the filename itself. fn try_match(&self, file: &str, prefix: &str, suffix: &str) -> Option<String>{ let middle = file.slice(prefix.len(), file.len() - suffix.len()); debug!("matching -- {}, middle: {}", file, middle); let mut parts = middle.splitn('-', 1); let hash = match parts.next() { Some(h) => h, None => return None }; debug!("matching -- {}, hash: {} (want {})", file, hash, self.id_hash); let vers = match parts.next() { Some(v) => v, None => return None }; debug!("matching -- {}, vers: {} (want {})", file, vers, self.crate_id.version); match self.crate_id.version { Some(ref version) if version.as_slice()!= vers => return None, Some(..) => {} // check the hash // hash is irrelevant, no version specified None => return Some(hash.to_string()) } debug!("matching -- {}, vers ok", file); // hashes in filenames are prefixes of the "true hash" if self.id_hash == hash.as_slice() { debug!("matching -- {}, hash ok", file); Some(hash.to_string()) } else { None } } // Attempts to extract *one* library from the set `m`. If the set has no // elements, `None` is returned. If the set has more than one element, then // the errors and notes are emitted about the set of libraries. // // With only one library in the set, this function will extract it, and then // read the metadata from it if `*slot` is `None`. If the metadata couldn't // be read, it is assumed that the file isn't a valid rust library (no // errors are emitted). fn extract_one(&mut self, m: HashSet<Path>, flavor: &str, slot: &mut Option<MetadataBlob>) -> Option<Path> { let mut ret = None::<Path>; let mut error = 0; if slot.is_some() { // FIXME(#10786): for an optimization, we only read one of the // library's metadata sections. In theory we should // read both, but reading dylib metadata is quite // slow. if m.len() == 0 { return None } else if m.len() == 1 { return Some(m.move_iter().next().unwrap()) } } for lib in m.move_iter() { info!("{} reading metadata from: {}", flavor, lib.display()); let metadata = match get_metadata_section(self.os, &lib) { Ok(blob) => { if self.crate_matches(blob.as_slice(), &lib) { blob } else { info!("metadata mismatch"); continue } } Err(_) => { info!("no metadata found"); continue } }; if ret.is_some() { self.sess.span_err(self.span, format!("multiple {} candidates for `{}` \ found", flavor, self.crate_id.name).as_slice()); self.sess.span_note(self.span, format!(r"candidate \#1: {}", ret.get_ref() .display()).as_slice()); error = 1; ret = None; } if error > 0 { error += 1; self.sess.span_note(self.span, format!(r"candidate \#{}: {}", error, lib.display()).as_slice()); continue } *slot = Some(metadata); ret = Some(lib); } return if error > 0 {None} else {ret} } fn crate_matches(&mut self, crate_data: &[u8], libpath: &Path) -> bool { match decoder::maybe_get_crate_id(crate_data) { Some(ref id) if self.crate_id.matches(id) => {} _ => { info!("Rejecting via crate_id"); return false } } let hash = match decoder::maybe_get_crate_hash(crate_data) { Some(hash) => hash, None => { info!("Rejecting via lack of crate hash"); return false; } }; let triple = decoder::get_crate_triple(crate_data); if triple.as_slice()!= self.triple { info!("Rejecting via crate triple: expected {} got {}", self.triple, triple); self.rejected_via_triple.push(CrateMismatch { path: libpath.clone(), got: triple.to_string() }); return false; } match self.hash { None => true, Some(myhash) => { if *myhash!= hash { info!("Rejecting via hash: expected {} got {}", *myhash, hash); self.rejected_via_hash.push(CrateMismatch { path: libpath.clone(), got: myhash.as_str().to_string() }); false } else { true } } } } // Returns the corresponding (prefix, suffix) that files need to have for // dynamic libraries fn dylibname(&self) -> (&'static str, &'static str) { match self.os { OsWin32 => (WIN32_DLL_PREFIX, WIN32_DLL_SUFFIX), OsMacos => (MACOS_DLL_PREFIX, MACOS_DLL_SUFFIX), OsLinux => (LINUX_DLL_PREFIX, LINUX_DLL_SUFFIX), OsAndroid => (ANDROID_DLL_PREFIX, ANDROID_DLL_SUFFIX), OsFreebsd => (FREEBSD_DLL_PREFIX, FREEBSD_DLL_SUFFIX), } } } pub fn note_crateid_attr(diag: &SpanHandler, crateid: &CrateId) { diag.handler().note(format!("crate_id: {}", crateid.to_str()).as_slice()); } impl ArchiveMetadata { fn new(ar: ArchiveRO) -> Option<ArchiveMetadata> { let data: &'static [u8] = { let data = match ar.read(METADATA_FILENAME) { Some(data) => data, None => { debug!("didn't find '{}' in the archive", METADATA_FILENAME); return None; } }; // This data is actually a pointer inside of the archive itself, but // we essentially want to cache it because the lookup inside the // archive is a fairly expensive operation (and it's queried for // *very* frequently). For this reason, we transmute it to the // static lifetime to put into the struct. Note that the buffer is // never actually handed out with a static lifetime, but rather the // buffer is loaned with the lifetime of this containing object. // Hence, we're guaranteed that the buffer will never be used after // this object is dead, so this is a safe operation to transmute and // store the data as a static buffer. unsafe { mem::transmute(data) } }; Some(ArchiveMetadata { archive: ar, data: data, }) } pub fn as_slice<'a>(&'a self) -> &'a [u8] { self.data } } // Just a small wrapper to time how long reading metadata takes. fn get_metadata_section(os: Os, filename: &Path) -> Result<MetadataBlob, String> { let start = time::precise_time_ns(); let ret = get_metadata_section_imp(os, filename); info!("reading {} => {}ms", filename.filename_display(), (time::precise_time_ns() - start) / 1000000); return ret; } fn get_metadata_section_imp(os: Os, filename: &Path) -> Result<MetadataBlob, String> { if!filename.exists() { return Err(format!("no such file: '{}'", filename.display())); } if filename.filename_str().unwrap().ends_with(".rlib") { // Use ArchiveRO for speed here, it's backed by LLVM and uses mmap // internally to read the file. We also avoid even using a memcpy by // just keeping the archive along while the metadata is in use. let archive = match ArchiveRO::open(filename) { Some(ar) => ar, None => { debug!("llvm didn't like `{}`", filename.display()); return Err(format!("failed to read rlib metadata: '{}'", filename.display())); } }; return match ArchiveMetadata::new(archive).map(|ar| MetadataArchive(ar)) { None => { return Err((format!("failed to read rlib metadata: '{}'", filename.display()))) } Some(blob) => return Ok(blob) } } unsafe { let mb = filename.with_c_str(|buf| { llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf) }); if mb as int == 0 { return Err(format!("error reading library: '{}'", filename.display())) } let of = match ObjectFile::new(mb) { Some(of) => of, _ => { return Err((format!("provided path not an object file: '{}'", filename.display()))) } }; let si = mk_section_iter(of.llof); while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False { let mut name_buf = ptr::null(); let name_len = llvm::LLVMRustGetSectionName(si.llsi, &mut name_buf); let name = str::raw::from_buf_len(name_buf as *u8, name_len as uint); debug!("get_metadata_section: name {}", name); if read_meta_section_name(os).as_slice() == name.as_slice() { let cbuf = llvm::LLVMGetSectionContents(si.llsi); let csz = llvm::LLVMGetSectionSize(si.llsi) as uint; let mut found = Err(format!("metadata not found: '{}'", filename.display())); let cvbuf: *u8 = mem::transmute(cbuf); let vlen = encoder::metadata_encoding_version.len(); debug!("checking {} bytes of metadata-version stamp", vlen); let minsz = cmp::min(vlen, csz); let version_ok = slice::raw::buf_as_slice(cvbuf, minsz, |buf0| buf0 == encoder::metadata_encoding_version); if!version_ok { return Err((format!("incompatible metadata version found: '{}'", filename.display()))); } let cvbuf1 = cvbuf.offset(vlen as int); debug!("inflating {} bytes of compressed metadata", csz - vlen); slice::raw::buf_as_slice(cvbuf1, csz-vlen, |bytes| { match flate::inflate_bytes(bytes) { Some(inflated) => found = Ok(MetadataVec(inflated)), None => { found = Err(format!("failed to decompress \ metadata for: '{}'", filename.display())) } } }); if found.is_ok() { return found; } } llvm::LLVMMoveToNextSection(si.llsi); } return Err(format!("metadata not found: '{}'", filename.display())); } } pub fn meta_section_name(os: Os) -> &'static str { match os { OsMacos => "__DATA,__note.rustc", OsWin32 => ".note.rustc", OsLinux => ".note.rustc", OsAndroid => ".note.rustc", OsFreebsd => ".note.rustc" } } pub fn read_meta_section_name(os: Os) -> &'static str { match os { OsMacos => "__note.rustc", OsWin32 => ".note.rustc", OsLinux => ".note.rustc", OsAndroid => ".note.rustc", OsFreebsd => ".note.rustc" } } // A diagnostic function for dumping crate metadata to an output stream pub fn list_file_metadata(os: Os, path: &Path, out: &mut io::Writer) -> io::IoResult<()>
{ match get_metadata_section(os, path) { Ok(bytes) => decoder::list_crate_metadata(bytes.as_slice(), out), Err(msg) => { write!(out, "{}\n", msg) } } }
identifier_body
signer.rs
// Copyright 2015-2017 Parity Technologies (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. //! A signer used by Engines which need to sign messages. use util::{Arc, Mutex, RwLock, H256, Address}; use ethkey::Signature; use account_provider::{self, AccountProvider}; /// Everything that an Engine needs to sign messages. pub struct EngineSigner { account_provider: Mutex<Arc<AccountProvider>>, address: RwLock<Address>, password: RwLock<Option<String>>, } impl Default for EngineSigner { fn default() -> Self { EngineSigner { account_provider: Mutex::new(Arc::new(AccountProvider::transient_provider())), address: Default::default(), password: Default::default(), } } } impl EngineSigner { /// Set up the signer to sign with given address and password. pub fn set(&self, ap: Arc<AccountProvider>, address: Address, password: String) { *self.account_provider.lock() = ap; *self.address.write() = address; *self.password.write() = Some(password); debug!(target: "poa", "Setting Engine signer to {}", address); } /// Sign a consensus message hash. pub fn sign(&self, hash: H256) -> Result<Signature, account_provider::SignError> { self.account_provider.lock().sign(*self.address.read(), self.password.read().clone(), hash) } /// Signing address. pub fn address(&self) -> Address
/// Check if the given address is the signing address. pub fn is_address(&self, address: &Address) -> bool { *self.address.read() == *address } }
{ self.address.read().clone() }
identifier_body
signer.rs
// Copyright 2015-2017 Parity Technologies (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. //! A signer used by Engines which need to sign messages. use util::{Arc, Mutex, RwLock, H256, Address}; use ethkey::Signature; use account_provider::{self, AccountProvider}; /// Everything that an Engine needs to sign messages. pub struct EngineSigner { account_provider: Mutex<Arc<AccountProvider>>, address: RwLock<Address>, password: RwLock<Option<String>>, } impl Default for EngineSigner { fn default() -> Self { EngineSigner { account_provider: Mutex::new(Arc::new(AccountProvider::transient_provider())), address: Default::default(), password: Default::default(), } } } impl EngineSigner { /// Set up the signer to sign with given address and password. pub fn
(&self, ap: Arc<AccountProvider>, address: Address, password: String) { *self.account_provider.lock() = ap; *self.address.write() = address; *self.password.write() = Some(password); debug!(target: "poa", "Setting Engine signer to {}", address); } /// Sign a consensus message hash. pub fn sign(&self, hash: H256) -> Result<Signature, account_provider::SignError> { self.account_provider.lock().sign(*self.address.read(), self.password.read().clone(), hash) } /// Signing address. pub fn address(&self) -> Address { self.address.read().clone() } /// Check if the given address is the signing address. pub fn is_address(&self, address: &Address) -> bool { *self.address.read() == *address } }
set
identifier_name
signer.rs
// Copyright 2015-2017 Parity Technologies (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. //! A signer used by Engines which need to sign messages. use util::{Arc, Mutex, RwLock, H256, Address}; use ethkey::Signature; use account_provider::{self, AccountProvider}; /// Everything that an Engine needs to sign messages. pub struct EngineSigner { account_provider: Mutex<Arc<AccountProvider>>, address: RwLock<Address>, password: RwLock<Option<String>>, }
fn default() -> Self { EngineSigner { account_provider: Mutex::new(Arc::new(AccountProvider::transient_provider())), address: Default::default(), password: Default::default(), } } } impl EngineSigner { /// Set up the signer to sign with given address and password. pub fn set(&self, ap: Arc<AccountProvider>, address: Address, password: String) { *self.account_provider.lock() = ap; *self.address.write() = address; *self.password.write() = Some(password); debug!(target: "poa", "Setting Engine signer to {}", address); } /// Sign a consensus message hash. pub fn sign(&self, hash: H256) -> Result<Signature, account_provider::SignError> { self.account_provider.lock().sign(*self.address.read(), self.password.read().clone(), hash) } /// Signing address. pub fn address(&self) -> Address { self.address.read().clone() } /// Check if the given address is the signing address. pub fn is_address(&self, address: &Address) -> bool { *self.address.read() == *address } }
impl Default for EngineSigner {
random_line_split
credential.rs
use std::collections::HashMap; use ursa::cl::{ CredentialSignature, RevocationRegistry, SignatureCorrectnessProof, Witness }; use indy_api_types::validation::Validatable; use super::credential_definition::CredentialDefinitionId; use super::revocation_registry_definition::RevocationRegistryId; use super::schema::SchemaId; #[derive(Debug, Deserialize, Serialize)] pub struct Credential { pub schema_id: SchemaId, pub cred_def_id: CredentialDefinitionId, pub rev_reg_id: Option<RevocationRegistryId>, pub values: CredentialValues, pub signature: CredentialSignature, pub signature_correctness_proof: SignatureCorrectnessProof, pub rev_reg: Option<RevocationRegistry>, pub witness: Option<Witness> } impl Credential { pub const QUALIFIABLE_TAGS: [&'static str; 5] = ["issuer_did", "cred_def_id", "schema_id", "schema_issuer_did", "rev_reg_id"]; pub const EXTRA_TAG_SUFFIX: &'static str = "_short"; pub fn add_extra_tag_suffix(tag: &str) -> String { format!("{}{}", tag, Self::EXTRA_TAG_SUFFIX) } } #[derive(Clone, Debug, Deserialize, Serialize, Eq, PartialEq)] pub struct CredentialInfo { pub referent: String, pub attrs: ShortCredentialValues, pub schema_id: SchemaId, pub cred_def_id: CredentialDefinitionId, pub rev_reg_id: Option<RevocationRegistryId>, pub cred_rev_id: Option<String> } pub type ShortCredentialValues = HashMap<String, String>; #[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)] pub struct
(pub HashMap<String, AttributeValues>); #[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)] pub struct AttributeValues { pub raw: String, pub encoded: String } impl Validatable for CredentialValues { fn validate(&self) -> Result<(), String> { if self.0.is_empty() { return Err(String::from("CredentialValues validation failed: empty list has been passed")); } Ok(()) } } impl Validatable for Credential { fn validate(&self) -> Result<(), String> { self.schema_id.validate()?; self.cred_def_id.validate()?; self.values.validate()?; if self.rev_reg_id.is_some() && (self.witness.is_none() || self.rev_reg.is_none()) { return Err(String::from("Credential validation failed: `witness` and `rev_reg` must be passed for revocable Credential")); } if self.values.0.is_empty() { return Err(String::from("Credential validation failed: `values` is empty")); } Ok(()) } }
CredentialValues
identifier_name
credential.rs
use std::collections::HashMap; use ursa::cl::{ CredentialSignature, RevocationRegistry, SignatureCorrectnessProof, Witness }; use indy_api_types::validation::Validatable; use super::credential_definition::CredentialDefinitionId; use super::revocation_registry_definition::RevocationRegistryId; use super::schema::SchemaId; #[derive(Debug, Deserialize, Serialize)] pub struct Credential { pub schema_id: SchemaId, pub cred_def_id: CredentialDefinitionId, pub rev_reg_id: Option<RevocationRegistryId>, pub values: CredentialValues, pub signature: CredentialSignature, pub signature_correctness_proof: SignatureCorrectnessProof, pub rev_reg: Option<RevocationRegistry>, pub witness: Option<Witness> } impl Credential { pub const QUALIFIABLE_TAGS: [&'static str; 5] = ["issuer_did", "cred_def_id", "schema_id", "schema_issuer_did", "rev_reg_id"]; pub const EXTRA_TAG_SUFFIX: &'static str = "_short"; pub fn add_extra_tag_suffix(tag: &str) -> String { format!("{}{}", tag, Self::EXTRA_TAG_SUFFIX) } } #[derive(Clone, Debug, Deserialize, Serialize, Eq, PartialEq)] pub struct CredentialInfo { pub referent: String, pub attrs: ShortCredentialValues, pub schema_id: SchemaId, pub cred_def_id: CredentialDefinitionId, pub rev_reg_id: Option<RevocationRegistryId>, pub cred_rev_id: Option<String> } pub type ShortCredentialValues = HashMap<String, String>; #[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)] pub struct CredentialValues(pub HashMap<String, AttributeValues>); #[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)] pub struct AttributeValues { pub raw: String, pub encoded: String } impl Validatable for CredentialValues { fn validate(&self) -> Result<(), String> { if self.0.is_empty() { return Err(String::from("CredentialValues validation failed: empty list has been passed")); } Ok(()) } } impl Validatable for Credential { fn validate(&self) -> Result<(), String> { self.schema_id.validate()?; self.cred_def_id.validate()?; self.values.validate()?; if self.rev_reg_id.is_some() && (self.witness.is_none() || self.rev_reg.is_none())
if self.values.0.is_empty() { return Err(String::from("Credential validation failed: `values` is empty")); } Ok(()) } }
{ return Err(String::from("Credential validation failed: `witness` and `rev_reg` must be passed for revocable Credential")); }
conditional_block
credential.rs
use std::collections::HashMap; use ursa::cl::{ CredentialSignature, RevocationRegistry, SignatureCorrectnessProof, Witness }; use indy_api_types::validation::Validatable; use super::credential_definition::CredentialDefinitionId; use super::revocation_registry_definition::RevocationRegistryId; use super::schema::SchemaId; #[derive(Debug, Deserialize, Serialize)] pub struct Credential { pub schema_id: SchemaId, pub cred_def_id: CredentialDefinitionId, pub rev_reg_id: Option<RevocationRegistryId>, pub values: CredentialValues, pub signature: CredentialSignature, pub signature_correctness_proof: SignatureCorrectnessProof, pub rev_reg: Option<RevocationRegistry>, pub witness: Option<Witness> } impl Credential { pub const QUALIFIABLE_TAGS: [&'static str; 5] = ["issuer_did", "cred_def_id", "schema_id", "schema_issuer_did", "rev_reg_id"]; pub const EXTRA_TAG_SUFFIX: &'static str = "_short"; pub fn add_extra_tag_suffix(tag: &str) -> String { format!("{}{}", tag, Self::EXTRA_TAG_SUFFIX) } } #[derive(Clone, Debug, Deserialize, Serialize, Eq, PartialEq)] pub struct CredentialInfo { pub referent: String, pub attrs: ShortCredentialValues, pub schema_id: SchemaId, pub cred_def_id: CredentialDefinitionId, pub rev_reg_id: Option<RevocationRegistryId>, pub cred_rev_id: Option<String> } pub type ShortCredentialValues = HashMap<String, String>; #[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)] pub struct CredentialValues(pub HashMap<String, AttributeValues>); #[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)] pub struct AttributeValues { pub raw: String, pub encoded: String } impl Validatable for CredentialValues { fn validate(&self) -> Result<(), String> { if self.0.is_empty() { return Err(String::from("CredentialValues validation failed: empty list has been passed")); } Ok(()) } } impl Validatable for Credential { fn validate(&self) -> Result<(), String> { self.schema_id.validate()?;
self.values.validate()?; if self.rev_reg_id.is_some() && (self.witness.is_none() || self.rev_reg.is_none()) { return Err(String::from("Credential validation failed: `witness` and `rev_reg` must be passed for revocable Credential")); } if self.values.0.is_empty() { return Err(String::from("Credential validation failed: `values` is empty")); } Ok(()) } }
self.cred_def_id.validate()?;
random_line_split
hof.rs
#![feature(iter_arith)] fn main() { println!("Find the sum of all the squared odd numbers under 1000"); let upper = 1000; // Imperative approach // Declare accumulator variable let mut acc = 0; // Iterate: 0, 1, 2,... to infinity for n in 0.. { // Square the number let n_squared = n * n; if n_squared >= upper { // Break loop if exceeded the upper limit break; } else if is_odd(n_squared) { // Accumulate value, if it's odd acc += n_squared; }
// Functional approach let sum_of_squared_odd_numbers: u32 = (0..).map(|n| n * n) // All natural numbers squared .take_while(|&n| n < upper) // Below upper limit .filter(|n| is_odd(*n)) // That are odd .sum(); // Sum them println!("functional style: {}", sum_of_squared_odd_numbers); } fn is_odd(n: u32) -> bool { n % 2 == 1 }
} println!("imperative style: {}", acc);
random_line_split
hof.rs
#![feature(iter_arith)] fn main() { println!("Find the sum of all the squared odd numbers under 1000"); let upper = 1000; // Imperative approach // Declare accumulator variable let mut acc = 0; // Iterate: 0, 1, 2,... to infinity for n in 0.. { // Square the number let n_squared = n * n; if n_squared >= upper { // Break loop if exceeded the upper limit break; } else if is_odd(n_squared)
} println!("imperative style: {}", acc); // Functional approach let sum_of_squared_odd_numbers: u32 = (0..).map(|n| n * n) // All natural numbers squared .take_while(|&n| n < upper) // Below upper limit .filter(|n| is_odd(*n)) // That are odd .sum(); // Sum them println!("functional style: {}", sum_of_squared_odd_numbers); } fn is_odd(n: u32) -> bool { n % 2 == 1 }
{ // Accumulate value, if it's odd acc += n_squared; }
conditional_block
hof.rs
#![feature(iter_arith)] fn
() { println!("Find the sum of all the squared odd numbers under 1000"); let upper = 1000; // Imperative approach // Declare accumulator variable let mut acc = 0; // Iterate: 0, 1, 2,... to infinity for n in 0.. { // Square the number let n_squared = n * n; if n_squared >= upper { // Break loop if exceeded the upper limit break; } else if is_odd(n_squared) { // Accumulate value, if it's odd acc += n_squared; } } println!("imperative style: {}", acc); // Functional approach let sum_of_squared_odd_numbers: u32 = (0..).map(|n| n * n) // All natural numbers squared .take_while(|&n| n < upper) // Below upper limit .filter(|n| is_odd(*n)) // That are odd .sum(); // Sum them println!("functional style: {}", sum_of_squared_odd_numbers); } fn is_odd(n: u32) -> bool { n % 2 == 1 }
main
identifier_name
hof.rs
#![feature(iter_arith)] fn main() { println!("Find the sum of all the squared odd numbers under 1000"); let upper = 1000; // Imperative approach // Declare accumulator variable let mut acc = 0; // Iterate: 0, 1, 2,... to infinity for n in 0.. { // Square the number let n_squared = n * n; if n_squared >= upper { // Break loop if exceeded the upper limit break; } else if is_odd(n_squared) { // Accumulate value, if it's odd acc += n_squared; } } println!("imperative style: {}", acc); // Functional approach let sum_of_squared_odd_numbers: u32 = (0..).map(|n| n * n) // All natural numbers squared .take_while(|&n| n < upper) // Below upper limit .filter(|n| is_odd(*n)) // That are odd .sum(); // Sum them println!("functional style: {}", sum_of_squared_odd_numbers); } fn is_odd(n: u32) -> bool
{ n % 2 == 1 }
identifier_body
slice_stack.rs
// This file is part of libfringe, a low-level green threading library. // Copyright (c) whitequark <[email protected]> // See the LICENSE file included in this distribution. /// SliceStack holds a non-guarded stack allocated elsewhere and provided as a mutable slice. /// /// Any slice used in a SliceStack must adhere to the [Stack contract][contract]. /// [contract]: trait.Stack.html #[derive(Debug)] pub struct SliceStack<'a>(pub &'a mut [u8]); impl<'a> ::stack::Stack for SliceStack<'a> { #[inline(always)] fn base(&self) -> *mut u8
#[inline(always)] fn limit(&self) -> *mut u8 { self.0.as_ptr() as *mut u8 } }
{ // The slice cannot wrap around the address space, so the conversion from usize // to isize will not wrap either. let len: isize = self.0.len() as isize; unsafe { self.limit().offset(len) } }
identifier_body
slice_stack.rs
// This file is part of libfringe, a low-level green threading library. // Copyright (c) whitequark <[email protected]> // See the LICENSE file included in this distribution. /// SliceStack holds a non-guarded stack allocated elsewhere and provided as a mutable slice. /// /// Any slice used in a SliceStack must adhere to the [Stack contract][contract]. /// [contract]: trait.Stack.html #[derive(Debug)] pub struct SliceStack<'a>(pub &'a mut [u8]); impl<'a> ::stack::Stack for SliceStack<'a> { #[inline(always)] fn base(&self) -> *mut u8 { // The slice cannot wrap around the address space, so the conversion from usize // to isize will not wrap either. let len: isize = self.0.len() as isize; unsafe { self.limit().offset(len) } } #[inline(always)] fn
(&self) -> *mut u8 { self.0.as_ptr() as *mut u8 } }
limit
identifier_name
slice_stack.rs
// This file is part of libfringe, a low-level green threading library. // Copyright (c) whitequark <[email protected]> // See the LICENSE file included in this distribution. /// SliceStack holds a non-guarded stack allocated elsewhere and provided as a mutable slice. /// /// Any slice used in a SliceStack must adhere to the [Stack contract][contract]. /// [contract]: trait.Stack.html
#[inline(always)] fn base(&self) -> *mut u8 { // The slice cannot wrap around the address space, so the conversion from usize // to isize will not wrap either. let len: isize = self.0.len() as isize; unsafe { self.limit().offset(len) } } #[inline(always)] fn limit(&self) -> *mut u8 { self.0.as_ptr() as *mut u8 } }
#[derive(Debug)] pub struct SliceStack<'a>(pub &'a mut [u8]); impl<'a> ::stack::Stack for SliceStack<'a> {
random_line_split
coinched.rs
extern crate coinched; extern crate clap; extern crate env_logger; #[macro_use] extern crate log; use std::str::FromStr; use clap::{Arg, App}; fn main() { env_logger::init().unwrap(); let matches = App::new("coinched") .version(env!("CARGO_PKG_VERSION")) .author("Alexandre Bury <[email protected]>") .about("A coinche server") .arg(Arg::with_name("PORT") .help("Port to listen to (defaults to 3000)") .short("p") .long("port") .takes_value(true)) .get_matches(); let port = if let Some(port) = matches.value_of("PORT") { match u16::from_str(port) { Ok(port) => port, Err(err) => { println!("Invalid port: `{}` ({})", port, err); std::process::exit(1); } } } else
; let server = coinched::server::http::Server::new(port); server.run(); }
{ 3000 }
conditional_block
coinched.rs
extern crate coinched; extern crate clap; extern crate env_logger; #[macro_use] extern crate log; use std::str::FromStr; use clap::{Arg, App}; fn
() { env_logger::init().unwrap(); let matches = App::new("coinched") .version(env!("CARGO_PKG_VERSION")) .author("Alexandre Bury <[email protected]>") .about("A coinche server") .arg(Arg::with_name("PORT") .help("Port to listen to (defaults to 3000)") .short("p") .long("port") .takes_value(true)) .get_matches(); let port = if let Some(port) = matches.value_of("PORT") { match u16::from_str(port) { Ok(port) => port, Err(err) => { println!("Invalid port: `{}` ({})", port, err); std::process::exit(1); } } } else { 3000 }; let server = coinched::server::http::Server::new(port); server.run(); }
main
identifier_name
coinched.rs
extern crate coinched; extern crate clap; extern crate env_logger; #[macro_use] extern crate log; use std::str::FromStr; use clap::{Arg, App}; fn main() { env_logger::init().unwrap(); let matches = App::new("coinched") .version(env!("CARGO_PKG_VERSION")) .author("Alexandre Bury <[email protected]>")
.short("p") .long("port") .takes_value(true)) .get_matches(); let port = if let Some(port) = matches.value_of("PORT") { match u16::from_str(port) { Ok(port) => port, Err(err) => { println!("Invalid port: `{}` ({})", port, err); std::process::exit(1); } } } else { 3000 }; let server = coinched::server::http::Server::new(port); server.run(); }
.about("A coinche server") .arg(Arg::with_name("PORT") .help("Port to listen to (defaults to 3000)")
random_line_split
coinched.rs
extern crate coinched; extern crate clap; extern crate env_logger; #[macro_use] extern crate log; use std::str::FromStr; use clap::{Arg, App}; fn main()
} } } else { 3000 }; let server = coinched::server::http::Server::new(port); server.run(); }
{ env_logger::init().unwrap(); let matches = App::new("coinched") .version(env!("CARGO_PKG_VERSION")) .author("Alexandre Bury <[email protected]>") .about("A coinche server") .arg(Arg::with_name("PORT") .help("Port to listen to (defaults to 3000)") .short("p") .long("port") .takes_value(true)) .get_matches(); let port = if let Some(port) = matches.value_of("PORT") { match u16::from_str(port) { Ok(port) => port, Err(err) => { println!("Invalid port: `{}` ({})", port, err); std::process::exit(1);
identifier_body
entry.rs
use consts::*; #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub struct Entry { pub cell: u8, pub num: u8, } impl Entry { #[inline] pub fn cell(self) -> usize { self.cell as usize } #[inline] pub fn row(self) -> u8 { self.cell as u8 / 9 } #[inline] pub fn col(self) -> u8 { self.cell as u8 % 9 } #[inline] pub fn field(self) -> u8 { self.row() / 3 * 3 + self.col() / 3 } #[inline] pub fn num(self) -> u8 { self.num } #[inline] pub fn conflicts_with(self, other: Self) -> bool { self.cell() == other.cell() || (self.num == other.num && ( self.row() == other.row() || self.col() == other.col() || self.field() == other.field() ) ) } #[inline] pub fn num_offset(self) -> usize
#[inline] pub fn row_constraint(self) -> usize { self.row() as usize * 9 + self.num_offset() } #[inline] pub fn col_constraint(self) -> usize { self.col() as usize * 9 + self.num_offset() + COL_OFFSET } #[inline] pub fn field_constraint(self) -> usize { self.field() as usize * 9 + self.num_offset() + FIELD_OFFSET } #[inline] pub fn cell_constraint(self) -> usize { self.cell() + CELL_OFFSET } #[inline] pub fn constrains(self, constraint_nr: usize) -> bool { constraint_nr == match constraint_nr { 0...80 => self.row_constraint(), 81...161 => self.col_constraint(), 162...242 => self.field_constraint(), 243...323 => self.cell_constraint(), _ => unreachable!(), } } }
{ self.num() as usize - 1 }
identifier_body
entry.rs
use consts::*; #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub struct Entry { pub cell: u8, pub num: u8, } impl Entry { #[inline] pub fn cell(self) -> usize { self.cell as usize } #[inline] pub fn row(self) -> u8 { self.cell as u8 / 9 } #[inline] pub fn col(self) -> u8 { self.cell as u8 % 9 } #[inline] pub fn field(self) -> u8 { self.row() / 3 * 3 + self.col() / 3 } #[inline] pub fn num(self) -> u8 { self.num } #[inline] pub fn conflicts_with(self, other: Self) -> bool { self.cell() == other.cell() || (self.num == other.num && ( self.row() == other.row() || self.col() == other.col() || self.field() == other.field() ) ) } #[inline] pub fn num_offset(self) -> usize { self.num() as usize - 1 } #[inline] pub fn row_constraint(self) -> usize { self.row() as usize * 9 + self.num_offset() } #[inline] pub fn col_constraint(self) -> usize { self.col() as usize * 9 + self.num_offset() + COL_OFFSET } #[inline] pub fn field_constraint(self) -> usize { self.field() as usize * 9 + self.num_offset() + FIELD_OFFSET } #[inline] pub fn cell_constraint(self) -> usize { self.cell() + CELL_OFFSET }
0...80 => self.row_constraint(), 81...161 => self.col_constraint(), 162...242 => self.field_constraint(), 243...323 => self.cell_constraint(), _ => unreachable!(), } } }
#[inline] pub fn constrains(self, constraint_nr: usize) -> bool { constraint_nr == match constraint_nr {
random_line_split
entry.rs
use consts::*; #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub struct Entry { pub cell: u8, pub num: u8, } impl Entry { #[inline] pub fn
(self) -> usize { self.cell as usize } #[inline] pub fn row(self) -> u8 { self.cell as u8 / 9 } #[inline] pub fn col(self) -> u8 { self.cell as u8 % 9 } #[inline] pub fn field(self) -> u8 { self.row() / 3 * 3 + self.col() / 3 } #[inline] pub fn num(self) -> u8 { self.num } #[inline] pub fn conflicts_with(self, other: Self) -> bool { self.cell() == other.cell() || (self.num == other.num && ( self.row() == other.row() || self.col() == other.col() || self.field() == other.field() ) ) } #[inline] pub fn num_offset(self) -> usize { self.num() as usize - 1 } #[inline] pub fn row_constraint(self) -> usize { self.row() as usize * 9 + self.num_offset() } #[inline] pub fn col_constraint(self) -> usize { self.col() as usize * 9 + self.num_offset() + COL_OFFSET } #[inline] pub fn field_constraint(self) -> usize { self.field() as usize * 9 + self.num_offset() + FIELD_OFFSET } #[inline] pub fn cell_constraint(self) -> usize { self.cell() + CELL_OFFSET } #[inline] pub fn constrains(self, constraint_nr: usize) -> bool { constraint_nr == match constraint_nr { 0...80 => self.row_constraint(), 81...161 => self.col_constraint(), 162...242 => self.field_constraint(), 243...323 => self.cell_constraint(), _ => unreachable!(), } } }
cell
identifier_name
adv3.rs
#![allow(warnings)] // Goal #1: Eliminate the borrow check error in the `remove` method. pub struct Map<K: Eq, V> { elements: Vec<(K, V)>, } impl<K: Eq, V> Map<K, V> { pub fn new() -> Self { Map { elements: vec![] } } pub fn
(&mut self, key: K, value: V) { self.elements.push((key, value)); } pub fn get(&self, key: &K) -> Option<&V> { self.elements.iter().rev().find(|pair| pair.0 == *key).map(|pair| &pair.1) } pub fn remove(&mut self, key: &K) { let mut i : Option<usize> = None; for (index, pair) in self.elements.iter().enumerate() { if pair.0 == *key { i = Some(index); break; } } match i { Some(index) => {self.elements.remove(index);}, None => {}, } } }
insert
identifier_name
adv3.rs
#![allow(warnings)] // Goal #1: Eliminate the borrow check error in the `remove` method. pub struct Map<K: Eq, V> { elements: Vec<(K, V)>, } impl<K: Eq, V> Map<K, V> { pub fn new() -> Self { Map { elements: vec![] } } pub fn insert(&mut self, key: K, value: V) { self.elements.push((key, value)); } pub fn get(&self, key: &K) -> Option<&V> { self.elements.iter().rev().find(|pair| pair.0 == *key).map(|pair| &pair.1) } pub fn remove(&mut self, key: &K) { let mut i : Option<usize> = None; for (index, pair) in self.elements.iter().enumerate() { if pair.0 == *key { i = Some(index); break; } } match i { Some(index) => {self.elements.remove(index);}, None =>
, } } }
{}
conditional_block