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
svh.rs
// 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. //! Calculation and management of a Strict Version Hash for crates //! //! # Today's ABI problem //! //! In today's implementation of rustc, it is incredibly difficult to achieve //! forward binary compatibility without resorting to C-like interfaces. Within //! rust code itself, abi details such as symbol names suffer from a variety of //! unrelated factors to code changing such as the "def id drift" problem. This //! ends up yielding confusing error messages about metadata mismatches and //! such. //! //! The core of this problem is when an upstream dependency changes and //! downstream dependents are not recompiled. This causes compile errors because //! the upstream crate's metadata has changed but the downstream crates are //! still referencing the older crate's metadata. //! //! This problem exists for many reasons, the primary of which is that rust does //! not currently support forwards ABI compatibility (in place upgrades of a //! crate). //! //! # SVH and how it alleviates the problem //! //! With all of this knowledge on hand, this module contains the implementation //! of a notion of a "Strict Version Hash" for a crate. This is essentially a //! hash of all contents of a crate which can somehow be exposed to downstream //! crates. //! //! This hash is currently calculated by just hashing the AST, but this is //! obviously wrong (doc changes should not result in an incompatible ABI). //! Implementation-wise, this is required at this moment in time. //! //! By encoding this strict version hash into all crate's metadata, stale crates //! can be detected immediately and error'd about by rustc itself. //! //! # Relevant links //! //! Original issue: https://github.com/rust-lang/rust/issues/10207 use std::fmt; use std::hash::Hash; use std::hash::sip::SipState; use std::iter::range_step; use syntax::ast; use syntax::visit; #[deriving(Clone, PartialEq)] pub struct Svh { hash: String, } impl Svh { pub fn new(hash: &str) -> Svh { assert!(hash.len() == 16); Svh { hash: hash.to_string() } } pub fn as_str<'a>(&'a self) -> &'a str { self.hash.as_slice() } pub fn calculate(metadata: &Vec<String>, krate: &ast::Crate) -> Svh { // FIXME (#14132): This is better than it used to be, but it still not // ideal. We now attempt to hash only the relevant portions of the // Crate AST as well as the top-level crate attributes. (However, // the hashing of the crate attributes should be double-checked // to ensure it is not incorporating implementation artifacts into // the hash that are not otherwise visible.) // FIXME: this should use SHA1, not SipHash. SipHash is not built to // avoid collisions. let mut state = SipState::new(); for data in metadata.iter() { data.hash(&mut state); } { let mut visit = svh_visitor::make(&mut state); visit::walk_crate(&mut visit, krate); } // FIXME (#14132): This hash is still sensitive to e.g. the // spans of the crate Attributes and their underlying // MetaItems; we should make ContentHashable impl for those // types and then use hash_content. But, since all crate // attributes should appear near beginning of the file, it is // not such a big deal to be sensitive to their spans for now. // // We hash only the MetaItems instead of the entire Attribute // to avoid hashing the AttrId for attr in krate.attrs.iter() { attr.node.value.hash(&mut state); } let hash = state.result(); return Svh { hash: range_step(0u, 64u, 4u).map(|i| hex(hash >> i)).collect() }; fn hex(b: u64) -> char { let b = (b & 0xf) as u8; let b = match b { 0... 9 => '0' as u8 + b, _ => 'a' as u8 + b - 10, }; b as char } } } impl fmt::Show for Svh { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.pad(self.as_str()) } } // FIXME (#14132): Even this SVH computation still has implementation // artifacts: namely, the order of item declaration will affect the // hash computation, but for many kinds of items the order of // declaration should be irrelevant to the ABI. mod svh_visitor { pub use self::SawExprComponent::*; pub use self::SawStmtComponent::*; use self::SawAbiComponent::*; use syntax::ast; use syntax::ast::*; use syntax::codemap::Span; use syntax::parse::token; use syntax::print::pprust; use syntax::visit; use syntax::visit::{Visitor, FnKind}; use std::hash::Hash; use std::hash::sip::SipState; pub struct StrictVersionHashVisitor<'a> { pub st: &'a mut SipState, } pub fn make<'a>(st: &'a mut SipState) -> StrictVersionHashVisitor<'a> { StrictVersionHashVisitor { st: st } } // To off-load the bulk of the hash-computation on deriving(Hash), // we define a set of enums corresponding to the content that our // crate visitor will encounter as it traverses the ast. // // The important invariant is that all of the Saw*Component enums // do not carry any Spans, Names, or Idents. // // Not carrying any Names/Idents is the important fix for problem // noted on PR #13948: using the ident.name as the basis for a // hash leads to unstable SVH, because ident.name is just an index // into intern table (i.e. essentially a random address), not // computed from the name content. // // With the below enums, the SVH computation is not sensitive to // artifacts of how rustc was invoked nor of how the source code // was laid out. (Or at least it is *less* sensitive.) // This enum represents the different potential bits of code the // visitor could encounter that could affect the ABI for the crate, // and assigns each a distinct tag to feed into the hash computation. #[deriving(Hash)] enum SawAbiComponent<'a> { // FIXME (#14132): should we include (some function of) // ident.ctxt as well? SawIdent(token::InternedString), SawStructDef(token::InternedString), SawLifetimeRef(token::InternedString), SawLifetimeDef(token::InternedString), SawMod, SawViewItem, SawForeignItem, SawItem, SawDecl, SawTy, SawGenerics, SawFn, SawTyMethod, SawTraitMethod, SawStructField, SawVariant, SawExplicitSelf, SawPath, SawOptLifetimeRef, SawBlock, SawPat, SawLocal, SawArm, SawExpr(SawExprComponent<'a>), SawStmt(SawStmtComponent), } /// SawExprComponent carries all of the information that we want /// to include in the hash that *won't* be covered by the /// subsequent recursive traversal of the expression's /// substructure by the visitor. /// /// We know every Expr_ variant is covered by a variant because /// `fn saw_expr` maps each to some case below. Ensuring that /// each variant carries an appropriate payload has to be verified /// by hand. /// /// (However, getting that *exactly* right is not so important /// because the SVH is just a developer convenience; there is no /// guarantee of collision-freedom, hash collisions are just /// (hopefully) unlikely.) #[deriving(Hash)] pub enum SawExprComponent<'a> { SawExprLoop(Option<token::InternedString>), SawExprField(token::InternedString), SawExprTupField(uint), SawExprBreak(Option<token::InternedString>), SawExprAgain(Option<token::InternedString>), SawExprBox, SawExprVec, SawExprCall, SawExprMethodCall, SawExprTup, SawExprBinary(ast::BinOp), SawExprUnary(ast::UnOp), SawExprLit(ast::Lit_), SawExprCast, SawExprIf, SawExprWhile, SawExprMatch, SawExprFnBlock, SawExprUnboxedFn, SawExprProc, SawExprBlock, SawExprAssign, SawExprAssignOp(ast::BinOp), SawExprIndex, SawExprSlice, SawExprPath, SawExprAddrOf(ast::Mutability), SawExprRet, SawExprInlineAsm(&'a ast::InlineAsm), SawExprStruct, SawExprRepeat, SawExprParen, SawExprForLoop, } fn saw_expr<'a>(node: &'a Expr_) -> SawExprComponent<'a> { match *node { ExprBox(..) => SawExprBox, ExprVec(..) => SawExprVec, ExprCall(..) => SawExprCall, ExprMethodCall(..) => SawExprMethodCall, ExprTup(..) => SawExprTup, ExprBinary(op, _, _) => SawExprBinary(op), ExprUnary(op, _) => SawExprUnary(op), ExprLit(ref lit) => SawExprLit(lit.node.clone()), ExprCast(..) => SawExprCast, ExprIf(..) => SawExprIf, ExprWhile(..) => SawExprWhile, ExprLoop(_, id) => SawExprLoop(id.map(content)), ExprMatch(..) => SawExprMatch, ExprFnBlock(..) => SawExprFnBlock, ExprUnboxedFn(..) => SawExprUnboxedFn, ExprProc(..) => SawExprProc, ExprBlock(..) => SawExprBlock, ExprAssign(..) => SawExprAssign, ExprAssignOp(op, _, _) => SawExprAssignOp(op), ExprField(_, id, _) => SawExprField(content(id.node)), ExprTupField(_, id, _) => SawExprTupField(id.node), ExprIndex(..) => SawExprIndex, ExprSlice(..) => SawExprSlice, ExprPath(..) => SawExprPath, ExprAddrOf(m, _) => SawExprAddrOf(m), ExprBreak(id) => SawExprBreak(id.map(content)), ExprAgain(id) => SawExprAgain(id.map(content)), ExprRet(..) => SawExprRet, ExprInlineAsm(ref asm) => SawExprInlineAsm(asm), ExprStruct(..) => SawExprStruct, ExprRepeat(..) => SawExprRepeat, ExprParen(..) => SawExprParen, ExprForLoop(..) => SawExprForLoop, // just syntactic artifacts, expanded away by time of SVH. ExprIfLet(..) => unreachable!(), ExprWhileLet(..) => unreachable!(), ExprMac(..) => unreachable!(), } } /// SawStmtComponent is analogous to SawExprComponent, but for statements. #[deriving(Hash)] pub enum SawStmtComponent { SawStmtDecl, SawStmtExpr, SawStmtSemi, } fn saw_stmt(node: &Stmt_) -> SawStmtComponent { match *node { StmtDecl(..) => SawStmtDecl, StmtExpr(..) => SawStmtExpr, StmtSemi(..) => SawStmtSemi, StmtMac(..) => unreachable!(), } } // Ad-hoc overloading between Ident and Name to their intern table lookups. trait InternKey { fn get_content(self) -> token::InternedString; } impl InternKey for Ident { fn get_content(self) -> token::InternedString { token::get_ident(self) } } impl InternKey for Name { fn get_content(self) -> token::InternedString { token::get_name(self) } } fn content<K:InternKey>(k: K) -> token::InternedString { k.get_content() } impl<'a, 'v> Visitor<'v> for StrictVersionHashVisitor<'a> { fn visit_mac(&mut self, macro: &Mac) { // macro invocations, namely macro_rules definitions, // *can* appear as items, even in the expanded crate AST. if macro_name(macro).get() == "macro_rules" { // Pretty-printing definition to a string strips out // surface artifacts (currently), such as the span // information, yielding a content-based hash. // FIXME (#14132): building temporary string is // expensive; a direct content-based hash on token // trees might be faster. Implementing this is far // easier in short term. let macro_defn_as_string = pprust::to_string(|pp_state| pp_state.print_mac(macro)); macro_defn_as_string.hash(self.st); } else { // It is not possible to observe any kind of macro // invocation at this stage except `macro_rules!`. panic!("reached macro somehow: {}", pprust::to_string(|pp_state| pp_state.print_mac(macro))); } visit::walk_mac(self, macro); fn macro_name(macro: &Mac) -> token::InternedString { match &macro.node { &MacInvocTT(ref path, ref _tts, ref _stx_ctxt) => { let s = path.segments.as_slice(); assert_eq!(s.len(), 1); content(s[0].identifier) } } } } fn visit_struct_def(&mut self, s: &StructDef, ident: Ident, g: &Generics, _: NodeId) { SawStructDef(content(ident)).hash(self.st); visit::walk_generics(self, g); visit::walk_struct_def(self, s) } fn visit_variant(&mut self, v: &Variant, g: &Generics) { SawVariant.hash(self.st); // walk_variant does not call walk_generics, so do it here. visit::walk_generics(self, g); visit::walk_variant(self, v, g) } fn visit_opt_lifetime_ref(&mut self, _: Span, l: &Option<Lifetime>) { SawOptLifetimeRef.hash(self.st); // (This is a strange method in the visitor trait, in that // it does not expose a walk function to do the subroutine // calls.) match *l { Some(ref l) => self.visit_lifetime_ref(l), None => () } } // All of the remaining methods just record (in the hash // SipState) that the visitor saw that particular variant // (with its payload), and continue walking as the default // visitor would. // // Some of the implementations have some notes as to how one // might try to make their SVH computation less discerning // (e.g. by incorporating reachability analysis). But // currently all of their implementations are uniform and // uninteresting. // // (If you edit a method such that it deviates from the // pattern, please move that method up above this comment.) fn visit_ident(&mut self, _: Span, ident: Ident) { SawIdent(content(ident)).hash(self.st); } fn visit_lifetime_ref(&mut self, l: &Lifetime) { SawLifetimeRef(content(l.name)).hash(self.st); } fn visit_lifetime_def(&mut self, l: &LifetimeDef) { SawLifetimeDef(content(l.lifetime.name)).hash(self.st); } // We do recursively walk the bodies of functions/methods // (rather than omitting their bodies from the hash) since // monomorphization and cross-crate inlining generally implies // that a change to a crate body will require downstream // crates to be recompiled. fn visit_expr(&mut self, ex: &Expr) { SawExpr(saw_expr(&ex.node)).hash(self.st); visit::walk_expr(self, ex) } fn visit_stmt(&mut self, s: &Stmt) { SawStmt(saw_stmt(&s.node)).hash(self.st); visit::walk_stmt(self, s) } fn
(&mut self, i: &ViewItem) { // Two kinds of view items can affect the ABI for a crate: // exported `pub use` view items (since that may expose // items that downstream crates can call), and `use // foo::Trait`, since changing that may affect method // resolution. // // The simplest approach to handling both of the above is // just to adopt the same simple-minded (fine-grained) // hash that I am deploying elsewhere here. SawViewItem.hash(self.st); visit::walk_view_item(self, i) } fn visit_foreign_item(&mut self, i: &ForeignItem) { // FIXME (#14132) ideally we would incorporate privacy (or // perhaps reachability) somewhere here, so foreign items // that do not leak into downstream crates would not be // part of the ABI. SawForeignItem.hash(self.st); visit::walk_foreign_item(self, i) } fn visit_item(&mut self, i: &Item) { // FIXME (#14132) ideally would incorporate reachability // analysis somewhere here, so items that never leak into // downstream crates (e.g. via monomorphisation or // inlining) would not be part of the ABI. SawItem.hash(self.st); visit::walk_item(self, i) } fn visit_mod(&mut self, m: &Mod, _s: Span, _n: NodeId) { SawMod.hash(self.st); visit::walk_mod(self, m) } fn visit_decl(&mut self, d: &Decl) { SawDecl.hash(self.st); visit::walk_decl(self, d) } fn visit_ty(&mut self, t: &Ty) { SawTy.hash(self.st); visit::walk_ty(self, t) } fn visit_generics(&mut self, g: &Generics) { SawGenerics.hash(self.st); visit::walk_generics(self, g) } fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, _: NodeId) { SawFn.hash(self.st); visit::walk_fn(self, fk, fd, b, s) } fn visit_ty_method(&mut self, t: &TypeMethod) { SawTyMethod.hash(self.st); visit::walk_ty_method(self, t) } fn visit_trait_item(&mut self, t: &TraitItem) { SawTraitMethod.hash(self.st); visit::walk_trait_item(self, t) } fn visit_struct_field(&mut self, s: &StructField) { SawStructField.hash(self.st); visit::walk_struct_field(self, s) } fn visit_explicit_self(&mut self, es: &ExplicitSelf) { SawExplicitSelf.hash(self.st); visit::walk_explicit_self(self, es) } fn visit_path(&mut self, path: &Path, _: ast::NodeId) { SawPath.hash(self.st); visit::walk_path(self, path) } fn visit_block(&mut self, b: &Block) { SawBlock.hash(self.st); visit::walk_block(self, b) } fn visit_pat(&mut self, p: &Pat) { SawPat.hash(self.st); visit::walk_pat(self, p) }
visit_view_item
identifier_name
svh.rs
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. //! Calculation and management of a Strict Version Hash for crates //! //! # Today's ABI problem //! //! In today's implementation of rustc, it is incredibly difficult to achieve //! forward binary compatibility without resorting to C-like interfaces. Within //! rust code itself, abi details such as symbol names suffer from a variety of //! unrelated factors to code changing such as the "def id drift" problem. This //! ends up yielding confusing error messages about metadata mismatches and //! such. //! //! The core of this problem is when an upstream dependency changes and //! downstream dependents are not recompiled. This causes compile errors because //! the upstream crate's metadata has changed but the downstream crates are //! still referencing the older crate's metadata. //! //! This problem exists for many reasons, the primary of which is that rust does //! not currently support forwards ABI compatibility (in place upgrades of a //! crate). //! //! # SVH and how it alleviates the problem //! //! With all of this knowledge on hand, this module contains the implementation //! of a notion of a "Strict Version Hash" for a crate. This is essentially a //! hash of all contents of a crate which can somehow be exposed to downstream //! crates. //! //! This hash is currently calculated by just hashing the AST, but this is //! obviously wrong (doc changes should not result in an incompatible ABI). //! Implementation-wise, this is required at this moment in time. //! //! By encoding this strict version hash into all crate's metadata, stale crates //! can be detected immediately and error'd about by rustc itself. //! //! # Relevant links //! //! Original issue: https://github.com/rust-lang/rust/issues/10207 use std::fmt; use std::hash::Hash; use std::hash::sip::SipState; use std::iter::range_step; use syntax::ast; use syntax::visit; #[deriving(Clone, PartialEq)] pub struct Svh { hash: String, } impl Svh { pub fn new(hash: &str) -> Svh { assert!(hash.len() == 16); Svh { hash: hash.to_string() } } pub fn as_str<'a>(&'a self) -> &'a str { self.hash.as_slice() } pub fn calculate(metadata: &Vec<String>, krate: &ast::Crate) -> Svh { // FIXME (#14132): This is better than it used to be, but it still not // ideal. We now attempt to hash only the relevant portions of the // Crate AST as well as the top-level crate attributes. (However, // the hashing of the crate attributes should be double-checked // to ensure it is not incorporating implementation artifacts into // the hash that are not otherwise visible.) // FIXME: this should use SHA1, not SipHash. SipHash is not built to // avoid collisions. let mut state = SipState::new(); for data in metadata.iter() { data.hash(&mut state); } { let mut visit = svh_visitor::make(&mut state); visit::walk_crate(&mut visit, krate); } // FIXME (#14132): This hash is still sensitive to e.g. the // spans of the crate Attributes and their underlying // MetaItems; we should make ContentHashable impl for those // types and then use hash_content. But, since all crate // attributes should appear near beginning of the file, it is // not such a big deal to be sensitive to their spans for now. // // We hash only the MetaItems instead of the entire Attribute // to avoid hashing the AttrId for attr in krate.attrs.iter() { attr.node.value.hash(&mut state); } let hash = state.result(); return Svh { hash: range_step(0u, 64u, 4u).map(|i| hex(hash >> i)).collect() }; fn hex(b: u64) -> char { let b = (b & 0xf) as u8; let b = match b { 0... 9 => '0' as u8 + b, _ => 'a' as u8 + b - 10, }; b as char } } } impl fmt::Show for Svh { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.pad(self.as_str()) } } // FIXME (#14132): Even this SVH computation still has implementation // artifacts: namely, the order of item declaration will affect the // hash computation, but for many kinds of items the order of // declaration should be irrelevant to the ABI. mod svh_visitor { pub use self::SawExprComponent::*; pub use self::SawStmtComponent::*; use self::SawAbiComponent::*; use syntax::ast; use syntax::ast::*; use syntax::codemap::Span; use syntax::parse::token; use syntax::print::pprust; use syntax::visit; use syntax::visit::{Visitor, FnKind}; use std::hash::Hash; use std::hash::sip::SipState; pub struct StrictVersionHashVisitor<'a> { pub st: &'a mut SipState, } pub fn make<'a>(st: &'a mut SipState) -> StrictVersionHashVisitor<'a> { StrictVersionHashVisitor { st: st } } // To off-load the bulk of the hash-computation on deriving(Hash), // we define a set of enums corresponding to the content that our // crate visitor will encounter as it traverses the ast. // // The important invariant is that all of the Saw*Component enums // do not carry any Spans, Names, or Idents. // // Not carrying any Names/Idents is the important fix for problem // noted on PR #13948: using the ident.name as the basis for a // hash leads to unstable SVH, because ident.name is just an index // into intern table (i.e. essentially a random address), not // computed from the name content. // // With the below enums, the SVH computation is not sensitive to // artifacts of how rustc was invoked nor of how the source code // was laid out. (Or at least it is *less* sensitive.) // This enum represents the different potential bits of code the // visitor could encounter that could affect the ABI for the crate, // and assigns each a distinct tag to feed into the hash computation. #[deriving(Hash)] enum SawAbiComponent<'a> { // FIXME (#14132): should we include (some function of) // ident.ctxt as well? SawIdent(token::InternedString), SawStructDef(token::InternedString), SawLifetimeRef(token::InternedString), SawLifetimeDef(token::InternedString), SawMod, SawViewItem, SawForeignItem, SawItem, SawDecl, SawTy, SawGenerics, SawFn, SawTyMethod, SawTraitMethod, SawStructField, SawVariant, SawExplicitSelf, SawPath, SawOptLifetimeRef, SawBlock, SawPat, SawLocal, SawArm, SawExpr(SawExprComponent<'a>), SawStmt(SawStmtComponent), } /// SawExprComponent carries all of the information that we want /// to include in the hash that *won't* be covered by the /// subsequent recursive traversal of the expression's /// substructure by the visitor. /// /// We know every Expr_ variant is covered by a variant because /// `fn saw_expr` maps each to some case below. Ensuring that /// each variant carries an appropriate payload has to be verified /// by hand. /// /// (However, getting that *exactly* right is not so important /// because the SVH is just a developer convenience; there is no /// guarantee of collision-freedom, hash collisions are just /// (hopefully) unlikely.) #[deriving(Hash)] pub enum SawExprComponent<'a> { SawExprLoop(Option<token::InternedString>), SawExprField(token::InternedString), SawExprTupField(uint), SawExprBreak(Option<token::InternedString>), SawExprAgain(Option<token::InternedString>), SawExprBox, SawExprVec, SawExprCall, SawExprMethodCall, SawExprTup, SawExprBinary(ast::BinOp), SawExprUnary(ast::UnOp), SawExprLit(ast::Lit_), SawExprCast, SawExprIf, SawExprWhile, SawExprMatch, SawExprFnBlock, SawExprUnboxedFn, SawExprProc, SawExprBlock, SawExprAssign, SawExprAssignOp(ast::BinOp), SawExprIndex, SawExprSlice, SawExprPath, SawExprAddrOf(ast::Mutability), SawExprRet, SawExprInlineAsm(&'a ast::InlineAsm), SawExprStruct, SawExprRepeat, SawExprParen, SawExprForLoop, } fn saw_expr<'a>(node: &'a Expr_) -> SawExprComponent<'a> { match *node { ExprBox(..) => SawExprBox, ExprVec(..) => SawExprVec, ExprCall(..) => SawExprCall, ExprMethodCall(..) => SawExprMethodCall, ExprTup(..) => SawExprTup, ExprBinary(op, _, _) => SawExprBinary(op), ExprUnary(op, _) => SawExprUnary(op), ExprLit(ref lit) => SawExprLit(lit.node.clone()), ExprCast(..) => SawExprCast, ExprIf(..) => SawExprIf, ExprWhile(..) => SawExprWhile, ExprLoop(_, id) => SawExprLoop(id.map(content)), ExprMatch(..) => SawExprMatch, ExprFnBlock(..) => SawExprFnBlock, ExprUnboxedFn(..) => SawExprUnboxedFn, ExprProc(..) => SawExprProc, ExprBlock(..) => SawExprBlock, ExprAssign(..) => SawExprAssign, ExprAssignOp(op, _, _) => SawExprAssignOp(op), ExprField(_, id, _) => SawExprField(content(id.node)), ExprTupField(_, id, _) => SawExprTupField(id.node), ExprIndex(..) => SawExprIndex, ExprSlice(..) => SawExprSlice, ExprPath(..) => SawExprPath, ExprAddrOf(m, _) => SawExprAddrOf(m), ExprBreak(id) => SawExprBreak(id.map(content)), ExprAgain(id) => SawExprAgain(id.map(content)), ExprRet(..) => SawExprRet, ExprInlineAsm(ref asm) => SawExprInlineAsm(asm), ExprStruct(..) => SawExprStruct, ExprRepeat(..) => SawExprRepeat, ExprParen(..) => SawExprParen, ExprForLoop(..) => SawExprForLoop, // just syntactic artifacts, expanded away by time of SVH. ExprIfLet(..) => unreachable!(), ExprWhileLet(..) => unreachable!(), ExprMac(..) => unreachable!(), } } /// SawStmtComponent is analogous to SawExprComponent, but for statements. #[deriving(Hash)] pub enum SawStmtComponent { SawStmtDecl, SawStmtExpr, SawStmtSemi, } fn saw_stmt(node: &Stmt_) -> SawStmtComponent { match *node { StmtDecl(..) => SawStmtDecl, StmtExpr(..) => SawStmtExpr, StmtSemi(..) => SawStmtSemi, StmtMac(..) => unreachable!(), } } // Ad-hoc overloading between Ident and Name to their intern table lookups. trait InternKey { fn get_content(self) -> token::InternedString; }
impl InternKey for Name { fn get_content(self) -> token::InternedString { token::get_name(self) } } fn content<K:InternKey>(k: K) -> token::InternedString { k.get_content() } impl<'a, 'v> Visitor<'v> for StrictVersionHashVisitor<'a> { fn visit_mac(&mut self, macro: &Mac) { // macro invocations, namely macro_rules definitions, // *can* appear as items, even in the expanded crate AST. if macro_name(macro).get() == "macro_rules" { // Pretty-printing definition to a string strips out // surface artifacts (currently), such as the span // information, yielding a content-based hash. // FIXME (#14132): building temporary string is // expensive; a direct content-based hash on token // trees might be faster. Implementing this is far // easier in short term. let macro_defn_as_string = pprust::to_string(|pp_state| pp_state.print_mac(macro)); macro_defn_as_string.hash(self.st); } else { // It is not possible to observe any kind of macro // invocation at this stage except `macro_rules!`. panic!("reached macro somehow: {}", pprust::to_string(|pp_state| pp_state.print_mac(macro))); } visit::walk_mac(self, macro); fn macro_name(macro: &Mac) -> token::InternedString { match &macro.node { &MacInvocTT(ref path, ref _tts, ref _stx_ctxt) => { let s = path.segments.as_slice(); assert_eq!(s.len(), 1); content(s[0].identifier) } } } } fn visit_struct_def(&mut self, s: &StructDef, ident: Ident, g: &Generics, _: NodeId) { SawStructDef(content(ident)).hash(self.st); visit::walk_generics(self, g); visit::walk_struct_def(self, s) } fn visit_variant(&mut self, v: &Variant, g: &Generics) { SawVariant.hash(self.st); // walk_variant does not call walk_generics, so do it here. visit::walk_generics(self, g); visit::walk_variant(self, v, g) } fn visit_opt_lifetime_ref(&mut self, _: Span, l: &Option<Lifetime>) { SawOptLifetimeRef.hash(self.st); // (This is a strange method in the visitor trait, in that // it does not expose a walk function to do the subroutine // calls.) match *l { Some(ref l) => self.visit_lifetime_ref(l), None => () } } // All of the remaining methods just record (in the hash // SipState) that the visitor saw that particular variant // (with its payload), and continue walking as the default // visitor would. // // Some of the implementations have some notes as to how one // might try to make their SVH computation less discerning // (e.g. by incorporating reachability analysis). But // currently all of their implementations are uniform and // uninteresting. // // (If you edit a method such that it deviates from the // pattern, please move that method up above this comment.) fn visit_ident(&mut self, _: Span, ident: Ident) { SawIdent(content(ident)).hash(self.st); } fn visit_lifetime_ref(&mut self, l: &Lifetime) { SawLifetimeRef(content(l.name)).hash(self.st); } fn visit_lifetime_def(&mut self, l: &LifetimeDef) { SawLifetimeDef(content(l.lifetime.name)).hash(self.st); } // We do recursively walk the bodies of functions/methods // (rather than omitting their bodies from the hash) since // monomorphization and cross-crate inlining generally implies // that a change to a crate body will require downstream // crates to be recompiled. fn visit_expr(&mut self, ex: &Expr) { SawExpr(saw_expr(&ex.node)).hash(self.st); visit::walk_expr(self, ex) } fn visit_stmt(&mut self, s: &Stmt) { SawStmt(saw_stmt(&s.node)).hash(self.st); visit::walk_stmt(self, s) } fn visit_view_item(&mut self, i: &ViewItem) { // Two kinds of view items can affect the ABI for a crate: // exported `pub use` view items (since that may expose // items that downstream crates can call), and `use // foo::Trait`, since changing that may affect method // resolution. // // The simplest approach to handling both of the above is // just to adopt the same simple-minded (fine-grained) // hash that I am deploying elsewhere here. SawViewItem.hash(self.st); visit::walk_view_item(self, i) } fn visit_foreign_item(&mut self, i: &ForeignItem) { // FIXME (#14132) ideally we would incorporate privacy (or // perhaps reachability) somewhere here, so foreign items // that do not leak into downstream crates would not be // part of the ABI. SawForeignItem.hash(self.st); visit::walk_foreign_item(self, i) } fn visit_item(&mut self, i: &Item) { // FIXME (#14132) ideally would incorporate reachability // analysis somewhere here, so items that never leak into // downstream crates (e.g. via monomorphisation or // inlining) would not be part of the ABI. SawItem.hash(self.st); visit::walk_item(self, i) } fn visit_mod(&mut self, m: &Mod, _s: Span, _n: NodeId) { SawMod.hash(self.st); visit::walk_mod(self, m) } fn visit_decl(&mut self, d: &Decl) { SawDecl.hash(self.st); visit::walk_decl(self, d) } fn visit_ty(&mut self, t: &Ty) { SawTy.hash(self.st); visit::walk_ty(self, t) } fn visit_generics(&mut self, g: &Generics) { SawGenerics.hash(self.st); visit::walk_generics(self, g) } fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, _: NodeId) { SawFn.hash(self.st); visit::walk_fn(self, fk, fd, b, s) } fn visit_ty_method(&mut self, t: &TypeMethod) { SawTyMethod.hash(self.st); visit::walk_ty_method(self, t) } fn visit_trait_item(&mut self, t: &TraitItem) { SawTraitMethod.hash(self.st); visit::walk_trait_item(self, t) } fn visit_struct_field(&mut self, s: &StructField) { SawStructField.hash(self.st); visit::walk_struct_field(self, s) } fn visit_explicit_self(&mut self, es: &ExplicitSelf) { SawExplicitSelf.hash(self.st); visit::walk_explicit_self(self, es) } fn visit_path(&mut self, path: &Path, _: ast::NodeId) { SawPath.hash(self.st); visit::walk_path(self, path) } fn visit_block(&mut self, b: &Block) { SawBlock.hash(self.st); visit::walk_block(self, b) } fn visit_pat(&mut self, p: &Pat) { SawPat.hash(self.st); visit::walk_pat(self, p) }
impl InternKey for Ident { fn get_content(self) -> token::InternedString { token::get_ident(self) } }
random_line_split
svh.rs
// 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. //! Calculation and management of a Strict Version Hash for crates //! //! # Today's ABI problem //! //! In today's implementation of rustc, it is incredibly difficult to achieve //! forward binary compatibility without resorting to C-like interfaces. Within //! rust code itself, abi details such as symbol names suffer from a variety of //! unrelated factors to code changing such as the "def id drift" problem. This //! ends up yielding confusing error messages about metadata mismatches and //! such. //! //! The core of this problem is when an upstream dependency changes and //! downstream dependents are not recompiled. This causes compile errors because //! the upstream crate's metadata has changed but the downstream crates are //! still referencing the older crate's metadata. //! //! This problem exists for many reasons, the primary of which is that rust does //! not currently support forwards ABI compatibility (in place upgrades of a //! crate). //! //! # SVH and how it alleviates the problem //! //! With all of this knowledge on hand, this module contains the implementation //! of a notion of a "Strict Version Hash" for a crate. This is essentially a //! hash of all contents of a crate which can somehow be exposed to downstream //! crates. //! //! This hash is currently calculated by just hashing the AST, but this is //! obviously wrong (doc changes should not result in an incompatible ABI). //! Implementation-wise, this is required at this moment in time. //! //! By encoding this strict version hash into all crate's metadata, stale crates //! can be detected immediately and error'd about by rustc itself. //! //! # Relevant links //! //! Original issue: https://github.com/rust-lang/rust/issues/10207 use std::fmt; use std::hash::Hash; use std::hash::sip::SipState; use std::iter::range_step; use syntax::ast; use syntax::visit; #[deriving(Clone, PartialEq)] pub struct Svh { hash: String, } impl Svh { pub fn new(hash: &str) -> Svh { assert!(hash.len() == 16); Svh { hash: hash.to_string() } } pub fn as_str<'a>(&'a self) -> &'a str { self.hash.as_slice() } pub fn calculate(metadata: &Vec<String>, krate: &ast::Crate) -> Svh { // FIXME (#14132): This is better than it used to be, but it still not // ideal. We now attempt to hash only the relevant portions of the // Crate AST as well as the top-level crate attributes. (However, // the hashing of the crate attributes should be double-checked // to ensure it is not incorporating implementation artifacts into // the hash that are not otherwise visible.) // FIXME: this should use SHA1, not SipHash. SipHash is not built to // avoid collisions. let mut state = SipState::new(); for data in metadata.iter() { data.hash(&mut state); } { let mut visit = svh_visitor::make(&mut state); visit::walk_crate(&mut visit, krate); } // FIXME (#14132): This hash is still sensitive to e.g. the // spans of the crate Attributes and their underlying // MetaItems; we should make ContentHashable impl for those // types and then use hash_content. But, since all crate // attributes should appear near beginning of the file, it is // not such a big deal to be sensitive to their spans for now. // // We hash only the MetaItems instead of the entire Attribute // to avoid hashing the AttrId for attr in krate.attrs.iter() { attr.node.value.hash(&mut state); } let hash = state.result(); return Svh { hash: range_step(0u, 64u, 4u).map(|i| hex(hash >> i)).collect() }; fn hex(b: u64) -> char { let b = (b & 0xf) as u8; let b = match b { 0... 9 => '0' as u8 + b, _ => 'a' as u8 + b - 10, }; b as char } } } impl fmt::Show for Svh { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.pad(self.as_str()) } } // FIXME (#14132): Even this SVH computation still has implementation // artifacts: namely, the order of item declaration will affect the // hash computation, but for many kinds of items the order of // declaration should be irrelevant to the ABI. mod svh_visitor { pub use self::SawExprComponent::*; pub use self::SawStmtComponent::*; use self::SawAbiComponent::*; use syntax::ast; use syntax::ast::*; use syntax::codemap::Span; use syntax::parse::token; use syntax::print::pprust; use syntax::visit; use syntax::visit::{Visitor, FnKind}; use std::hash::Hash; use std::hash::sip::SipState; pub struct StrictVersionHashVisitor<'a> { pub st: &'a mut SipState, } pub fn make<'a>(st: &'a mut SipState) -> StrictVersionHashVisitor<'a> { StrictVersionHashVisitor { st: st } } // To off-load the bulk of the hash-computation on deriving(Hash), // we define a set of enums corresponding to the content that our // crate visitor will encounter as it traverses the ast. // // The important invariant is that all of the Saw*Component enums // do not carry any Spans, Names, or Idents. // // Not carrying any Names/Idents is the important fix for problem // noted on PR #13948: using the ident.name as the basis for a // hash leads to unstable SVH, because ident.name is just an index // into intern table (i.e. essentially a random address), not // computed from the name content. // // With the below enums, the SVH computation is not sensitive to // artifacts of how rustc was invoked nor of how the source code // was laid out. (Or at least it is *less* sensitive.) // This enum represents the different potential bits of code the // visitor could encounter that could affect the ABI for the crate, // and assigns each a distinct tag to feed into the hash computation. #[deriving(Hash)] enum SawAbiComponent<'a> { // FIXME (#14132): should we include (some function of) // ident.ctxt as well? SawIdent(token::InternedString), SawStructDef(token::InternedString), SawLifetimeRef(token::InternedString), SawLifetimeDef(token::InternedString), SawMod, SawViewItem, SawForeignItem, SawItem, SawDecl, SawTy, SawGenerics, SawFn, SawTyMethod, SawTraitMethod, SawStructField, SawVariant, SawExplicitSelf, SawPath, SawOptLifetimeRef, SawBlock, SawPat, SawLocal, SawArm, SawExpr(SawExprComponent<'a>), SawStmt(SawStmtComponent), } /// SawExprComponent carries all of the information that we want /// to include in the hash that *won't* be covered by the /// subsequent recursive traversal of the expression's /// substructure by the visitor. /// /// We know every Expr_ variant is covered by a variant because /// `fn saw_expr` maps each to some case below. Ensuring that /// each variant carries an appropriate payload has to be verified /// by hand. /// /// (However, getting that *exactly* right is not so important /// because the SVH is just a developer convenience; there is no /// guarantee of collision-freedom, hash collisions are just /// (hopefully) unlikely.) #[deriving(Hash)] pub enum SawExprComponent<'a> { SawExprLoop(Option<token::InternedString>), SawExprField(token::InternedString), SawExprTupField(uint), SawExprBreak(Option<token::InternedString>), SawExprAgain(Option<token::InternedString>), SawExprBox, SawExprVec, SawExprCall, SawExprMethodCall, SawExprTup, SawExprBinary(ast::BinOp), SawExprUnary(ast::UnOp), SawExprLit(ast::Lit_), SawExprCast, SawExprIf, SawExprWhile, SawExprMatch, SawExprFnBlock, SawExprUnboxedFn, SawExprProc, SawExprBlock, SawExprAssign, SawExprAssignOp(ast::BinOp), SawExprIndex, SawExprSlice, SawExprPath, SawExprAddrOf(ast::Mutability), SawExprRet, SawExprInlineAsm(&'a ast::InlineAsm), SawExprStruct, SawExprRepeat, SawExprParen, SawExprForLoop, } fn saw_expr<'a>(node: &'a Expr_) -> SawExprComponent<'a> { match *node { ExprBox(..) => SawExprBox, ExprVec(..) => SawExprVec, ExprCall(..) => SawExprCall, ExprMethodCall(..) => SawExprMethodCall, ExprTup(..) => SawExprTup, ExprBinary(op, _, _) => SawExprBinary(op), ExprUnary(op, _) => SawExprUnary(op), ExprLit(ref lit) => SawExprLit(lit.node.clone()), ExprCast(..) => SawExprCast, ExprIf(..) => SawExprIf, ExprWhile(..) => SawExprWhile, ExprLoop(_, id) => SawExprLoop(id.map(content)), ExprMatch(..) => SawExprMatch, ExprFnBlock(..) => SawExprFnBlock, ExprUnboxedFn(..) => SawExprUnboxedFn, ExprProc(..) => SawExprProc, ExprBlock(..) => SawExprBlock, ExprAssign(..) => SawExprAssign, ExprAssignOp(op, _, _) => SawExprAssignOp(op), ExprField(_, id, _) => SawExprField(content(id.node)), ExprTupField(_, id, _) => SawExprTupField(id.node), ExprIndex(..) => SawExprIndex, ExprSlice(..) => SawExprSlice, ExprPath(..) => SawExprPath, ExprAddrOf(m, _) => SawExprAddrOf(m), ExprBreak(id) => SawExprBreak(id.map(content)), ExprAgain(id) => SawExprAgain(id.map(content)), ExprRet(..) => SawExprRet, ExprInlineAsm(ref asm) => SawExprInlineAsm(asm), ExprStruct(..) => SawExprStruct, ExprRepeat(..) => SawExprRepeat, ExprParen(..) => SawExprParen, ExprForLoop(..) => SawExprForLoop, // just syntactic artifacts, expanded away by time of SVH. ExprIfLet(..) => unreachable!(), ExprWhileLet(..) => unreachable!(), ExprMac(..) => unreachable!(), } } /// SawStmtComponent is analogous to SawExprComponent, but for statements. #[deriving(Hash)] pub enum SawStmtComponent { SawStmtDecl, SawStmtExpr, SawStmtSemi, } fn saw_stmt(node: &Stmt_) -> SawStmtComponent { match *node { StmtDecl(..) => SawStmtDecl, StmtExpr(..) => SawStmtExpr, StmtSemi(..) => SawStmtSemi, StmtMac(..) => unreachable!(), } } // Ad-hoc overloading between Ident and Name to their intern table lookups. trait InternKey { fn get_content(self) -> token::InternedString; } impl InternKey for Ident { fn get_content(self) -> token::InternedString { token::get_ident(self) } } impl InternKey for Name { fn get_content(self) -> token::InternedString { token::get_name(self) } } fn content<K:InternKey>(k: K) -> token::InternedString
impl<'a, 'v> Visitor<'v> for StrictVersionHashVisitor<'a> { fn visit_mac(&mut self, macro: &Mac) { // macro invocations, namely macro_rules definitions, // *can* appear as items, even in the expanded crate AST. if macro_name(macro).get() == "macro_rules" { // Pretty-printing definition to a string strips out // surface artifacts (currently), such as the span // information, yielding a content-based hash. // FIXME (#14132): building temporary string is // expensive; a direct content-based hash on token // trees might be faster. Implementing this is far // easier in short term. let macro_defn_as_string = pprust::to_string(|pp_state| pp_state.print_mac(macro)); macro_defn_as_string.hash(self.st); } else { // It is not possible to observe any kind of macro // invocation at this stage except `macro_rules!`. panic!("reached macro somehow: {}", pprust::to_string(|pp_state| pp_state.print_mac(macro))); } visit::walk_mac(self, macro); fn macro_name(macro: &Mac) -> token::InternedString { match &macro.node { &MacInvocTT(ref path, ref _tts, ref _stx_ctxt) => { let s = path.segments.as_slice(); assert_eq!(s.len(), 1); content(s[0].identifier) } } } } fn visit_struct_def(&mut self, s: &StructDef, ident: Ident, g: &Generics, _: NodeId) { SawStructDef(content(ident)).hash(self.st); visit::walk_generics(self, g); visit::walk_struct_def(self, s) } fn visit_variant(&mut self, v: &Variant, g: &Generics) { SawVariant.hash(self.st); // walk_variant does not call walk_generics, so do it here. visit::walk_generics(self, g); visit::walk_variant(self, v, g) } fn visit_opt_lifetime_ref(&mut self, _: Span, l: &Option<Lifetime>) { SawOptLifetimeRef.hash(self.st); // (This is a strange method in the visitor trait, in that // it does not expose a walk function to do the subroutine // calls.) match *l { Some(ref l) => self.visit_lifetime_ref(l), None => () } } // All of the remaining methods just record (in the hash // SipState) that the visitor saw that particular variant // (with its payload), and continue walking as the default // visitor would. // // Some of the implementations have some notes as to how one // might try to make their SVH computation less discerning // (e.g. by incorporating reachability analysis). But // currently all of their implementations are uniform and // uninteresting. // // (If you edit a method such that it deviates from the // pattern, please move that method up above this comment.) fn visit_ident(&mut self, _: Span, ident: Ident) { SawIdent(content(ident)).hash(self.st); } fn visit_lifetime_ref(&mut self, l: &Lifetime) { SawLifetimeRef(content(l.name)).hash(self.st); } fn visit_lifetime_def(&mut self, l: &LifetimeDef) { SawLifetimeDef(content(l.lifetime.name)).hash(self.st); } // We do recursively walk the bodies of functions/methods // (rather than omitting their bodies from the hash) since // monomorphization and cross-crate inlining generally implies // that a change to a crate body will require downstream // crates to be recompiled. fn visit_expr(&mut self, ex: &Expr) { SawExpr(saw_expr(&ex.node)).hash(self.st); visit::walk_expr(self, ex) } fn visit_stmt(&mut self, s: &Stmt) { SawStmt(saw_stmt(&s.node)).hash(self.st); visit::walk_stmt(self, s) } fn visit_view_item(&mut self, i: &ViewItem) { // Two kinds of view items can affect the ABI for a crate: // exported `pub use` view items (since that may expose // items that downstream crates can call), and `use // foo::Trait`, since changing that may affect method // resolution. // // The simplest approach to handling both of the above is // just to adopt the same simple-minded (fine-grained) // hash that I am deploying elsewhere here. SawViewItem.hash(self.st); visit::walk_view_item(self, i) } fn visit_foreign_item(&mut self, i: &ForeignItem) { // FIXME (#14132) ideally we would incorporate privacy (or // perhaps reachability) somewhere here, so foreign items // that do not leak into downstream crates would not be // part of the ABI. SawForeignItem.hash(self.st); visit::walk_foreign_item(self, i) } fn visit_item(&mut self, i: &Item) { // FIXME (#14132) ideally would incorporate reachability // analysis somewhere here, so items that never leak into // downstream crates (e.g. via monomorphisation or // inlining) would not be part of the ABI. SawItem.hash(self.st); visit::walk_item(self, i) } fn visit_mod(&mut self, m: &Mod, _s: Span, _n: NodeId) { SawMod.hash(self.st); visit::walk_mod(self, m) } fn visit_decl(&mut self, d: &Decl) { SawDecl.hash(self.st); visit::walk_decl(self, d) } fn visit_ty(&mut self, t: &Ty) { SawTy.hash(self.st); visit::walk_ty(self, t) } fn visit_generics(&mut self, g: &Generics) { SawGenerics.hash(self.st); visit::walk_generics(self, g) } fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, _: NodeId) { SawFn.hash(self.st); visit::walk_fn(self, fk, fd, b, s) } fn visit_ty_method(&mut self, t: &TypeMethod) { SawTyMethod.hash(self.st); visit::walk_ty_method(self, t) } fn visit_trait_item(&mut self, t: &TraitItem) { SawTraitMethod.hash(self.st); visit::walk_trait_item(self, t) } fn visit_struct_field(&mut self, s: &StructField) { SawStructField.hash(self.st); visit::walk_struct_field(self, s) } fn visit_explicit_self(&mut self, es: &ExplicitSelf) { SawExplicitSelf.hash(self.st); visit::walk_explicit_self(self, es) } fn visit_path(&mut self, path: &Path, _: ast::NodeId) { SawPath.hash(self.st); visit::walk_path(self, path) } fn visit_block(&mut self, b: &Block) { SawBlock.hash(self.st); visit::walk_block(self, b) } fn visit_pat(&mut self, p: &Pat) { SawPat.hash(self.st); visit::walk_pat(self, p) }
{ k.get_content() }
identifier_body
generation_size.rs
/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * This software may be used and distributed according to the terms of the * GNU General Public License version 2. */ use std::collections::HashMap; use crate::utils; use crate::MononokeSQLBlobGCArgs; use anyhow::Result; use bytesize::ByteSize; use clap::Parser; use futures::stream::{self, StreamExt, TryStreamExt}; use futures::TryFutureExt; use mononoke_app::MononokeApp; /// measure generation sizes #[derive(Parser)] pub struct CommandArgs {} fn
(sizes: &HashMap<Option<u64>, u64>) { let generations = { let mut keys: Vec<_> = sizes.keys().collect(); keys.sort_unstable(); keys }; println!("Generation | Size"); println!("-----------------"); for generation in generations { let size = ByteSize::b(sizes[generation]); let generation = match generation { None => "NULL".to_string(), Some(g) => g.to_string(), }; println!("{:>10} | {}", generation, size.to_string_as(true)); } } pub async fn run(app: MononokeApp, _args: CommandArgs) -> Result<()> { let common_args: MononokeSQLBlobGCArgs = app.args()?; let max_parallelism: usize = common_args.scheduled_max; let (sqlblob, shard_range) = utils::get_sqlblob_and_shard_range(&app).await?; let scuba_sample_builder = app.environment().scuba_sample_builder.clone(); let shard_sizes: Vec<(usize, HashMap<Option<u64>, (u64, u64)>)> = stream::iter(shard_range) .map(|shard| { sqlblob .get_chunk_sizes_by_generation(shard) .map_ok(move |gen_to_size| (shard, gen_to_size)) }) .buffer_unordered(max_parallelism) .try_collect::<Vec<(usize, HashMap<Option<u64>, (u64, u64)>)>>() .await?; let mut size_summary = HashMap::new(); for (shard, sizes) in shard_sizes { for (generation, (size, chunk_id_count)) in sizes.into_iter() { let mut sample = scuba_sample_builder.clone(); sample.add("shard", shard); sample.add_opt("generation", generation); sample.add("size", size); sample.add("chunk_id_count", chunk_id_count); sample.log(); *size_summary.entry(generation).or_insert(0u64) += size; } } if scuba_sample_builder.is_discard() { print_sizes(&size_summary); } Ok(()) }
print_sizes
identifier_name
generation_size.rs
/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * This software may be used and distributed according to the terms of the * GNU General Public License version 2. */ use std::collections::HashMap; use crate::utils; use crate::MononokeSQLBlobGCArgs; use anyhow::Result; use bytesize::ByteSize; use clap::Parser; use futures::stream::{self, StreamExt, TryStreamExt}; use futures::TryFutureExt; use mononoke_app::MononokeApp; /// measure generation sizes #[derive(Parser)] pub struct CommandArgs {} fn print_sizes(sizes: &HashMap<Option<u64>, u64>) { let generations = { let mut keys: Vec<_> = sizes.keys().collect(); keys.sort_unstable(); keys }; println!("Generation | Size"); println!("-----------------"); for generation in generations { let size = ByteSize::b(sizes[generation]); let generation = match generation { None => "NULL".to_string(), Some(g) => g.to_string(), }; println!("{:>10} | {}", generation, size.to_string_as(true)); } } pub async fn run(app: MononokeApp, _args: CommandArgs) -> Result<()>
for (shard, sizes) in shard_sizes { for (generation, (size, chunk_id_count)) in sizes.into_iter() { let mut sample = scuba_sample_builder.clone(); sample.add("shard", shard); sample.add_opt("generation", generation); sample.add("size", size); sample.add("chunk_id_count", chunk_id_count); sample.log(); *size_summary.entry(generation).or_insert(0u64) += size; } } if scuba_sample_builder.is_discard() { print_sizes(&size_summary); } Ok(()) }
{ let common_args: MononokeSQLBlobGCArgs = app.args()?; let max_parallelism: usize = common_args.scheduled_max; let (sqlblob, shard_range) = utils::get_sqlblob_and_shard_range(&app).await?; let scuba_sample_builder = app.environment().scuba_sample_builder.clone(); let shard_sizes: Vec<(usize, HashMap<Option<u64>, (u64, u64)>)> = stream::iter(shard_range) .map(|shard| { sqlblob .get_chunk_sizes_by_generation(shard) .map_ok(move |gen_to_size| (shard, gen_to_size)) }) .buffer_unordered(max_parallelism) .try_collect::<Vec<(usize, HashMap<Option<u64>, (u64, u64)>)>>() .await?; let mut size_summary = HashMap::new();
identifier_body
generation_size.rs
/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * This software may be used and distributed according to the terms of the * GNU General Public License version 2. */ use std::collections::HashMap; use crate::utils; use crate::MononokeSQLBlobGCArgs; use anyhow::Result; use bytesize::ByteSize; use clap::Parser; use futures::stream::{self, StreamExt, TryStreamExt}; use futures::TryFutureExt; use mononoke_app::MononokeApp; /// measure generation sizes #[derive(Parser)] pub struct CommandArgs {} fn print_sizes(sizes: &HashMap<Option<u64>, u64>) { let generations = { let mut keys: Vec<_> = sizes.keys().collect(); keys.sort_unstable(); keys }; println!("Generation | Size"); println!("-----------------"); for generation in generations { let size = ByteSize::b(sizes[generation]); let generation = match generation { None => "NULL".to_string(),
}; println!("{:>10} | {}", generation, size.to_string_as(true)); } } pub async fn run(app: MononokeApp, _args: CommandArgs) -> Result<()> { let common_args: MononokeSQLBlobGCArgs = app.args()?; let max_parallelism: usize = common_args.scheduled_max; let (sqlblob, shard_range) = utils::get_sqlblob_and_shard_range(&app).await?; let scuba_sample_builder = app.environment().scuba_sample_builder.clone(); let shard_sizes: Vec<(usize, HashMap<Option<u64>, (u64, u64)>)> = stream::iter(shard_range) .map(|shard| { sqlblob .get_chunk_sizes_by_generation(shard) .map_ok(move |gen_to_size| (shard, gen_to_size)) }) .buffer_unordered(max_parallelism) .try_collect::<Vec<(usize, HashMap<Option<u64>, (u64, u64)>)>>() .await?; let mut size_summary = HashMap::new(); for (shard, sizes) in shard_sizes { for (generation, (size, chunk_id_count)) in sizes.into_iter() { let mut sample = scuba_sample_builder.clone(); sample.add("shard", shard); sample.add_opt("generation", generation); sample.add("size", size); sample.add("chunk_id_count", chunk_id_count); sample.log(); *size_summary.entry(generation).or_insert(0u64) += size; } } if scuba_sample_builder.is_discard() { print_sizes(&size_summary); } Ok(()) }
Some(g) => g.to_string(),
random_line_split
ast_util.rs
BiLe => "<=", BiNe => "!=", BiGe => ">=", BiGt => ">" } } pub fn lazy_binop(b: BinOp) -> bool { match b { BiAnd => true, BiOr => true, _ => false } } pub fn is_shift_binop(b: BinOp) -> bool { match b { BiShl => true, BiShr => true, _ => false } } pub fn unop_to_str(op: UnOp) -> &'static str { match op { UnBox => "box(GC) ", UnUniq => "box() ", UnDeref => "*", UnNot => "!", UnNeg => "-", } } pub fn is_path(e: Gc<Expr>) -> bool { return match e.node { ExprPath(_) => true, _ => false }; } // Get a string representation of a signed int type, with its value. // We want to avoid "45int" and "-3int" in favor of "45" and "-3" pub fn int_ty_to_str(t: IntTy, val: Option<i64>) -> String { let s = match t { TyI if val.is_some() => "i", TyI => "int", TyI8 => "i8", TyI16 => "i16", TyI32 => "i32", TyI64 => "i64" }; match val { // cast to a u64 so we can correctly print INT64_MIN. All integral types // are parsed as u64, so we wouldn't want to print an extra negative // sign. Some(n) => format!("{}{}", n as u64, s), None => s.to_string() } } pub fn int_ty_max(t: IntTy) -> u64 { match t { TyI8 => 0x80u64, TyI16 => 0x8000u64, TyI | TyI32 => 0x80000000u64, // actually ni about TyI TyI64 => 0x8000000000000000u64 } } // Get a string representation of an unsigned int type, with its value. // We want to avoid "42uint" in favor of "42u" pub fn uint_ty_to_str(t: UintTy, val: Option<u64>) -> String { let s = match t { TyU if val.is_some() => "u", TyU => "uint", TyU8 => "u8", TyU16 => "u16", TyU32 => "u32", TyU64 => "u64" }; match val { Some(n) => format!("{}{}", n, s), None => s.to_string() } } pub fn uint_ty_max(t: UintTy) -> u64 { match t { TyU8 => 0xffu64, TyU16 => 0xffffu64, TyU | TyU32 => 0xffffffffu64, // actually ni about TyU TyU64 => 0xffffffffffffffffu64 } } pub fn float_ty_to_str(t: FloatTy) -> String { match t { TyF32 => "f32".to_string(), TyF64 => "f64".to_string(), } } pub fn is_call_expr(e: Gc<Expr>) -> bool { match e.node { ExprCall(..) => true, _ => false } } pub fn block_from_expr(e: Gc<Expr>) -> P<Block> { P(Block { view_items: Vec::new(), stmts: Vec::new(), expr: Some(e), id: e.id, rules: DefaultBlock, span: e.span }) } pub fn ident_to_path(s: Span, identifier: Ident) -> Path { ast::Path { span: s, global: false, segments: vec!( ast::PathSegment { identifier: identifier, lifetimes: Vec::new(), types: OwnedSlice::empty(), } ), } } pub fn ident_to_pat(id: NodeId, s: Span, i: Ident) -> Gc<Pat> { box(GC) ast::Pat { id: id, node: PatIdent(BindByValue(MutImmutable), ident_to_path(s, i), None), span: s } } pub fn name_to_dummy_lifetime(name: Name) -> Lifetime { Lifetime { id: DUMMY_NODE_ID, span: codemap::DUMMY_SP, name: name } } pub fn is_unguarded(a: &Arm) -> bool { match a.guard { None => true, _ => false } } pub fn unguarded_pat(a: &Arm) -> Option<Vec<Gc<Pat>>>
/// Generate a "pretty" name for an `impl` from its type and trait. /// This is designed so that symbols of `impl`'d methods give some /// hint of where they came from, (previously they would all just be /// listed as `__extensions__::method_name::hash`, with no indication /// of the type). pub fn impl_pretty_name(trait_ref: &Option<TraitRef>, ty: &Ty) -> Ident { let mut pretty = pprust::ty_to_str(ty); match *trait_ref { Some(ref trait_ref) => { pretty.push_char('.'); pretty.push_str(pprust::path_to_str(&trait_ref.path).as_slice()); } None => {} } token::gensym_ident(pretty.as_slice()) } pub fn public_methods(ms: Vec<Gc<Method>> ) -> Vec<Gc<Method>> { ms.move_iter().filter(|m| { match m.vis { Public => true, _ => false } }).collect() } // extract a TypeMethod from a TraitMethod. if the TraitMethod is // a default, pull out the useful fields to make a TypeMethod pub fn trait_method_to_ty_method(method: &TraitMethod) -> TypeMethod { match *method { Required(ref m) => (*m).clone(), Provided(ref m) => { TypeMethod { ident: m.ident, attrs: m.attrs.clone(), fn_style: m.fn_style, decl: m.decl, generics: m.generics.clone(), explicit_self: m.explicit_self, id: m.id, span: m.span, vis: m.vis, } } } } pub fn split_trait_methods(trait_methods: &[TraitMethod]) -> (Vec<TypeMethod>, Vec<Gc<Method>> ) { let mut reqd = Vec::new(); let mut provd = Vec::new(); for trt_method in trait_methods.iter() { match *trt_method { Required(ref tm) => reqd.push((*tm).clone()), Provided(m) => provd.push(m) } }; (reqd, provd) } pub fn struct_field_visibility(field: ast::StructField) -> Visibility { match field.node.kind { ast::NamedField(_, v) | ast::UnnamedField(v) => v } } /// Maps a binary operator to its precedence pub fn operator_prec(op: ast::BinOp) -> uint { match op { // 'as' sits here with 12 BiMul | BiDiv | BiRem => 11u, BiAdd | BiSub => 10u, BiShl | BiShr => 9u, BiBitAnd => 8u, BiBitXor => 7u, BiBitOr => 6u, BiLt | BiLe | BiGe | BiGt => 4u, BiEq | BiNe => 3u, BiAnd => 2u, BiOr => 1u } } /// Precedence of the `as` operator, which is a binary operator /// not appearing in the prior table. pub static as_prec: uint = 12u; pub fn empty_generics() -> Generics { Generics {lifetimes: Vec::new(), ty_params: OwnedSlice::empty()} } // ______________________________________________________________________ // Enumerating the IDs which appear in an AST #[deriving(Encodable, Decodable)] pub struct IdRange { pub min: NodeId, pub max: NodeId, } impl IdRange { pub fn max() -> IdRange { IdRange { min: u32::MAX, max: u32::MIN, } } pub fn empty(&self) -> bool { self.min >= self.max } pub fn add(&mut self, id: NodeId) { self.min = cmp::min(self.min, id); self.max = cmp::max(self.max, id + 1); } } pub trait IdVisitingOperation { fn visit_id(&self, node_id: NodeId); } pub struct IdVisitor<'a, O> { pub operation: &'a O, pub pass_through_items: bool, pub visited_outermost: bool, } impl<'a, O: IdVisitingOperation> IdVisitor<'a, O> { fn visit_generics_helper(&self, generics: &Generics) { for type_parameter in generics.ty_params.iter() { self.operation.visit_id(type_parameter.id) } for lifetime in generics.lifetimes.iter() { self.operation.visit_id(lifetime.id) } } } impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> { fn visit_mod(&mut self, module: &Mod, _: Span, node_id: NodeId, env: ()) { self.operation.visit_id(node_id); visit::walk_mod(self, module, env) } fn visit_view_item(&mut self, view_item: &ViewItem, env: ()) { if!self.pass_through_items { if self.visited_outermost { return; } else { self.visited_outermost = true; } } match view_item.node { ViewItemExternCrate(_, _, node_id) => { self.operation.visit_id(node_id) } ViewItemUse(ref view_path) => { match view_path.node { ViewPathSimple(_, _, node_id) | ViewPathGlob(_, node_id) => { self.operation.visit_id(node_id) } ViewPathList(_, ref paths, node_id) => { self.operation.visit_id(node_id); for path in paths.iter() { self.operation.visit_id(path.node.id) } } } } } visit::walk_view_item(self, view_item, env); self.visited_outermost = false; } fn visit_foreign_item(&mut self, foreign_item: &ForeignItem, env: ()) { self.operation.visit_id(foreign_item.id); visit::walk_foreign_item(self, foreign_item, env) } fn visit_item(&mut self, item: &Item, env: ()) { if!self.pass_through_items { if self.visited_outermost { return } else { self.visited_outermost = true } } self.operation.visit_id(item.id); match item.node { ItemEnum(ref enum_definition, _) => { for variant in enum_definition.variants.iter() { self.operation.visit_id(variant.node.id) } } _ => {} } visit::walk_item(self, item, env); self.visited_outermost = false } fn visit_local(&mut self, local: &Local, env: ()) { self.operation.visit_id(local.id); visit::walk_local(self, local, env) } fn visit_block(&mut self, block: &Block, env: ()) { self.operation.visit_id(block.id); visit::walk_block(self, block, env) } fn visit_stmt(&mut self, statement: &Stmt, env: ()) { self.operation.visit_id(ast_util::stmt_id(statement)); visit::walk_stmt(self, statement, env) } fn visit_pat(&mut self, pattern: &Pat, env: ()) { self.operation.visit_id(pattern.id); visit::walk_pat(self, pattern, env) } fn visit_expr(&mut self, expression: &Expr, env: ()) { self.operation.visit_id(expression.id); visit::walk_expr(self, expression, env) } fn visit_ty(&mut self, typ: &Ty, env: ()) { self.operation.visit_id(typ.id); match typ.node { TyPath(_, _, id) => self.operation.visit_id(id), _ => {} } visit::walk_ty(self, typ, env) } fn visit_generics(&mut self, generics: &Generics, env: ()) { self.visit_generics_helper(generics); visit::walk_generics(self, generics, env) } fn visit_fn(&mut self, function_kind: &visit::FnKind, function_declaration: &FnDecl, block: &Block, span: Span, node_id: NodeId, env: ()) { if!self.pass_through_items { match *function_kind { visit::FkMethod(..) if self.visited_outermost => return, visit::FkMethod(..) => self.visited_outermost = true, _ => {} } } self.operation.visit_id(node_id); match *function_kind { visit::FkItemFn(_, generics, _, _) | visit::FkMethod(_, generics, _) => { self.visit_generics_helper(generics) } visit::FkFnBlock => {} } for argument in function_declaration.inputs.iter() { self.operation.visit_id(argument.id) } visit::walk_fn(self, function_kind, function_declaration, block, span, env); if!self.pass_through_items { match *function_kind { visit::FkMethod(..) => self.visited_outermost = false, _ => {} } } } fn visit_struct_field(&mut self, struct_field: &StructField, env: ()) { self.operation.visit_id(struct_field.node.id); visit::walk_struct_field(self, struct_field, env) } fn visit_struct_def(&mut self, struct_def: &StructDef, _: ast::Ident, _: &ast::Generics, id: NodeId, _: ()) { self.operation.visit_id(id); struct_def.ctor_id.map(|ctor_id| self.operation.visit_id(ctor_id)); visit::walk_struct_def(self, struct_def, ()); } fn visit_trait_method(&mut self, tm: &ast::TraitMethod, _: ()) { match *tm { ast::Required(ref m) => self.operation.visit_id(m.id), ast::Provided(ref m) => self.operation.visit_id(m.id), } visit::walk_trait_method(self, tm, ()); } } pub fn visit_ids_for_inlined_item<O: IdVisitingOperation>(item: &InlinedItem, operation: &O) { let mut id_visitor = IdVisitor { operation: operation, pass_through_items: true, visited_outermost: false, }; visit::walk_inlined_item(&mut id_visitor, item, ()); } struct IdRangeComputingVisitor { result: Cell<IdRange>, } impl IdVisitingOperation for IdRangeComputingVisitor { fn visit_id(&self, id: NodeId) { let mut id_range = self.result.get(); id_range.add(id); self.result.set(id_range) } } pub fn compute_id_range_for_inlined_item(item: &InlinedItem) -> IdRange { let visitor = IdRangeComputingVisitor { result: Cell::new(IdRange::max()) }; visit_ids_for_inlined_item(item, &visitor); visitor.result.get() } pub fn compute_id_range_for_fn_body(fk: &visit::FnKind, decl: &FnDecl, body: &Block, sp: Span, id: NodeId) -> IdRange { /*! * Computes the id range for a single fn body, * ignoring nested items. */ let visitor = IdRangeComputingVisitor { result: Cell::new(IdRange::max()) }; let mut id_visitor = IdVisitor { operation: &visitor, pass_through_items: false, visited_outermost: false, }; id_visitor.visit_fn(fk, decl, body, sp, id, ()); visitor.result.get() } pub fn is_item_impl(item: Gc<ast::Item>) -> bool { match item.node { ItemImpl(..) => true, _ => false } } pub fn walk_pat(pat: &Pat, it: |&Pat| -> bool) -> bool { if!it(pat) { return false; } match pat.node { PatIdent(_, _, Some(ref p)) => walk_pat(&**p, it), PatStruct(_, ref fields, _) => { fields.iter().advance(|f| walk_pat(&*f.pat, |p| it(p))) } PatEnum(_, Some(ref s)) | PatTup(ref s) => { s.iter().advance(|p| walk_pat(&**p, |p| it(p))) } PatBox(ref s) | PatRegion(ref s) => { walk_pat(&**s, it) } PatVec(ref before, ref slice, ref after) => { before.iter().advance(|p| walk_pat(&**p, |p| it(p))) && slice.iter().advance(|p| walk_pat(&**p, |p| it(p))) && after.iter().advance(|p| walk_pat(&**p, |p| it(p))) } PatMac(_) => fail!("attempted to analyze unexpanded pattern"), PatWild | PatWildMulti | PatLit(_) | PatRange(_, _) | PatIdent(_, _, _) | PatEnum(_, _) => { true } } } pub trait EachViewItem { fn each_view_item(&self, f: |&ast::ViewItem| -> bool) -> bool; } struct EachViewItemData<'a> { callback: |&ast::ViewItem|: 'a -> bool, } impl<'a> Visitor<()> for EachViewItemData<'a> { fn visit_view_item(&mut self, view_item: &ast::ViewItem, _: ()) { let _ = (self.callback)(view_item); } } impl EachViewItem for ast::Crate { fn each_view_item(&self,
{ if is_unguarded(a) { Some(/* FIXME (#2543) */ a.pats.clone()) } else { None } }
identifier_body
ast_util.rs
BiLe => "<=", BiNe => "!=", BiGe => ">=", BiGt => ">" } } pub fn lazy_binop(b: BinOp) -> bool { match b { BiAnd => true, BiOr => true, _ => false } } pub fn is_shift_binop(b: BinOp) -> bool { match b { BiShl => true, BiShr => true, _ => false } } pub fn unop_to_str(op: UnOp) -> &'static str { match op { UnBox => "box(GC) ", UnUniq => "box() ", UnDeref => "*", UnNot => "!", UnNeg => "-", } } pub fn is_path(e: Gc<Expr>) -> bool { return match e.node { ExprPath(_) => true, _ => false }; } // Get a string representation of a signed int type, with its value. // We want to avoid "45int" and "-3int" in favor of "45" and "-3" pub fn int_ty_to_str(t: IntTy, val: Option<i64>) -> String { let s = match t { TyI if val.is_some() => "i", TyI => "int", TyI8 => "i8", TyI16 => "i16", TyI32 => "i32", TyI64 => "i64" }; match val { // cast to a u64 so we can correctly print INT64_MIN. All integral types // are parsed as u64, so we wouldn't want to print an extra negative // sign. Some(n) => format!("{}{}", n as u64, s), None => s.to_string() } } pub fn int_ty_max(t: IntTy) -> u64 { match t { TyI8 => 0x80u64, TyI16 => 0x8000u64, TyI | TyI32 => 0x80000000u64, // actually ni about TyI TyI64 => 0x8000000000000000u64 } } // Get a string representation of an unsigned int type, with its value. // We want to avoid "42uint" in favor of "42u" pub fn uint_ty_to_str(t: UintTy, val: Option<u64>) -> String { let s = match t { TyU if val.is_some() => "u", TyU => "uint", TyU8 => "u8", TyU16 => "u16", TyU32 => "u32", TyU64 => "u64" }; match val { Some(n) => format!("{}{}", n, s), None => s.to_string() } } pub fn uint_ty_max(t: UintTy) -> u64 { match t { TyU8 => 0xffu64, TyU16 => 0xffffu64, TyU | TyU32 => 0xffffffffu64, // actually ni about TyU TyU64 => 0xffffffffffffffffu64 } } pub fn float_ty_to_str(t: FloatTy) -> String { match t { TyF32 => "f32".to_string(), TyF64 => "f64".to_string(), } } pub fn is_call_expr(e: Gc<Expr>) -> bool { match e.node { ExprCall(..) => true, _ => false } } pub fn block_from_expr(e: Gc<Expr>) -> P<Block> { P(Block { view_items: Vec::new(), stmts: Vec::new(), expr: Some(e), id: e.id, rules: DefaultBlock, span: e.span }) } pub fn ident_to_path(s: Span, identifier: Ident) -> Path { ast::Path { span: s, global: false, segments: vec!( ast::PathSegment { identifier: identifier, lifetimes: Vec::new(), types: OwnedSlice::empty(), } ), } } pub fn ident_to_pat(id: NodeId, s: Span, i: Ident) -> Gc<Pat> { box(GC) ast::Pat { id: id, node: PatIdent(BindByValue(MutImmutable), ident_to_path(s, i), None), span: s } } pub fn name_to_dummy_lifetime(name: Name) -> Lifetime { Lifetime { id: DUMMY_NODE_ID, span: codemap::DUMMY_SP, name: name } } pub fn is_unguarded(a: &Arm) -> bool { match a.guard { None => true, _ => false } } pub fn unguarded_pat(a: &Arm) -> Option<Vec<Gc<Pat>>> { if is_unguarded(a) { Some(/* FIXME (#2543) */ a.pats.clone()) } else { None } } /// Generate a "pretty" name for an `impl` from its type and trait. /// This is designed so that symbols of `impl`'d methods give some /// hint of where they came from, (previously they would all just be /// listed as `__extensions__::method_name::hash`, with no indication /// of the type). pub fn impl_pretty_name(trait_ref: &Option<TraitRef>, ty: &Ty) -> Ident { let mut pretty = pprust::ty_to_str(ty); match *trait_ref { Some(ref trait_ref) => { pretty.push_char('.'); pretty.push_str(pprust::path_to_str(&trait_ref.path).as_slice()); } None => {} } token::gensym_ident(pretty.as_slice()) } pub fn public_methods(ms: Vec<Gc<Method>> ) -> Vec<Gc<Method>> { ms.move_iter().filter(|m| { match m.vis { Public => true, _ => false } }).collect() } // extract a TypeMethod from a TraitMethod. if the TraitMethod is // a default, pull out the useful fields to make a TypeMethod pub fn trait_method_to_ty_method(method: &TraitMethod) -> TypeMethod { match *method { Required(ref m) => (*m).clone(), Provided(ref m) => { TypeMethod { ident: m.ident, attrs: m.attrs.clone(), fn_style: m.fn_style, decl: m.decl, generics: m.generics.clone(), explicit_self: m.explicit_self, id: m.id, span: m.span, vis: m.vis, } } } } pub fn split_trait_methods(trait_methods: &[TraitMethod]) -> (Vec<TypeMethod>, Vec<Gc<Method>> ) { let mut reqd = Vec::new(); let mut provd = Vec::new(); for trt_method in trait_methods.iter() { match *trt_method { Required(ref tm) => reqd.push((*tm).clone()), Provided(m) => provd.push(m) } }; (reqd, provd) } pub fn struct_field_visibility(field: ast::StructField) -> Visibility { match field.node.kind { ast::NamedField(_, v) | ast::UnnamedField(v) => v } } /// Maps a binary operator to its precedence pub fn operator_prec(op: ast::BinOp) -> uint { match op { // 'as' sits here with 12 BiMul | BiDiv | BiRem => 11u, BiAdd | BiSub => 10u, BiShl | BiShr => 9u, BiBitAnd => 8u, BiBitXor => 7u, BiBitOr => 6u, BiLt | BiLe | BiGe | BiGt => 4u, BiEq | BiNe => 3u, BiAnd => 2u, BiOr => 1u } } /// Precedence of the `as` operator, which is a binary operator /// not appearing in the prior table. pub static as_prec: uint = 12u; pub fn empty_generics() -> Generics { Generics {lifetimes: Vec::new(), ty_params: OwnedSlice::empty()} } // ______________________________________________________________________ // Enumerating the IDs which appear in an AST #[deriving(Encodable, Decodable)] pub struct IdRange { pub min: NodeId, pub max: NodeId, } impl IdRange { pub fn max() -> IdRange { IdRange { min: u32::MAX, max: u32::MIN, } } pub fn empty(&self) -> bool { self.min >= self.max } pub fn add(&mut self, id: NodeId) { self.min = cmp::min(self.min, id); self.max = cmp::max(self.max, id + 1); } } pub trait IdVisitingOperation { fn visit_id(&self, node_id: NodeId); } pub struct IdVisitor<'a, O> { pub operation: &'a O, pub pass_through_items: bool, pub visited_outermost: bool, } impl<'a, O: IdVisitingOperation> IdVisitor<'a, O> { fn visit_generics_helper(&self, generics: &Generics) { for type_parameter in generics.ty_params.iter() { self.operation.visit_id(type_parameter.id) } for lifetime in generics.lifetimes.iter() { self.operation.visit_id(lifetime.id) } } } impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> { fn visit_mod(&mut self, module: &Mod, _: Span, node_id: NodeId, env: ()) { self.operation.visit_id(node_id); visit::walk_mod(self, module, env) } fn visit_view_item(&mut self, view_item: &ViewItem, env: ()) { if!self.pass_through_items { if self.visited_outermost { return; } else { self.visited_outermost = true; } } match view_item.node { ViewItemExternCrate(_, _, node_id) => { self.operation.visit_id(node_id) } ViewItemUse(ref view_path) => { match view_path.node { ViewPathSimple(_, _, node_id) | ViewPathGlob(_, node_id) => { self.operation.visit_id(node_id) } ViewPathList(_, ref paths, node_id) => { self.operation.visit_id(node_id); for path in paths.iter() { self.operation.visit_id(path.node.id) } } } } } visit::walk_view_item(self, view_item, env); self.visited_outermost = false; } fn visit_foreign_item(&mut self, foreign_item: &ForeignItem, env: ()) { self.operation.visit_id(foreign_item.id); visit::walk_foreign_item(self, foreign_item, env) } fn visit_item(&mut self, item: &Item, env: ()) { if!self.pass_through_items { if self.visited_outermost { return } else { self.visited_outermost = true } } self.operation.visit_id(item.id); match item.node { ItemEnum(ref enum_definition, _) => { for variant in enum_definition.variants.iter() { self.operation.visit_id(variant.node.id) } } _ => {} } visit::walk_item(self, item, env); self.visited_outermost = false } fn visit_local(&mut self, local: &Local, env: ()) { self.operation.visit_id(local.id); visit::walk_local(self, local, env) } fn visit_block(&mut self, block: &Block, env: ()) { self.operation.visit_id(block.id); visit::walk_block(self, block, env) } fn visit_stmt(&mut self, statement: &Stmt, env: ()) { self.operation.visit_id(ast_util::stmt_id(statement)); visit::walk_stmt(self, statement, env) } fn visit_pat(&mut self, pattern: &Pat, env: ()) { self.operation.visit_id(pattern.id); visit::walk_pat(self, pattern, env) } fn visit_expr(&mut self, expression: &Expr, env: ()) { self.operation.visit_id(expression.id); visit::walk_expr(self, expression, env) } fn visit_ty(&mut self, typ: &Ty, env: ()) { self.operation.visit_id(typ.id); match typ.node { TyPath(_, _, id) => self.operation.visit_id(id), _ => {} } visit::walk_ty(self, typ, env) } fn visit_generics(&mut self, generics: &Generics, env: ()) { self.visit_generics_helper(generics); visit::walk_generics(self, generics, env) } fn visit_fn(&mut self, function_kind: &visit::FnKind, function_declaration: &FnDecl, block: &Block, span: Span, node_id: NodeId, env: ()) { if!self.pass_through_items { match *function_kind { visit::FkMethod(..) if self.visited_outermost => return, visit::FkMethod(..) => self.visited_outermost = true, _ => {} } } self.operation.visit_id(node_id); match *function_kind { visit::FkItemFn(_, generics, _, _) | visit::FkMethod(_, generics, _) => { self.visit_generics_helper(generics) } visit::FkFnBlock => {} } for argument in function_declaration.inputs.iter() { self.operation.visit_id(argument.id) } visit::walk_fn(self, function_kind, function_declaration, block, span, env); if!self.pass_through_items { match *function_kind { visit::FkMethod(..) => self.visited_outermost = false, _ => {} } } } fn visit_struct_field(&mut self, struct_field: &StructField, env: ()) { self.operation.visit_id(struct_field.node.id); visit::walk_struct_field(self, struct_field, env) } fn visit_struct_def(&mut self, struct_def: &StructDef, _: ast::Ident, _: &ast::Generics, id: NodeId, _: ()) { self.operation.visit_id(id); struct_def.ctor_id.map(|ctor_id| self.operation.visit_id(ctor_id)); visit::walk_struct_def(self, struct_def, ()); } fn visit_trait_method(&mut self, tm: &ast::TraitMethod, _: ()) { match *tm { ast::Required(ref m) => self.operation.visit_id(m.id), ast::Provided(ref m) => self.operation.visit_id(m.id), } visit::walk_trait_method(self, tm, ()); } } pub fn visit_ids_for_inlined_item<O: IdVisitingOperation>(item: &InlinedItem, operation: &O) { let mut id_visitor = IdVisitor { operation: operation, pass_through_items: true, visited_outermost: false, }; visit::walk_inlined_item(&mut id_visitor, item, ()); } struct IdRangeComputingVisitor {
} impl IdVisitingOperation for IdRangeComputingVisitor { fn visit_id(&self, id: NodeId) { let mut id_range = self.result.get(); id_range.add(id); self.result.set(id_range) } } pub fn compute_id_range_for_inlined_item(item: &InlinedItem) -> IdRange { let visitor = IdRangeComputingVisitor { result: Cell::new(IdRange::max()) }; visit_ids_for_inlined_item(item, &visitor); visitor.result.get() } pub fn compute_id_range_for_fn_body(fk: &visit::FnKind, decl: &FnDecl, body: &Block, sp: Span, id: NodeId) -> IdRange { /*! * Computes the id range for a single fn body, * ignoring nested items. */ let visitor = IdRangeComputingVisitor { result: Cell::new(IdRange::max()) }; let mut id_visitor = IdVisitor { operation: &visitor, pass_through_items: false, visited_outermost: false, }; id_visitor.visit_fn(fk, decl, body, sp, id, ()); visitor.result.get() } pub fn is_item_impl(item: Gc<ast::Item>) -> bool { match item.node { ItemImpl(..) => true, _ => false } } pub fn walk_pat(pat: &Pat, it: |&Pat| -> bool) -> bool { if!it(pat) { return false; } match pat.node { PatIdent(_, _, Some(ref p)) => walk_pat(&**p, it), PatStruct(_, ref fields, _) => { fields.iter().advance(|f| walk_pat(&*f.pat, |p| it(p))) } PatEnum(_, Some(ref s)) | PatTup(ref s) => { s.iter().advance(|p| walk_pat(&**p, |p| it(p))) } PatBox(ref s) | PatRegion(ref s) => { walk_pat(&**s, it) } PatVec(ref before, ref slice, ref after) => { before.iter().advance(|p| walk_pat(&**p, |p| it(p))) && slice.iter().advance(|p| walk_pat(&**p, |p| it(p))) && after.iter().advance(|p| walk_pat(&**p, |p| it(p))) } PatMac(_) => fail!("attempted to analyze unexpanded pattern"), PatWild | PatWildMulti | PatLit(_) | PatRange(_, _) | PatIdent(_, _, _) | PatEnum(_, _) => { true } } } pub trait EachViewItem { fn each_view_item(&self, f: |&ast::ViewItem| -> bool) -> bool; } struct EachViewItemData<'a> { callback: |&ast::ViewItem|: 'a -> bool, } impl<'a> Visitor<()> for EachViewItemData<'a> { fn visit_view_item(&mut self, view_item: &ast::ViewItem, _: ()) { let _ = (self.callback)(view_item); } } impl EachViewItem for ast::Crate { fn each_view_item(&self, f:
result: Cell<IdRange>,
random_line_split
ast_util.rs
BiLe => "<=", BiNe => "!=", BiGe => ">=", BiGt => ">" } } pub fn lazy_binop(b: BinOp) -> bool { match b { BiAnd => true, BiOr => true, _ => false } } pub fn is_shift_binop(b: BinOp) -> bool { match b { BiShl => true, BiShr => true, _ => false } } pub fn unop_to_str(op: UnOp) -> &'static str { match op { UnBox => "box(GC) ", UnUniq => "box() ", UnDeref => "*", UnNot => "!", UnNeg => "-", } } pub fn is_path(e: Gc<Expr>) -> bool { return match e.node { ExprPath(_) => true, _ => false }; } // Get a string representation of a signed int type, with its value. // We want to avoid "45int" and "-3int" in favor of "45" and "-3" pub fn int_ty_to_str(t: IntTy, val: Option<i64>) -> String { let s = match t { TyI if val.is_some() => "i", TyI => "int", TyI8 => "i8", TyI16 => "i16", TyI32 => "i32", TyI64 => "i64" }; match val { // cast to a u64 so we can correctly print INT64_MIN. All integral types // are parsed as u64, so we wouldn't want to print an extra negative // sign. Some(n) => format!("{}{}", n as u64, s), None => s.to_string() } } pub fn int_ty_max(t: IntTy) -> u64 { match t { TyI8 => 0x80u64, TyI16 => 0x8000u64, TyI | TyI32 => 0x80000000u64, // actually ni about TyI TyI64 => 0x8000000000000000u64 } } // Get a string representation of an unsigned int type, with its value. // We want to avoid "42uint" in favor of "42u" pub fn uint_ty_to_str(t: UintTy, val: Option<u64>) -> String { let s = match t { TyU if val.is_some() => "u", TyU => "uint", TyU8 => "u8", TyU16 => "u16", TyU32 => "u32", TyU64 => "u64" }; match val { Some(n) => format!("{}{}", n, s), None => s.to_string() } } pub fn uint_ty_max(t: UintTy) -> u64 { match t { TyU8 => 0xffu64, TyU16 => 0xffffu64, TyU | TyU32 => 0xffffffffu64, // actually ni about TyU TyU64 => 0xffffffffffffffffu64 } } pub fn float_ty_to_str(t: FloatTy) -> String { match t { TyF32 => "f32".to_string(), TyF64 => "f64".to_string(), } } pub fn is_call_expr(e: Gc<Expr>) -> bool { match e.node { ExprCall(..) => true, _ => false } } pub fn block_from_expr(e: Gc<Expr>) -> P<Block> { P(Block { view_items: Vec::new(), stmts: Vec::new(), expr: Some(e), id: e.id, rules: DefaultBlock, span: e.span }) } pub fn ident_to_path(s: Span, identifier: Ident) -> Path { ast::Path { span: s, global: false, segments: vec!( ast::PathSegment { identifier: identifier, lifetimes: Vec::new(), types: OwnedSlice::empty(), } ), } } pub fn ident_to_pat(id: NodeId, s: Span, i: Ident) -> Gc<Pat> { box(GC) ast::Pat { id: id, node: PatIdent(BindByValue(MutImmutable), ident_to_path(s, i), None), span: s } } pub fn name_to_dummy_lifetime(name: Name) -> Lifetime { Lifetime { id: DUMMY_NODE_ID, span: codemap::DUMMY_SP, name: name } } pub fn is_unguarded(a: &Arm) -> bool { match a.guard { None => true, _ => false } } pub fn unguarded_pat(a: &Arm) -> Option<Vec<Gc<Pat>>> { if is_unguarded(a) { Some(/* FIXME (#2543) */ a.pats.clone()) } else { None } } /// Generate a "pretty" name for an `impl` from its type and trait. /// This is designed so that symbols of `impl`'d methods give some /// hint of where they came from, (previously they would all just be /// listed as `__extensions__::method_name::hash`, with no indication /// of the type). pub fn
(trait_ref: &Option<TraitRef>, ty: &Ty) -> Ident { let mut pretty = pprust::ty_to_str(ty); match *trait_ref { Some(ref trait_ref) => { pretty.push_char('.'); pretty.push_str(pprust::path_to_str(&trait_ref.path).as_slice()); } None => {} } token::gensym_ident(pretty.as_slice()) } pub fn public_methods(ms: Vec<Gc<Method>> ) -> Vec<Gc<Method>> { ms.move_iter().filter(|m| { match m.vis { Public => true, _ => false } }).collect() } // extract a TypeMethod from a TraitMethod. if the TraitMethod is // a default, pull out the useful fields to make a TypeMethod pub fn trait_method_to_ty_method(method: &TraitMethod) -> TypeMethod { match *method { Required(ref m) => (*m).clone(), Provided(ref m) => { TypeMethod { ident: m.ident, attrs: m.attrs.clone(), fn_style: m.fn_style, decl: m.decl, generics: m.generics.clone(), explicit_self: m.explicit_self, id: m.id, span: m.span, vis: m.vis, } } } } pub fn split_trait_methods(trait_methods: &[TraitMethod]) -> (Vec<TypeMethod>, Vec<Gc<Method>> ) { let mut reqd = Vec::new(); let mut provd = Vec::new(); for trt_method in trait_methods.iter() { match *trt_method { Required(ref tm) => reqd.push((*tm).clone()), Provided(m) => provd.push(m) } }; (reqd, provd) } pub fn struct_field_visibility(field: ast::StructField) -> Visibility { match field.node.kind { ast::NamedField(_, v) | ast::UnnamedField(v) => v } } /// Maps a binary operator to its precedence pub fn operator_prec(op: ast::BinOp) -> uint { match op { // 'as' sits here with 12 BiMul | BiDiv | BiRem => 11u, BiAdd | BiSub => 10u, BiShl | BiShr => 9u, BiBitAnd => 8u, BiBitXor => 7u, BiBitOr => 6u, BiLt | BiLe | BiGe | BiGt => 4u, BiEq | BiNe => 3u, BiAnd => 2u, BiOr => 1u } } /// Precedence of the `as` operator, which is a binary operator /// not appearing in the prior table. pub static as_prec: uint = 12u; pub fn empty_generics() -> Generics { Generics {lifetimes: Vec::new(), ty_params: OwnedSlice::empty()} } // ______________________________________________________________________ // Enumerating the IDs which appear in an AST #[deriving(Encodable, Decodable)] pub struct IdRange { pub min: NodeId, pub max: NodeId, } impl IdRange { pub fn max() -> IdRange { IdRange { min: u32::MAX, max: u32::MIN, } } pub fn empty(&self) -> bool { self.min >= self.max } pub fn add(&mut self, id: NodeId) { self.min = cmp::min(self.min, id); self.max = cmp::max(self.max, id + 1); } } pub trait IdVisitingOperation { fn visit_id(&self, node_id: NodeId); } pub struct IdVisitor<'a, O> { pub operation: &'a O, pub pass_through_items: bool, pub visited_outermost: bool, } impl<'a, O: IdVisitingOperation> IdVisitor<'a, O> { fn visit_generics_helper(&self, generics: &Generics) { for type_parameter in generics.ty_params.iter() { self.operation.visit_id(type_parameter.id) } for lifetime in generics.lifetimes.iter() { self.operation.visit_id(lifetime.id) } } } impl<'a, O: IdVisitingOperation> Visitor<()> for IdVisitor<'a, O> { fn visit_mod(&mut self, module: &Mod, _: Span, node_id: NodeId, env: ()) { self.operation.visit_id(node_id); visit::walk_mod(self, module, env) } fn visit_view_item(&mut self, view_item: &ViewItem, env: ()) { if!self.pass_through_items { if self.visited_outermost { return; } else { self.visited_outermost = true; } } match view_item.node { ViewItemExternCrate(_, _, node_id) => { self.operation.visit_id(node_id) } ViewItemUse(ref view_path) => { match view_path.node { ViewPathSimple(_, _, node_id) | ViewPathGlob(_, node_id) => { self.operation.visit_id(node_id) } ViewPathList(_, ref paths, node_id) => { self.operation.visit_id(node_id); for path in paths.iter() { self.operation.visit_id(path.node.id) } } } } } visit::walk_view_item(self, view_item, env); self.visited_outermost = false; } fn visit_foreign_item(&mut self, foreign_item: &ForeignItem, env: ()) { self.operation.visit_id(foreign_item.id); visit::walk_foreign_item(self, foreign_item, env) } fn visit_item(&mut self, item: &Item, env: ()) { if!self.pass_through_items { if self.visited_outermost { return } else { self.visited_outermost = true } } self.operation.visit_id(item.id); match item.node { ItemEnum(ref enum_definition, _) => { for variant in enum_definition.variants.iter() { self.operation.visit_id(variant.node.id) } } _ => {} } visit::walk_item(self, item, env); self.visited_outermost = false } fn visit_local(&mut self, local: &Local, env: ()) { self.operation.visit_id(local.id); visit::walk_local(self, local, env) } fn visit_block(&mut self, block: &Block, env: ()) { self.operation.visit_id(block.id); visit::walk_block(self, block, env) } fn visit_stmt(&mut self, statement: &Stmt, env: ()) { self.operation.visit_id(ast_util::stmt_id(statement)); visit::walk_stmt(self, statement, env) } fn visit_pat(&mut self, pattern: &Pat, env: ()) { self.operation.visit_id(pattern.id); visit::walk_pat(self, pattern, env) } fn visit_expr(&mut self, expression: &Expr, env: ()) { self.operation.visit_id(expression.id); visit::walk_expr(self, expression, env) } fn visit_ty(&mut self, typ: &Ty, env: ()) { self.operation.visit_id(typ.id); match typ.node { TyPath(_, _, id) => self.operation.visit_id(id), _ => {} } visit::walk_ty(self, typ, env) } fn visit_generics(&mut self, generics: &Generics, env: ()) { self.visit_generics_helper(generics); visit::walk_generics(self, generics, env) } fn visit_fn(&mut self, function_kind: &visit::FnKind, function_declaration: &FnDecl, block: &Block, span: Span, node_id: NodeId, env: ()) { if!self.pass_through_items { match *function_kind { visit::FkMethod(..) if self.visited_outermost => return, visit::FkMethod(..) => self.visited_outermost = true, _ => {} } } self.operation.visit_id(node_id); match *function_kind { visit::FkItemFn(_, generics, _, _) | visit::FkMethod(_, generics, _) => { self.visit_generics_helper(generics) } visit::FkFnBlock => {} } for argument in function_declaration.inputs.iter() { self.operation.visit_id(argument.id) } visit::walk_fn(self, function_kind, function_declaration, block, span, env); if!self.pass_through_items { match *function_kind { visit::FkMethod(..) => self.visited_outermost = false, _ => {} } } } fn visit_struct_field(&mut self, struct_field: &StructField, env: ()) { self.operation.visit_id(struct_field.node.id); visit::walk_struct_field(self, struct_field, env) } fn visit_struct_def(&mut self, struct_def: &StructDef, _: ast::Ident, _: &ast::Generics, id: NodeId, _: ()) { self.operation.visit_id(id); struct_def.ctor_id.map(|ctor_id| self.operation.visit_id(ctor_id)); visit::walk_struct_def(self, struct_def, ()); } fn visit_trait_method(&mut self, tm: &ast::TraitMethod, _: ()) { match *tm { ast::Required(ref m) => self.operation.visit_id(m.id), ast::Provided(ref m) => self.operation.visit_id(m.id), } visit::walk_trait_method(self, tm, ()); } } pub fn visit_ids_for_inlined_item<O: IdVisitingOperation>(item: &InlinedItem, operation: &O) { let mut id_visitor = IdVisitor { operation: operation, pass_through_items: true, visited_outermost: false, }; visit::walk_inlined_item(&mut id_visitor, item, ()); } struct IdRangeComputingVisitor { result: Cell<IdRange>, } impl IdVisitingOperation for IdRangeComputingVisitor { fn visit_id(&self, id: NodeId) { let mut id_range = self.result.get(); id_range.add(id); self.result.set(id_range) } } pub fn compute_id_range_for_inlined_item(item: &InlinedItem) -> IdRange { let visitor = IdRangeComputingVisitor { result: Cell::new(IdRange::max()) }; visit_ids_for_inlined_item(item, &visitor); visitor.result.get() } pub fn compute_id_range_for_fn_body(fk: &visit::FnKind, decl: &FnDecl, body: &Block, sp: Span, id: NodeId) -> IdRange { /*! * Computes the id range for a single fn body, * ignoring nested items. */ let visitor = IdRangeComputingVisitor { result: Cell::new(IdRange::max()) }; let mut id_visitor = IdVisitor { operation: &visitor, pass_through_items: false, visited_outermost: false, }; id_visitor.visit_fn(fk, decl, body, sp, id, ()); visitor.result.get() } pub fn is_item_impl(item: Gc<ast::Item>) -> bool { match item.node { ItemImpl(..) => true, _ => false } } pub fn walk_pat(pat: &Pat, it: |&Pat| -> bool) -> bool { if!it(pat) { return false; } match pat.node { PatIdent(_, _, Some(ref p)) => walk_pat(&**p, it), PatStruct(_, ref fields, _) => { fields.iter().advance(|f| walk_pat(&*f.pat, |p| it(p))) } PatEnum(_, Some(ref s)) | PatTup(ref s) => { s.iter().advance(|p| walk_pat(&**p, |p| it(p))) } PatBox(ref s) | PatRegion(ref s) => { walk_pat(&**s, it) } PatVec(ref before, ref slice, ref after) => { before.iter().advance(|p| walk_pat(&**p, |p| it(p))) && slice.iter().advance(|p| walk_pat(&**p, |p| it(p))) && after.iter().advance(|p| walk_pat(&**p, |p| it(p))) } PatMac(_) => fail!("attempted to analyze unexpanded pattern"), PatWild | PatWildMulti | PatLit(_) | PatRange(_, _) | PatIdent(_, _, _) | PatEnum(_, _) => { true } } } pub trait EachViewItem { fn each_view_item(&self, f: |&ast::ViewItem| -> bool) -> bool; } struct EachViewItemData<'a> { callback: |&ast::ViewItem|: 'a -> bool, } impl<'a> Visitor<()> for EachViewItemData<'a> { fn visit_view_item(&mut self, view_item: &ast::ViewItem, _: ()) { let _ = (self.callback)(view_item); } } impl EachViewItem for ast::Crate { fn each_view_item(&self,
impl_pretty_name
identifier_name
float.rs
// Copyright 2013-2014 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. #![allow(missing_doc)] use char; use collections::Collection; use fmt; use iter::{range, DoubleEndedIterator}; use num::{Float, FPNaN, FPInfinite, ToPrimitive, Primitive}; use num::{Zero, One, cast}; use result::Ok; use slice::{ImmutableSlice, MutableSlice}; use slice; use str::StrSlice; /// A flag that specifies whether to use exponential (scientific) notation. pub enum ExponentFormat { /// Do not use exponential notation. ExpNone, /// Use exponential notation with the exponent having a base of 10 and the /// exponent sign being `e` or `E`. For example, 1000 would be printed /// 1e3. ExpDec } /// The number of digits used for emitting the fractional part of a number, if /// any. pub enum SignificantDigits { /// At most the given number of digits will be printed, truncating any /// trailing zeroes. DigMax(uint), /// Precisely the given number of digits will be printed. DigExact(uint) } /// How to emit the sign of a number. pub enum SignFormat { /// `-` will be printed for negative values, but no sign will be emitted /// for positive numbers. SignNeg } static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u; /** * Converts a number to its string representation as a byte vector. * This is meant to be a common base implementation for all numeric string * conversion functions like `to_string()` or `to_str_radix()`. * * # Arguments * - `num` - The number to convert. Accepts any number that * implements the numeric traits. * - `radix` - Base to use. Accepts only the values 2-36. If the exponential notation * is used, then this base is only used for the significand. The exponent * itself always printed using a base of 10. * - `negative_zero` - Whether to treat the special value `-0` as * `-0` or as `+0`. * - `sign` - How to emit the sign. See `SignFormat`. * - `digits` - The amount of digits to use for emitting the fractional * part, if any. See `SignificantDigits`. * - `exp_format` - Whether or not to use the exponential (scientific) notation. * See `ExponentFormat`. * - `exp_capital` - Whether or not to use a capital letter for the exponent sign, if * exponential notation is desired. * - `f` - A closure to invoke with the bytes representing the * float. * * # Failure * - Fails if `radix` < 2 or `radix` > 36. * - Fails if `radix` > 14 and `exp_format` is `ExpDec` due to conflict * between digit and exponent sign `'e'`. * - Fails if `radix` > 25 and `exp_format` is `ExpBin` due to conflict * between digit and exponent sign `'p'`. */ pub fn float_to_str_bytes_common<T: Primitive + Float, U>( num: T, radix: uint, negative_zero: bool, sign: SignFormat, digits: SignificantDigits, exp_format: ExponentFormat, exp_upper: bool, f: |&[u8]| -> U ) -> U { assert!(2 <= radix && radix <= 36); match exp_format { ExpDec if radix >= DIGIT_E_RADIX // decimal exponent 'e' => fail!("float_to_str_bytes_common: radix {} incompatible with \ use of 'e' as decimal exponent", radix), _ => () } let _0: T = Zero::zero(); let _1: T = One::one(); match num.classify() { FPNaN => return f("NaN".as_bytes()), FPInfinite if num > _0 => { return f("inf".as_bytes()); } FPInfinite if num < _0 => { return f("-inf".as_bytes()); } _ => {} } let neg = num < _0 || (negative_zero && _1 / num == Float::neg_infinity()); // For an f64 the exponent is in the range of [-1022, 1023] for base 2, so // we may have up to that many digits. Give ourselves some extra wiggle room // otherwise as well. let mut buf = [0u8,..1536]; let mut end = 0; let radix_gen: T = cast(radix as int).unwrap(); let (num, exp) = match exp_format { ExpNone => (num, 0i32), ExpDec if num == _0 => (num, 0i32), ExpDec => { let (exp, exp_base) = match exp_format { ExpDec => (num.abs().log10().floor(), cast::<f64, T>(10.0f64).unwrap()), ExpNone => fail!("unreachable"), }; (num / exp_base.powf(exp), cast::<T, i32>(exp).unwrap()) } }; // First emit the non-fractional part, looping at least once to make // sure at least a `0` gets emitted. let mut deccum = num.trunc(); loop { // Calculate the absolute value of each digit instead of only // doing it once for the whole number because a // representable negative number doesn't necessary have an // representable additive inverse of the same type // (See twos complement). But we assume that for the // numbers [-35.. 0] we always have [0.. 35]. let current_digit = (deccum % radix_gen).abs(); // Decrease the deccumulator one digit at a time deccum = deccum / radix_gen; deccum = deccum.trunc(); let c = char::from_digit(current_digit.to_int().unwrap() as uint, radix); buf[end] = c.unwrap() as u8; end += 1; // No more digits to calculate for the non-fractional part -> break if deccum == _0 { break; } } // If limited digits, calculate one digit more for rounding. let (limit_digits, digit_count, exact) = match digits { DigMax(count) => (true, count + 1, false), DigExact(count) => (true, count + 1, true) }; // Decide what sign to put in front match sign { SignNeg if neg => { buf[end] = b'-'; end += 1; } _ => () } buf.slice_to_mut(end).reverse(); // Remember start of the fractional digits. // Points one beyond end of buf if none get generated, // or at the '.' otherwise. let start_fractional_digits = end; // Now emit the fractional part, if any deccum = num.fract(); if deccum!= _0 || (limit_digits && exact && digit_count > 0) { buf[end] = b'.'; end += 1; let mut dig = 0u; // calculate new digits while // - there is no limit and there are digits left // - or there is a limit, it's not reached yet and // - it's exact // - or it's a maximum, and there are still digits left while (!limit_digits && deccum!= _0) || (limit_digits && dig < digit_count && ( exact || (!exact && deccum!= _0) ) ) { // Shift first fractional digit into the integer part deccum = deccum * radix_gen; // Calculate the absolute value of each digit. // See note in first loop. let current_digit = deccum.trunc().abs(); let c = char::from_digit(current_digit.to_int().unwrap() as uint, radix); buf[end] = c.unwrap() as u8; end += 1; // Decrease the deccumulator one fractional digit at a time deccum = deccum.fract(); dig += 1u; } // If digits are limited, and that limit has been reached, // cut off the one extra digit, and depending on its value // round the remaining ones. if limit_digits && dig == digit_count { let ascii2value = |chr: u8| { char::to_digit(chr as char, radix).unwrap() }; let value2ascii = |val: uint| { char::from_digit(val, radix).unwrap() as u8 }; let extra_digit = ascii2value(buf[end - 1]); end -= 1; if extra_digit >= radix / 2 { // -> need to round let mut i: int = end as int - 1; loop { // If reached left end of number, have to // insert additional digit: if i < 0
for j in range(i as uint + 1, end).rev() { buf[j + 1] = buf[j]; } buf[(i + 1) as uint] = value2ascii(1); end += 1; break; } // Skip the '.' if buf[i as uint] == b'.' { i -= 1; continue; } // Either increment the digit, // or set to 0 if max and carry the 1. let current_digit = ascii2value(buf[i as uint]); if current_digit < (radix - 1) { buf[i as uint] = value2ascii(current_digit+1); break; } else { buf[i as uint] = value2ascii(0); i -= 1; } } } } } // if number of digits is not exact, remove all trailing '0's up to // and including the '.' if!exact { let buf_max_i = end - 1; // index to truncate from let mut i = buf_max_i; // discover trailing zeros of fractional part while i > start_fractional_digits && buf[i] == b'0' { i -= 1; } // Only attempt to truncate digits if buf has fractional digits if i >= start_fractional_digits { // If buf ends with '.', cut that too. if buf[i] == b'.' { i -= 1 } // only resize buf if we actually remove digits if i < buf_max_i { end = i + 1; } } } // If exact and trailing '.', just cut that else { let max_i = end - 1; if buf[max_i] == b'.' { end = max_i; } } match exp_format { ExpNone => {}, _ => { buf[end] = match exp_format { ExpDec if exp_upper => 'E', ExpDec if!exp_upper => 'e', _ => fail!("unreachable"), } as u8; end += 1; struct Filler<'a> { buf: &'a mut [u8], end: &'a mut uint, } impl<'a> fmt::FormatWriter for Filler<'a> { fn write(&mut self, bytes: &[u8]) -> fmt::Result { slice::bytes::copy_memory(self.buf.slice_from_mut(*self.end), bytes); *self.end += bytes.len(); Ok(()) } } let mut filler = Filler { buf: buf, end: &mut end }; match sign { SignNeg => { let _ = format_args!(|args| { fmt::write(&mut filler, args) }, "{:-}", exp); } } } } f(buf.slice_to(end)) }
|| buf[i as uint] == b'-' || buf[i as uint] == b'+' {
random_line_split
float.rs
// Copyright 2013-2014 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. #![allow(missing_doc)] use char; use collections::Collection; use fmt; use iter::{range, DoubleEndedIterator}; use num::{Float, FPNaN, FPInfinite, ToPrimitive, Primitive}; use num::{Zero, One, cast}; use result::Ok; use slice::{ImmutableSlice, MutableSlice}; use slice; use str::StrSlice; /// A flag that specifies whether to use exponential (scientific) notation. pub enum ExponentFormat { /// Do not use exponential notation. ExpNone, /// Use exponential notation with the exponent having a base of 10 and the /// exponent sign being `e` or `E`. For example, 1000 would be printed /// 1e3. ExpDec } /// The number of digits used for emitting the fractional part of a number, if /// any. pub enum SignificantDigits { /// At most the given number of digits will be printed, truncating any /// trailing zeroes. DigMax(uint), /// Precisely the given number of digits will be printed. DigExact(uint) } /// How to emit the sign of a number. pub enum SignFormat { /// `-` will be printed for negative values, but no sign will be emitted /// for positive numbers. SignNeg } static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u; /** * Converts a number to its string representation as a byte vector. * This is meant to be a common base implementation for all numeric string * conversion functions like `to_string()` or `to_str_radix()`. * * # Arguments * - `num` - The number to convert. Accepts any number that * implements the numeric traits. * - `radix` - Base to use. Accepts only the values 2-36. If the exponential notation * is used, then this base is only used for the significand. The exponent * itself always printed using a base of 10. * - `negative_zero` - Whether to treat the special value `-0` as * `-0` or as `+0`. * - `sign` - How to emit the sign. See `SignFormat`. * - `digits` - The amount of digits to use for emitting the fractional * part, if any. See `SignificantDigits`. * - `exp_format` - Whether or not to use the exponential (scientific) notation. * See `ExponentFormat`. * - `exp_capital` - Whether or not to use a capital letter for the exponent sign, if * exponential notation is desired. * - `f` - A closure to invoke with the bytes representing the * float. * * # Failure * - Fails if `radix` < 2 or `radix` > 36. * - Fails if `radix` > 14 and `exp_format` is `ExpDec` due to conflict * between digit and exponent sign `'e'`. * - Fails if `radix` > 25 and `exp_format` is `ExpBin` due to conflict * between digit and exponent sign `'p'`. */ pub fn float_to_str_bytes_common<T: Primitive + Float, U>( num: T, radix: uint, negative_zero: bool, sign: SignFormat, digits: SignificantDigits, exp_format: ExponentFormat, exp_upper: bool, f: |&[u8]| -> U ) -> U { assert!(2 <= radix && radix <= 36); match exp_format { ExpDec if radix >= DIGIT_E_RADIX // decimal exponent 'e' => fail!("float_to_str_bytes_common: radix {} incompatible with \ use of 'e' as decimal exponent", radix), _ => () } let _0: T = Zero::zero(); let _1: T = One::one(); match num.classify() { FPNaN => return f("NaN".as_bytes()), FPInfinite if num > _0 => { return f("inf".as_bytes()); } FPInfinite if num < _0 => { return f("-inf".as_bytes()); } _ => {} } let neg = num < _0 || (negative_zero && _1 / num == Float::neg_infinity()); // For an f64 the exponent is in the range of [-1022, 1023] for base 2, so // we may have up to that many digits. Give ourselves some extra wiggle room // otherwise as well. let mut buf = [0u8,..1536]; let mut end = 0; let radix_gen: T = cast(radix as int).unwrap(); let (num, exp) = match exp_format { ExpNone => (num, 0i32), ExpDec if num == _0 => (num, 0i32), ExpDec => { let (exp, exp_base) = match exp_format { ExpDec => (num.abs().log10().floor(), cast::<f64, T>(10.0f64).unwrap()), ExpNone => fail!("unreachable"), }; (num / exp_base.powf(exp), cast::<T, i32>(exp).unwrap()) } }; // First emit the non-fractional part, looping at least once to make // sure at least a `0` gets emitted. let mut deccum = num.trunc(); loop { // Calculate the absolute value of each digit instead of only // doing it once for the whole number because a // representable negative number doesn't necessary have an // representable additive inverse of the same type // (See twos complement). But we assume that for the // numbers [-35.. 0] we always have [0.. 35]. let current_digit = (deccum % radix_gen).abs(); // Decrease the deccumulator one digit at a time deccum = deccum / radix_gen; deccum = deccum.trunc(); let c = char::from_digit(current_digit.to_int().unwrap() as uint, radix); buf[end] = c.unwrap() as u8; end += 1; // No more digits to calculate for the non-fractional part -> break if deccum == _0 { break; } } // If limited digits, calculate one digit more for rounding. let (limit_digits, digit_count, exact) = match digits { DigMax(count) => (true, count + 1, false), DigExact(count) => (true, count + 1, true) }; // Decide what sign to put in front match sign { SignNeg if neg => { buf[end] = b'-'; end += 1; } _ => () } buf.slice_to_mut(end).reverse(); // Remember start of the fractional digits. // Points one beyond end of buf if none get generated, // or at the '.' otherwise. let start_fractional_digits = end; // Now emit the fractional part, if any deccum = num.fract(); if deccum!= _0 || (limit_digits && exact && digit_count > 0) { buf[end] = b'.'; end += 1; let mut dig = 0u; // calculate new digits while // - there is no limit and there are digits left // - or there is a limit, it's not reached yet and // - it's exact // - or it's a maximum, and there are still digits left while (!limit_digits && deccum!= _0) || (limit_digits && dig < digit_count && ( exact || (!exact && deccum!= _0) ) ) { // Shift first fractional digit into the integer part deccum = deccum * radix_gen; // Calculate the absolute value of each digit. // See note in first loop. let current_digit = deccum.trunc().abs(); let c = char::from_digit(current_digit.to_int().unwrap() as uint, radix); buf[end] = c.unwrap() as u8; end += 1; // Decrease the deccumulator one fractional digit at a time deccum = deccum.fract(); dig += 1u; } // If digits are limited, and that limit has been reached, // cut off the one extra digit, and depending on its value // round the remaining ones. if limit_digits && dig == digit_count { let ascii2value = |chr: u8| { char::to_digit(chr as char, radix).unwrap() }; let value2ascii = |val: uint| { char::from_digit(val, radix).unwrap() as u8 }; let extra_digit = ascii2value(buf[end - 1]); end -= 1; if extra_digit >= radix / 2 { // -> need to round let mut i: int = end as int - 1; loop { // If reached left end of number, have to // insert additional digit: if i < 0 || buf[i as uint] == b'-' || buf[i as uint] == b'+' { for j in range(i as uint + 1, end).rev() { buf[j + 1] = buf[j]; } buf[(i + 1) as uint] = value2ascii(1); end += 1; break; } // Skip the '.' if buf[i as uint] == b'.' { i -= 1; continue; } // Either increment the digit, // or set to 0 if max and carry the 1. let current_digit = ascii2value(buf[i as uint]); if current_digit < (radix - 1) { buf[i as uint] = value2ascii(current_digit+1); break; } else { buf[i as uint] = value2ascii(0); i -= 1; } } } } } // if number of digits is not exact, remove all trailing '0's up to // and including the '.' if!exact { let buf_max_i = end - 1; // index to truncate from let mut i = buf_max_i; // discover trailing zeros of fractional part while i > start_fractional_digits && buf[i] == b'0' { i -= 1; } // Only attempt to truncate digits if buf has fractional digits if i >= start_fractional_digits { // If buf ends with '.', cut that too. if buf[i] == b'.' { i -= 1 } // only resize buf if we actually remove digits if i < buf_max_i { end = i + 1; } } } // If exact and trailing '.', just cut that else { let max_i = end - 1; if buf[max_i] == b'.' { end = max_i; } } match exp_format { ExpNone => {}, _ => { buf[end] = match exp_format { ExpDec if exp_upper => 'E', ExpDec if!exp_upper => 'e', _ => fail!("unreachable"), } as u8; end += 1; struct Filler<'a> { buf: &'a mut [u8], end: &'a mut uint, } impl<'a> fmt::FormatWriter for Filler<'a> { fn
(&mut self, bytes: &[u8]) -> fmt::Result { slice::bytes::copy_memory(self.buf.slice_from_mut(*self.end), bytes); *self.end += bytes.len(); Ok(()) } } let mut filler = Filler { buf: buf, end: &mut end }; match sign { SignNeg => { let _ = format_args!(|args| { fmt::write(&mut filler, args) }, "{:-}", exp); } } } } f(buf.slice_to(end)) }
write
identifier_name
dst-coerce-rc.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. // Test a very simple custom DST coercion. #![feature(core)] use std::rc::Rc; trait Baz { fn get(&self) -> i32; } impl Baz for i32 { fn
(&self) -> i32 { *self } } fn main() { let a: Rc<[i32; 3]> = Rc::new([1, 2, 3]); let b: Rc<[i32]> = a; assert_eq!(b[0], 1); assert_eq!(b[1], 2); assert_eq!(b[2], 3); let a: Rc<i32> = Rc::new(42); let b: Rc<Baz> = a.clone(); assert_eq!(b.get(), 42); let _c = b.clone(); }
get
identifier_name
dst-coerce-rc.rs
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at
// 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. // Test a very simple custom DST coercion. #![feature(core)] use std::rc::Rc; trait Baz { fn get(&self) -> i32; } impl Baz for i32 { fn get(&self) -> i32 { *self } } fn main() { let a: Rc<[i32; 3]> = Rc::new([1, 2, 3]); let b: Rc<[i32]> = a; assert_eq!(b[0], 1); assert_eq!(b[1], 2); assert_eq!(b[2], 3); let a: Rc<i32> = Rc::new(42); let b: Rc<Baz> = a.clone(); assert_eq!(b.get(), 42); let _c = b.clone(); }
// http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
random_line_split
dst-coerce-rc.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. // Test a very simple custom DST coercion. #![feature(core)] use std::rc::Rc; trait Baz { fn get(&self) -> i32; } impl Baz for i32 { fn get(&self) -> i32
} fn main() { let a: Rc<[i32; 3]> = Rc::new([1, 2, 3]); let b: Rc<[i32]> = a; assert_eq!(b[0], 1); assert_eq!(b[1], 2); assert_eq!(b[2], 3); let a: Rc<i32> = Rc::new(42); let b: Rc<Baz> = a.clone(); assert_eq!(b.get(), 42); let _c = b.clone(); }
{ *self }
identifier_body
appthread.rs
//! Types for the mutator to use to build data structures use std::cell::Cell; use std::mem::transmute; use std::ops::{Deref, DerefMut}; use std::ptr::{null, null_mut}; use std::raw::TraitObject; use std::sync::atomic::{AtomicPtr, Ordering}; use std::thread; use constants::{INC_BIT, JOURNAL_BUFFER_SIZE, NEW_BIT, TRAVERSE_BIT}; use gcthread::{JournalSender, EntrySender}; use heap::{Object, TraceStack}; use journal; use trace::Trace; /// Each thread gets it's own EntrySender thread_local!( static GC_JOURNAL: Cell<*const EntrySender> = Cell::new(null()) ); /// GcBox struct and traits: a boxed object that is GC managed pub struct GcBox<T: Trace> { value: T, } /// Root smart pointer, sends reference count changes to the journal. /// /// Whenever a reference to an object on the heap must be retained on the stack, this type must be /// used. It's use will ensure that the object will be seen as a root. pub struct GcRoot<T: Trace> { ptr: *mut GcBox<T>, } /// Non-atomic pointer type. This type is `!Sync` and thus is useful for presenting a Rust-ish /// API to a data structure where aliasing and mutability must follow the standard rules: there /// can be only one mutator. /// /// *Important note:* even though this type is `!Sync`, any data structures that are composed of /// `Gc` pointers must still be designed with the awareness that the GC thread will call `trace()` /// at any point and so, must still be thread safe! /// /// This is not a root pointer type. It should be used inside data structures to reference other /// GC-managed objects. pub struct Gc<T: Trace> { ptr: *mut GcBox<T>, } /// Atomic pointer type that points at a traceable object. This type is `Sync` and can be used to /// build concurrent data structures. /// /// This type should be used inside data structures to reference other GC-managed objects, but /// provides interior mutability and atomic methods. /// /// TODO: cas, swap etc for GcRoot and Gc pub struct GcAtomic<T: Trace> { ptr: AtomicPtr<GcBox<T>>, } /// An Application Thread, manages a thread-local reference to a tx channel /// /// TODO: a version of `spawn()` is required that can be called from an existing mutator thread. pub struct AppThread; impl AppThread { /// As thread::spawn but takes a journal Sender to initialize the thread_local instance with. pub fn spawn_from_gc<F, T>(tx: JournalSender, f: F) -> thread::JoinHandle<T> where F: FnOnce() -> T, F: Send +'static, T: Send +'static { thread::spawn(move || { let (jtx, jrx) = journal::make_journal(JOURNAL_BUFFER_SIZE); tx.send(jrx).expect("Failed to send a new Journal to the GC thread!"); GC_JOURNAL.with(|j| { j.set(&jtx); }); f() }) } } // Reference count functions. Only new-objects need to specify the traverse bit. #[inline] fn
<T: Trace>(object: &T) -> TraitObject { let trace: &Trace = object; unsafe { transmute(trace) } } /// Write a reference count increment to the journal for a newly allocated object #[inline] fn write<T: Trace>(object: &T, is_new: bool, flags: usize) { GC_JOURNAL.with(|j| { let tx = unsafe { &*j.get() }; let tobj = as_traitobject(object); // set the refcount-increment bit let ptr = (tobj.data as usize) | flags; // set the traversible bit let mut vtable = tobj.vtable as usize; if is_new && object.traversible() { vtable |= TRAVERSE_BIT; } tx.send(Object { ptr: ptr, vtable: vtable, }); }); } // GcBox implementation impl<T: Trace> GcBox<T> { fn new(value: T) -> GcBox<T> { GcBox { value: value, } } } unsafe impl<T: Trace> Trace for GcBox<T> { #[inline] fn traversible(&self) -> bool { self.value.traversible() } #[inline] unsafe fn trace(&self, heap: &mut TraceStack) { self.value.trace(heap); } } // GcRoot implementation impl<T: Trace> GcRoot<T> { /// Put a new object on the heap and hand ownership to the GC, writing a reference count /// increment to the journal. pub fn new(value: T) -> GcRoot<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT | INC_BIT); GcRoot { ptr: Box::into_raw(boxed) } } fn from_raw(ptr: *mut GcBox<T>) -> GcRoot<T> { let root = GcRoot { ptr: ptr }; write(&*root, false, INC_BIT); root } fn ptr(&self) -> *mut GcBox<T> { self.ptr } fn value(&self) -> &T { unsafe { &(*self.ptr).value } } fn value_mut(&mut self) -> &mut T { unsafe { &mut (*self.ptr).value } } } impl<T: Trace> Drop for GcRoot<T> { fn drop(&mut self) { write(&**self, false, 0); } } impl<T: Trace> Deref for GcRoot<T> { type Target = T; fn deref(&self) -> &T { self.value() } } impl<T: Trace> DerefMut for GcRoot<T> { fn deref_mut(&mut self) -> &mut T { self.value_mut() } } impl<T: Trace> Clone for GcRoot<T> { fn clone(&self) -> Self { GcRoot::from_raw(self.ptr()) } } // Gc implementation impl<T: Trace> Gc<T> { /// Creates a new null pointer. pub fn null() -> Gc<T> { Gc { ptr: null_mut(), } } /// Move a value to the heap and create a pointer to it. pub fn new(value: T) -> Gc<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT); Gc { ptr: Box::into_raw(boxed) } } /// Return the raw pointer value, or None if it is a null pointer. pub fn as_raw(&self) -> Option<*mut GcBox<T>> { if self.ptr.is_null() { None } else { Some(self.ptr) } } /// Pointer equality comparison. pub fn is(&self, other: Gc<T>) -> bool { self.ptr == other.ptr } fn from_raw(ptr: *mut GcBox<T>) -> Gc<T> { Gc { ptr: ptr, } } fn ptr(&self) -> *mut GcBox<T> { self.ptr } fn value(&self) -> &T { unsafe { &(*self.ptr).value } } fn value_mut(&mut self) -> &mut T { unsafe { &mut (*self.ptr).value } } } impl<T: Trace> Deref for Gc<T> { type Target = T; fn deref(&self) -> &T { self.value() } } impl<T: Trace> DerefMut for Gc<T> { fn deref_mut(&mut self) -> &mut T { self.value_mut() } } impl<T: Trace> Clone for Gc<T> { fn clone(&self) -> Self { Gc { ptr: self.ptr, } } } impl<T: Trace> Copy for Gc<T> {} // GcAtomic implementation impl<T: Trace> GcAtomic<T> { /// Instantiate a new null pointer pub fn null() -> GcAtomic<T> { GcAtomic { ptr: AtomicPtr::new(null_mut()) } } /// Instantiate a new pointer, moving `value` to the heap. Writes to the journal. pub fn new(value: T) -> GcAtomic<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT); GcAtomic { ptr: AtomicPtr::new(Box::into_raw(boxed)), } } /// Root the pointer by loading it into a `GcRoot<T>` /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_into_root(&self, order: Ordering) -> GcRoot<T> { let root = GcRoot { ptr: self.ptr.load(order), }; write(&*root, false, INC_BIT); root } /// Copy the pointer into a new `Gc` instance. /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_into_gc(&self, order: Ordering) -> Gc<T> { Gc::from_raw(self.ptr.load(order)) } /// Fetch the current raw pointer value /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_raw(&self, order: Ordering) -> *mut GcBox<T> { self.ptr.load(order) } /// Replace the current pointer value with the pointer from the given `GcRoot`. /// /// Panics if `order` is `Acquire` or `AcqRel`. pub fn store_from_root(&self, root: GcRoot<T>, order: Ordering) { self.ptr.store(root.ptr(), order); } /// Replace the current pointer value with the pointer from the given `Gc`. /// /// Panics of `order` is `Acquire` or `AcqRel`. pub fn store_from_gc(&self, gc: Gc<T>, order: Ordering) { self.ptr.store(gc.ptr(), order); } /// Replace the current pointer value with the given raw pointer /// /// Panics if `order` is `Acquire` or `AcqRel`. pub fn store_raw(&self, ptr: *mut GcBox<T>, order: Ordering) { self.ptr.store(ptr, order); } }
as_traitobject
identifier_name
appthread.rs
//! Types for the mutator to use to build data structures use std::cell::Cell; use std::mem::transmute; use std::ops::{Deref, DerefMut}; use std::ptr::{null, null_mut}; use std::raw::TraitObject; use std::sync::atomic::{AtomicPtr, Ordering}; use std::thread; use constants::{INC_BIT, JOURNAL_BUFFER_SIZE, NEW_BIT, TRAVERSE_BIT}; use gcthread::{JournalSender, EntrySender}; use heap::{Object, TraceStack}; use journal; use trace::Trace; /// Each thread gets it's own EntrySender thread_local!( static GC_JOURNAL: Cell<*const EntrySender> = Cell::new(null()) ); /// GcBox struct and traits: a boxed object that is GC managed pub struct GcBox<T: Trace> { value: T, } /// Root smart pointer, sends reference count changes to the journal. /// /// Whenever a reference to an object on the heap must be retained on the stack, this type must be /// used. It's use will ensure that the object will be seen as a root. pub struct GcRoot<T: Trace> { ptr: *mut GcBox<T>, } /// Non-atomic pointer type. This type is `!Sync` and thus is useful for presenting a Rust-ish /// API to a data structure where aliasing and mutability must follow the standard rules: there /// can be only one mutator. /// /// *Important note:* even though this type is `!Sync`, any data structures that are composed of /// `Gc` pointers must still be designed with the awareness that the GC thread will call `trace()` /// at any point and so, must still be thread safe! /// /// This is not a root pointer type. It should be used inside data structures to reference other /// GC-managed objects. pub struct Gc<T: Trace> { ptr: *mut GcBox<T>, } /// Atomic pointer type that points at a traceable object. This type is `Sync` and can be used to /// build concurrent data structures. /// /// This type should be used inside data structures to reference other GC-managed objects, but /// provides interior mutability and atomic methods. /// /// TODO: cas, swap etc for GcRoot and Gc pub struct GcAtomic<T: Trace> { ptr: AtomicPtr<GcBox<T>>, } /// An Application Thread, manages a thread-local reference to a tx channel /// /// TODO: a version of `spawn()` is required that can be called from an existing mutator thread. pub struct AppThread; impl AppThread { /// As thread::spawn but takes a journal Sender to initialize the thread_local instance with. pub fn spawn_from_gc<F, T>(tx: JournalSender, f: F) -> thread::JoinHandle<T> where F: FnOnce() -> T, F: Send +'static, T: Send +'static { thread::spawn(move || { let (jtx, jrx) = journal::make_journal(JOURNAL_BUFFER_SIZE); tx.send(jrx).expect("Failed to send a new Journal to the GC thread!"); GC_JOURNAL.with(|j| { j.set(&jtx); }); f() }) } } // Reference count functions. Only new-objects need to specify the traverse bit. #[inline] fn as_traitobject<T: Trace>(object: &T) -> TraitObject { let trace: &Trace = object; unsafe { transmute(trace) } } /// Write a reference count increment to the journal for a newly allocated object #[inline] fn write<T: Trace>(object: &T, is_new: bool, flags: usize)
} // GcBox implementation impl<T: Trace> GcBox<T> { fn new(value: T) -> GcBox<T> { GcBox { value: value, } } } unsafe impl<T: Trace> Trace for GcBox<T> { #[inline] fn traversible(&self) -> bool { self.value.traversible() } #[inline] unsafe fn trace(&self, heap: &mut TraceStack) { self.value.trace(heap); } } // GcRoot implementation impl<T: Trace> GcRoot<T> { /// Put a new object on the heap and hand ownership to the GC, writing a reference count /// increment to the journal. pub fn new(value: T) -> GcRoot<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT | INC_BIT); GcRoot { ptr: Box::into_raw(boxed) } } fn from_raw(ptr: *mut GcBox<T>) -> GcRoot<T> { let root = GcRoot { ptr: ptr }; write(&*root, false, INC_BIT); root } fn ptr(&self) -> *mut GcBox<T> { self.ptr } fn value(&self) -> &T { unsafe { &(*self.ptr).value } } fn value_mut(&mut self) -> &mut T { unsafe { &mut (*self.ptr).value } } } impl<T: Trace> Drop for GcRoot<T> { fn drop(&mut self) { write(&**self, false, 0); } } impl<T: Trace> Deref for GcRoot<T> { type Target = T; fn deref(&self) -> &T { self.value() } } impl<T: Trace> DerefMut for GcRoot<T> { fn deref_mut(&mut self) -> &mut T { self.value_mut() } } impl<T: Trace> Clone for GcRoot<T> { fn clone(&self) -> Self { GcRoot::from_raw(self.ptr()) } } // Gc implementation impl<T: Trace> Gc<T> { /// Creates a new null pointer. pub fn null() -> Gc<T> { Gc { ptr: null_mut(), } } /// Move a value to the heap and create a pointer to it. pub fn new(value: T) -> Gc<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT); Gc { ptr: Box::into_raw(boxed) } } /// Return the raw pointer value, or None if it is a null pointer. pub fn as_raw(&self) -> Option<*mut GcBox<T>> { if self.ptr.is_null() { None } else { Some(self.ptr) } } /// Pointer equality comparison. pub fn is(&self, other: Gc<T>) -> bool { self.ptr == other.ptr } fn from_raw(ptr: *mut GcBox<T>) -> Gc<T> { Gc { ptr: ptr, } } fn ptr(&self) -> *mut GcBox<T> { self.ptr } fn value(&self) -> &T { unsafe { &(*self.ptr).value } } fn value_mut(&mut self) -> &mut T { unsafe { &mut (*self.ptr).value } } } impl<T: Trace> Deref for Gc<T> { type Target = T; fn deref(&self) -> &T { self.value() } } impl<T: Trace> DerefMut for Gc<T> { fn deref_mut(&mut self) -> &mut T { self.value_mut() } } impl<T: Trace> Clone for Gc<T> { fn clone(&self) -> Self { Gc { ptr: self.ptr, } } } impl<T: Trace> Copy for Gc<T> {} // GcAtomic implementation impl<T: Trace> GcAtomic<T> { /// Instantiate a new null pointer pub fn null() -> GcAtomic<T> { GcAtomic { ptr: AtomicPtr::new(null_mut()) } } /// Instantiate a new pointer, moving `value` to the heap. Writes to the journal. pub fn new(value: T) -> GcAtomic<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT); GcAtomic { ptr: AtomicPtr::new(Box::into_raw(boxed)), } } /// Root the pointer by loading it into a `GcRoot<T>` /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_into_root(&self, order: Ordering) -> GcRoot<T> { let root = GcRoot { ptr: self.ptr.load(order), }; write(&*root, false, INC_BIT); root } /// Copy the pointer into a new `Gc` instance. /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_into_gc(&self, order: Ordering) -> Gc<T> { Gc::from_raw(self.ptr.load(order)) } /// Fetch the current raw pointer value /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_raw(&self, order: Ordering) -> *mut GcBox<T> { self.ptr.load(order) } /// Replace the current pointer value with the pointer from the given `GcRoot`. /// /// Panics if `order` is `Acquire` or `AcqRel`. pub fn store_from_root(&self, root: GcRoot<T>, order: Ordering) { self.ptr.store(root.ptr(), order); } /// Replace the current pointer value with the pointer from the given `Gc`. /// /// Panics of `order` is `Acquire` or `AcqRel`. pub fn store_from_gc(&self, gc: Gc<T>, order: Ordering) { self.ptr.store(gc.ptr(), order); } /// Replace the current pointer value with the given raw pointer /// /// Panics if `order` is `Acquire` or `AcqRel`. pub fn store_raw(&self, ptr: *mut GcBox<T>, order: Ordering) { self.ptr.store(ptr, order); } }
{ GC_JOURNAL.with(|j| { let tx = unsafe { &*j.get() }; let tobj = as_traitobject(object); // set the refcount-increment bit let ptr = (tobj.data as usize) | flags; // set the traversible bit let mut vtable = tobj.vtable as usize; if is_new && object.traversible() { vtable |= TRAVERSE_BIT; } tx.send(Object { ptr: ptr, vtable: vtable, }); });
identifier_body
appthread.rs
//! Types for the mutator to use to build data structures use std::cell::Cell; use std::mem::transmute; use std::ops::{Deref, DerefMut}; use std::ptr::{null, null_mut}; use std::raw::TraitObject; use std::sync::atomic::{AtomicPtr, Ordering}; use std::thread; use constants::{INC_BIT, JOURNAL_BUFFER_SIZE, NEW_BIT, TRAVERSE_BIT}; use gcthread::{JournalSender, EntrySender}; use heap::{Object, TraceStack}; use journal; use trace::Trace; /// Each thread gets it's own EntrySender thread_local!( static GC_JOURNAL: Cell<*const EntrySender> = Cell::new(null()) ); /// GcBox struct and traits: a boxed object that is GC managed pub struct GcBox<T: Trace> { value: T, } /// Root smart pointer, sends reference count changes to the journal. /// /// Whenever a reference to an object on the heap must be retained on the stack, this type must be /// used. It's use will ensure that the object will be seen as a root. pub struct GcRoot<T: Trace> { ptr: *mut GcBox<T>, } /// Non-atomic pointer type. This type is `!Sync` and thus is useful for presenting a Rust-ish /// API to a data structure where aliasing and mutability must follow the standard rules: there /// can be only one mutator. /// /// *Important note:* even though this type is `!Sync`, any data structures that are composed of /// `Gc` pointers must still be designed with the awareness that the GC thread will call `trace()` /// at any point and so, must still be thread safe! /// /// This is not a root pointer type. It should be used inside data structures to reference other /// GC-managed objects. pub struct Gc<T: Trace> { ptr: *mut GcBox<T>, } /// Atomic pointer type that points at a traceable object. This type is `Sync` and can be used to /// build concurrent data structures. /// /// This type should be used inside data structures to reference other GC-managed objects, but /// provides interior mutability and atomic methods. /// /// TODO: cas, swap etc for GcRoot and Gc pub struct GcAtomic<T: Trace> { ptr: AtomicPtr<GcBox<T>>, } /// An Application Thread, manages a thread-local reference to a tx channel /// /// TODO: a version of `spawn()` is required that can be called from an existing mutator thread. pub struct AppThread; impl AppThread { /// As thread::spawn but takes a journal Sender to initialize the thread_local instance with. pub fn spawn_from_gc<F, T>(tx: JournalSender, f: F) -> thread::JoinHandle<T> where F: FnOnce() -> T, F: Send +'static, T: Send +'static { thread::spawn(move || { let (jtx, jrx) = journal::make_journal(JOURNAL_BUFFER_SIZE); tx.send(jrx).expect("Failed to send a new Journal to the GC thread!"); GC_JOURNAL.with(|j| { j.set(&jtx); }); f() }) } } // Reference count functions. Only new-objects need to specify the traverse bit. #[inline] fn as_traitobject<T: Trace>(object: &T) -> TraitObject { let trace: &Trace = object; unsafe { transmute(trace) } } /// Write a reference count increment to the journal for a newly allocated object #[inline] fn write<T: Trace>(object: &T, is_new: bool, flags: usize) { GC_JOURNAL.with(|j| { let tx = unsafe { &*j.get() }; let tobj = as_traitobject(object); // set the refcount-increment bit let ptr = (tobj.data as usize) | flags; // set the traversible bit let mut vtable = tobj.vtable as usize; if is_new && object.traversible() { vtable |= TRAVERSE_BIT; } tx.send(Object { ptr: ptr, vtable: vtable, }); }); } // GcBox implementation impl<T: Trace> GcBox<T> { fn new(value: T) -> GcBox<T> { GcBox { value: value, } } } unsafe impl<T: Trace> Trace for GcBox<T> { #[inline] fn traversible(&self) -> bool { self.value.traversible() } #[inline] unsafe fn trace(&self, heap: &mut TraceStack) { self.value.trace(heap); } } // GcRoot implementation impl<T: Trace> GcRoot<T> { /// Put a new object on the heap and hand ownership to the GC, writing a reference count /// increment to the journal. pub fn new(value: T) -> GcRoot<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT | INC_BIT); GcRoot { ptr: Box::into_raw(boxed) } } fn from_raw(ptr: *mut GcBox<T>) -> GcRoot<T> { let root = GcRoot { ptr: ptr }; write(&*root, false, INC_BIT); root } fn ptr(&self) -> *mut GcBox<T> { self.ptr } fn value(&self) -> &T { unsafe { &(*self.ptr).value } } fn value_mut(&mut self) -> &mut T { unsafe { &mut (*self.ptr).value } } } impl<T: Trace> Drop for GcRoot<T> { fn drop(&mut self) { write(&**self, false, 0); } } impl<T: Trace> Deref for GcRoot<T> { type Target = T; fn deref(&self) -> &T { self.value() } } impl<T: Trace> DerefMut for GcRoot<T> { fn deref_mut(&mut self) -> &mut T { self.value_mut() } } impl<T: Trace> Clone for GcRoot<T> { fn clone(&self) -> Self { GcRoot::from_raw(self.ptr()) } } // Gc implementation impl<T: Trace> Gc<T> { /// Creates a new null pointer. pub fn null() -> Gc<T> { Gc { ptr: null_mut(), } } /// Move a value to the heap and create a pointer to it. pub fn new(value: T) -> Gc<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT); Gc { ptr: Box::into_raw(boxed) } } /// Return the raw pointer value, or None if it is a null pointer. pub fn as_raw(&self) -> Option<*mut GcBox<T>> { if self.ptr.is_null() { None } else { Some(self.ptr) } } /// Pointer equality comparison. pub fn is(&self, other: Gc<T>) -> bool { self.ptr == other.ptr } fn from_raw(ptr: *mut GcBox<T>) -> Gc<T> { Gc {
} } fn ptr(&self) -> *mut GcBox<T> { self.ptr } fn value(&self) -> &T { unsafe { &(*self.ptr).value } } fn value_mut(&mut self) -> &mut T { unsafe { &mut (*self.ptr).value } } } impl<T: Trace> Deref for Gc<T> { type Target = T; fn deref(&self) -> &T { self.value() } } impl<T: Trace> DerefMut for Gc<T> { fn deref_mut(&mut self) -> &mut T { self.value_mut() } } impl<T: Trace> Clone for Gc<T> { fn clone(&self) -> Self { Gc { ptr: self.ptr, } } } impl<T: Trace> Copy for Gc<T> {} // GcAtomic implementation impl<T: Trace> GcAtomic<T> { /// Instantiate a new null pointer pub fn null() -> GcAtomic<T> { GcAtomic { ptr: AtomicPtr::new(null_mut()) } } /// Instantiate a new pointer, moving `value` to the heap. Writes to the journal. pub fn new(value: T) -> GcAtomic<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT); GcAtomic { ptr: AtomicPtr::new(Box::into_raw(boxed)), } } /// Root the pointer by loading it into a `GcRoot<T>` /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_into_root(&self, order: Ordering) -> GcRoot<T> { let root = GcRoot { ptr: self.ptr.load(order), }; write(&*root, false, INC_BIT); root } /// Copy the pointer into a new `Gc` instance. /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_into_gc(&self, order: Ordering) -> Gc<T> { Gc::from_raw(self.ptr.load(order)) } /// Fetch the current raw pointer value /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_raw(&self, order: Ordering) -> *mut GcBox<T> { self.ptr.load(order) } /// Replace the current pointer value with the pointer from the given `GcRoot`. /// /// Panics if `order` is `Acquire` or `AcqRel`. pub fn store_from_root(&self, root: GcRoot<T>, order: Ordering) { self.ptr.store(root.ptr(), order); } /// Replace the current pointer value with the pointer from the given `Gc`. /// /// Panics of `order` is `Acquire` or `AcqRel`. pub fn store_from_gc(&self, gc: Gc<T>, order: Ordering) { self.ptr.store(gc.ptr(), order); } /// Replace the current pointer value with the given raw pointer /// /// Panics if `order` is `Acquire` or `AcqRel`. pub fn store_raw(&self, ptr: *mut GcBox<T>, order: Ordering) { self.ptr.store(ptr, order); } }
ptr: ptr,
random_line_split
appthread.rs
//! Types for the mutator to use to build data structures use std::cell::Cell; use std::mem::transmute; use std::ops::{Deref, DerefMut}; use std::ptr::{null, null_mut}; use std::raw::TraitObject; use std::sync::atomic::{AtomicPtr, Ordering}; use std::thread; use constants::{INC_BIT, JOURNAL_BUFFER_SIZE, NEW_BIT, TRAVERSE_BIT}; use gcthread::{JournalSender, EntrySender}; use heap::{Object, TraceStack}; use journal; use trace::Trace; /// Each thread gets it's own EntrySender thread_local!( static GC_JOURNAL: Cell<*const EntrySender> = Cell::new(null()) ); /// GcBox struct and traits: a boxed object that is GC managed pub struct GcBox<T: Trace> { value: T, } /// Root smart pointer, sends reference count changes to the journal. /// /// Whenever a reference to an object on the heap must be retained on the stack, this type must be /// used. It's use will ensure that the object will be seen as a root. pub struct GcRoot<T: Trace> { ptr: *mut GcBox<T>, } /// Non-atomic pointer type. This type is `!Sync` and thus is useful for presenting a Rust-ish /// API to a data structure where aliasing and mutability must follow the standard rules: there /// can be only one mutator. /// /// *Important note:* even though this type is `!Sync`, any data structures that are composed of /// `Gc` pointers must still be designed with the awareness that the GC thread will call `trace()` /// at any point and so, must still be thread safe! /// /// This is not a root pointer type. It should be used inside data structures to reference other /// GC-managed objects. pub struct Gc<T: Trace> { ptr: *mut GcBox<T>, } /// Atomic pointer type that points at a traceable object. This type is `Sync` and can be used to /// build concurrent data structures. /// /// This type should be used inside data structures to reference other GC-managed objects, but /// provides interior mutability and atomic methods. /// /// TODO: cas, swap etc for GcRoot and Gc pub struct GcAtomic<T: Trace> { ptr: AtomicPtr<GcBox<T>>, } /// An Application Thread, manages a thread-local reference to a tx channel /// /// TODO: a version of `spawn()` is required that can be called from an existing mutator thread. pub struct AppThread; impl AppThread { /// As thread::spawn but takes a journal Sender to initialize the thread_local instance with. pub fn spawn_from_gc<F, T>(tx: JournalSender, f: F) -> thread::JoinHandle<T> where F: FnOnce() -> T, F: Send +'static, T: Send +'static { thread::spawn(move || { let (jtx, jrx) = journal::make_journal(JOURNAL_BUFFER_SIZE); tx.send(jrx).expect("Failed to send a new Journal to the GC thread!"); GC_JOURNAL.with(|j| { j.set(&jtx); }); f() }) } } // Reference count functions. Only new-objects need to specify the traverse bit. #[inline] fn as_traitobject<T: Trace>(object: &T) -> TraitObject { let trace: &Trace = object; unsafe { transmute(trace) } } /// Write a reference count increment to the journal for a newly allocated object #[inline] fn write<T: Trace>(object: &T, is_new: bool, flags: usize) { GC_JOURNAL.with(|j| { let tx = unsafe { &*j.get() }; let tobj = as_traitobject(object); // set the refcount-increment bit let ptr = (tobj.data as usize) | flags; // set the traversible bit let mut vtable = tobj.vtable as usize; if is_new && object.traversible() { vtable |= TRAVERSE_BIT; } tx.send(Object { ptr: ptr, vtable: vtable, }); }); } // GcBox implementation impl<T: Trace> GcBox<T> { fn new(value: T) -> GcBox<T> { GcBox { value: value, } } } unsafe impl<T: Trace> Trace for GcBox<T> { #[inline] fn traversible(&self) -> bool { self.value.traversible() } #[inline] unsafe fn trace(&self, heap: &mut TraceStack) { self.value.trace(heap); } } // GcRoot implementation impl<T: Trace> GcRoot<T> { /// Put a new object on the heap and hand ownership to the GC, writing a reference count /// increment to the journal. pub fn new(value: T) -> GcRoot<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT | INC_BIT); GcRoot { ptr: Box::into_raw(boxed) } } fn from_raw(ptr: *mut GcBox<T>) -> GcRoot<T> { let root = GcRoot { ptr: ptr }; write(&*root, false, INC_BIT); root } fn ptr(&self) -> *mut GcBox<T> { self.ptr } fn value(&self) -> &T { unsafe { &(*self.ptr).value } } fn value_mut(&mut self) -> &mut T { unsafe { &mut (*self.ptr).value } } } impl<T: Trace> Drop for GcRoot<T> { fn drop(&mut self) { write(&**self, false, 0); } } impl<T: Trace> Deref for GcRoot<T> { type Target = T; fn deref(&self) -> &T { self.value() } } impl<T: Trace> DerefMut for GcRoot<T> { fn deref_mut(&mut self) -> &mut T { self.value_mut() } } impl<T: Trace> Clone for GcRoot<T> { fn clone(&self) -> Self { GcRoot::from_raw(self.ptr()) } } // Gc implementation impl<T: Trace> Gc<T> { /// Creates a new null pointer. pub fn null() -> Gc<T> { Gc { ptr: null_mut(), } } /// Move a value to the heap and create a pointer to it. pub fn new(value: T) -> Gc<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT); Gc { ptr: Box::into_raw(boxed) } } /// Return the raw pointer value, or None if it is a null pointer. pub fn as_raw(&self) -> Option<*mut GcBox<T>> { if self.ptr.is_null() { None } else
} /// Pointer equality comparison. pub fn is(&self, other: Gc<T>) -> bool { self.ptr == other.ptr } fn from_raw(ptr: *mut GcBox<T>) -> Gc<T> { Gc { ptr: ptr, } } fn ptr(&self) -> *mut GcBox<T> { self.ptr } fn value(&self) -> &T { unsafe { &(*self.ptr).value } } fn value_mut(&mut self) -> &mut T { unsafe { &mut (*self.ptr).value } } } impl<T: Trace> Deref for Gc<T> { type Target = T; fn deref(&self) -> &T { self.value() } } impl<T: Trace> DerefMut for Gc<T> { fn deref_mut(&mut self) -> &mut T { self.value_mut() } } impl<T: Trace> Clone for Gc<T> { fn clone(&self) -> Self { Gc { ptr: self.ptr, } } } impl<T: Trace> Copy for Gc<T> {} // GcAtomic implementation impl<T: Trace> GcAtomic<T> { /// Instantiate a new null pointer pub fn null() -> GcAtomic<T> { GcAtomic { ptr: AtomicPtr::new(null_mut()) } } /// Instantiate a new pointer, moving `value` to the heap. Writes to the journal. pub fn new(value: T) -> GcAtomic<T> { let boxed = Box::new(GcBox::new(value)); write(&*boxed, true, NEW_BIT); GcAtomic { ptr: AtomicPtr::new(Box::into_raw(boxed)), } } /// Root the pointer by loading it into a `GcRoot<T>` /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_into_root(&self, order: Ordering) -> GcRoot<T> { let root = GcRoot { ptr: self.ptr.load(order), }; write(&*root, false, INC_BIT); root } /// Copy the pointer into a new `Gc` instance. /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_into_gc(&self, order: Ordering) -> Gc<T> { Gc::from_raw(self.ptr.load(order)) } /// Fetch the current raw pointer value /// /// Panics if `order` is `Release` or `AcqRel`. pub fn load_raw(&self, order: Ordering) -> *mut GcBox<T> { self.ptr.load(order) } /// Replace the current pointer value with the pointer from the given `GcRoot`. /// /// Panics if `order` is `Acquire` or `AcqRel`. pub fn store_from_root(&self, root: GcRoot<T>, order: Ordering) { self.ptr.store(root.ptr(), order); } /// Replace the current pointer value with the pointer from the given `Gc`. /// /// Panics of `order` is `Acquire` or `AcqRel`. pub fn store_from_gc(&self, gc: Gc<T>, order: Ordering) { self.ptr.store(gc.ptr(), order); } /// Replace the current pointer value with the given raw pointer /// /// Panics if `order` is `Acquire` or `AcqRel`. pub fn store_raw(&self, ptr: *mut GcBox<T>, order: Ordering) { self.ptr.store(ptr, order); } }
{ Some(self.ptr) }
conditional_block
self-impl-2.rs
// run-pass #![allow(dead_code)] #![allow(unused_variables)] // Test that we can use `Self` types in impls in the expected way. // pretty-expanded FIXME #23616 struct Foo; // Test uses on inherent impl. impl Foo { fn
(_x: Self, _y: &Self, _z: Box<Self>) -> Self { Foo } fn baz() { // Test that Self cannot be shadowed. type Foo = i32; // There is no empty method on i32. Self::empty(); let _: Self = Foo; } fn empty() {} } // Test uses when implementing a trait and with a type parameter. pub struct Baz<X> { pub f: X, } trait SuperBar { type SuperQux; } trait Bar<X>: SuperBar { type Qux; fn bar(x: Self, y: &Self, z: Box<Self>, _: Self::SuperQux) -> Self; fn dummy(&self, x: X) { } } impl SuperBar for Box<Baz<isize>> { type SuperQux = bool; } impl Bar<isize> for Box<Baz<isize>> { type Qux = i32; fn bar(_x: Self, _y: &Self, _z: Box<Self>, _: Self::SuperQux) -> Self { let _: Self::Qux = 42; let _: <Self as Bar<isize>>::Qux = 42; let _: Self::SuperQux = true; let _: <Self as SuperBar>::SuperQux = true; Box::new(Baz { f: 42 }) } } fn main() { let _: Foo = Foo::foo(Foo, &Foo, Box::new(Foo)); let _: Box<Baz<isize>> = Bar::bar(Box::new(Baz { f: 42 }), &Box::new(Baz { f: 42 }), Box::new(Box::new(Baz { f: 42 })), true); }
foo
identifier_name
self-impl-2.rs
// run-pass #![allow(dead_code)] #![allow(unused_variables)] // Test that we can use `Self` types in impls in the expected way. // pretty-expanded FIXME #23616 struct Foo; // Test uses on inherent impl. impl Foo { fn foo(_x: Self, _y: &Self, _z: Box<Self>) -> Self { Foo } fn baz() { // Test that Self cannot be shadowed. type Foo = i32; // There is no empty method on i32. Self::empty(); let _: Self = Foo; } fn empty() {} } // Test uses when implementing a trait and with a type parameter. pub struct Baz<X> { pub f: X, } trait SuperBar { type SuperQux; } trait Bar<X>: SuperBar { type Qux;
impl SuperBar for Box<Baz<isize>> { type SuperQux = bool; } impl Bar<isize> for Box<Baz<isize>> { type Qux = i32; fn bar(_x: Self, _y: &Self, _z: Box<Self>, _: Self::SuperQux) -> Self { let _: Self::Qux = 42; let _: <Self as Bar<isize>>::Qux = 42; let _: Self::SuperQux = true; let _: <Self as SuperBar>::SuperQux = true; Box::new(Baz { f: 42 }) } } fn main() { let _: Foo = Foo::foo(Foo, &Foo, Box::new(Foo)); let _: Box<Baz<isize>> = Bar::bar(Box::new(Baz { f: 42 }), &Box::new(Baz { f: 42 }), Box::new(Box::new(Baz { f: 42 })), true); }
fn bar(x: Self, y: &Self, z: Box<Self>, _: Self::SuperQux) -> Self; fn dummy(&self, x: X) { } }
random_line_split
self-impl-2.rs
// run-pass #![allow(dead_code)] #![allow(unused_variables)] // Test that we can use `Self` types in impls in the expected way. // pretty-expanded FIXME #23616 struct Foo; // Test uses on inherent impl. impl Foo { fn foo(_x: Self, _y: &Self, _z: Box<Self>) -> Self { Foo } fn baz()
fn empty() {} } // Test uses when implementing a trait and with a type parameter. pub struct Baz<X> { pub f: X, } trait SuperBar { type SuperQux; } trait Bar<X>: SuperBar { type Qux; fn bar(x: Self, y: &Self, z: Box<Self>, _: Self::SuperQux) -> Self; fn dummy(&self, x: X) { } } impl SuperBar for Box<Baz<isize>> { type SuperQux = bool; } impl Bar<isize> for Box<Baz<isize>> { type Qux = i32; fn bar(_x: Self, _y: &Self, _z: Box<Self>, _: Self::SuperQux) -> Self { let _: Self::Qux = 42; let _: <Self as Bar<isize>>::Qux = 42; let _: Self::SuperQux = true; let _: <Self as SuperBar>::SuperQux = true; Box::new(Baz { f: 42 }) } } fn main() { let _: Foo = Foo::foo(Foo, &Foo, Box::new(Foo)); let _: Box<Baz<isize>> = Bar::bar(Box::new(Baz { f: 42 }), &Box::new(Baz { f: 42 }), Box::new(Box::new(Baz { f: 42 })), true); }
{ // Test that Self cannot be shadowed. type Foo = i32; // There is no empty method on i32. Self::empty(); let _: Self = Foo; }
identifier_body
areas.rs
use spin::Once; static AREAS: Once<Areas> = Once::new(); #[derive(Debug)] struct Areas { areas: [Area; 16], count: usize, } //TODO Do we align the base and length here, // provide methods for it, // or leave it up to the user #[derive(Copy, Clone, Debug)] pub struct Area { pub base: u64, pub length: u64, } #[derive(Debug, Clone)] pub struct AreaIter { areas: &'static Areas, i: usize, } impl Areas { const fn new() -> Areas { Areas { areas: [Area{base:0, length: 0};16], count: 0, }
fn add_area(&mut self, base: u64, length: u64) { self.areas[self.count] = Area{base:base, length: length}; self.count += 1; } fn iter(&'static self) -> AreaIter { AreaIter {i: 0, areas: self} } } impl Iterator for AreaIter { type Item = &'static Area; fn next(&mut self) -> Option<Self::Item> { if self.i < self.areas.count { let item = &self.areas.areas[self.i]; self.i += 1; Some(item) } else { None } } } fn areas() -> &'static Areas { AREAS.try().expect("AREAS not initialized yet") } pub fn memory_areas() -> AreaIter { areas().iter() } pub fn init(boot_info: &::bootinfo::BootInfo) { AREAS.call_once(|| { let mut areas = Areas::new(); for area in boot_info.memory_areas() { // Only copy free areas if area.usage == ::bootinfo::Usage::Free { areas.add_area(area.start, area.length); } } areas }); //TODO I'm not sure if I want this here // We should probably move this to a print function, or something. println!("Areas"); for area in memory_areas() { println!(" start: 0x{:x}, length: 0x{:x}", area.base, area.length); } }
}
random_line_split
areas.rs
use spin::Once; static AREAS: Once<Areas> = Once::new(); #[derive(Debug)] struct Areas { areas: [Area; 16], count: usize, } //TODO Do we align the base and length here, // provide methods for it, // or leave it up to the user #[derive(Copy, Clone, Debug)] pub struct Area { pub base: u64, pub length: u64, } #[derive(Debug, Clone)] pub struct AreaIter { areas: &'static Areas, i: usize, } impl Areas { const fn new() -> Areas { Areas { areas: [Area{base:0, length: 0};16], count: 0, } } fn add_area(&mut self, base: u64, length: u64) { self.areas[self.count] = Area{base:base, length: length}; self.count += 1; } fn iter(&'static self) -> AreaIter { AreaIter {i: 0, areas: self} } } impl Iterator for AreaIter { type Item = &'static Area; fn next(&mut self) -> Option<Self::Item> { if self.i < self.areas.count { let item = &self.areas.areas[self.i]; self.i += 1; Some(item) } else { None } } } fn areas() -> &'static Areas { AREAS.try().expect("AREAS not initialized yet") } pub fn memory_areas() -> AreaIter { areas().iter() } pub fn init(boot_info: &::bootinfo::BootInfo) { AREAS.call_once(|| { let mut areas = Areas::new(); for area in boot_info.memory_areas() { // Only copy free areas if area.usage == ::bootinfo::Usage::Free
} areas }); //TODO I'm not sure if I want this here // We should probably move this to a print function, or something. println!("Areas"); for area in memory_areas() { println!(" start: 0x{:x}, length: 0x{:x}", area.base, area.length); } }
{ areas.add_area(area.start, area.length); }
conditional_block
areas.rs
use spin::Once; static AREAS: Once<Areas> = Once::new(); #[derive(Debug)] struct Areas { areas: [Area; 16], count: usize, } //TODO Do we align the base and length here, // provide methods for it, // or leave it up to the user #[derive(Copy, Clone, Debug)] pub struct Area { pub base: u64, pub length: u64, } #[derive(Debug, Clone)] pub struct AreaIter { areas: &'static Areas, i: usize, } impl Areas { const fn new() -> Areas { Areas { areas: [Area{base:0, length: 0};16], count: 0, } } fn add_area(&mut self, base: u64, length: u64) { self.areas[self.count] = Area{base:base, length: length}; self.count += 1; } fn iter(&'static self) -> AreaIter
} impl Iterator for AreaIter { type Item = &'static Area; fn next(&mut self) -> Option<Self::Item> { if self.i < self.areas.count { let item = &self.areas.areas[self.i]; self.i += 1; Some(item) } else { None } } } fn areas() -> &'static Areas { AREAS.try().expect("AREAS not initialized yet") } pub fn memory_areas() -> AreaIter { areas().iter() } pub fn init(boot_info: &::bootinfo::BootInfo) { AREAS.call_once(|| { let mut areas = Areas::new(); for area in boot_info.memory_areas() { // Only copy free areas if area.usage == ::bootinfo::Usage::Free { areas.add_area(area.start, area.length); } } areas }); //TODO I'm not sure if I want this here // We should probably move this to a print function, or something. println!("Areas"); for area in memory_areas() { println!(" start: 0x{:x}, length: 0x{:x}", area.base, area.length); } }
{ AreaIter {i: 0, areas: self} }
identifier_body
areas.rs
use spin::Once; static AREAS: Once<Areas> = Once::new(); #[derive(Debug)] struct Areas { areas: [Area; 16], count: usize, } //TODO Do we align the base and length here, // provide methods for it, // or leave it up to the user #[derive(Copy, Clone, Debug)] pub struct Area { pub base: u64, pub length: u64, } #[derive(Debug, Clone)] pub struct AreaIter { areas: &'static Areas, i: usize, } impl Areas { const fn
() -> Areas { Areas { areas: [Area{base:0, length: 0};16], count: 0, } } fn add_area(&mut self, base: u64, length: u64) { self.areas[self.count] = Area{base:base, length: length}; self.count += 1; } fn iter(&'static self) -> AreaIter { AreaIter {i: 0, areas: self} } } impl Iterator for AreaIter { type Item = &'static Area; fn next(&mut self) -> Option<Self::Item> { if self.i < self.areas.count { let item = &self.areas.areas[self.i]; self.i += 1; Some(item) } else { None } } } fn areas() -> &'static Areas { AREAS.try().expect("AREAS not initialized yet") } pub fn memory_areas() -> AreaIter { areas().iter() } pub fn init(boot_info: &::bootinfo::BootInfo) { AREAS.call_once(|| { let mut areas = Areas::new(); for area in boot_info.memory_areas() { // Only copy free areas if area.usage == ::bootinfo::Usage::Free { areas.add_area(area.start, area.length); } } areas }); //TODO I'm not sure if I want this here // We should probably move this to a print function, or something. println!("Areas"); for area in memory_areas() { println!(" start: 0x{:x}, length: 0x{:x}", area.base, area.length); } }
new
identifier_name
dominators.rs
//! Compute dominators of a control-flow graph. //! //! # The Dominance Relation //! //! In a directed graph with a root node **R**, a node **A** is said to *dominate* a //! node **B** iff every path from **R** to **B** contains **A**. //! //! The node **A** is said to *strictly dominate* the node **B** iff **A** dominates //! **B** and **A ≠ B**. //! //! The node **A** is said to be the *immediate dominator* of a node **B** iff it //! strictly dominates **B** and there does not exist any node **C** where **A** //! dominates **C** and **C** dominates **B**. use std::cmp::Ordering; use std::collections::{HashMap, HashSet, hash_map::Iter}; use std::hash::Hash; use crate::visit::{DfsPostOrder, GraphBase, IntoNeighbors, Visitable, Walker}; /// The dominance relation for some graph and root. #[derive(Debug, Clone)] pub struct Dominators<N> where N: Copy + Eq + Hash, { root: N, dominators: HashMap<N, N>, } impl<N> Dominators<N> where N: Copy + Eq + Hash, { /// Get the root node used to construct these dominance relations. pub fn root(&self) -> N { self.root } /// Get the immediate dominator of the given node. /// /// Returns `None` for any node that is not reachable from the root, and for /// the root itself. pub fn immediate_dominator(&self, node: N) -> Option<N> {
/// Iterate over the given node's strict dominators. /// /// If the given node is not reachable from the root, then `None` is /// returned. pub fn strict_dominators(&self, node: N) -> Option<DominatorsIter<N>> { if self.dominators.contains_key(&node) { Some(DominatorsIter { dominators: self, node: self.immediate_dominator(node), }) } else { None } } /// Iterate over all of the given node's dominators (including the given /// node itself). /// /// If the given node is not reachable from the root, then `None` is /// returned. pub fn dominators(&self, node: N) -> Option<DominatorsIter<N>> { if self.dominators.contains_key(&node) { Some(DominatorsIter { dominators: self, node: Some(node), }) } else { None } } /// Iterate over all nodes immediately dominated by the given node (not /// including the given node itself). pub fn immediately_dominated_by(&self, node: N) -> DominatedByIter<N> { DominatedByIter { iter: self.dominators.iter(), node: node } } } /// Iterator for a node's dominators. pub struct DominatorsIter<'a, N> where N: 'a + Copy + Eq + Hash, { dominators: &'a Dominators<N>, node: Option<N>, } impl<'a, N> Iterator for DominatorsIter<'a, N> where N: 'a + Copy + Eq + Hash, { type Item = N; fn next(&mut self) -> Option<Self::Item> { let next = self.node.take(); if let Some(next) = next { self.node = self.dominators.immediate_dominator(next); } next } } /// Iterator for nodes dominated by a given node. pub struct DominatedByIter<'a, N> where N: 'a + Copy + Eq + Hash, { iter: Iter<'a, N, N>, node: N, } impl<'a, N> Iterator for DominatedByIter<'a, N> where N: 'a + Copy + Eq + Hash, { type Item = N; fn next(&mut self) -> Option<Self::Item> { while let Some(next) = self.iter.next() { if next.1 == &self.node { return Some(*next.0); } } None } } /// The undefined dominator sentinel, for when we have not yet discovered a /// node's dominator. const UNDEFINED: usize = ::std::usize::MAX; /// This is an implementation of the engineered ["Simple, Fast Dominance /// Algorithm"][0] discovered by Cooper et al. /// /// This algorithm is **O(|V|²)**, and therefore has slower theoretical running time /// than the Lengauer-Tarjan algorithm (which is **O(|E| log |V|)**. However, /// Cooper et al found it to be faster in practice on control flow graphs of up /// to ~30,000 vertices. /// /// [0]: http://www.cs.rice.edu/~keith/EMBED/dom.pdf pub fn simple_fast<G>(graph: G, root: G::NodeId) -> Dominators<G::NodeId> where G: IntoNeighbors + Visitable, <G as GraphBase>::NodeId: Eq + Hash, { let (post_order, predecessor_sets) = simple_fast_post_order(graph, root); let length = post_order.len(); debug_assert!(length > 0); debug_assert!(post_order.last() == Some(&root)); // From here on out we use indices into `post_order` instead of actual // `NodeId`s wherever possible. This greatly improves the performance of // this implementation, but we have to pay a little bit of upfront cost to // convert our data structures to play along first. // Maps a node to its index into `post_order`. let node_to_post_order_idx: HashMap<_, _> = post_order .iter() .enumerate() .map(|(idx, &node)| (node, idx)) .collect(); // Maps a node's `post_order` index to its set of predecessors's indices // into `post_order` (as a vec). let idx_to_predecessor_vec = predecessor_sets_to_idx_vecs(&post_order, &node_to_post_order_idx, predecessor_sets); let mut dominators = vec![UNDEFINED; length]; dominators[length - 1] = length - 1; let mut changed = true; while changed { changed = false; // Iterate in reverse post order, skipping the root. for idx in (0..length - 1).rev() { debug_assert!(post_order[idx]!= root); // Take the intersection of every predecessor's dominator set; that // is the current best guess at the immediate dominator for this // node. let new_idom_idx = { let mut predecessors = idx_to_predecessor_vec[idx] .iter() .filter(|&&p| dominators[p]!= UNDEFINED); let new_idom_idx = predecessors.next().expect( "Because the root is initialized to dominate itself, and is the \ first node in every path, there must exist a predecessor to this \ node that also has a dominator", ); predecessors.fold(*new_idom_idx, |new_idom_idx, &predecessor_idx| { intersect(&dominators, new_idom_idx, predecessor_idx) }) }; debug_assert!(new_idom_idx < length); if new_idom_idx!= dominators[idx] { dominators[idx] = new_idom_idx; changed = true; } } } // All done! Translate the indices back into proper `G::NodeId`s. debug_assert!(!dominators.iter().any(|&dom| dom == UNDEFINED)); Dominators { root, dominators: dominators .into_iter() .enumerate() .map(|(idx, dom_idx)| (post_order[idx], post_order[dom_idx])) .collect(), } } fn intersect(dominators: &[usize], mut finger1: usize, mut finger2: usize) -> usize { loop { match finger1.cmp(&finger2) { Ordering::Less => finger1 = dominators[finger1], Ordering::Greater => finger2 = dominators[finger2], Ordering::Equal => return finger1, } } } fn predecessor_sets_to_idx_vecs<N>( post_order: &[N], node_to_post_order_idx: &HashMap<N, usize>, mut predecessor_sets: HashMap<N, HashSet<N>>, ) -> Vec<Vec<usize>> where N: Copy + Eq + Hash, { post_order .iter() .map(|node| { predecessor_sets .remove(node) .map(|predecessors| { predecessors .into_iter() .map(|p| *node_to_post_order_idx.get(&p).unwrap()) .collect() }) .unwrap_or_else(Vec::new) }) .collect() } fn simple_fast_post_order<G>( graph: G, root: G::NodeId, ) -> (Vec<G::NodeId>, HashMap<G::NodeId, HashSet<G::NodeId>>) where G: IntoNeighbors + Visitable, <G as GraphBase>::NodeId: Eq + Hash, { let mut post_order = vec![]; let mut predecessor_sets = HashMap::new(); for node in DfsPostOrder::new(graph, root).iter(graph) { post_order.push(node); for successor in graph.neighbors(node) { predecessor_sets .entry(successor) .or_insert_with(HashSet::new) .insert(node); } } (post_order, predecessor_sets) } #[cfg(test)] mod tests { use super::*; #[test] fn test_iter_dominators() { let doms: Dominators<u32> = Dominators { root: 0, dominators: [(2, 1), (1, 0), (0, 0)].iter().cloned().collect(), }; let all_doms: Vec<_> = doms.dominators(2).unwrap().collect(); assert_eq!(vec![2, 1, 0], all_doms); assert_eq!(None::<()>, doms.dominators(99).map(|_| unreachable!())); let strict_doms: Vec<_> = doms.strict_dominators(2).unwrap().collect(); assert_eq!(vec![1, 0], strict_doms); assert_eq!( None::<()>, doms.strict_dominators(99).map(|_| unreachable!()) ); let dom_by: Vec<_> = doms.immediately_dominated_by(1).collect(); assert_eq!(vec![2], dom_by); assert_eq!(None, doms.immediately_dominated_by(99).next()); } }
if node == self.root { None } else { self.dominators.get(&node).cloned() } }
identifier_body
dominators.rs
//! Compute dominators of a control-flow graph. //! //! # The Dominance Relation //! //! In a directed graph with a root node **R**, a node **A** is said to *dominate* a //! node **B** iff every path from **R** to **B** contains **A**. //! //! The node **A** is said to *strictly dominate* the node **B** iff **A** dominates //! **B** and **A ≠ B**. //! //! The node **A** is said to be the *immediate dominator* of a node **B** iff it //! strictly dominates **B** and there does not exist any node **C** where **A** //! dominates **C** and **C** dominates **B**. use std::cmp::Ordering; use std::collections::{HashMap, HashSet, hash_map::Iter}; use std::hash::Hash; use crate::visit::{DfsPostOrder, GraphBase, IntoNeighbors, Visitable, Walker}; /// The dominance relation for some graph and root. #[derive(Debug, Clone)] pub struct Dominators<N> where N: Copy + Eq + Hash, { root: N, dominators: HashMap<N, N>, } impl<N> Dominators<N> where N: Copy + Eq + Hash, { /// Get the root node used to construct these dominance relations. pub fn root(&self) -> N { self.root } /// Get the immediate dominator of the given node. /// /// Returns `None` for any node that is not reachable from the root, and for /// the root itself. pub fn immediate_dominator(&self, node: N) -> Option<N> { if node == self.root { None } else { self.dominators.get(&node).cloned() } } /// Iterate over the given node's strict dominators. /// /// If the given node is not reachable from the root, then `None` is /// returned. pub fn strict_dominators(&self, node: N) -> Option<DominatorsIter<N>> { if self.dominators.contains_key(&node) { Some(DominatorsIter { dominators: self, node: self.immediate_dominator(node), }) } else { None } } /// Iterate over all of the given node's dominators (including the given /// node itself). /// /// If the given node is not reachable from the root, then `None` is /// returned. pub fn dominators(&self, node: N) -> Option<DominatorsIter<N>> { if self.dominators.contains_key(&node) { Some(DominatorsIter { dominators: self, node: Some(node), }) } else { None } } /// Iterate over all nodes immediately dominated by the given node (not /// including the given node itself). pub fn immediately_dominated_by(&self, node: N) -> DominatedByIter<N> { DominatedByIter { iter: self.dominators.iter(), node: node } } } /// Iterator for a node's dominators. pub struct DominatorsIter<'a, N> where N: 'a + Copy + Eq + Hash, { dominators: &'a Dominators<N>, node: Option<N>, } impl<'a, N> Iterator for DominatorsIter<'a, N> where N: 'a + Copy + Eq + Hash, { type Item = N; fn next(&mut self) -> Option<Self::Item> { let next = self.node.take(); if let Some(next) = next { self.node = self.dominators.immediate_dominator(next); } next } } /// Iterator for nodes dominated by a given node. pub struct DominatedByIter<'a, N> where N: 'a + Copy + Eq + Hash, { iter: Iter<'a, N, N>, node: N, } impl<'a, N> Iterator for DominatedByIter<'a, N> where N: 'a + Copy + Eq + Hash, { type Item = N; fn next(&mut self) -> Option<Self::Item> { while let Some(next) = self.iter.next() { if next.1 == &self.node { return Some(*next.0); } } None } } /// The undefined dominator sentinel, for when we have not yet discovered a /// node's dominator. const UNDEFINED: usize = ::std::usize::MAX; /// This is an implementation of the engineered ["Simple, Fast Dominance /// Algorithm"][0] discovered by Cooper et al. /// /// This algorithm is **O(|V|²)**, and therefore has slower theoretical running time /// than the Lengauer-Tarjan algorithm (which is **O(|E| log |V|)**. However, /// Cooper et al found it to be faster in practice on control flow graphs of up /// to ~30,000 vertices. /// /// [0]: http://www.cs.rice.edu/~keith/EMBED/dom.pdf pub fn simple_fast<G>(graph: G, root: G::NodeId) -> Dominators<G::NodeId> where G: IntoNeighbors + Visitable, <G as GraphBase>::NodeId: Eq + Hash, { let (post_order, predecessor_sets) = simple_fast_post_order(graph, root); let length = post_order.len(); debug_assert!(length > 0); debug_assert!(post_order.last() == Some(&root)); // From here on out we use indices into `post_order` instead of actual // `NodeId`s wherever possible. This greatly improves the performance of // this implementation, but we have to pay a little bit of upfront cost to // convert our data structures to play along first. // Maps a node to its index into `post_order`. let node_to_post_order_idx: HashMap<_, _> = post_order .iter() .enumerate() .map(|(idx, &node)| (node, idx)) .collect(); // Maps a node's `post_order` index to its set of predecessors's indices // into `post_order` (as a vec). let idx_to_predecessor_vec = predecessor_sets_to_idx_vecs(&post_order, &node_to_post_order_idx, predecessor_sets); let mut dominators = vec![UNDEFINED; length]; dominators[length - 1] = length - 1; let mut changed = true; while changed { changed = false; // Iterate in reverse post order, skipping the root. for idx in (0..length - 1).rev() { debug_assert!(post_order[idx]!= root); // Take the intersection of every predecessor's dominator set; that // is the current best guess at the immediate dominator for this // node. let new_idom_idx = { let mut predecessors = idx_to_predecessor_vec[idx] .iter() .filter(|&&p| dominators[p]!= UNDEFINED); let new_idom_idx = predecessors.next().expect( "Because the root is initialized to dominate itself, and is the \ first node in every path, there must exist a predecessor to this \ node that also has a dominator", ); predecessors.fold(*new_idom_idx, |new_idom_idx, &predecessor_idx| { intersect(&dominators, new_idom_idx, predecessor_idx) }) }; debug_assert!(new_idom_idx < length); if new_idom_idx!= dominators[idx] { dominators[idx] = new_idom_idx; changed = true; } } } // All done! Translate the indices back into proper `G::NodeId`s. debug_assert!(!dominators.iter().any(|&dom| dom == UNDEFINED)); Dominators { root, dominators: dominators .into_iter() .enumerate() .map(|(idx, dom_idx)| (post_order[idx], post_order[dom_idx])) .collect(), } } fn intersect(dominators: &[usize], mut finger1: usize, mut finger2: usize) -> usize { loop { match finger1.cmp(&finger2) { Ordering::Less => finger1 = dominators[finger1], Ordering::Greater => finger2 = dominators[finger2], Ordering::Equal => return finger1, } } } fn predecessor_sets_to_idx_vecs<N>( post_order: &[N], node_to_post_order_idx: &HashMap<N, usize>, mut predecessor_sets: HashMap<N, HashSet<N>>, ) -> Vec<Vec<usize>> where N: Copy + Eq + Hash, { post_order .iter() .map(|node| { predecessor_sets .remove(node) .map(|predecessors| { predecessors .into_iter() .map(|p| *node_to_post_order_idx.get(&p).unwrap()) .collect() }) .unwrap_or_else(Vec::new) }) .collect() } fn simple_fast_post_order<G>( graph: G, root: G::NodeId, ) -> (Vec<G::NodeId>, HashMap<G::NodeId, HashSet<G::NodeId>>) where G: IntoNeighbors + Visitable, <G as GraphBase>::NodeId: Eq + Hash, { let mut post_order = vec![]; let mut predecessor_sets = HashMap::new(); for node in DfsPostOrder::new(graph, root).iter(graph) { post_order.push(node); for successor in graph.neighbors(node) { predecessor_sets .entry(successor) .or_insert_with(HashSet::new) .insert(node); } } (post_order, predecessor_sets) } #[cfg(test)] mod tests { use super::*; #[test]
}; let all_doms: Vec<_> = doms.dominators(2).unwrap().collect(); assert_eq!(vec![2, 1, 0], all_doms); assert_eq!(None::<()>, doms.dominators(99).map(|_| unreachable!())); let strict_doms: Vec<_> = doms.strict_dominators(2).unwrap().collect(); assert_eq!(vec![1, 0], strict_doms); assert_eq!( None::<()>, doms.strict_dominators(99).map(|_| unreachable!()) ); let dom_by: Vec<_> = doms.immediately_dominated_by(1).collect(); assert_eq!(vec![2], dom_by); assert_eq!(None, doms.immediately_dominated_by(99).next()); } }
fn test_iter_dominators() { let doms: Dominators<u32> = Dominators { root: 0, dominators: [(2, 1), (1, 0), (0, 0)].iter().cloned().collect(),
random_line_split
dominators.rs
//! Compute dominators of a control-flow graph. //! //! # The Dominance Relation //! //! In a directed graph with a root node **R**, a node **A** is said to *dominate* a //! node **B** iff every path from **R** to **B** contains **A**. //! //! The node **A** is said to *strictly dominate* the node **B** iff **A** dominates //! **B** and **A ≠ B**. //! //! The node **A** is said to be the *immediate dominator* of a node **B** iff it //! strictly dominates **B** and there does not exist any node **C** where **A** //! dominates **C** and **C** dominates **B**. use std::cmp::Ordering; use std::collections::{HashMap, HashSet, hash_map::Iter}; use std::hash::Hash; use crate::visit::{DfsPostOrder, GraphBase, IntoNeighbors, Visitable, Walker}; /// The dominance relation for some graph and root. #[derive(Debug, Clone)] pub struct Dominators<N> where N: Copy + Eq + Hash, { root: N, dominators: HashMap<N, N>, } impl<N> Dominators<N> where N: Copy + Eq + Hash, { /// Get the root node used to construct these dominance relations. pub fn root(&self) -> N { self.root } /// Get the immediate dominator of the given node. /// /// Returns `None` for any node that is not reachable from the root, and for /// the root itself. pub fn immediate_dominator(&self, node: N) -> Option<N> { if node == self.root { None } else { self.dominators.get(&node).cloned() } } /// Iterate over the given node's strict dominators. /// /// If the given node is not reachable from the root, then `None` is /// returned. pub fn strict_dominators(&self, node: N) -> Option<DominatorsIter<N>> { if self.dominators.contains_key(&node) { Some(DominatorsIter { dominators: self, node: self.immediate_dominator(node), }) } else {
} /// Iterate over all of the given node's dominators (including the given /// node itself). /// /// If the given node is not reachable from the root, then `None` is /// returned. pub fn dominators(&self, node: N) -> Option<DominatorsIter<N>> { if self.dominators.contains_key(&node) { Some(DominatorsIter { dominators: self, node: Some(node), }) } else { None } } /// Iterate over all nodes immediately dominated by the given node (not /// including the given node itself). pub fn immediately_dominated_by(&self, node: N) -> DominatedByIter<N> { DominatedByIter { iter: self.dominators.iter(), node: node } } } /// Iterator for a node's dominators. pub struct DominatorsIter<'a, N> where N: 'a + Copy + Eq + Hash, { dominators: &'a Dominators<N>, node: Option<N>, } impl<'a, N> Iterator for DominatorsIter<'a, N> where N: 'a + Copy + Eq + Hash, { type Item = N; fn next(&mut self) -> Option<Self::Item> { let next = self.node.take(); if let Some(next) = next { self.node = self.dominators.immediate_dominator(next); } next } } /// Iterator for nodes dominated by a given node. pub struct DominatedByIter<'a, N> where N: 'a + Copy + Eq + Hash, { iter: Iter<'a, N, N>, node: N, } impl<'a, N> Iterator for DominatedByIter<'a, N> where N: 'a + Copy + Eq + Hash, { type Item = N; fn next(&mut self) -> Option<Self::Item> { while let Some(next) = self.iter.next() { if next.1 == &self.node { return Some(*next.0); } } None } } /// The undefined dominator sentinel, for when we have not yet discovered a /// node's dominator. const UNDEFINED: usize = ::std::usize::MAX; /// This is an implementation of the engineered ["Simple, Fast Dominance /// Algorithm"][0] discovered by Cooper et al. /// /// This algorithm is **O(|V|²)**, and therefore has slower theoretical running time /// than the Lengauer-Tarjan algorithm (which is **O(|E| log |V|)**. However, /// Cooper et al found it to be faster in practice on control flow graphs of up /// to ~30,000 vertices. /// /// [0]: http://www.cs.rice.edu/~keith/EMBED/dom.pdf pub fn simple_fast<G>(graph: G, root: G::NodeId) -> Dominators<G::NodeId> where G: IntoNeighbors + Visitable, <G as GraphBase>::NodeId: Eq + Hash, { let (post_order, predecessor_sets) = simple_fast_post_order(graph, root); let length = post_order.len(); debug_assert!(length > 0); debug_assert!(post_order.last() == Some(&root)); // From here on out we use indices into `post_order` instead of actual // `NodeId`s wherever possible. This greatly improves the performance of // this implementation, but we have to pay a little bit of upfront cost to // convert our data structures to play along first. // Maps a node to its index into `post_order`. let node_to_post_order_idx: HashMap<_, _> = post_order .iter() .enumerate() .map(|(idx, &node)| (node, idx)) .collect(); // Maps a node's `post_order` index to its set of predecessors's indices // into `post_order` (as a vec). let idx_to_predecessor_vec = predecessor_sets_to_idx_vecs(&post_order, &node_to_post_order_idx, predecessor_sets); let mut dominators = vec![UNDEFINED; length]; dominators[length - 1] = length - 1; let mut changed = true; while changed { changed = false; // Iterate in reverse post order, skipping the root. for idx in (0..length - 1).rev() { debug_assert!(post_order[idx]!= root); // Take the intersection of every predecessor's dominator set; that // is the current best guess at the immediate dominator for this // node. let new_idom_idx = { let mut predecessors = idx_to_predecessor_vec[idx] .iter() .filter(|&&p| dominators[p]!= UNDEFINED); let new_idom_idx = predecessors.next().expect( "Because the root is initialized to dominate itself, and is the \ first node in every path, there must exist a predecessor to this \ node that also has a dominator", ); predecessors.fold(*new_idom_idx, |new_idom_idx, &predecessor_idx| { intersect(&dominators, new_idom_idx, predecessor_idx) }) }; debug_assert!(new_idom_idx < length); if new_idom_idx!= dominators[idx] { dominators[idx] = new_idom_idx; changed = true; } } } // All done! Translate the indices back into proper `G::NodeId`s. debug_assert!(!dominators.iter().any(|&dom| dom == UNDEFINED)); Dominators { root, dominators: dominators .into_iter() .enumerate() .map(|(idx, dom_idx)| (post_order[idx], post_order[dom_idx])) .collect(), } } fn intersect(dominators: &[usize], mut finger1: usize, mut finger2: usize) -> usize { loop { match finger1.cmp(&finger2) { Ordering::Less => finger1 = dominators[finger1], Ordering::Greater => finger2 = dominators[finger2], Ordering::Equal => return finger1, } } } fn predecessor_sets_to_idx_vecs<N>( post_order: &[N], node_to_post_order_idx: &HashMap<N, usize>, mut predecessor_sets: HashMap<N, HashSet<N>>, ) -> Vec<Vec<usize>> where N: Copy + Eq + Hash, { post_order .iter() .map(|node| { predecessor_sets .remove(node) .map(|predecessors| { predecessors .into_iter() .map(|p| *node_to_post_order_idx.get(&p).unwrap()) .collect() }) .unwrap_or_else(Vec::new) }) .collect() } fn simple_fast_post_order<G>( graph: G, root: G::NodeId, ) -> (Vec<G::NodeId>, HashMap<G::NodeId, HashSet<G::NodeId>>) where G: IntoNeighbors + Visitable, <G as GraphBase>::NodeId: Eq + Hash, { let mut post_order = vec![]; let mut predecessor_sets = HashMap::new(); for node in DfsPostOrder::new(graph, root).iter(graph) { post_order.push(node); for successor in graph.neighbors(node) { predecessor_sets .entry(successor) .or_insert_with(HashSet::new) .insert(node); } } (post_order, predecessor_sets) } #[cfg(test)] mod tests { use super::*; #[test] fn test_iter_dominators() { let doms: Dominators<u32> = Dominators { root: 0, dominators: [(2, 1), (1, 0), (0, 0)].iter().cloned().collect(), }; let all_doms: Vec<_> = doms.dominators(2).unwrap().collect(); assert_eq!(vec![2, 1, 0], all_doms); assert_eq!(None::<()>, doms.dominators(99).map(|_| unreachable!())); let strict_doms: Vec<_> = doms.strict_dominators(2).unwrap().collect(); assert_eq!(vec![1, 0], strict_doms); assert_eq!( None::<()>, doms.strict_dominators(99).map(|_| unreachable!()) ); let dom_by: Vec<_> = doms.immediately_dominated_by(1).collect(); assert_eq!(vec![2], dom_by); assert_eq!(None, doms.immediately_dominated_by(99).next()); } }
None }
conditional_block
dominators.rs
//! Compute dominators of a control-flow graph. //! //! # The Dominance Relation //! //! In a directed graph with a root node **R**, a node **A** is said to *dominate* a //! node **B** iff every path from **R** to **B** contains **A**. //! //! The node **A** is said to *strictly dominate* the node **B** iff **A** dominates //! **B** and **A ≠ B**. //! //! The node **A** is said to be the *immediate dominator* of a node **B** iff it //! strictly dominates **B** and there does not exist any node **C** where **A** //! dominates **C** and **C** dominates **B**. use std::cmp::Ordering; use std::collections::{HashMap, HashSet, hash_map::Iter}; use std::hash::Hash; use crate::visit::{DfsPostOrder, GraphBase, IntoNeighbors, Visitable, Walker}; /// The dominance relation for some graph and root. #[derive(Debug, Clone)] pub struct Dominators<N> where N: Copy + Eq + Hash, { root: N, dominators: HashMap<N, N>, } impl<N> Dominators<N> where N: Copy + Eq + Hash, { /// Get the root node used to construct these dominance relations. pub fn root(&self) -> N { self.root } /// Get the immediate dominator of the given node. /// /// Returns `None` for any node that is not reachable from the root, and for /// the root itself. pub fn immediate_dominator(&self, node: N) -> Option<N> { if node == self.root { None } else { self.dominators.get(&node).cloned() } } /// Iterate over the given node's strict dominators. /// /// If the given node is not reachable from the root, then `None` is /// returned. pub fn strict_dominators(&self, node: N) -> Option<DominatorsIter<N>> { if self.dominators.contains_key(&node) { Some(DominatorsIter { dominators: self, node: self.immediate_dominator(node), }) } else { None } } /// Iterate over all of the given node's dominators (including the given /// node itself). /// /// If the given node is not reachable from the root, then `None` is /// returned. pub fn dominators(&self, node: N) -> Option<DominatorsIter<N>> { if self.dominators.contains_key(&node) { Some(DominatorsIter { dominators: self, node: Some(node), }) } else { None } } /// Iterate over all nodes immediately dominated by the given node (not /// including the given node itself). pub fn immediately_dominated_by(&self, node: N) -> DominatedByIter<N> { DominatedByIter { iter: self.dominators.iter(), node: node } } } /// Iterator for a node's dominators. pub struct DominatorsIter<'a, N> where N: 'a + Copy + Eq + Hash, { dominators: &'a Dominators<N>, node: Option<N>, } impl<'a, N> Iterator for DominatorsIter<'a, N> where N: 'a + Copy + Eq + Hash, { type Item = N; fn next(&mut self) -> Option<Self::Item> { let next = self.node.take(); if let Some(next) = next { self.node = self.dominators.immediate_dominator(next); } next } } /// Iterator for nodes dominated by a given node. pub struct DominatedByIter<'a, N> where N: 'a + Copy + Eq + Hash, { iter: Iter<'a, N, N>, node: N, } impl<'a, N> Iterator for DominatedByIter<'a, N> where N: 'a + Copy + Eq + Hash, { type Item = N; fn next(&mut self) -> Option<Self::Item> { while let Some(next) = self.iter.next() { if next.1 == &self.node { return Some(*next.0); } } None } } /// The undefined dominator sentinel, for when we have not yet discovered a /// node's dominator. const UNDEFINED: usize = ::std::usize::MAX; /// This is an implementation of the engineered ["Simple, Fast Dominance /// Algorithm"][0] discovered by Cooper et al. /// /// This algorithm is **O(|V|²)**, and therefore has slower theoretical running time /// than the Lengauer-Tarjan algorithm (which is **O(|E| log |V|)**. However, /// Cooper et al found it to be faster in practice on control flow graphs of up /// to ~30,000 vertices. /// /// [0]: http://www.cs.rice.edu/~keith/EMBED/dom.pdf pub fn simple_fast<G>(graph: G, root: G::NodeId) -> Dominators<G::NodeId> where G: IntoNeighbors + Visitable, <G as GraphBase>::NodeId: Eq + Hash, { let (post_order, predecessor_sets) = simple_fast_post_order(graph, root); let length = post_order.len(); debug_assert!(length > 0); debug_assert!(post_order.last() == Some(&root)); // From here on out we use indices into `post_order` instead of actual // `NodeId`s wherever possible. This greatly improves the performance of // this implementation, but we have to pay a little bit of upfront cost to // convert our data structures to play along first. // Maps a node to its index into `post_order`. let node_to_post_order_idx: HashMap<_, _> = post_order .iter() .enumerate() .map(|(idx, &node)| (node, idx)) .collect(); // Maps a node's `post_order` index to its set of predecessors's indices // into `post_order` (as a vec). let idx_to_predecessor_vec = predecessor_sets_to_idx_vecs(&post_order, &node_to_post_order_idx, predecessor_sets); let mut dominators = vec![UNDEFINED; length]; dominators[length - 1] = length - 1; let mut changed = true; while changed { changed = false; // Iterate in reverse post order, skipping the root. for idx in (0..length - 1).rev() { debug_assert!(post_order[idx]!= root); // Take the intersection of every predecessor's dominator set; that // is the current best guess at the immediate dominator for this // node. let new_idom_idx = { let mut predecessors = idx_to_predecessor_vec[idx] .iter() .filter(|&&p| dominators[p]!= UNDEFINED); let new_idom_idx = predecessors.next().expect( "Because the root is initialized to dominate itself, and is the \ first node in every path, there must exist a predecessor to this \ node that also has a dominator", ); predecessors.fold(*new_idom_idx, |new_idom_idx, &predecessor_idx| { intersect(&dominators, new_idom_idx, predecessor_idx) }) }; debug_assert!(new_idom_idx < length); if new_idom_idx!= dominators[idx] { dominators[idx] = new_idom_idx; changed = true; } } } // All done! Translate the indices back into proper `G::NodeId`s. debug_assert!(!dominators.iter().any(|&dom| dom == UNDEFINED)); Dominators { root, dominators: dominators .into_iter() .enumerate() .map(|(idx, dom_idx)| (post_order[idx], post_order[dom_idx])) .collect(), } } fn intersect(dominators: &[usize], mut finger1: usize, mut finger2: usize) -> usize { loop { match finger1.cmp(&finger2) { Ordering::Less => finger1 = dominators[finger1], Ordering::Greater => finger2 = dominators[finger2], Ordering::Equal => return finger1, } } } fn pre
( post_order: &[N], node_to_post_order_idx: &HashMap<N, usize>, mut predecessor_sets: HashMap<N, HashSet<N>>, ) -> Vec<Vec<usize>> where N: Copy + Eq + Hash, { post_order .iter() .map(|node| { predecessor_sets .remove(node) .map(|predecessors| { predecessors .into_iter() .map(|p| *node_to_post_order_idx.get(&p).unwrap()) .collect() }) .unwrap_or_else(Vec::new) }) .collect() } fn simple_fast_post_order<G>( graph: G, root: G::NodeId, ) -> (Vec<G::NodeId>, HashMap<G::NodeId, HashSet<G::NodeId>>) where G: IntoNeighbors + Visitable, <G as GraphBase>::NodeId: Eq + Hash, { let mut post_order = vec![]; let mut predecessor_sets = HashMap::new(); for node in DfsPostOrder::new(graph, root).iter(graph) { post_order.push(node); for successor in graph.neighbors(node) { predecessor_sets .entry(successor) .or_insert_with(HashSet::new) .insert(node); } } (post_order, predecessor_sets) } #[cfg(test)] mod tests { use super::*; #[test] fn test_iter_dominators() { let doms: Dominators<u32> = Dominators { root: 0, dominators: [(2, 1), (1, 0), (0, 0)].iter().cloned().collect(), }; let all_doms: Vec<_> = doms.dominators(2).unwrap().collect(); assert_eq!(vec![2, 1, 0], all_doms); assert_eq!(None::<()>, doms.dominators(99).map(|_| unreachable!())); let strict_doms: Vec<_> = doms.strict_dominators(2).unwrap().collect(); assert_eq!(vec![1, 0], strict_doms); assert_eq!( None::<()>, doms.strict_dominators(99).map(|_| unreachable!()) ); let dom_by: Vec<_> = doms.immediately_dominated_by(1).collect(); assert_eq!(vec![2], dom_by); assert_eq!(None, doms.immediately_dominated_by(99).next()); } }
decessor_sets_to_idx_vecs<N>
identifier_name
boolean.rs
// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation // Copyright (C) 2020 Stacks Open Internet Foundation // // This program 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. // // This program 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 this program. If not, see <http://www.gnu.org/licenses/>. use vm::costs::cost_functions::ClarityCostFunction; use vm::costs::{cost_functions, runtime_cost}; use vm::errors::{ check_argument_count, check_arguments_at_least, CheckErrors, InterpreterResult as Result, }; use vm::representations::SymbolicExpression; use vm::types::{TypeSignature, Value}; use vm::{eval, Environment, LocalContext}; fn type_force_bool(value: &Value) -> Result<bool> { match *value { Value::Bool(boolean) => Ok(boolean), _ => Err(CheckErrors::TypeValueError(TypeSignature::BoolType, value.clone()).into()), } } pub fn special_or( args: &[SymbolicExpression], env: &mut Environment, context: &LocalContext, ) -> Result<Value> { check_arguments_at_least(1, args)?; runtime_cost(ClarityCostFunction::Or, env, args.len())?; for arg in args.iter() { let evaluated = eval(&arg, env, context)?; let result = type_force_bool(&evaluated)?;
Ok(Value::Bool(false)) } pub fn special_and( args: &[SymbolicExpression], env: &mut Environment, context: &LocalContext, ) -> Result<Value> { check_arguments_at_least(1, args)?; runtime_cost(ClarityCostFunction::And, env, args.len())?; for arg in args.iter() { let evaluated = eval(&arg, env, context)?; let result = type_force_bool(&evaluated)?; if!result { return Ok(Value::Bool(false)); } } Ok(Value::Bool(true)) } pub fn native_not(input: Value) -> Result<Value> { let value = type_force_bool(&input)?; Ok(Value::Bool(!value)) }
if result { return Ok(Value::Bool(true)); } }
random_line_split
boolean.rs
// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation // Copyright (C) 2020 Stacks Open Internet Foundation // // This program 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. // // This program 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 this program. If not, see <http://www.gnu.org/licenses/>. use vm::costs::cost_functions::ClarityCostFunction; use vm::costs::{cost_functions, runtime_cost}; use vm::errors::{ check_argument_count, check_arguments_at_least, CheckErrors, InterpreterResult as Result, }; use vm::representations::SymbolicExpression; use vm::types::{TypeSignature, Value}; use vm::{eval, Environment, LocalContext}; fn type_force_bool(value: &Value) -> Result<bool> { match *value { Value::Bool(boolean) => Ok(boolean), _ => Err(CheckErrors::TypeValueError(TypeSignature::BoolType, value.clone()).into()), } } pub fn
( args: &[SymbolicExpression], env: &mut Environment, context: &LocalContext, ) -> Result<Value> { check_arguments_at_least(1, args)?; runtime_cost(ClarityCostFunction::Or, env, args.len())?; for arg in args.iter() { let evaluated = eval(&arg, env, context)?; let result = type_force_bool(&evaluated)?; if result { return Ok(Value::Bool(true)); } } Ok(Value::Bool(false)) } pub fn special_and( args: &[SymbolicExpression], env: &mut Environment, context: &LocalContext, ) -> Result<Value> { check_arguments_at_least(1, args)?; runtime_cost(ClarityCostFunction::And, env, args.len())?; for arg in args.iter() { let evaluated = eval(&arg, env, context)?; let result = type_force_bool(&evaluated)?; if!result { return Ok(Value::Bool(false)); } } Ok(Value::Bool(true)) } pub fn native_not(input: Value) -> Result<Value> { let value = type_force_bool(&input)?; Ok(Value::Bool(!value)) }
special_or
identifier_name
boolean.rs
// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation // Copyright (C) 2020 Stacks Open Internet Foundation // // This program 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. // // This program 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 this program. If not, see <http://www.gnu.org/licenses/>. use vm::costs::cost_functions::ClarityCostFunction; use vm::costs::{cost_functions, runtime_cost}; use vm::errors::{ check_argument_count, check_arguments_at_least, CheckErrors, InterpreterResult as Result, }; use vm::representations::SymbolicExpression; use vm::types::{TypeSignature, Value}; use vm::{eval, Environment, LocalContext}; fn type_force_bool(value: &Value) -> Result<bool> { match *value { Value::Bool(boolean) => Ok(boolean), _ => Err(CheckErrors::TypeValueError(TypeSignature::BoolType, value.clone()).into()), } } pub fn special_or( args: &[SymbolicExpression], env: &mut Environment, context: &LocalContext, ) -> Result<Value> { check_arguments_at_least(1, args)?; runtime_cost(ClarityCostFunction::Or, env, args.len())?; for arg in args.iter() { let evaluated = eval(&arg, env, context)?; let result = type_force_bool(&evaluated)?; if result { return Ok(Value::Bool(true)); } } Ok(Value::Bool(false)) } pub fn special_and( args: &[SymbolicExpression], env: &mut Environment, context: &LocalContext, ) -> Result<Value> { check_arguments_at_least(1, args)?; runtime_cost(ClarityCostFunction::And, env, args.len())?; for arg in args.iter() { let evaluated = eval(&arg, env, context)?; let result = type_force_bool(&evaluated)?; if!result { return Ok(Value::Bool(false)); } } Ok(Value::Bool(true)) } pub fn native_not(input: Value) -> Result<Value>
{ let value = type_force_bool(&input)?; Ok(Value::Bool(!value)) }
identifier_body
touch.rs
use crate::sys; pub type Finger = sys::SDL_Finger; pub type TouchDevice = sys::SDL_TouchID; #[doc(alias = "SDL_GetNumTouchDevices")] pub fn num_touch_devices() -> i32 { unsafe { sys::SDL_GetNumTouchDevices() } } #[doc(alias = "SDL_GetTouchDevice")] pub fn touch_device(index: i32) -> TouchDevice { unsafe { sys::SDL_GetTouchDevice(index) } } #[doc(alias = "SDL_GetNumTouchFingers")] pub fn num_touch_fingers(touch: TouchDevice) -> i32 { unsafe { sys::SDL_GetNumTouchFingers(touch) } }
pub fn touch_finger(touch: TouchDevice, index: i32) -> Option<Finger> { let raw = unsafe { sys::SDL_GetTouchFinger(touch, index) }; if raw.is_null() { None } else { unsafe { Some(*raw) } } }
#[doc(alias = "SDL_GetTouchFinger")]
random_line_split
touch.rs
use crate::sys; pub type Finger = sys::SDL_Finger; pub type TouchDevice = sys::SDL_TouchID; #[doc(alias = "SDL_GetNumTouchDevices")] pub fn num_touch_devices() -> i32 { unsafe { sys::SDL_GetNumTouchDevices() } } #[doc(alias = "SDL_GetTouchDevice")] pub fn touch_device(index: i32) -> TouchDevice { unsafe { sys::SDL_GetTouchDevice(index) } } #[doc(alias = "SDL_GetNumTouchFingers")] pub fn num_touch_fingers(touch: TouchDevice) -> i32 { unsafe { sys::SDL_GetNumTouchFingers(touch) } } #[doc(alias = "SDL_GetTouchFinger")] pub fn touch_finger(touch: TouchDevice, index: i32) -> Option<Finger> { let raw = unsafe { sys::SDL_GetTouchFinger(touch, index) }; if raw.is_null() { None } else
}
{ unsafe { Some(*raw) } }
conditional_block
touch.rs
use crate::sys; pub type Finger = sys::SDL_Finger; pub type TouchDevice = sys::SDL_TouchID; #[doc(alias = "SDL_GetNumTouchDevices")] pub fn num_touch_devices() -> i32 { unsafe { sys::SDL_GetNumTouchDevices() } } #[doc(alias = "SDL_GetTouchDevice")] pub fn touch_device(index: i32) -> TouchDevice { unsafe { sys::SDL_GetTouchDevice(index) } } #[doc(alias = "SDL_GetNumTouchFingers")] pub fn num_touch_fingers(touch: TouchDevice) -> i32 { unsafe { sys::SDL_GetNumTouchFingers(touch) } } #[doc(alias = "SDL_GetTouchFinger")] pub fn
(touch: TouchDevice, index: i32) -> Option<Finger> { let raw = unsafe { sys::SDL_GetTouchFinger(touch, index) }; if raw.is_null() { None } else { unsafe { Some(*raw) } } }
touch_finger
identifier_name
touch.rs
use crate::sys; pub type Finger = sys::SDL_Finger; pub type TouchDevice = sys::SDL_TouchID; #[doc(alias = "SDL_GetNumTouchDevices")] pub fn num_touch_devices() -> i32
#[doc(alias = "SDL_GetTouchDevice")] pub fn touch_device(index: i32) -> TouchDevice { unsafe { sys::SDL_GetTouchDevice(index) } } #[doc(alias = "SDL_GetNumTouchFingers")] pub fn num_touch_fingers(touch: TouchDevice) -> i32 { unsafe { sys::SDL_GetNumTouchFingers(touch) } } #[doc(alias = "SDL_GetTouchFinger")] pub fn touch_finger(touch: TouchDevice, index: i32) -> Option<Finger> { let raw = unsafe { sys::SDL_GetTouchFinger(touch, index) }; if raw.is_null() { None } else { unsafe { Some(*raw) } } }
{ unsafe { sys::SDL_GetNumTouchDevices() } }
identifier_body
mod.rs
af_get_features_score(out: *mut af_array, feat: af_features) -> c_int; fn af_get_features_orientation(out: *mut af_array, feat: af_features) -> c_int; fn af_get_features_size(out: *mut af_array, feat: af_features) -> c_int;
thr: c_float, arc_len: c_uint, non_max: bool, feature_ratio: c_float, edge: c_uint, ) -> c_int; fn af_harris( out: *mut af_features, input: af_array, m: c_uint, r: c_float, s: c_float, bs: c_uint, k: c_float, ) -> c_int; fn af_orb( out: *mut af_features, desc: *mut af_array, arr: af_array, fast_thr: c_float, max_feat: c_uint, scl_fctr: c_float, levels: c_uint, blur_img: bool, ) -> c_int; fn af_hamming_matcher( idx: *mut af_array, dist: *mut af_array, query: af_array, train: af_array, dist_dim: dim_t, n_dist: c_uint, ) -> c_int; fn af_nearest_neighbour( idx: *mut af_array, dist: *mut af_array, q: af_array, t: af_array, dist_dim: dim_t, n_dist: c_uint, dist_type: c_int, ) -> c_int; fn af_match_template( out: *mut af_array, search_img: af_array, template_img: af_array, mtype: c_uint, ) -> c_int; fn af_susan( feat: *mut af_features, i: af_array, r: c_uint, d: c_float, g: c_float, f: c_float, e: c_uint, ) -> c_int; fn af_dog(out: *mut af_array, i: af_array, r1: c_int, r2: c_int) -> c_int; fn af_homography( H: *mut af_array, inliers: *mut c_int, x_src: af_array, y_src: af_array, x_dst: af_array, y_dst: af_array, htype: c_uint, inlier_thr: c_float, iterations: c_uint, otype: c_uint, ) -> c_int; } /// A set of Array objects (usually, used in Computer vision context) /// /// `Features` struct is used by computer vision functions /// to return the outcome of their operation. Typically, such output /// has the following Arrays: /// /// - X positions of the features /// - Y positions of the features /// - Scores of the features /// - Orientations of the features /// - Sizes of the features /// /// ## Sharing Across Threads /// /// While sharing this object with other threads, there is no need to wrap /// this in an Arc object unless only one such object is required to exist. /// The reason being that ArrayFire's internal details that are pointed to /// by the features handle are appropriately reference counted in thread safe /// manner. However, if these features are to be edited, then please do wrap /// the object using a Mutex or Read-Write lock. pub struct Features { feat: af_features, } unsafe impl Send for Features {} unsafe impl Sync for Features {} macro_rules! feat_func_def { ($doc_str: expr, $fn_name: ident, $ffi_name: ident) => { #[doc=$doc_str] pub fn $fn_name(&self) -> Array<f32> { unsafe { let mut temp: af_array = std::ptr::null_mut(); let err_val = $ffi_name(&mut temp as *mut af_array, self.feat); HANDLE_ERROR(AfError::from(err_val)); let temp_array: Array<f32> = temp.into(); let retained = temp_array.clone(); mem::forget(temp_array); retained } } }; } impl Features { /// Create and return an object of type Features /// /// This object is basically a bunch of Arrays. pub fn new(n: u64) -> Self { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_create_features(&mut temp as *mut af_features, n as dim_t); HANDLE_ERROR(AfError::from(err_val)); Self { feat: temp } } } /// Get total number of features found pub fn num_features(&self) -> i64 { let mut temp: i64 = 0; unsafe { let err_val = af_get_features_num( &mut temp as *mut dim_t, self.feat as *const dim_t as af_features, ); HANDLE_ERROR(AfError::from(err_val)); } temp } feat_func_def!("Get x coordinates Array", xpos, af_get_features_xpos); feat_func_def!("Get y coordinates Array", ypos, af_get_features_ypos); feat_func_def!("Get score Array", score, af_get_features_score); feat_func_def!( "Get orientation Array", orientation, af_get_features_orientation ); feat_func_def!("Get features size Array", size, af_get_features_size); } impl Clone for Features { fn clone(&self) -> Self { unsafe { let mut temp: af_features = std::ptr::null_mut(); let ret_val = af_retain_features(&mut temp as *mut af_features, self.feat); HANDLE_ERROR(AfError::from(ret_val)); Self { feat: temp } } } } impl Drop for Features { fn drop(&mut self) { unsafe { let ret_val = af_release_features(self.feat); HANDLE_ERROR(AfError::from(ret_val)); } } } /// Fast feature detector /// /// A circle of radius 3 pixels, translating into a total of 16 pixels, is checked for sequential /// segments of pixels much brighter or much darker than the central one. For a pixel p to be /// considered a feature, there must exist a sequential segment of arc_length pixels in the circle /// around it such that all are greather than (p + thr) or smaller than (p - thr). After all /// features in the image are detected, if nonmax is true, the non-maximal suppression is applied, /// checking all detected features and the features detected in its 8-neighborhood and discard it /// if its score is non maximal. /// /// # Parameters /// /// - `input` - the input image Array /// - `thr` - FAST threshold for which pixel of the circle around the center pixel is considered to /// be greater or smaller /// - `arc_len` - length of arc (or sequential segment) to be tested, must be within range [9-16] /// - `non_max` - performs non-maximal supression if true /// - `feat_ratio` - maximum ratio of features to detect, the maximum number of features is /// calculated by `feature_ratio * num of elements`. The maximum number of features is not based on /// the score, instead, features detected after the limit is reached are discarded. /// - `edge` - is the length of the edges in the image to be discarded by FAST(minimum is 3, as the /// radius of the circle) /// /// # Return Values /// /// This function returns an object of struct [Features](./struct.Features.html) containing Arrays /// for x and y coordinates and score, while array oreientation is set to 0 as FAST does not /// compute orientation. Size is set to 1 as FAST does not compute multiple scales. pub fn fast<T>( input: &Array<T>, thr: f32, arc_len: u32, non_max: bool, feat_ratio: f32, edge: u32, ) -> Features where T: HasAfEnum + ImageFilterType, { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_fast( &mut temp as *mut af_features, input.get(), thr, arc_len, non_max, feat_ratio, edge, ); HANDLE_ERROR(AfError::from(err_val)); Features { feat: temp } } } /// Harris corner detector. /// /// Compute corners using the Harris corner detector approach. For each pixel, a small window is /// used to calculate the determinant and trace of such a window, from which a response is /// calculated. Pixels are considered corners if they are local maximas and have a high positive /// response. /// /// # Parameters /// /// - `input` is the array containing a grayscale image (color images are not supported) /// - `max_corners` is the maximum number of corners to keep, only retains those with highest Harris responses /// - `min_response` is the minimum response in order for a corner to be retained, only used if max_corners = 0 /// - `sigma` is the standard deviation of a circular window (its dimensions will be calculated according to the standard deviation), the covariation matrix will be calculated to a circular neighborhood of this standard deviation (only used when block_size == 0, must be >= 0.5f and <= 5.0f) /// - `block_size` is square window size, the covariation matrix will be calculated to a square neighborhood of this size (must be >= 3 and <= 31) /// - `k_thr` is the Harris constant, usually set empirically to 0.04f (must be >= 0.01f) /// /// # Return Values /// /// This function returns an object of struct [Features](./struct.Features.html) containing Arrays /// for x and y coordinates and score, while array oreientation & size are set to 0 & 1, /// respectively, since harris doesn't compute that information pub fn harris<T>( input: &Array<T>, max_corners: u32, min_response: f32, sigma: f32, block_size: u32, k_thr: f32, ) -> Features where T: HasAfEnum + RealFloating, { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_harris( &mut temp as *mut af_features, input.get(), max_corners, min_response, sigma, block_size, k_thr, ); HANDLE_ERROR(AfError::from(err_val)); Features { feat: temp } } } /// ORB feature descriptor /// /// Extract ORB descriptors from FAST features that hold higher Harris responses. FAST does not /// compute orientation, thus, orientation of features is calculated using the intensity centroid. /// As FAST is also not multi-scale enabled, a multi-scale pyramid is calculated by downsampling /// the input image multiple times followed by FAST feature detection on each scale. /// /// # Parameters /// /// - `input` - the input image Array /// - `fast_thr` - FAST threshold for which a pixel of the circle around the central pixel is /// considered to be brighter or darker /// - `max_feat` - maximum number of features to hold /// - `scl_fctr` - factor to downsample the input image, meaning that each level with hold prior /// level dimensions divided by `scl_fctr` /// - `levels` - number of levels to be computed for the image pyramid /// - `blur_img` - blur image with a Gaussian filter with sigma=2 before computing descriptors to /// increase robustness against noise if true /// /// # Return Values /// /// This function returns a tuple of [`Features`](./struct.Features.html) and [`Array`](./struct.Array.html). The features objects composed of Arrays for x and y coordinates, score, orientation and size of selected features. The Array object is a two dimensional Array of size Nx8 where N is number of selected features. pub fn orb<T>( input: &Array<T>, fast_thr: f32, max_feat: u32, scl_fctr: f32, levels: u32, blur_img: bool, ) -> (Features, Array<T>) where T: HasAfEnum + RealFloating, { unsafe { let mut f: af_features = std::ptr::null_mut(); let mut d: af_array = std::ptr::null_mut(); let err_val = af_orb( &mut f as *mut af_features, &mut d as *mut af_array, input.get(), fast_thr, max_feat, scl_fctr, levels, blur_img, ); HANDLE_ERROR(AfError::from(err_val)); (Features { feat: f }, d.into()) } } /// Hamming feature matcher /// /// Calculates Hamming distances between two 2-dimensional arrays containing features, one of the /// arrays containing the training data and the other the query data. One of the dimensions of the /// both arrays must be equal among them, identifying the length of each feature. The other /// dimension indicates the total number of features in each of the training and query arrays. Two /// 1-dimensional arrays are created as results, one containg the smallest N distances of the query /// array and another containing the indices of these distances in the training array. The /// resulting 1-dimensional arrays have length equal to the number of features contained in the /// query array. /// /// # Parameters /// /// - `query` - Array containing the data to be queried /// - `train` - Array containing the data to be used as training data /// - `dist_dims` - indicates the dimension to analyze for distance (the dimension indicated here /// must be of equal length for both query and train arrays) /// - `n_dist` - is the number of smallest distances to return (currently, only values <= 256 are supported) /// /// /// # Return Values /// /// This function returns a tuple of [Array](./struct.Array.html)'s. /// /// First Array is an array of MxN size, where M is equal to the number of query features and N is /// equal to n_dist. The value at position IxJ indicates the index of the Jth smallest distance to /// the Ith query value in the train data array. the index of the Ith smallest distance of the Mth /// query. /// /// Second Array is an array of MxN size, where M is equal to the number of query features and N is /// equal to n_dist. The value at position IxJ indicates the Hamming distance of the Jth smallest /// distance to the Ith query value in the train data array. pub fn hamming_matcher<T>( query: &Array<T>, train: &Array<T>, dist_dims: i64, n_dist: u32, ) -> (Array<u32>, Array<T::AggregateOutType>) where T: HasAfEnum + ImageFilterType, T::AggregateOutType: HasAfEnum, { unsafe { let mut idx: af_array = std::ptr::null_mut(); let mut dist: af_array = std::ptr::null_mut(); let err_val = af_hamming_matcher( &mut idx as *mut af_array, &mut dist as *mut af_array, query.get(), train.get(), dist_dims, n_dist, ); HANDLE_ERROR(AfError::from(err_val)); (idx.into(), dist.into()) } } /// Nearest Neighbour. /// /// Calculates nearest distances between two 2-dimensional arrays containing features based on the /// type of distance computation chosen. Currently, AF_SAD (sum of absolute differences), AF_SSD /// (sum of squared differences) and AF_SHD (hamming distance) are supported. One of the arrays /// containing the training data and the other the query data. One of the dimensions of the both /// arrays must be equal among them, identifying the length of each feature. The other dimension /// indicates the total number of features in each of the training and query arrays. Two /// 1-dimensional arrays are created as results, one containg the smallest N distances of the query /// array and another containing the indices of these distances in the training array. The resulting /// 1-dimensional arrays have length equal to the number of features contained in the query array. /// /// # Parameters /// /// - `query` is the array containing the data to be queried /// - `train` is the array containing the data used as training data /// - `dist_dim` indicates the dimension to analyze for distance (the dimension indicated here must be of equal length for both query and train arrays) /// - `n_dist` is the number of smallest distances to return (currently, only values <= 256 are supported) /// - `dist_type` is the distance computation type. Currently [`MatchType::SAD`](./enum.MatchType.html), [`MatchType::SSD`](./enum.MatchType.html), and [`MatchType::SHD`](./enum.MatchType.html) are supported. /// /// # Return Values /// /// A tuple of Arrays. /// /// The first Array is is an array of MxN size, where M is equal to the number of query features /// and N is equal to `n_dist`. The value at position IxJ indicates the index of the Jth smallest /// distance to the Ith query value in the train data array. the index of the Ith smallest distance /// of the Mth query. /// /// The second Array is is an array of MxN size, where M is equal to the number of query features /// and N is equal to `n_dist`. The value at position IxJ indicates the distance of the Jth smallest /// distance to the Ith query value in the train data array based on the `dist_type` chosen. pub fn nearest_neighbour<T>( query: &Array<T>, train: &Array<T>, dist_dim: i64, n_dist: u32, dist_type: MatchType, ) -> (Array<u32>, Array<T::AggregateOutType>) where T: HasAfEnum + ImageFilterType, T::AggregateOutType: HasAfEnum, { unsafe { let mut idx: af_array = std::ptr::null_mut(); let mut dist: af_array = std::ptr::null_mut(); let err_val = af_nearest_neighbour( &mut idx as *mut af_array, &mut dist as *mut af_array, query.get(), train.get(), dist_dim, n_dist, dist_type as c_int, ); HANDLE_ERROR(AfError::from(err_val)); (idx.into(), dist.into()) } } /// Image matching /// /// Template matching is an image processing technique to find small patches of an image which /// match a given template image. A more in depth discussion on the topic can be found /// [here](https://en.wikipedia.org/wiki/Template_matching). /// /// # Parameters /// /// - `search_img` is an array with image data /// - `template_img` is the template we are looking for in the image /// - `mtype` is metric that should be used to calculate the disparity between window in the image and the template image. It can be one of the values defined by the enum [MatchType](./enum.MatchType.html). /// # Return Values /// /// This function returns an Array with disparity values for the window starting at corresponding pixel position. pub fn match_template<T>( search_img: &Array<T>, template_img: &Array<T>, mtype: MatchType, ) -> Array<T::AbsOutType> where T: HasAfEnum + ImageFilterType, T::AbsOutType: HasAfEnum, { unsafe { let mut temp: af_array = std::ptr::null_mut(); let err_val = af_match_template( &mut temp as *mut af_array, search_img.get(), template_img.get(), mtype as c_uint, ); HANDLE_ERROR(AfError::from(err_val)); temp.into() } } /// SUSAN corner detector. /// /// SUSAN is an acronym standing for Smallest Univalue Segment Assimilating Nucleus. This method /// places a circular disc over the pixel to be tested (a.k.a nucleus) to compute the corner /// measure of that corresponding pixel. The region covered by the circular disc is M, and a pixel /// in this region is represented by m⃗ ∈M where m⃗ 0 is the nucleus. Every pixel in the region is /// compared to the nucleus using the following comparison function: /// /// c(m⃗ )=e^−((I(m⃗)−I(m⃗_0))/t)^6 /// /// where t is radius of the region, I is the brightness of the pixel. /// /// Response of SUSAN operator is given by the following equation: /// /// R(M) = g−n(M) if n(M) < g /// /// R(M) = 0 otherwise, /// /// where n(M)=∑c(m⃗) m⃗∈M, g is named the geometric threshold and n is the number of pixels in the /// mask which are within t of the nucleus. /// /// Importance of the parameters, t and g is explained below: /// /// - t determines how similar points have to be to the nucleusbefore they are considered to be a /// part of the univalue segment /// - g determines the minimum size of the univalue segment. For a large enough g, SUSAN operator /// becomes an edge dectector. /// /// # Parameters /// /// - `input` is input grayscale/intensity image /// - `radius` is the nucleus radius for each pixel neighborhood /// - `diff_thr` is intensity difference threshold a.k.a **t** from equations in description /// - `geom_thr` is the geometric threshold /// - `feature_ratio` is maximum number of features that will be returned by the function /// - `edge` indicates how many pixels width area should be skipped for corner detection /// /// # Return Values /// An object of type [Features](./struct.Features.html) composed of arrays for x and y coordinates, score, orientation and size of selected features. pub fn susan<T>( input: &Array<T>, radius: u32, diff_thr: f32, geom_thr: f32, feature_ratio: f32, edge: u32, ) -> Features where T: HasAfEnum + ImageFilterType, { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_susan( &mut temp as *mut af_features, input.get(), radius, diff_thr, geom_thr, feature_ratio, edge, ); HANDLE_ERROR(AfError::from(err_val)); Features { feat: temp } } } /// Difference of Gaussians. /// /// Given an image, this function computes two different versions of smoothed input image using the /// difference smoothing parameters and subtracts one from the other and returns the result. /// /// # Parameters /// /// - `input` is the input image /// - `radius1` is the radius of the first gaussian kernel /// - `radius2` is the radius of the second gaussian kernel /// /// # Return Values /// /// Difference of smoothed inputs - An Array. pub fn dog<T>(input: &Array<T>, radius1: i32, radius2: i32) -> Array<T::AbsOutType> where T: HasAfEnum + ImageFilterType, T::AbsOutType: HasAfEnum, { unsafe { let mut temp: af_array = std::ptr::null_mut(); let err_val = af_dog(&mut temp as *mut af_array, input.get(), radius1, radius2); HANDLE_ERROR(AfError::from(err_val)); temp.into() } } /// Homography estimation /// /// Homography estimation find a perspective transform between two sets of 2D points. /// Currently, two methods are supported for the estimation, RANSAC (RANdom SAmple Consensus) /// and LMedS (Least Median of Squares). Both methods work by randomly selecting a subset /// of 4 points of the set of source points, computing the eigenvectors of that set and /// finding the perspective transform. The process is repeated several times, a maximum of /// times given by the value passed to the iterations arguments for RANSAC (for the CPU /// backend, usually less than that, depending on the quality of the dataset, but for CUDA /// and OpenCL backends the transformation will be computed exactly the amount of times /// passed via the iterations parameter), the returned value is the one that matches the /// best number of inliers, which are all of the points that fall within a maximum L2 /// distance from the value passed to the inlier_thr argument. /// /// # Parameters /// /// - `x_src` is the x coordinates of the source points. /// - `y_src` is the y coordinates of the source points. /// - `x_dst` is the x coordinates of the destination points. /// - `y_dst` is the y coordinates of the destination points. /// - `htype` can be AF_HOMOGRAPHY_RANSAC, for which a RANdom SAmple Consensus will be used to evaluate the homography quality (e.g., number of inliers), or AF_HOMOGRAPHY_LMEDS, which will use Least Median of Squares method to evaluate homography quality /// - `inlier_thr` - if htype is AF_HOMOGRAPHY_RANSAC
fn af_release_features(feat: af_features) -> c_int; fn af_fast( out: *mut af_features, input: af_array,
random_line_split
mod.rs
_get_features_score(out: *mut af_array, feat: af_features) -> c_int; fn af_get_features_orientation(out: *mut af_array, feat: af_features) -> c_int; fn af_get_features_size(out: *mut af_array, feat: af_features) -> c_int; fn af_release_features(feat: af_features) -> c_int; fn af_fast( out: *mut af_features, input: af_array, thr: c_float, arc_len: c_uint, non_max: bool, feature_ratio: c_float, edge: c_uint, ) -> c_int; fn af_harris( out: *mut af_features, input: af_array, m: c_uint, r: c_float, s: c_float, bs: c_uint, k: c_float, ) -> c_int; fn af_orb( out: *mut af_features, desc: *mut af_array, arr: af_array, fast_thr: c_float, max_feat: c_uint, scl_fctr: c_float, levels: c_uint, blur_img: bool, ) -> c_int; fn af_hamming_matcher( idx: *mut af_array, dist: *mut af_array, query: af_array, train: af_array, dist_dim: dim_t, n_dist: c_uint, ) -> c_int; fn af_nearest_neighbour( idx: *mut af_array, dist: *mut af_array, q: af_array, t: af_array, dist_dim: dim_t, n_dist: c_uint, dist_type: c_int, ) -> c_int; fn af_match_template( out: *mut af_array, search_img: af_array, template_img: af_array, mtype: c_uint, ) -> c_int; fn af_susan( feat: *mut af_features, i: af_array, r: c_uint, d: c_float, g: c_float, f: c_float, e: c_uint, ) -> c_int; fn af_dog(out: *mut af_array, i: af_array, r1: c_int, r2: c_int) -> c_int; fn af_homography( H: *mut af_array, inliers: *mut c_int, x_src: af_array, y_src: af_array, x_dst: af_array, y_dst: af_array, htype: c_uint, inlier_thr: c_float, iterations: c_uint, otype: c_uint, ) -> c_int; } /// A set of Array objects (usually, used in Computer vision context) /// /// `Features` struct is used by computer vision functions /// to return the outcome of their operation. Typically, such output /// has the following Arrays: /// /// - X positions of the features /// - Y positions of the features /// - Scores of the features /// - Orientations of the features /// - Sizes of the features /// /// ## Sharing Across Threads /// /// While sharing this object with other threads, there is no need to wrap /// this in an Arc object unless only one such object is required to exist. /// The reason being that ArrayFire's internal details that are pointed to /// by the features handle are appropriately reference counted in thread safe /// manner. However, if these features are to be edited, then please do wrap /// the object using a Mutex or Read-Write lock. pub struct Features { feat: af_features, } unsafe impl Send for Features {} unsafe impl Sync for Features {} macro_rules! feat_func_def { ($doc_str: expr, $fn_name: ident, $ffi_name: ident) => { #[doc=$doc_str] pub fn $fn_name(&self) -> Array<f32> { unsafe { let mut temp: af_array = std::ptr::null_mut(); let err_val = $ffi_name(&mut temp as *mut af_array, self.feat); HANDLE_ERROR(AfError::from(err_val)); let temp_array: Array<f32> = temp.into(); let retained = temp_array.clone(); mem::forget(temp_array); retained } } }; } impl Features { /// Create and return an object of type Features /// /// This object is basically a bunch of Arrays. pub fn new(n: u64) -> Self { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_create_features(&mut temp as *mut af_features, n as dim_t); HANDLE_ERROR(AfError::from(err_val)); Self { feat: temp } } } /// Get total number of features found pub fn num_features(&self) -> i64 { let mut temp: i64 = 0; unsafe { let err_val = af_get_features_num( &mut temp as *mut dim_t, self.feat as *const dim_t as af_features, ); HANDLE_ERROR(AfError::from(err_val)); } temp } feat_func_def!("Get x coordinates Array", xpos, af_get_features_xpos); feat_func_def!("Get y coordinates Array", ypos, af_get_features_ypos); feat_func_def!("Get score Array", score, af_get_features_score); feat_func_def!( "Get orientation Array", orientation, af_get_features_orientation ); feat_func_def!("Get features size Array", size, af_get_features_size); } impl Clone for Features { fn clone(&self) -> Self { unsafe { let mut temp: af_features = std::ptr::null_mut(); let ret_val = af_retain_features(&mut temp as *mut af_features, self.feat); HANDLE_ERROR(AfError::from(ret_val)); Self { feat: temp } } } } impl Drop for Features { fn drop(&mut self) { unsafe { let ret_val = af_release_features(self.feat); HANDLE_ERROR(AfError::from(ret_val)); } } } /// Fast feature detector /// /// A circle of radius 3 pixels, translating into a total of 16 pixels, is checked for sequential /// segments of pixels much brighter or much darker than the central one. For a pixel p to be /// considered a feature, there must exist a sequential segment of arc_length pixels in the circle /// around it such that all are greather than (p + thr) or smaller than (p - thr). After all /// features in the image are detected, if nonmax is true, the non-maximal suppression is applied, /// checking all detected features and the features detected in its 8-neighborhood and discard it /// if its score is non maximal. /// /// # Parameters /// /// - `input` - the input image Array /// - `thr` - FAST threshold for which pixel of the circle around the center pixel is considered to /// be greater or smaller /// - `arc_len` - length of arc (or sequential segment) to be tested, must be within range [9-16] /// - `non_max` - performs non-maximal supression if true /// - `feat_ratio` - maximum ratio of features to detect, the maximum number of features is /// calculated by `feature_ratio * num of elements`. The maximum number of features is not based on /// the score, instead, features detected after the limit is reached are discarded. /// - `edge` - is the length of the edges in the image to be discarded by FAST(minimum is 3, as the /// radius of the circle) /// /// # Return Values /// /// This function returns an object of struct [Features](./struct.Features.html) containing Arrays /// for x and y coordinates and score, while array oreientation is set to 0 as FAST does not /// compute orientation. Size is set to 1 as FAST does not compute multiple scales. pub fn fast<T>( input: &Array<T>, thr: f32, arc_len: u32, non_max: bool, feat_ratio: f32, edge: u32, ) -> Features where T: HasAfEnum + ImageFilterType, { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_fast( &mut temp as *mut af_features, input.get(), thr, arc_len, non_max, feat_ratio, edge, ); HANDLE_ERROR(AfError::from(err_val)); Features { feat: temp } } } /// Harris corner detector. /// /// Compute corners using the Harris corner detector approach. For each pixel, a small window is /// used to calculate the determinant and trace of such a window, from which a response is /// calculated. Pixels are considered corners if they are local maximas and have a high positive /// response. /// /// # Parameters /// /// - `input` is the array containing a grayscale image (color images are not supported) /// - `max_corners` is the maximum number of corners to keep, only retains those with highest Harris responses /// - `min_response` is the minimum response in order for a corner to be retained, only used if max_corners = 0 /// - `sigma` is the standard deviation of a circular window (its dimensions will be calculated according to the standard deviation), the covariation matrix will be calculated to a circular neighborhood of this standard deviation (only used when block_size == 0, must be >= 0.5f and <= 5.0f) /// - `block_size` is square window size, the covariation matrix will be calculated to a square neighborhood of this size (must be >= 3 and <= 31) /// - `k_thr` is the Harris constant, usually set empirically to 0.04f (must be >= 0.01f) /// /// # Return Values /// /// This function returns an object of struct [Features](./struct.Features.html) containing Arrays /// for x and y coordinates and score, while array oreientation & size are set to 0 & 1, /// respectively, since harris doesn't compute that information pub fn harris<T>( input: &Array<T>, max_corners: u32, min_response: f32, sigma: f32, block_size: u32, k_thr: f32, ) -> Features where T: HasAfEnum + RealFloating, { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_harris( &mut temp as *mut af_features, input.get(), max_corners, min_response, sigma, block_size, k_thr, ); HANDLE_ERROR(AfError::from(err_val)); Features { feat: temp } } } /// ORB feature descriptor /// /// Extract ORB descriptors from FAST features that hold higher Harris responses. FAST does not /// compute orientation, thus, orientation of features is calculated using the intensity centroid. /// As FAST is also not multi-scale enabled, a multi-scale pyramid is calculated by downsampling /// the input image multiple times followed by FAST feature detection on each scale. /// /// # Parameters /// /// - `input` - the input image Array /// - `fast_thr` - FAST threshold for which a pixel of the circle around the central pixel is /// considered to be brighter or darker /// - `max_feat` - maximum number of features to hold /// - `scl_fctr` - factor to downsample the input image, meaning that each level with hold prior /// level dimensions divided by `scl_fctr` /// - `levels` - number of levels to be computed for the image pyramid /// - `blur_img` - blur image with a Gaussian filter with sigma=2 before computing descriptors to /// increase robustness against noise if true /// /// # Return Values /// /// This function returns a tuple of [`Features`](./struct.Features.html) and [`Array`](./struct.Array.html). The features objects composed of Arrays for x and y coordinates, score, orientation and size of selected features. The Array object is a two dimensional Array of size Nx8 where N is number of selected features. pub fn orb<T>( input: &Array<T>, fast_thr: f32, max_feat: u32, scl_fctr: f32, levels: u32, blur_img: bool, ) -> (Features, Array<T>) where T: HasAfEnum + RealFloating, { unsafe { let mut f: af_features = std::ptr::null_mut(); let mut d: af_array = std::ptr::null_mut(); let err_val = af_orb( &mut f as *mut af_features, &mut d as *mut af_array, input.get(), fast_thr, max_feat, scl_fctr, levels, blur_img, ); HANDLE_ERROR(AfError::from(err_val)); (Features { feat: f }, d.into()) } } /// Hamming feature matcher /// /// Calculates Hamming distances between two 2-dimensional arrays containing features, one of the /// arrays containing the training data and the other the query data. One of the dimensions of the /// both arrays must be equal among them, identifying the length of each feature. The other /// dimension indicates the total number of features in each of the training and query arrays. Two /// 1-dimensional arrays are created as results, one containg the smallest N distances of the query /// array and another containing the indices of these distances in the training array. The /// resulting 1-dimensional arrays have length equal to the number of features contained in the /// query array. /// /// # Parameters /// /// - `query` - Array containing the data to be queried /// - `train` - Array containing the data to be used as training data /// - `dist_dims` - indicates the dimension to analyze for distance (the dimension indicated here /// must be of equal length for both query and train arrays) /// - `n_dist` - is the number of smallest distances to return (currently, only values <= 256 are supported) /// /// /// # Return Values /// /// This function returns a tuple of [Array](./struct.Array.html)'s. /// /// First Array is an array of MxN size, where M is equal to the number of query features and N is /// equal to n_dist. The value at position IxJ indicates the index of the Jth smallest distance to /// the Ith query value in the train data array. the index of the Ith smallest distance of the Mth /// query. /// /// Second Array is an array of MxN size, where M is equal to the number of query features and N is /// equal to n_dist. The value at position IxJ indicates the Hamming distance of the Jth smallest /// distance to the Ith query value in the train data array. pub fn hamming_matcher<T>( query: &Array<T>, train: &Array<T>, dist_dims: i64, n_dist: u32, ) -> (Array<u32>, Array<T::AggregateOutType>) where T: HasAfEnum + ImageFilterType, T::AggregateOutType: HasAfEnum, { unsafe { let mut idx: af_array = std::ptr::null_mut(); let mut dist: af_array = std::ptr::null_mut(); let err_val = af_hamming_matcher( &mut idx as *mut af_array, &mut dist as *mut af_array, query.get(), train.get(), dist_dims, n_dist, ); HANDLE_ERROR(AfError::from(err_val)); (idx.into(), dist.into()) } } /// Nearest Neighbour. /// /// Calculates nearest distances between two 2-dimensional arrays containing features based on the /// type of distance computation chosen. Currently, AF_SAD (sum of absolute differences), AF_SSD /// (sum of squared differences) and AF_SHD (hamming distance) are supported. One of the arrays /// containing the training data and the other the query data. One of the dimensions of the both /// arrays must be equal among them, identifying the length of each feature. The other dimension /// indicates the total number of features in each of the training and query arrays. Two /// 1-dimensional arrays are created as results, one containg the smallest N distances of the query /// array and another containing the indices of these distances in the training array. The resulting /// 1-dimensional arrays have length equal to the number of features contained in the query array. /// /// # Parameters /// /// - `query` is the array containing the data to be queried /// - `train` is the array containing the data used as training data /// - `dist_dim` indicates the dimension to analyze for distance (the dimension indicated here must be of equal length for both query and train arrays) /// - `n_dist` is the number of smallest distances to return (currently, only values <= 256 are supported) /// - `dist_type` is the distance computation type. Currently [`MatchType::SAD`](./enum.MatchType.html), [`MatchType::SSD`](./enum.MatchType.html), and [`MatchType::SHD`](./enum.MatchType.html) are supported. /// /// # Return Values /// /// A tuple of Arrays. /// /// The first Array is is an array of MxN size, where M is equal to the number of query features /// and N is equal to `n_dist`. The value at position IxJ indicates the index of the Jth smallest /// distance to the Ith query value in the train data array. the index of the Ith smallest distance /// of the Mth query. /// /// The second Array is is an array of MxN size, where M is equal to the number of query features /// and N is equal to `n_dist`. The value at position IxJ indicates the distance of the Jth smallest /// distance to the Ith query value in the train data array based on the `dist_type` chosen. pub fn nearest_neighbour<T>( query: &Array<T>, train: &Array<T>, dist_dim: i64, n_dist: u32, dist_type: MatchType, ) -> (Array<u32>, Array<T::AggregateOutType>) where T: HasAfEnum + ImageFilterType, T::AggregateOutType: HasAfEnum, { unsafe { let mut idx: af_array = std::ptr::null_mut(); let mut dist: af_array = std::ptr::null_mut(); let err_val = af_nearest_neighbour( &mut idx as *mut af_array, &mut dist as *mut af_array, query.get(), train.get(), dist_dim, n_dist, dist_type as c_int, ); HANDLE_ERROR(AfError::from(err_val)); (idx.into(), dist.into()) } } /// Image matching /// /// Template matching is an image processing technique to find small patches of an image which /// match a given template image. A more in depth discussion on the topic can be found /// [here](https://en.wikipedia.org/wiki/Template_matching). /// /// # Parameters /// /// - `search_img` is an array with image data /// - `template_img` is the template we are looking for in the image /// - `mtype` is metric that should be used to calculate the disparity between window in the image and the template image. It can be one of the values defined by the enum [MatchType](./enum.MatchType.html). /// # Return Values /// /// This function returns an Array with disparity values for the window starting at corresponding pixel position. pub fn match_template<T>( search_img: &Array<T>, template_img: &Array<T>, mtype: MatchType, ) -> Array<T::AbsOutType> where T: HasAfEnum + ImageFilterType, T::AbsOutType: HasAfEnum,
/// SUSAN corner detector. /// /// SUSAN is an acronym standing for Smallest Univalue Segment Assimilating Nucleus. This method /// places a circular disc over the pixel to be tested (a.k.a nucleus) to compute the corner /// measure of that corresponding pixel. The region covered by the circular disc is M, and a pixel /// in this region is represented by m⃗ ∈M where m⃗ 0 is the nucleus. Every pixel in the region is /// compared to the nucleus using the following comparison function: /// /// c(m⃗ )=e^−((I(m⃗)−I(m⃗_0))/t)^6 /// /// where t is radius of the region, I is the brightness of the pixel. /// /// Response of SUSAN operator is given by the following equation: /// /// R(M) = g−n(M) if n(M) < g /// /// R(M) = 0 otherwise, /// /// where n(M)=∑c(m⃗) m⃗∈M, g is named the geometric threshold and n is the number of pixels in the /// mask which are within t of the nucleus. /// /// Importance of the parameters, t and g is explained below: /// /// - t determines how similar points have to be to the nucleusbefore they are considered to be a /// part of the univalue segment /// - g determines the minimum size of the univalue segment. For a large enough g, SUSAN operator /// becomes an edge dectector. /// /// # Parameters /// /// - `input` is input grayscale/intensity image /// - `radius` is the nucleus radius for each pixel neighborhood /// - `diff_thr` is intensity difference threshold a.k.a **t** from equations in description /// - `geom_thr` is the geometric threshold /// - `feature_ratio` is maximum number of features that will be returned by the function /// - `edge` indicates how many pixels width area should be skipped for corner detection /// /// # Return Values /// An object of type [Features](./struct.Features.html) composed of arrays for x and y coordinates, score, orientation and size of selected features. pub fn susan<T>( input: &Array<T>, radius: u32, diff_thr: f32, geom_thr: f32, feature_ratio: f32, edge: u32, ) -> Features where T: HasAfEnum + ImageFilterType, { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_susan( &mut temp as *mut af_features, input.get(), radius, diff_thr, geom_thr, feature_ratio, edge, ); HANDLE_ERROR(AfError::from(err_val)); Features { feat: temp } } } /// Difference of Gaussians. /// /// Given an image, this function computes two different versions of smoothed input image using the /// difference smoothing parameters and subtracts one from the other and returns the result. /// /// # Parameters /// /// - `input` is the input image /// - `radius1` is the radius of the first gaussian kernel /// - `radius2` is the radius of the second gaussian kernel /// /// # Return Values /// /// Difference of smoothed inputs - An Array. pub fn dog<T>(input: &Array<T>, radius1: i32, radius2: i32) -> Array<T::AbsOutType> where T: HasAfEnum + ImageFilterType, T::AbsOutType: HasAfEnum, { unsafe { let mut temp: af_array = std::ptr::null_mut(); let err_val = af_dog(&mut temp as *mut af_array, input.get(), radius1, radius2); HANDLE_ERROR(AfError::from(err_val)); temp.into() } } /// Homography estimation /// /// Homography estimation find a perspective transform between two sets of 2D points. /// Currently, two methods are supported for the estimation, RANSAC (RANdom SAmple Consensus) /// and LMedS (Least Median of Squares). Both methods work by randomly selecting a subset /// of 4 points of the set of source points, computing the eigenvectors of that set and /// finding the perspective transform. The process is repeated several times, a maximum of /// times given by the value passed to the iterations arguments for RANSAC (for the CPU /// backend, usually less than that, depending on the quality of the dataset, but for CUDA /// and OpenCL backends the transformation will be computed exactly the amount of times /// passed via the iterations parameter), the returned value is the one that matches the /// best number of inliers, which are all of the points that fall within a maximum L2 /// distance from the value passed to the inlier_thr argument. /// /// # Parameters /// /// - `x_src` is the x coordinates of the source points. /// - `y_src` is the y coordinates of the source points. /// - `x_dst` is the x coordinates of the destination points. /// - `y_dst` is the y coordinates of the destination points. /// - `htype` can be AF_HOMOGRAPHY_RANSAC, for which a RANdom SAmple Consensus will be used to evaluate the homography quality (e.g., number of inliers), or AF_HOMOGRAPHY_LMEDS, which will use Least Median of Squares method to evaluate homography quality /// - `inlier_thr` - if htype is AF_HOMOGRAPHY_RAN
{ unsafe { let mut temp: af_array = std::ptr::null_mut(); let err_val = af_match_template( &mut temp as *mut af_array, search_img.get(), template_img.get(), mtype as c_uint, ); HANDLE_ERROR(AfError::from(err_val)); temp.into() } }
identifier_body
mod.rs
get_features_score(out: *mut af_array, feat: af_features) -> c_int; fn af_get_features_orientation(out: *mut af_array, feat: af_features) -> c_int; fn af_get_features_size(out: *mut af_array, feat: af_features) -> c_int; fn af_release_features(feat: af_features) -> c_int; fn af_fast( out: *mut af_features, input: af_array, thr: c_float, arc_len: c_uint, non_max: bool, feature_ratio: c_float, edge: c_uint, ) -> c_int; fn af_harris( out: *mut af_features, input: af_array, m: c_uint, r: c_float, s: c_float, bs: c_uint, k: c_float, ) -> c_int; fn af_orb( out: *mut af_features, desc: *mut af_array, arr: af_array, fast_thr: c_float, max_feat: c_uint, scl_fctr: c_float, levels: c_uint, blur_img: bool, ) -> c_int; fn af_hamming_matcher( idx: *mut af_array, dist: *mut af_array, query: af_array, train: af_array, dist_dim: dim_t, n_dist: c_uint, ) -> c_int; fn af_nearest_neighbour( idx: *mut af_array, dist: *mut af_array, q: af_array, t: af_array, dist_dim: dim_t, n_dist: c_uint, dist_type: c_int, ) -> c_int; fn af_match_template( out: *mut af_array, search_img: af_array, template_img: af_array, mtype: c_uint, ) -> c_int; fn af_susan( feat: *mut af_features, i: af_array, r: c_uint, d: c_float, g: c_float, f: c_float, e: c_uint, ) -> c_int; fn af_dog(out: *mut af_array, i: af_array, r1: c_int, r2: c_int) -> c_int; fn af_homography( H: *mut af_array, inliers: *mut c_int, x_src: af_array, y_src: af_array, x_dst: af_array, y_dst: af_array, htype: c_uint, inlier_thr: c_float, iterations: c_uint, otype: c_uint, ) -> c_int; } /// A set of Array objects (usually, used in Computer vision context) /// /// `Features` struct is used by computer vision functions /// to return the outcome of their operation. Typically, such output /// has the following Arrays: /// /// - X positions of the features /// - Y positions of the features /// - Scores of the features /// - Orientations of the features /// - Sizes of the features /// /// ## Sharing Across Threads /// /// While sharing this object with other threads, there is no need to wrap /// this in an Arc object unless only one such object is required to exist. /// The reason being that ArrayFire's internal details that are pointed to /// by the features handle are appropriately reference counted in thread safe /// manner. However, if these features are to be edited, then please do wrap /// the object using a Mutex or Read-Write lock. pub struct Features { feat: af_features, } unsafe impl Send for Features {} unsafe impl Sync for Features {} macro_rules! feat_func_def { ($doc_str: expr, $fn_name: ident, $ffi_name: ident) => { #[doc=$doc_str] pub fn $fn_name(&self) -> Array<f32> { unsafe { let mut temp: af_array = std::ptr::null_mut(); let err_val = $ffi_name(&mut temp as *mut af_array, self.feat); HANDLE_ERROR(AfError::from(err_val)); let temp_array: Array<f32> = temp.into(); let retained = temp_array.clone(); mem::forget(temp_array); retained } } }; } impl Features { /// Create and return an object of type Features /// /// This object is basically a bunch of Arrays. pub fn new(n: u64) -> Self { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_create_features(&mut temp as *mut af_features, n as dim_t); HANDLE_ERROR(AfError::from(err_val)); Self { feat: temp } } } /// Get total number of features found pub fn num_features(&self) -> i64 { let mut temp: i64 = 0; unsafe { let err_val = af_get_features_num( &mut temp as *mut dim_t, self.feat as *const dim_t as af_features, ); HANDLE_ERROR(AfError::from(err_val)); } temp } feat_func_def!("Get x coordinates Array", xpos, af_get_features_xpos); feat_func_def!("Get y coordinates Array", ypos, af_get_features_ypos); feat_func_def!("Get score Array", score, af_get_features_score); feat_func_def!( "Get orientation Array", orientation, af_get_features_orientation ); feat_func_def!("Get features size Array", size, af_get_features_size); } impl Clone for Features { fn clone(&self) -> Self { unsafe { let mut temp: af_features = std::ptr::null_mut(); let ret_val = af_retain_features(&mut temp as *mut af_features, self.feat); HANDLE_ERROR(AfError::from(ret_val)); Self { feat: temp } } } } impl Drop for Features { fn drop(&mut self) { unsafe { let ret_val = af_release_features(self.feat); HANDLE_ERROR(AfError::from(ret_val)); } } } /// Fast feature detector /// /// A circle of radius 3 pixels, translating into a total of 16 pixels, is checked for sequential /// segments of pixels much brighter or much darker than the central one. For a pixel p to be /// considered a feature, there must exist a sequential segment of arc_length pixels in the circle /// around it such that all are greather than (p + thr) or smaller than (p - thr). After all /// features in the image are detected, if nonmax is true, the non-maximal suppression is applied, /// checking all detected features and the features detected in its 8-neighborhood and discard it /// if its score is non maximal. /// /// # Parameters /// /// - `input` - the input image Array /// - `thr` - FAST threshold for which pixel of the circle around the center pixel is considered to /// be greater or smaller /// - `arc_len` - length of arc (or sequential segment) to be tested, must be within range [9-16] /// - `non_max` - performs non-maximal supression if true /// - `feat_ratio` - maximum ratio of features to detect, the maximum number of features is /// calculated by `feature_ratio * num of elements`. The maximum number of features is not based on /// the score, instead, features detected after the limit is reached are discarded. /// - `edge` - is the length of the edges in the image to be discarded by FAST(minimum is 3, as the /// radius of the circle) /// /// # Return Values /// /// This function returns an object of struct [Features](./struct.Features.html) containing Arrays /// for x and y coordinates and score, while array oreientation is set to 0 as FAST does not /// compute orientation. Size is set to 1 as FAST does not compute multiple scales. pub fn
<T>( input: &Array<T>, thr: f32, arc_len: u32, non_max: bool, feat_ratio: f32, edge: u32, ) -> Features where T: HasAfEnum + ImageFilterType, { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_fast( &mut temp as *mut af_features, input.get(), thr, arc_len, non_max, feat_ratio, edge, ); HANDLE_ERROR(AfError::from(err_val)); Features { feat: temp } } } /// Harris corner detector. /// /// Compute corners using the Harris corner detector approach. For each pixel, a small window is /// used to calculate the determinant and trace of such a window, from which a response is /// calculated. Pixels are considered corners if they are local maximas and have a high positive /// response. /// /// # Parameters /// /// - `input` is the array containing a grayscale image (color images are not supported) /// - `max_corners` is the maximum number of corners to keep, only retains those with highest Harris responses /// - `min_response` is the minimum response in order for a corner to be retained, only used if max_corners = 0 /// - `sigma` is the standard deviation of a circular window (its dimensions will be calculated according to the standard deviation), the covariation matrix will be calculated to a circular neighborhood of this standard deviation (only used when block_size == 0, must be >= 0.5f and <= 5.0f) /// - `block_size` is square window size, the covariation matrix will be calculated to a square neighborhood of this size (must be >= 3 and <= 31) /// - `k_thr` is the Harris constant, usually set empirically to 0.04f (must be >= 0.01f) /// /// # Return Values /// /// This function returns an object of struct [Features](./struct.Features.html) containing Arrays /// for x and y coordinates and score, while array oreientation & size are set to 0 & 1, /// respectively, since harris doesn't compute that information pub fn harris<T>( input: &Array<T>, max_corners: u32, min_response: f32, sigma: f32, block_size: u32, k_thr: f32, ) -> Features where T: HasAfEnum + RealFloating, { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_harris( &mut temp as *mut af_features, input.get(), max_corners, min_response, sigma, block_size, k_thr, ); HANDLE_ERROR(AfError::from(err_val)); Features { feat: temp } } } /// ORB feature descriptor /// /// Extract ORB descriptors from FAST features that hold higher Harris responses. FAST does not /// compute orientation, thus, orientation of features is calculated using the intensity centroid. /// As FAST is also not multi-scale enabled, a multi-scale pyramid is calculated by downsampling /// the input image multiple times followed by FAST feature detection on each scale. /// /// # Parameters /// /// - `input` - the input image Array /// - `fast_thr` - FAST threshold for which a pixel of the circle around the central pixel is /// considered to be brighter or darker /// - `max_feat` - maximum number of features to hold /// - `scl_fctr` - factor to downsample the input image, meaning that each level with hold prior /// level dimensions divided by `scl_fctr` /// - `levels` - number of levels to be computed for the image pyramid /// - `blur_img` - blur image with a Gaussian filter with sigma=2 before computing descriptors to /// increase robustness against noise if true /// /// # Return Values /// /// This function returns a tuple of [`Features`](./struct.Features.html) and [`Array`](./struct.Array.html). The features objects composed of Arrays for x and y coordinates, score, orientation and size of selected features. The Array object is a two dimensional Array of size Nx8 where N is number of selected features. pub fn orb<T>( input: &Array<T>, fast_thr: f32, max_feat: u32, scl_fctr: f32, levels: u32, blur_img: bool, ) -> (Features, Array<T>) where T: HasAfEnum + RealFloating, { unsafe { let mut f: af_features = std::ptr::null_mut(); let mut d: af_array = std::ptr::null_mut(); let err_val = af_orb( &mut f as *mut af_features, &mut d as *mut af_array, input.get(), fast_thr, max_feat, scl_fctr, levels, blur_img, ); HANDLE_ERROR(AfError::from(err_val)); (Features { feat: f }, d.into()) } } /// Hamming feature matcher /// /// Calculates Hamming distances between two 2-dimensional arrays containing features, one of the /// arrays containing the training data and the other the query data. One of the dimensions of the /// both arrays must be equal among them, identifying the length of each feature. The other /// dimension indicates the total number of features in each of the training and query arrays. Two /// 1-dimensional arrays are created as results, one containg the smallest N distances of the query /// array and another containing the indices of these distances in the training array. The /// resulting 1-dimensional arrays have length equal to the number of features contained in the /// query array. /// /// # Parameters /// /// - `query` - Array containing the data to be queried /// - `train` - Array containing the data to be used as training data /// - `dist_dims` - indicates the dimension to analyze for distance (the dimension indicated here /// must be of equal length for both query and train arrays) /// - `n_dist` - is the number of smallest distances to return (currently, only values <= 256 are supported) /// /// /// # Return Values /// /// This function returns a tuple of [Array](./struct.Array.html)'s. /// /// First Array is an array of MxN size, where M is equal to the number of query features and N is /// equal to n_dist. The value at position IxJ indicates the index of the Jth smallest distance to /// the Ith query value in the train data array. the index of the Ith smallest distance of the Mth /// query. /// /// Second Array is an array of MxN size, where M is equal to the number of query features and N is /// equal to n_dist. The value at position IxJ indicates the Hamming distance of the Jth smallest /// distance to the Ith query value in the train data array. pub fn hamming_matcher<T>( query: &Array<T>, train: &Array<T>, dist_dims: i64, n_dist: u32, ) -> (Array<u32>, Array<T::AggregateOutType>) where T: HasAfEnum + ImageFilterType, T::AggregateOutType: HasAfEnum, { unsafe { let mut idx: af_array = std::ptr::null_mut(); let mut dist: af_array = std::ptr::null_mut(); let err_val = af_hamming_matcher( &mut idx as *mut af_array, &mut dist as *mut af_array, query.get(), train.get(), dist_dims, n_dist, ); HANDLE_ERROR(AfError::from(err_val)); (idx.into(), dist.into()) } } /// Nearest Neighbour. /// /// Calculates nearest distances between two 2-dimensional arrays containing features based on the /// type of distance computation chosen. Currently, AF_SAD (sum of absolute differences), AF_SSD /// (sum of squared differences) and AF_SHD (hamming distance) are supported. One of the arrays /// containing the training data and the other the query data. One of the dimensions of the both /// arrays must be equal among them, identifying the length of each feature. The other dimension /// indicates the total number of features in each of the training and query arrays. Two /// 1-dimensional arrays are created as results, one containg the smallest N distances of the query /// array and another containing the indices of these distances in the training array. The resulting /// 1-dimensional arrays have length equal to the number of features contained in the query array. /// /// # Parameters /// /// - `query` is the array containing the data to be queried /// - `train` is the array containing the data used as training data /// - `dist_dim` indicates the dimension to analyze for distance (the dimension indicated here must be of equal length for both query and train arrays) /// - `n_dist` is the number of smallest distances to return (currently, only values <= 256 are supported) /// - `dist_type` is the distance computation type. Currently [`MatchType::SAD`](./enum.MatchType.html), [`MatchType::SSD`](./enum.MatchType.html), and [`MatchType::SHD`](./enum.MatchType.html) are supported. /// /// # Return Values /// /// A tuple of Arrays. /// /// The first Array is is an array of MxN size, where M is equal to the number of query features /// and N is equal to `n_dist`. The value at position IxJ indicates the index of the Jth smallest /// distance to the Ith query value in the train data array. the index of the Ith smallest distance /// of the Mth query. /// /// The second Array is is an array of MxN size, where M is equal to the number of query features /// and N is equal to `n_dist`. The value at position IxJ indicates the distance of the Jth smallest /// distance to the Ith query value in the train data array based on the `dist_type` chosen. pub fn nearest_neighbour<T>( query: &Array<T>, train: &Array<T>, dist_dim: i64, n_dist: u32, dist_type: MatchType, ) -> (Array<u32>, Array<T::AggregateOutType>) where T: HasAfEnum + ImageFilterType, T::AggregateOutType: HasAfEnum, { unsafe { let mut idx: af_array = std::ptr::null_mut(); let mut dist: af_array = std::ptr::null_mut(); let err_val = af_nearest_neighbour( &mut idx as *mut af_array, &mut dist as *mut af_array, query.get(), train.get(), dist_dim, n_dist, dist_type as c_int, ); HANDLE_ERROR(AfError::from(err_val)); (idx.into(), dist.into()) } } /// Image matching /// /// Template matching is an image processing technique to find small patches of an image which /// match a given template image. A more in depth discussion on the topic can be found /// [here](https://en.wikipedia.org/wiki/Template_matching). /// /// # Parameters /// /// - `search_img` is an array with image data /// - `template_img` is the template we are looking for in the image /// - `mtype` is metric that should be used to calculate the disparity between window in the image and the template image. It can be one of the values defined by the enum [MatchType](./enum.MatchType.html). /// # Return Values /// /// This function returns an Array with disparity values for the window starting at corresponding pixel position. pub fn match_template<T>( search_img: &Array<T>, template_img: &Array<T>, mtype: MatchType, ) -> Array<T::AbsOutType> where T: HasAfEnum + ImageFilterType, T::AbsOutType: HasAfEnum, { unsafe { let mut temp: af_array = std::ptr::null_mut(); let err_val = af_match_template( &mut temp as *mut af_array, search_img.get(), template_img.get(), mtype as c_uint, ); HANDLE_ERROR(AfError::from(err_val)); temp.into() } } /// SUSAN corner detector. /// /// SUSAN is an acronym standing for Smallest Univalue Segment Assimilating Nucleus. This method /// places a circular disc over the pixel to be tested (a.k.a nucleus) to compute the corner /// measure of that corresponding pixel. The region covered by the circular disc is M, and a pixel /// in this region is represented by m⃗ ∈M where m⃗ 0 is the nucleus. Every pixel in the region is /// compared to the nucleus using the following comparison function: /// /// c(m⃗ )=e^−((I(m⃗)−I(m⃗_0))/t)^6 /// /// where t is radius of the region, I is the brightness of the pixel. /// /// Response of SUSAN operator is given by the following equation: /// /// R(M) = g−n(M) if n(M) < g /// /// R(M) = 0 otherwise, /// /// where n(M)=∑c(m⃗) m⃗∈M, g is named the geometric threshold and n is the number of pixels in the /// mask which are within t of the nucleus. /// /// Importance of the parameters, t and g is explained below: /// /// - t determines how similar points have to be to the nucleusbefore they are considered to be a /// part of the univalue segment /// - g determines the minimum size of the univalue segment. For a large enough g, SUSAN operator /// becomes an edge dectector. /// /// # Parameters /// /// - `input` is input grayscale/intensity image /// - `radius` is the nucleus radius for each pixel neighborhood /// - `diff_thr` is intensity difference threshold a.k.a **t** from equations in description /// - `geom_thr` is the geometric threshold /// - `feature_ratio` is maximum number of features that will be returned by the function /// - `edge` indicates how many pixels width area should be skipped for corner detection /// /// # Return Values /// An object of type [Features](./struct.Features.html) composed of arrays for x and y coordinates, score, orientation and size of selected features. pub fn susan<T>( input: &Array<T>, radius: u32, diff_thr: f32, geom_thr: f32, feature_ratio: f32, edge: u32, ) -> Features where T: HasAfEnum + ImageFilterType, { unsafe { let mut temp: af_features = std::ptr::null_mut(); let err_val = af_susan( &mut temp as *mut af_features, input.get(), radius, diff_thr, geom_thr, feature_ratio, edge, ); HANDLE_ERROR(AfError::from(err_val)); Features { feat: temp } } } /// Difference of Gaussians. /// /// Given an image, this function computes two different versions of smoothed input image using the /// difference smoothing parameters and subtracts one from the other and returns the result. /// /// # Parameters /// /// - `input` is the input image /// - `radius1` is the radius of the first gaussian kernel /// - `radius2` is the radius of the second gaussian kernel /// /// # Return Values /// /// Difference of smoothed inputs - An Array. pub fn dog<T>(input: &Array<T>, radius1: i32, radius2: i32) -> Array<T::AbsOutType> where T: HasAfEnum + ImageFilterType, T::AbsOutType: HasAfEnum, { unsafe { let mut temp: af_array = std::ptr::null_mut(); let err_val = af_dog(&mut temp as *mut af_array, input.get(), radius1, radius2); HANDLE_ERROR(AfError::from(err_val)); temp.into() } } /// Homography estimation /// /// Homography estimation find a perspective transform between two sets of 2D points. /// Currently, two methods are supported for the estimation, RANSAC (RANdom SAmple Consensus) /// and LMedS (Least Median of Squares). Both methods work by randomly selecting a subset /// of 4 points of the set of source points, computing the eigenvectors of that set and /// finding the perspective transform. The process is repeated several times, a maximum of /// times given by the value passed to the iterations arguments for RANSAC (for the CPU /// backend, usually less than that, depending on the quality of the dataset, but for CUDA /// and OpenCL backends the transformation will be computed exactly the amount of times /// passed via the iterations parameter), the returned value is the one that matches the /// best number of inliers, which are all of the points that fall within a maximum L2 /// distance from the value passed to the inlier_thr argument. /// /// # Parameters /// /// - `x_src` is the x coordinates of the source points. /// - `y_src` is the y coordinates of the source points. /// - `x_dst` is the x coordinates of the destination points. /// - `y_dst` is the y coordinates of the destination points. /// - `htype` can be AF_HOMOGRAPHY_RANSAC, for which a RANdom SAmple Consensus will be used to evaluate the homography quality (e.g., number of inliers), or AF_HOMOGRAPHY_LMEDS, which will use Least Median of Squares method to evaluate homography quality /// - `inlier_thr` - if htype is AF_HOMOGRAPHY_RAN
fast
identifier_name
decode_properties.rs
// Copyright 2020 TiKV Project Authors. Licensed under Apache-2.0. //! Base types used by various rocks properties decoders use std::collections::BTreeMap; use std::io::Read; use std::ops::{Deref, DerefMut}; use tikv_util::codec::number::{self, NumberEncoder}; use tikv_util::codec::Result; #[derive(Clone, Debug, Default)] pub struct IndexHandle { pub size: u64, // The size of the stored block pub offset: u64, // The offset of the block in the file } #[derive(Debug, Default)] pub struct IndexHandles(BTreeMap<Vec<u8>, IndexHandle>); impl Deref for IndexHandles { type Target = BTreeMap<Vec<u8>, IndexHandle>; fn deref(&self) -> &BTreeMap<Vec<u8>, IndexHandle> { &self.0 } } impl DerefMut for IndexHandles { fn deref_mut(&mut self) -> &mut BTreeMap<Vec<u8>, IndexHandle> { &mut self.0 } } impl IndexHandles { pub fn new() -> IndexHandles { IndexHandles(BTreeMap::new()) } pub fn into_map(self) -> BTreeMap<Vec<u8>, IndexHandle> { self.0 } pub fn add(&mut self, key: Vec<u8>, index_handle: IndexHandle) { self.0.insert(key, index_handle); } // Format: | klen | k | v.size | v.offset | pub fn encode(&self) -> Vec<u8> { let mut buf = Vec::with_capacity(1024); for (k, v) in &self.0 { buf.encode_u64(k.len() as u64).unwrap(); buf.extend(k); buf.encode_u64(v.size).unwrap(); buf.encode_u64(v.offset).unwrap(); } buf } pub fn decode(mut buf: &[u8]) -> Result<IndexHandles> { let mut res = BTreeMap::new(); while!buf.is_empty() { let klen = number::decode_u64(&mut buf)?; let mut k = vec![0; klen as usize]; buf.read_exact(&mut k)?; let v = IndexHandle { size: number::decode_u64(&mut buf)?, offset: number::decode_u64(&mut buf)?, }; res.insert(k, v); } Ok(IndexHandles(res)) } } pub trait DecodeProperties { fn decode(&self, k: &str) -> Result<&[u8]>; fn decode_u64(&self, k: &str) -> Result<u64> { let mut buf = self.decode(k)?; number::decode_u64(&mut buf) }
fn decode_handles(&self, k: &str) -> Result<IndexHandles> { let buf = self.decode(k)?; IndexHandles::decode(buf) } } impl DecodeProperties for rocksdb::UserCollectedProperties { fn decode(&self, k: &str) -> tikv_util::codec::Result<&[u8]> { self.get(k.as_bytes()) .ok_or(tikv_util::codec::Error::KeyNotFound) } }
random_line_split
decode_properties.rs
// Copyright 2020 TiKV Project Authors. Licensed under Apache-2.0. //! Base types used by various rocks properties decoders use std::collections::BTreeMap; use std::io::Read; use std::ops::{Deref, DerefMut}; use tikv_util::codec::number::{self, NumberEncoder}; use tikv_util::codec::Result; #[derive(Clone, Debug, Default)] pub struct IndexHandle { pub size: u64, // The size of the stored block pub offset: u64, // The offset of the block in the file } #[derive(Debug, Default)] pub struct IndexHandles(BTreeMap<Vec<u8>, IndexHandle>); impl Deref for IndexHandles { type Target = BTreeMap<Vec<u8>, IndexHandle>; fn deref(&self) -> &BTreeMap<Vec<u8>, IndexHandle> { &self.0 } } impl DerefMut for IndexHandles { fn
(&mut self) -> &mut BTreeMap<Vec<u8>, IndexHandle> { &mut self.0 } } impl IndexHandles { pub fn new() -> IndexHandles { IndexHandles(BTreeMap::new()) } pub fn into_map(self) -> BTreeMap<Vec<u8>, IndexHandle> { self.0 } pub fn add(&mut self, key: Vec<u8>, index_handle: IndexHandle) { self.0.insert(key, index_handle); } // Format: | klen | k | v.size | v.offset | pub fn encode(&self) -> Vec<u8> { let mut buf = Vec::with_capacity(1024); for (k, v) in &self.0 { buf.encode_u64(k.len() as u64).unwrap(); buf.extend(k); buf.encode_u64(v.size).unwrap(); buf.encode_u64(v.offset).unwrap(); } buf } pub fn decode(mut buf: &[u8]) -> Result<IndexHandles> { let mut res = BTreeMap::new(); while!buf.is_empty() { let klen = number::decode_u64(&mut buf)?; let mut k = vec![0; klen as usize]; buf.read_exact(&mut k)?; let v = IndexHandle { size: number::decode_u64(&mut buf)?, offset: number::decode_u64(&mut buf)?, }; res.insert(k, v); } Ok(IndexHandles(res)) } } pub trait DecodeProperties { fn decode(&self, k: &str) -> Result<&[u8]>; fn decode_u64(&self, k: &str) -> Result<u64> { let mut buf = self.decode(k)?; number::decode_u64(&mut buf) } fn decode_handles(&self, k: &str) -> Result<IndexHandles> { let buf = self.decode(k)?; IndexHandles::decode(buf) } } impl DecodeProperties for rocksdb::UserCollectedProperties { fn decode(&self, k: &str) -> tikv_util::codec::Result<&[u8]> { self.get(k.as_bytes()) .ok_or(tikv_util::codec::Error::KeyNotFound) } }
deref_mut
identifier_name
knowledge.rs
use std::collections::BTreeMap; use game::*; use spatial_hash::*; use coord::Coord; use util::TwoDimensionalCons; /// Trait implemented by representations of knowledge about a level pub trait LevelKnowledge { /// Updates a cell of the knowledge representation, returnig true iff the /// knowledge of the cell changed as a result of the update. fn update_cell(&mut self, coord: Coord, world_cell: &SpatialHashCell, accuracy: f64, action_env: ActionEnv) -> bool; } #[derive(Serialize, Deserialize)] pub struct GameKnowledge<K: LevelKnowledge> { levels: BTreeMap<LevelId, K>, } impl<K: LevelKnowledge> GameKnowledge<K> { pub fn new() -> Self { GameKnowledge { levels: BTreeMap::new(), } } pub fn level(&self, level_id: LevelId) -> &K { self.levels.get(&level_id).expect("No such level") } pub fn level_mut(&mut self, level_id: LevelId) -> &mut K { self.levels.get_mut(&level_id).expect("No such level") } } impl<K: LevelKnowledge + Default> Default for GameKnowledge<K> { fn default() -> Self { Self::new() } } impl<K: LevelKnowledge + TwoDimensionalCons> GameKnowledge<K> { pub fn
(&mut self, level_id: LevelId, width: usize, height: usize) -> &mut K { self.levels.entry(level_id).or_insert_with(|| K::new(width, height)) } }
level_mut_or_insert_size
identifier_name
knowledge.rs
use std::collections::BTreeMap; use game::*; use spatial_hash::*; use coord::Coord; use util::TwoDimensionalCons; /// Trait implemented by representations of knowledge about a level pub trait LevelKnowledge { /// Updates a cell of the knowledge representation, returnig true iff the /// knowledge of the cell changed as a result of the update. fn update_cell(&mut self, coord: Coord, world_cell: &SpatialHashCell, accuracy: f64, action_env: ActionEnv) -> bool; } #[derive(Serialize, Deserialize)] pub struct GameKnowledge<K: LevelKnowledge> { levels: BTreeMap<LevelId, K>, } impl<K: LevelKnowledge> GameKnowledge<K> { pub fn new() -> Self { GameKnowledge { levels: BTreeMap::new(), } } pub fn level(&self, level_id: LevelId) -> &K { self.levels.get(&level_id).expect("No such level") } pub fn level_mut(&mut self, level_id: LevelId) -> &mut K { self.levels.get_mut(&level_id).expect("No such level") } } impl<K: LevelKnowledge + Default> Default for GameKnowledge<K> { fn default() -> Self { Self::new() } }
self.levels.entry(level_id).or_insert_with(|| K::new(width, height)) } }
impl<K: LevelKnowledge + TwoDimensionalCons> GameKnowledge<K> { pub fn level_mut_or_insert_size(&mut self, level_id: LevelId, width: usize, height: usize) -> &mut K {
random_line_split
knowledge.rs
use std::collections::BTreeMap; use game::*; use spatial_hash::*; use coord::Coord; use util::TwoDimensionalCons; /// Trait implemented by representations of knowledge about a level pub trait LevelKnowledge { /// Updates a cell of the knowledge representation, returnig true iff the /// knowledge of the cell changed as a result of the update. fn update_cell(&mut self, coord: Coord, world_cell: &SpatialHashCell, accuracy: f64, action_env: ActionEnv) -> bool; } #[derive(Serialize, Deserialize)] pub struct GameKnowledge<K: LevelKnowledge> { levels: BTreeMap<LevelId, K>, } impl<K: LevelKnowledge> GameKnowledge<K> { pub fn new() -> Self { GameKnowledge { levels: BTreeMap::new(), } } pub fn level(&self, level_id: LevelId) -> &K { self.levels.get(&level_id).expect("No such level") } pub fn level_mut(&mut self, level_id: LevelId) -> &mut K
} impl<K: LevelKnowledge + Default> Default for GameKnowledge<K> { fn default() -> Self { Self::new() } } impl<K: LevelKnowledge + TwoDimensionalCons> GameKnowledge<K> { pub fn level_mut_or_insert_size(&mut self, level_id: LevelId, width: usize, height: usize) -> &mut K { self.levels.entry(level_id).or_insert_with(|| K::new(width, height)) } }
{ self.levels.get_mut(&level_id).expect("No such level") }
identifier_body
no_1109_corporate_flight_bookings.rs
pub fn corp_flight_bookings(bookings: Vec<Vec<i32>>, n: i32) -> Vec<i32> { let mut answer = vec![0; n as usize]; for booking in bookings { answer[booking[0] as usize - 1] += booking[2]; if booking[1] < n { answer[booking[1] as usize] -= booking[2]; } } let mut sum = 0; for a in answer.iter_mut() { sum += *a; *a = sum; }
answer } #[cfg(test)] mod test { use super::*; #[test] fn test_corp_flight_bookings() { let answer = corp_flight_bookings(vec![vec![1, 2, 10], vec![2, 3, 20], vec![2, 5, 25]], 5); assert_eq!(answer, vec![10, 55, 45, 25, 25]); } }
random_line_split
no_1109_corporate_flight_bookings.rs
pub fn corp_flight_bookings(bookings: Vec<Vec<i32>>, n: i32) -> Vec<i32> { let mut answer = vec![0; n as usize]; for booking in bookings { answer[booking[0] as usize - 1] += booking[2]; if booking[1] < n { answer[booking[1] as usize] -= booking[2]; } } let mut sum = 0; for a in answer.iter_mut() { sum += *a; *a = sum; } answer } #[cfg(test)] mod test { use super::*; #[test] fn
() { let answer = corp_flight_bookings(vec![vec![1, 2, 10], vec![2, 3, 20], vec![2, 5, 25]], 5); assert_eq!(answer, vec![10, 55, 45, 25, 25]); } }
test_corp_flight_bookings
identifier_name
no_1109_corporate_flight_bookings.rs
pub fn corp_flight_bookings(bookings: Vec<Vec<i32>>, n: i32) -> Vec<i32> { let mut answer = vec![0; n as usize]; for booking in bookings { answer[booking[0] as usize - 1] += booking[2]; if booking[1] < n
} let mut sum = 0; for a in answer.iter_mut() { sum += *a; *a = sum; } answer } #[cfg(test)] mod test { use super::*; #[test] fn test_corp_flight_bookings() { let answer = corp_flight_bookings(vec![vec![1, 2, 10], vec![2, 3, 20], vec![2, 5, 25]], 5); assert_eq!(answer, vec![10, 55, 45, 25, 25]); } }
{ answer[booking[1] as usize] -= booking[2]; }
conditional_block
no_1109_corporate_flight_bookings.rs
pub fn corp_flight_bookings(bookings: Vec<Vec<i32>>, n: i32) -> Vec<i32>
#[cfg(test)] mod test { use super::*; #[test] fn test_corp_flight_bookings() { let answer = corp_flight_bookings(vec![vec![1, 2, 10], vec![2, 3, 20], vec![2, 5, 25]], 5); assert_eq!(answer, vec![10, 55, 45, 25, 25]); } }
{ let mut answer = vec![0; n as usize]; for booking in bookings { answer[booking[0] as usize - 1] += booking[2]; if booking[1] < n { answer[booking[1] as usize] -= booking[2]; } } let mut sum = 0; for a in answer.iter_mut() { sum += *a; *a = sum; } answer }
identifier_body
client_json.rs
#![deny(warnings)] extern crate hyper; #[macro_use] extern crate serde_derive; extern crate serde; extern crate serde_json; use hyper::Client; use hyper::rt::{self, Future, Stream}; fn main() { let url = "http://jsonplaceholder.typicode.com/users".parse().unwrap(); let fut = fetch_json(url) // use the parsed vector .map(|users| { // print users println!("users: {:#?}", users); // print the sum of ids let sum = users.iter().fold(0, |acc, user| acc + user.id); println!("sum of ids: {}", sum); }) // if there was an error print it .map_err(|e| { match e { FetchError::Http(e) => eprintln!("http error: {}", e), FetchError::Json(e) => eprintln!("json parsing error: {}", e), } }); // Run the runtime with the future trying to fetch, parse and print json. // // Note that in more complicated use cases, the runtime should probably // run on its own, and futures should just be spawned into it. rt::run(fut); } fn fetch_json(url: hyper::Uri) -> impl Future<Item=Vec<User>, Error=FetchError> { let client = Client::new(); client // Fetch the url... .get(url) // And then, if we get a response back... .and_then(|res| { // asynchronously concatenate chunks of the body res.into_body().concat2() }) .from_err::<FetchError>() // use the body after concatenation .and_then(|body| { // try to parse as json with serde_json let users = serde_json::from_slice(&body)?; Ok(users) }) .from_err() } #[derive(Deserialize, Debug)] struct User { id: i32, name: String, } // Define a type so we can return multiple types of errors
Json(serde_json::Error), } impl From<hyper::Error> for FetchError { fn from(err: hyper::Error) -> FetchError { FetchError::Http(err) } } impl From<serde_json::Error> for FetchError { fn from(err: serde_json::Error) -> FetchError { FetchError::Json(err) } }
enum FetchError { Http(hyper::Error),
random_line_split
client_json.rs
#![deny(warnings)] extern crate hyper; #[macro_use] extern crate serde_derive; extern crate serde; extern crate serde_json; use hyper::Client; use hyper::rt::{self, Future, Stream}; fn
() { let url = "http://jsonplaceholder.typicode.com/users".parse().unwrap(); let fut = fetch_json(url) // use the parsed vector .map(|users| { // print users println!("users: {:#?}", users); // print the sum of ids let sum = users.iter().fold(0, |acc, user| acc + user.id); println!("sum of ids: {}", sum); }) // if there was an error print it .map_err(|e| { match e { FetchError::Http(e) => eprintln!("http error: {}", e), FetchError::Json(e) => eprintln!("json parsing error: {}", e), } }); // Run the runtime with the future trying to fetch, parse and print json. // // Note that in more complicated use cases, the runtime should probably // run on its own, and futures should just be spawned into it. rt::run(fut); } fn fetch_json(url: hyper::Uri) -> impl Future<Item=Vec<User>, Error=FetchError> { let client = Client::new(); client // Fetch the url... .get(url) // And then, if we get a response back... .and_then(|res| { // asynchronously concatenate chunks of the body res.into_body().concat2() }) .from_err::<FetchError>() // use the body after concatenation .and_then(|body| { // try to parse as json with serde_json let users = serde_json::from_slice(&body)?; Ok(users) }) .from_err() } #[derive(Deserialize, Debug)] struct User { id: i32, name: String, } // Define a type so we can return multiple types of errors enum FetchError { Http(hyper::Error), Json(serde_json::Error), } impl From<hyper::Error> for FetchError { fn from(err: hyper::Error) -> FetchError { FetchError::Http(err) } } impl From<serde_json::Error> for FetchError { fn from(err: serde_json::Error) -> FetchError { FetchError::Json(err) } }
main
identifier_name
client_json.rs
#![deny(warnings)] extern crate hyper; #[macro_use] extern crate serde_derive; extern crate serde; extern crate serde_json; use hyper::Client; use hyper::rt::{self, Future, Stream}; fn main() { let url = "http://jsonplaceholder.typicode.com/users".parse().unwrap(); let fut = fetch_json(url) // use the parsed vector .map(|users| { // print users println!("users: {:#?}", users); // print the sum of ids let sum = users.iter().fold(0, |acc, user| acc + user.id); println!("sum of ids: {}", sum); }) // if there was an error print it .map_err(|e| { match e { FetchError::Http(e) => eprintln!("http error: {}", e), FetchError::Json(e) => eprintln!("json parsing error: {}", e), } }); // Run the runtime with the future trying to fetch, parse and print json. // // Note that in more complicated use cases, the runtime should probably // run on its own, and futures should just be spawned into it. rt::run(fut); } fn fetch_json(url: hyper::Uri) -> impl Future<Item=Vec<User>, Error=FetchError>
} #[derive(Deserialize, Debug)] struct User { id: i32, name: String, } // Define a type so we can return multiple types of errors enum FetchError { Http(hyper::Error), Json(serde_json::Error), } impl From<hyper::Error> for FetchError { fn from(err: hyper::Error) -> FetchError { FetchError::Http(err) } } impl From<serde_json::Error> for FetchError { fn from(err: serde_json::Error) -> FetchError { FetchError::Json(err) } }
{ let client = Client::new(); client // Fetch the url... .get(url) // And then, if we get a response back... .and_then(|res| { // asynchronously concatenate chunks of the body res.into_body().concat2() }) .from_err::<FetchError>() // use the body after concatenation .and_then(|body| { // try to parse as json with serde_json let users = serde_json::from_slice(&body)?; Ok(users) }) .from_err()
identifier_body
TestNativeExp2.rs
/* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License");
* 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. */ #pragma version(1) #pragma rs java_package_name(android.renderscript.cts) // Don't edit this file! It is auto-generated by frameworks/rs/api/gen_runtime. float __attribute__((kernel)) testNativeExp2FloatFloat(float inV) { return native_exp2(inV); } float2 __attribute__((kernel)) testNativeExp2Float2Float2(float2 inV) { return native_exp2(inV); } float3 __attribute__((kernel)) testNativeExp2Float3Float3(float3 inV) { return native_exp2(inV); } float4 __attribute__((kernel)) testNativeExp2Float4Float4(float4 inV) { return native_exp2(inV); }
* you may not use this file except in compliance with the License. * You may obtain a copy of the License at *
random_line_split
lib.rs
//! A wrapper around the uchardet library. Detects character encodings. //! //! Note that the underlying implemention is written in C and C++, and I'm //! not aware of any security audits which have been performed against it. //! //! ``` //! use uchardet::detect_encoding_name; //! //! assert_eq!("WINDOWS-1252", //! detect_encoding_name(&[0x46, 0x93, 0x72, 0x61, 0x6e, 0xe7, 0x6f, //! 0x69, 0x73, 0xe9, 0x94]).unwrap()); //! ``` //! //! For more information, see [this project on //! GitHub](https://github.com/emk/rust-uchardet). // Increase the compiler's recursion limit for the `error_chain` crate. #![recursion_limit = "1024"] #![deny(missing_docs)] #[macro_use] extern crate error_chain; extern crate libc; extern crate uchardet_sys as ffi; use libc::size_t; use std::ffi::CStr; use std::str::from_utf8; use std::os::raw::c_char; pub use errors::*;
/// We declare our `error_chain!` in a private submodule so that we can /// `allow(missing_docs)`. #[allow(missing_docs)] mod errors { error_chain! { errors { UnrecognizableCharset { description("unrecognizable charset") display("uchardet was unable to recognize a charset") } OutOfMemory { description("out of memory error") display("uchardet ran out of memory") } Other(int: i32) { description("unknown error") display("uchardet returned unknown error {}", int) } } } } impl ErrorKind { /// Convert an `nsresult` into a Rust error. We panic if the error /// value is zero. fn from_nsresult(nsresult: ::ffi::nsresult) -> ErrorKind { assert!(nsresult!= 0); match nsresult { 1 => ErrorKind::OutOfMemory, int => ErrorKind::Other(int), } } } /// Detects the encoding of text using the uchardet library. /// /// EXPERIMENTAL: This may be replaced by a better API soon. struct EncodingDetector { ptr: ffi::uchardet_t } /// Return the name of the charset used in `data` or an error if uchardet /// was unable to detect a charset. /// /// ``` /// use uchardet::detect_encoding_name; /// /// assert_eq!("ASCII", /// detect_encoding_name("ascii".as_bytes()).unwrap()); /// assert_eq!("UTF-8", /// detect_encoding_name("©français".as_bytes()).unwrap()); /// assert_eq!("WINDOWS-1252", /// detect_encoding_name(&[0x46, 0x93, 0x72, 0x61, 0x6e, 0xe7, 0x6f, /// 0x69, 0x73, 0xe9, 0x94]).unwrap()); /// ``` pub fn detect_encoding_name(data: &[u8]) -> Result<String> { let mut detector = EncodingDetector::new(); try!(detector.handle_data(data)); detector.data_end(); detector.charset() } impl EncodingDetector { /// Create a new EncodingDetector. fn new() -> EncodingDetector { let ptr = unsafe { ffi::uchardet_new() }; assert!(!ptr.is_null()); EncodingDetector{ptr: ptr} } /// Pass a chunk of raw bytes to the detector. This is a no-op if a /// charset has been detected. fn handle_data(&mut self, data: &[u8]) -> Result<()> { let nsresult = unsafe { ffi::uchardet_handle_data(self.ptr, data.as_ptr() as *const c_char, data.len() as size_t) }; match nsresult { 0 => Ok(()), int => { Err(ErrorKind::from_nsresult(int).into()) } } } /// Notify the detector that we're done calling `handle_data`, and that /// we want it to make a guess as to our encoding. This is a no-op if /// no data has been passed yet, or if an encoding has been detected /// for certain. From reading the code, it appears that you can safely /// call `handle_data` after calling this, but I'm not certain. fn data_end(&mut self) { unsafe { ffi::uchardet_data_end(self.ptr); } } /// Get the decoder's current best guess as to the encoding. May return /// an error if uchardet was unable to detect an encoding. fn charset(&self) -> Result<String> { unsafe { let internal_str = ffi::uchardet_get_charset(self.ptr); assert!(!internal_str.is_null()); let bytes = CStr::from_ptr(internal_str).to_bytes(); let charset = from_utf8(bytes); match charset { Err(_) => panic!("uchardet_get_charset returned a charset name \ containing invalid characters"), Ok("") => Err(ErrorKind::UnrecognizableCharset.into()), Ok(encoding) => Ok(encoding.to_string()) } } } } impl Drop for EncodingDetector { fn drop(&mut self) { unsafe { ffi::uchardet_delete(self.ptr) }; } }
random_line_split
lib.rs
//! A wrapper around the uchardet library. Detects character encodings. //! //! Note that the underlying implemention is written in C and C++, and I'm //! not aware of any security audits which have been performed against it. //! //! ``` //! use uchardet::detect_encoding_name; //! //! assert_eq!("WINDOWS-1252", //! detect_encoding_name(&[0x46, 0x93, 0x72, 0x61, 0x6e, 0xe7, 0x6f, //! 0x69, 0x73, 0xe9, 0x94]).unwrap()); //! ``` //! //! For more information, see [this project on //! GitHub](https://github.com/emk/rust-uchardet). // Increase the compiler's recursion limit for the `error_chain` crate. #![recursion_limit = "1024"] #![deny(missing_docs)] #[macro_use] extern crate error_chain; extern crate libc; extern crate uchardet_sys as ffi; use libc::size_t; use std::ffi::CStr; use std::str::from_utf8; use std::os::raw::c_char; pub use errors::*; /// We declare our `error_chain!` in a private submodule so that we can /// `allow(missing_docs)`. #[allow(missing_docs)] mod errors { error_chain! { errors { UnrecognizableCharset { description("unrecognizable charset") display("uchardet was unable to recognize a charset") } OutOfMemory { description("out of memory error") display("uchardet ran out of memory") } Other(int: i32) { description("unknown error") display("uchardet returned unknown error {}", int) } } } } impl ErrorKind { /// Convert an `nsresult` into a Rust error. We panic if the error /// value is zero. fn from_nsresult(nsresult: ::ffi::nsresult) -> ErrorKind { assert!(nsresult!= 0); match nsresult { 1 => ErrorKind::OutOfMemory, int => ErrorKind::Other(int), } } } /// Detects the encoding of text using the uchardet library. /// /// EXPERIMENTAL: This may be replaced by a better API soon. struct EncodingDetector { ptr: ffi::uchardet_t } /// Return the name of the charset used in `data` or an error if uchardet /// was unable to detect a charset. /// /// ``` /// use uchardet::detect_encoding_name; /// /// assert_eq!("ASCII", /// detect_encoding_name("ascii".as_bytes()).unwrap()); /// assert_eq!("UTF-8", /// detect_encoding_name("©français".as_bytes()).unwrap()); /// assert_eq!("WINDOWS-1252", /// detect_encoding_name(&[0x46, 0x93, 0x72, 0x61, 0x6e, 0xe7, 0x6f, /// 0x69, 0x73, 0xe9, 0x94]).unwrap()); /// ``` pub fn detect_encoding_name(data: &[u8]) -> Result<String> { let mut detector = EncodingDetector::new(); try!(detector.handle_data(data)); detector.data_end(); detector.charset() } impl EncodingDetector { /// Create a new EncodingDetector. fn new() -> EncodingDetector { let ptr = unsafe { ffi::uchardet_new() }; assert!(!ptr.is_null()); EncodingDetector{ptr: ptr} } /// Pass a chunk of raw bytes to the detector. This is a no-op if a /// charset has been detected. fn handle_data(&mut self, data: &[u8]) -> Result<()> { let nsresult = unsafe { ffi::uchardet_handle_data(self.ptr, data.as_ptr() as *const c_char, data.len() as size_t) }; match nsresult { 0 => Ok(()), int => { Err(ErrorKind::from_nsresult(int).into()) } } } /// Notify the detector that we're done calling `handle_data`, and that /// we want it to make a guess as to our encoding. This is a no-op if /// no data has been passed yet, or if an encoding has been detected /// for certain. From reading the code, it appears that you can safely /// call `handle_data` after calling this, but I'm not certain. fn data_end(&mut self) { unsafe { ffi::uchardet_data_end(self.ptr); } } /// Get the decoder's current best guess as to the encoding. May return /// an error if uchardet was unable to detect an encoding. fn charset(&self) -> Result<String> { unsafe { let internal_str = ffi::uchardet_get_charset(self.ptr); assert!(!internal_str.is_null()); let bytes = CStr::from_ptr(internal_str).to_bytes(); let charset = from_utf8(bytes); match charset { Err(_) => panic!("uchardet_get_charset returned a charset name \ containing invalid characters"), Ok("") => Err(ErrorKind::UnrecognizableCharset.into()), Ok(encoding) => Ok(encoding.to_string()) } } } } impl Drop for EncodingDetector { fn drop(&mut self) {
unsafe { ffi::uchardet_delete(self.ptr) }; } }
identifier_body
lib.rs
//! A wrapper around the uchardet library. Detects character encodings. //! //! Note that the underlying implemention is written in C and C++, and I'm //! not aware of any security audits which have been performed against it. //! //! ``` //! use uchardet::detect_encoding_name; //! //! assert_eq!("WINDOWS-1252", //! detect_encoding_name(&[0x46, 0x93, 0x72, 0x61, 0x6e, 0xe7, 0x6f, //! 0x69, 0x73, 0xe9, 0x94]).unwrap()); //! ``` //! //! For more information, see [this project on //! GitHub](https://github.com/emk/rust-uchardet). // Increase the compiler's recursion limit for the `error_chain` crate. #![recursion_limit = "1024"] #![deny(missing_docs)] #[macro_use] extern crate error_chain; extern crate libc; extern crate uchardet_sys as ffi; use libc::size_t; use std::ffi::CStr; use std::str::from_utf8; use std::os::raw::c_char; pub use errors::*; /// We declare our `error_chain!` in a private submodule so that we can /// `allow(missing_docs)`. #[allow(missing_docs)] mod errors { error_chain! { errors { UnrecognizableCharset { description("unrecognizable charset") display("uchardet was unable to recognize a charset") } OutOfMemory { description("out of memory error") display("uchardet ran out of memory") } Other(int: i32) { description("unknown error") display("uchardet returned unknown error {}", int) } } } } impl ErrorKind { /// Convert an `nsresult` into a Rust error. We panic if the error /// value is zero. fn from_nsresult(nsresult: ::ffi::nsresult) -> ErrorKind { assert!(nsresult!= 0); match nsresult { 1 => ErrorKind::OutOfMemory, int => ErrorKind::Other(int), } } } /// Detects the encoding of text using the uchardet library. /// /// EXPERIMENTAL: This may be replaced by a better API soon. struct EncodingDetector { ptr: ffi::uchardet_t } /// Return the name of the charset used in `data` or an error if uchardet /// was unable to detect a charset. /// /// ``` /// use uchardet::detect_encoding_name; /// /// assert_eq!("ASCII", /// detect_encoding_name("ascii".as_bytes()).unwrap()); /// assert_eq!("UTF-8", /// detect_encoding_name("©français".as_bytes()).unwrap()); /// assert_eq!("WINDOWS-1252", /// detect_encoding_name(&[0x46, 0x93, 0x72, 0x61, 0x6e, 0xe7, 0x6f, /// 0x69, 0x73, 0xe9, 0x94]).unwrap()); /// ``` pub fn detect_encoding_name(data: &[u8]) -> Result<String> { let mut detector = EncodingDetector::new(); try!(detector.handle_data(data)); detector.data_end(); detector.charset() } impl EncodingDetector { /// Create a new EncodingDetector. fn new() -> EncodingDetector { let ptr = unsafe { ffi::uchardet_new() }; assert!(!ptr.is_null()); EncodingDetector{ptr: ptr} } /// Pass a chunk of raw bytes to the detector. This is a no-op if a /// charset has been detected. fn handle_data(&mut self, data: &[u8]) -> Result<()> { let nsresult = unsafe { ffi::uchardet_handle_data(self.ptr, data.as_ptr() as *const c_char, data.len() as size_t) }; match nsresult { 0 => Ok(()), int => { Err(ErrorKind::from_nsresult(int).into()) } } } /// Notify the detector that we're done calling `handle_data`, and that /// we want it to make a guess as to our encoding. This is a no-op if /// no data has been passed yet, or if an encoding has been detected /// for certain. From reading the code, it appears that you can safely /// call `handle_data` after calling this, but I'm not certain. fn da
mut self) { unsafe { ffi::uchardet_data_end(self.ptr); } } /// Get the decoder's current best guess as to the encoding. May return /// an error if uchardet was unable to detect an encoding. fn charset(&self) -> Result<String> { unsafe { let internal_str = ffi::uchardet_get_charset(self.ptr); assert!(!internal_str.is_null()); let bytes = CStr::from_ptr(internal_str).to_bytes(); let charset = from_utf8(bytes); match charset { Err(_) => panic!("uchardet_get_charset returned a charset name \ containing invalid characters"), Ok("") => Err(ErrorKind::UnrecognizableCharset.into()), Ok(encoding) => Ok(encoding.to_string()) } } } } impl Drop for EncodingDetector { fn drop(&mut self) { unsafe { ffi::uchardet_delete(self.ptr) }; } }
ta_end(&
identifier_name
synonym.rs
use std::collections::HashMap; use std::collections::hash_map::{Iter, Keys}; use std::fmt::Debug; use std::hash::Hash; use std::iter::{FromIterator, IntoIterator}; use std::mem; #[derive(Clone)] pub struct SynonymMap<K, V> { vals: HashMap<K, V>, syns: HashMap<K, K>, } impl<K: Eq + Hash, V> SynonymMap<K, V> { pub fn new() -> SynonymMap<K, V> { SynonymMap { vals: HashMap::new(), syns: HashMap::new(), } } pub fn insert_synonym(&mut self, from: K, to: K) -> bool { assert!(self.vals.contains_key(&to)); self.syns.insert(from, to).is_none() } pub fn keys<'a>(&'a self) -> Keys<'a, K, V> { self.vals.keys() } pub fn iter<'a>(&'a self) -> Iter<'a, K, V> { self.vals.iter() } pub fn synonyms<'a>(&'a self) -> Iter<'a, K, K> { self.syns.iter() } pub fn find<'a>(&'a self, k: &K) -> Option<&'a V> { self.with_key(k, |k| self.vals.get(k)) } pub fn contains_key(&self, k: &K) -> bool { self.with_key(k, |k| self.vals.contains_key(k)) } pub fn len(&self) -> usize { self.vals.len() } fn with_key<T, F>(&self, k: &K, with: F) -> T where F: FnOnce(&K) -> T { if self.syns.contains_key(k) { with(&self.syns[k]) } else
} } impl<K: Eq + Hash + Clone, V> SynonymMap<K, V> { pub fn resolve(&self, k: &K) -> K { self.with_key(k, |k| k.clone()) } pub fn get<'a>(&'a self, k: &K) -> &'a V { self.find(k).unwrap() } pub fn find_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V> { if self.syns.contains_key(k) { self.vals.get_mut(&self.syns[k]) } else { self.vals.get_mut(k) } } pub fn swap(&mut self, k: K, mut new: V) -> Option<V> { if self.syns.contains_key(&k) { let old = self.vals.get_mut(&k).unwrap(); mem::swap(old, &mut new); Some(new) } else { self.vals.insert(k, new) } } pub fn insert(&mut self, k: K, v: V) -> bool { self.swap(k, v).is_none() } } impl<K: Eq + Hash + Clone, V> FromIterator<(K, V)> for SynonymMap<K, V> { fn from_iter<T: IntoIterator<Item=(K, V)>>(iter: T) -> SynonymMap<K, V> { let mut map = SynonymMap::new(); for (k, v) in iter { map.insert(k, v); } map } } impl<K: Eq + Hash + Debug, V: Debug> Debug for SynonymMap<K, V> { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { try!(self.vals.fmt(f)); write!(f, " (synomyns: {:?})", self.syns) } }
{ with(k) }
conditional_block
synonym.rs
use std::collections::HashMap; use std::collections::hash_map::{Iter, Keys}; use std::fmt::Debug; use std::hash::Hash; use std::iter::{FromIterator, IntoIterator}; use std::mem; #[derive(Clone)] pub struct SynonymMap<K, V> { vals: HashMap<K, V>, syns: HashMap<K, K>, } impl<K: Eq + Hash, V> SynonymMap<K, V> { pub fn new() -> SynonymMap<K, V> { SynonymMap { vals: HashMap::new(), syns: HashMap::new(), } } pub fn insert_synonym(&mut self, from: K, to: K) -> bool { assert!(self.vals.contains_key(&to)); self.syns.insert(from, to).is_none() } pub fn keys<'a>(&'a self) -> Keys<'a, K, V> { self.vals.keys() } pub fn iter<'a>(&'a self) -> Iter<'a, K, V> { self.vals.iter() } pub fn synonyms<'a>(&'a self) -> Iter<'a, K, K> { self.syns.iter() } pub fn find<'a>(&'a self, k: &K) -> Option<&'a V> { self.with_key(k, |k| self.vals.get(k)) } pub fn contains_key(&self, k: &K) -> bool { self.with_key(k, |k| self.vals.contains_key(k)) } pub fn len(&self) -> usize { self.vals.len() } fn with_key<T, F>(&self, k: &K, with: F) -> T where F: FnOnce(&K) -> T { if self.syns.contains_key(k) { with(&self.syns[k]) } else { with(k) } } } impl<K: Eq + Hash + Clone, V> SynonymMap<K, V> { pub fn resolve(&self, k: &K) -> K { self.with_key(k, |k| k.clone()) } pub fn get<'a>(&'a self, k: &K) -> &'a V { self.find(k).unwrap() } pub fn find_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V> { if self.syns.contains_key(k) { self.vals.get_mut(&self.syns[k]) } else { self.vals.get_mut(k) } } pub fn swap(&mut self, k: K, mut new: V) -> Option<V> { if self.syns.contains_key(&k) { let old = self.vals.get_mut(&k).unwrap(); mem::swap(old, &mut new); Some(new) } else { self.vals.insert(k, new) } } pub fn insert(&mut self, k: K, v: V) -> bool { self.swap(k, v).is_none() } } impl<K: Eq + Hash + Clone, V> FromIterator<(K, V)> for SynonymMap<K, V> { fn from_iter<T: IntoIterator<Item=(K, V)>>(iter: T) -> SynonymMap<K, V> { let mut map = SynonymMap::new(); for (k, v) in iter { map.insert(k, v); } map }
write!(f, " (synomyns: {:?})", self.syns) } }
} impl<K: Eq + Hash + Debug, V: Debug> Debug for SynonymMap<K, V> { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { try!(self.vals.fmt(f));
random_line_split
synonym.rs
use std::collections::HashMap; use std::collections::hash_map::{Iter, Keys}; use std::fmt::Debug; use std::hash::Hash; use std::iter::{FromIterator, IntoIterator}; use std::mem; #[derive(Clone)] pub struct SynonymMap<K, V> { vals: HashMap<K, V>, syns: HashMap<K, K>, } impl<K: Eq + Hash, V> SynonymMap<K, V> { pub fn
() -> SynonymMap<K, V> { SynonymMap { vals: HashMap::new(), syns: HashMap::new(), } } pub fn insert_synonym(&mut self, from: K, to: K) -> bool { assert!(self.vals.contains_key(&to)); self.syns.insert(from, to).is_none() } pub fn keys<'a>(&'a self) -> Keys<'a, K, V> { self.vals.keys() } pub fn iter<'a>(&'a self) -> Iter<'a, K, V> { self.vals.iter() } pub fn synonyms<'a>(&'a self) -> Iter<'a, K, K> { self.syns.iter() } pub fn find<'a>(&'a self, k: &K) -> Option<&'a V> { self.with_key(k, |k| self.vals.get(k)) } pub fn contains_key(&self, k: &K) -> bool { self.with_key(k, |k| self.vals.contains_key(k)) } pub fn len(&self) -> usize { self.vals.len() } fn with_key<T, F>(&self, k: &K, with: F) -> T where F: FnOnce(&K) -> T { if self.syns.contains_key(k) { with(&self.syns[k]) } else { with(k) } } } impl<K: Eq + Hash + Clone, V> SynonymMap<K, V> { pub fn resolve(&self, k: &K) -> K { self.with_key(k, |k| k.clone()) } pub fn get<'a>(&'a self, k: &K) -> &'a V { self.find(k).unwrap() } pub fn find_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V> { if self.syns.contains_key(k) { self.vals.get_mut(&self.syns[k]) } else { self.vals.get_mut(k) } } pub fn swap(&mut self, k: K, mut new: V) -> Option<V> { if self.syns.contains_key(&k) { let old = self.vals.get_mut(&k).unwrap(); mem::swap(old, &mut new); Some(new) } else { self.vals.insert(k, new) } } pub fn insert(&mut self, k: K, v: V) -> bool { self.swap(k, v).is_none() } } impl<K: Eq + Hash + Clone, V> FromIterator<(K, V)> for SynonymMap<K, V> { fn from_iter<T: IntoIterator<Item=(K, V)>>(iter: T) -> SynonymMap<K, V> { let mut map = SynonymMap::new(); for (k, v) in iter { map.insert(k, v); } map } } impl<K: Eq + Hash + Debug, V: Debug> Debug for SynonymMap<K, V> { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { try!(self.vals.fmt(f)); write!(f, " (synomyns: {:?})", self.syns) } }
new
identifier_name
synonym.rs
use std::collections::HashMap; use std::collections::hash_map::{Iter, Keys}; use std::fmt::Debug; use std::hash::Hash; use std::iter::{FromIterator, IntoIterator}; use std::mem; #[derive(Clone)] pub struct SynonymMap<K, V> { vals: HashMap<K, V>, syns: HashMap<K, K>, } impl<K: Eq + Hash, V> SynonymMap<K, V> { pub fn new() -> SynonymMap<K, V> { SynonymMap { vals: HashMap::new(), syns: HashMap::new(), } } pub fn insert_synonym(&mut self, from: K, to: K) -> bool { assert!(self.vals.contains_key(&to)); self.syns.insert(from, to).is_none() } pub fn keys<'a>(&'a self) -> Keys<'a, K, V> { self.vals.keys() } pub fn iter<'a>(&'a self) -> Iter<'a, K, V> { self.vals.iter() } pub fn synonyms<'a>(&'a self) -> Iter<'a, K, K> { self.syns.iter() } pub fn find<'a>(&'a self, k: &K) -> Option<&'a V>
pub fn contains_key(&self, k: &K) -> bool { self.with_key(k, |k| self.vals.contains_key(k)) } pub fn len(&self) -> usize { self.vals.len() } fn with_key<T, F>(&self, k: &K, with: F) -> T where F: FnOnce(&K) -> T { if self.syns.contains_key(k) { with(&self.syns[k]) } else { with(k) } } } impl<K: Eq + Hash + Clone, V> SynonymMap<K, V> { pub fn resolve(&self, k: &K) -> K { self.with_key(k, |k| k.clone()) } pub fn get<'a>(&'a self, k: &K) -> &'a V { self.find(k).unwrap() } pub fn find_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V> { if self.syns.contains_key(k) { self.vals.get_mut(&self.syns[k]) } else { self.vals.get_mut(k) } } pub fn swap(&mut self, k: K, mut new: V) -> Option<V> { if self.syns.contains_key(&k) { let old = self.vals.get_mut(&k).unwrap(); mem::swap(old, &mut new); Some(new) } else { self.vals.insert(k, new) } } pub fn insert(&mut self, k: K, v: V) -> bool { self.swap(k, v).is_none() } } impl<K: Eq + Hash + Clone, V> FromIterator<(K, V)> for SynonymMap<K, V> { fn from_iter<T: IntoIterator<Item=(K, V)>>(iter: T) -> SynonymMap<K, V> { let mut map = SynonymMap::new(); for (k, v) in iter { map.insert(k, v); } map } } impl<K: Eq + Hash + Debug, V: Debug> Debug for SynonymMap<K, V> { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { try!(self.vals.fmt(f)); write!(f, " (synomyns: {:?})", self.syns) } }
{ self.with_key(k, |k| self.vals.get(k)) }
identifier_body
base.rs
use std::io::Write; pub enum Color { Reset, Black, White, Grey, } // Shamelessly stolen from termios // which doesn't compile on Win32 // which is why I'm doing all this nonsense in the first place pub enum Event { Key(Key), Mouse(MouseEvent), Unsupported(Vec<u32>), } // Derived from termios, with modifications // Precedence **must** be Ctrl(Alt(Shift())) in that order #[derive(PartialEq, Eq, Hash, Debug, Clone)] pub enum Key { Backspace, Left, Right, Up, Down, Home, End, PageUp, PageDown, Delete, Insert,
F(u8), Char(char), Shift(Box<Key>), Alt(Box<Key>), Ctrl(Box<Key>), Null, Esc, } impl Key { pub fn is_char(&self) -> bool { match self { &Key::Char(_) => true, _ => false } } pub fn is_navigation(&self) -> bool { match self { &Key::Left | &Key::Right | &Key::Up | &Key::Down | &Key::Home | &Key::End | &Key::PageUp | &Key::PageDown => true, _ => false } } } // Also termios pub enum MouseEvent { Press(MouseButton, i32, i32), Release(i32, i32), Hold(i32, i32), } // Still termios pub enum MouseButton { Left, Right, Middle, WheelUp, WheelDown, } // Me again pub trait TermImpl: Write + Default { fn get_size(&self) -> (i32, i32); fn goto(&mut self, (i32, i32)); fn set_color_fg(&mut self, Color); fn set_color_bg(&mut self, Color); fn clear(&mut self); // fn keys(&mut self) -> Iterator<Item = Event>; }
random_line_split
base.rs
use std::io::Write; pub enum Color { Reset, Black, White, Grey, } // Shamelessly stolen from termios // which doesn't compile on Win32 // which is why I'm doing all this nonsense in the first place pub enum Event { Key(Key), Mouse(MouseEvent), Unsupported(Vec<u32>), } // Derived from termios, with modifications // Precedence **must** be Ctrl(Alt(Shift())) in that order #[derive(PartialEq, Eq, Hash, Debug, Clone)] pub enum Key { Backspace, Left, Right, Up, Down, Home, End, PageUp, PageDown, Delete, Insert, F(u8), Char(char), Shift(Box<Key>), Alt(Box<Key>), Ctrl(Box<Key>), Null, Esc, } impl Key { pub fn
(&self) -> bool { match self { &Key::Char(_) => true, _ => false } } pub fn is_navigation(&self) -> bool { match self { &Key::Left | &Key::Right | &Key::Up | &Key::Down | &Key::Home | &Key::End | &Key::PageUp | &Key::PageDown => true, _ => false } } } // Also termios pub enum MouseEvent { Press(MouseButton, i32, i32), Release(i32, i32), Hold(i32, i32), } // Still termios pub enum MouseButton { Left, Right, Middle, WheelUp, WheelDown, } // Me again pub trait TermImpl: Write + Default { fn get_size(&self) -> (i32, i32); fn goto(&mut self, (i32, i32)); fn set_color_fg(&mut self, Color); fn set_color_bg(&mut self, Color); fn clear(&mut self); // fn keys(&mut self) -> Iterator<Item = Event>; }
is_char
identifier_name
status.rs
// Copyright (C) 2016 Stefan Luecke // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as published // by the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program 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 Affero General Public License for more details. // // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // // Authors: Stefan Luecke <[email protected]> extern crate telegram_bot; extern crate hyper; use std::io::Read; use std::str::FromStr; use handler::Handler; pub struct StatusHandler { }
impl StatusHandler { pub fn new() -> StatusHandler { StatusHandler {} } } impl Handler for StatusHandler { fn msg_type() -> telegram_bot::MessageType { telegram_bot::MessageType::Text("".to_string()) } fn command() -> Vec<String> { vec![String::from_str("/status").unwrap()] } fn process(&self, m: telegram_bot::Message, a: telegram_bot::Api) -> Result<telegram_bot::Message, telegram_bot::Error> { let client = hyper::client::Client::new(); let status = client.get("https://labctl.openlab-augsburg.de/sphincter/?action=state") .send(); let name = m.from.first_name; match status { Ok(mut response) => { let mut buf = String::new(); let body = response.read_to_string(&mut buf); match body { Ok(_) => { return a.send_message(m.chat.id(), format!("Hey {}! The Lab status is {}", name, buf), None, None, None, None) } Err(e) => { println!("Error: {}", e); return a.send_message(m.chat.id(), format!("Sorry {}! The Lab status is currently \ unavailable. Please Try again later.", name), None, None, None, None); } } } Err(e) => { println!("Error: {}", e); return a.send_message(m.chat.id(), format!("Sorry {}! The Lab status is currently \ unavailable. Please Try again later.", name), None, None, None, None); } } } }
random_line_split
status.rs
// Copyright (C) 2016 Stefan Luecke // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as published // by the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program 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 Affero General Public License for more details. // // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // // Authors: Stefan Luecke <[email protected]> extern crate telegram_bot; extern crate hyper; use std::io::Read; use std::str::FromStr; use handler::Handler; pub struct StatusHandler { } impl StatusHandler { pub fn new() -> StatusHandler
} impl Handler for StatusHandler { fn msg_type() -> telegram_bot::MessageType { telegram_bot::MessageType::Text("".to_string()) } fn command() -> Vec<String> { vec![String::from_str("/status").unwrap()] } fn process(&self, m: telegram_bot::Message, a: telegram_bot::Api) -> Result<telegram_bot::Message, telegram_bot::Error> { let client = hyper::client::Client::new(); let status = client.get("https://labctl.openlab-augsburg.de/sphincter/?action=state") .send(); let name = m.from.first_name; match status { Ok(mut response) => { let mut buf = String::new(); let body = response.read_to_string(&mut buf); match body { Ok(_) => { return a.send_message(m.chat.id(), format!("Hey {}! The Lab status is {}", name, buf), None, None, None, None) } Err(e) => { println!("Error: {}", e); return a.send_message(m.chat.id(), format!("Sorry {}! The Lab status is currently \ unavailable. Please Try again later.", name), None, None, None, None); } } } Err(e) => { println!("Error: {}", e); return a.send_message(m.chat.id(), format!("Sorry {}! The Lab status is currently \ unavailable. Please Try again later.", name), None, None, None, None); } } } }
{ StatusHandler {} }
identifier_body
status.rs
// Copyright (C) 2016 Stefan Luecke // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as published // by the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program 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 Affero General Public License for more details. // // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // // Authors: Stefan Luecke <[email protected]> extern crate telegram_bot; extern crate hyper; use std::io::Read; use std::str::FromStr; use handler::Handler; pub struct StatusHandler { } impl StatusHandler { pub fn
() -> StatusHandler { StatusHandler {} } } impl Handler for StatusHandler { fn msg_type() -> telegram_bot::MessageType { telegram_bot::MessageType::Text("".to_string()) } fn command() -> Vec<String> { vec![String::from_str("/status").unwrap()] } fn process(&self, m: telegram_bot::Message, a: telegram_bot::Api) -> Result<telegram_bot::Message, telegram_bot::Error> { let client = hyper::client::Client::new(); let status = client.get("https://labctl.openlab-augsburg.de/sphincter/?action=state") .send(); let name = m.from.first_name; match status { Ok(mut response) => { let mut buf = String::new(); let body = response.read_to_string(&mut buf); match body { Ok(_) => { return a.send_message(m.chat.id(), format!("Hey {}! The Lab status is {}", name, buf), None, None, None, None) } Err(e) => { println!("Error: {}", e); return a.send_message(m.chat.id(), format!("Sorry {}! The Lab status is currently \ unavailable. Please Try again later.", name), None, None, None, None); } } } Err(e) => { println!("Error: {}", e); return a.send_message(m.chat.id(), format!("Sorry {}! The Lab status is currently \ unavailable. Please Try again later.", name), None, None, None, None); } } } }
new
identifier_name
render.rs
use smithay::{ backend::renderer::{Frame, ImportAll, Renderer}, desktop::{ draw_window, space::{DynamicRenderElements, RenderError, Space}, }, utils::{Logical, Rectangle}, wayland::output::Output, }; use crate::{drawing::*, shell::FullscreenSurface}; pub fn render_output<R>( output: &Output, space: &mut Space, renderer: &mut R, age: usize, elements: &[DynamicRenderElements<R>], log: &slog::Logger, ) -> Result<Option<Vec<Rectangle<i32, Logical>>>, RenderError<R>> where R: Renderer + ImportAll +'static, R::Frame:'static, R::TextureId:'static, R::Error:'static, { if let Some(window) = output .user_data() .get::<FullscreenSurface>() .and_then(|f| f.get()) { let transform = output.current_transform().into(); let mode = output.current_mode().unwrap(); let scale = space.output_scale(output).unwrap(); let output_geo = space .output_geometry(output) .unwrap_or_else(|| Rectangle::from_loc_and_size((0, 0), (0, 0))); renderer .render(mode.size, transform, |renderer, frame| { let mut damage = window.accumulated_damage(None); frame.clear(CLEAR_COLOR, &[Rectangle::from_loc_and_size((0, 0), mode.size)])?; draw_window( renderer, frame, &window, scale, (0, 0), &[Rectangle::from_loc_and_size( (0, 0), mode.size.to_f64().to_logical(scale).to_i32_round(), )], log, )?; for elem in elements { let geo = elem.geometry(); let location = geo.loc - output_geo.loc; let elem_damage = elem.accumulated_damage(None); elem.draw( renderer, frame, scale, location, &[Rectangle::from_loc_and_size((0, 0), geo.size)], log, )?; damage.extend(elem_damage.into_iter().map(|mut rect| { rect.loc += geo.loc; rect })) } Ok(Some(damage)) }) .and_then(std::convert::identity) .map_err(RenderError::<R>::Rendering) } else
}
{ space.render_output(&mut *renderer, output, age as usize, CLEAR_COLOR, &*elements) }
conditional_block
render.rs
use smithay::{ backend::renderer::{Frame, ImportAll, Renderer}, desktop::{ draw_window, space::{DynamicRenderElements, RenderError, Space}, }, utils::{Logical, Rectangle}, wayland::output::Output, }; use crate::{drawing::*, shell::FullscreenSurface}; pub fn render_output<R>( output: &Output, space: &mut Space, renderer: &mut R, age: usize, elements: &[DynamicRenderElements<R>], log: &slog::Logger, ) -> Result<Option<Vec<Rectangle<i32, Logical>>>, RenderError<R>> where R: Renderer + ImportAll +'static, R::Frame:'static, R::TextureId:'static, R::Error:'static,
scale, (0, 0), &[Rectangle::from_loc_and_size( (0, 0), mode.size.to_f64().to_logical(scale).to_i32_round(), )], log, )?; for elem in elements { let geo = elem.geometry(); let location = geo.loc - output_geo.loc; let elem_damage = elem.accumulated_damage(None); elem.draw( renderer, frame, scale, location, &[Rectangle::from_loc_and_size((0, 0), geo.size)], log, )?; damage.extend(elem_damage.into_iter().map(|mut rect| { rect.loc += geo.loc; rect })) } Ok(Some(damage)) }) .and_then(std::convert::identity) .map_err(RenderError::<R>::Rendering) } else { space.render_output(&mut *renderer, output, age as usize, CLEAR_COLOR, &*elements) } }
{ if let Some(window) = output .user_data() .get::<FullscreenSurface>() .and_then(|f| f.get()) { let transform = output.current_transform().into(); let mode = output.current_mode().unwrap(); let scale = space.output_scale(output).unwrap(); let output_geo = space .output_geometry(output) .unwrap_or_else(|| Rectangle::from_loc_and_size((0, 0), (0, 0))); renderer .render(mode.size, transform, |renderer, frame| { let mut damage = window.accumulated_damage(None); frame.clear(CLEAR_COLOR, &[Rectangle::from_loc_and_size((0, 0), mode.size)])?; draw_window( renderer, frame, &window,
identifier_body
render.rs
use smithay::{ backend::renderer::{Frame, ImportAll, Renderer}, desktop::{ draw_window, space::{DynamicRenderElements, RenderError, Space}, }, utils::{Logical, Rectangle}, wayland::output::Output, }; use crate::{drawing::*, shell::FullscreenSurface}; pub fn
<R>( output: &Output, space: &mut Space, renderer: &mut R, age: usize, elements: &[DynamicRenderElements<R>], log: &slog::Logger, ) -> Result<Option<Vec<Rectangle<i32, Logical>>>, RenderError<R>> where R: Renderer + ImportAll +'static, R::Frame:'static, R::TextureId:'static, R::Error:'static, { if let Some(window) = output .user_data() .get::<FullscreenSurface>() .and_then(|f| f.get()) { let transform = output.current_transform().into(); let mode = output.current_mode().unwrap(); let scale = space.output_scale(output).unwrap(); let output_geo = space .output_geometry(output) .unwrap_or_else(|| Rectangle::from_loc_and_size((0, 0), (0, 0))); renderer .render(mode.size, transform, |renderer, frame| { let mut damage = window.accumulated_damage(None); frame.clear(CLEAR_COLOR, &[Rectangle::from_loc_and_size((0, 0), mode.size)])?; draw_window( renderer, frame, &window, scale, (0, 0), &[Rectangle::from_loc_and_size( (0, 0), mode.size.to_f64().to_logical(scale).to_i32_round(), )], log, )?; for elem in elements { let geo = elem.geometry(); let location = geo.loc - output_geo.loc; let elem_damage = elem.accumulated_damage(None); elem.draw( renderer, frame, scale, location, &[Rectangle::from_loc_and_size((0, 0), geo.size)], log, )?; damage.extend(elem_damage.into_iter().map(|mut rect| { rect.loc += geo.loc; rect })) } Ok(Some(damage)) }) .and_then(std::convert::identity) .map_err(RenderError::<R>::Rendering) } else { space.render_output(&mut *renderer, output, age as usize, CLEAR_COLOR, &*elements) } }
render_output
identifier_name
render.rs
use smithay::{ backend::renderer::{Frame, ImportAll, Renderer}, desktop::{ draw_window, space::{DynamicRenderElements, RenderError, Space}, }, utils::{Logical, Rectangle}, wayland::output::Output, }; use crate::{drawing::*, shell::FullscreenSurface}; pub fn render_output<R>( output: &Output, space: &mut Space, renderer: &mut R, age: usize, elements: &[DynamicRenderElements<R>], log: &slog::Logger, ) -> Result<Option<Vec<Rectangle<i32, Logical>>>, RenderError<R>> where R: Renderer + ImportAll +'static, R::Frame:'static,
{ if let Some(window) = output .user_data() .get::<FullscreenSurface>() .and_then(|f| f.get()) { let transform = output.current_transform().into(); let mode = output.current_mode().unwrap(); let scale = space.output_scale(output).unwrap(); let output_geo = space .output_geometry(output) .unwrap_or_else(|| Rectangle::from_loc_and_size((0, 0), (0, 0))); renderer .render(mode.size, transform, |renderer, frame| { let mut damage = window.accumulated_damage(None); frame.clear(CLEAR_COLOR, &[Rectangle::from_loc_and_size((0, 0), mode.size)])?; draw_window( renderer, frame, &window, scale, (0, 0), &[Rectangle::from_loc_and_size( (0, 0), mode.size.to_f64().to_logical(scale).to_i32_round(), )], log, )?; for elem in elements { let geo = elem.geometry(); let location = geo.loc - output_geo.loc; let elem_damage = elem.accumulated_damage(None); elem.draw( renderer, frame, scale, location, &[Rectangle::from_loc_and_size((0, 0), geo.size)], log, )?; damage.extend(elem_damage.into_iter().map(|mut rect| { rect.loc += geo.loc; rect })) } Ok(Some(damage)) }) .and_then(std::convert::identity) .map_err(RenderError::<R>::Rendering) } else { space.render_output(&mut *renderer, output, age as usize, CLEAR_COLOR, &*elements) } }
R::TextureId: 'static, R::Error: 'static,
random_line_split
advent20.rs
// advent20.rs // factorizing // Used the first crate I found that did what I needed; turned out to be quite slow, oh well extern crate tcorp_math_mods; use std::io; fn main() { let mut input = String::new(); io::stdin().read_line(&mut input) .ok() .expect("Failed to read line"); let presents = input.trim().parse::<u32>().unwrap(); println!("first house: {}", find_lowest_house(presents)); println!("first house part 2: {}", find_lowest_house2(presents)); } fn find_lowest_house(min_presents: u32) -> u32 { (1u32..).find(|x| count_presents(*x) >= min_presents).unwrap() } fn count_presents(house: u32) -> u32 { assert!(house > 0); 10 * tcorp_math_mods::factors::factors_for(house).iter().fold(0, |acc, x| acc + x) } #[test] fn
() { assert_eq!(10, count_presents(1)); assert_eq!(30, count_presents(2)); assert_eq!(40, count_presents(3)); assert_eq!(70, count_presents(4)); assert_eq!(60, count_presents(5)); assert_eq!(120, count_presents(6)); assert_eq!(80, count_presents(7)); assert_eq!(150, count_presents(8)); assert_eq!(130, count_presents(9)); } #[test] fn test_find_lowest_house() { assert_eq!(6, find_lowest_house(100)); assert_eq!(6, find_lowest_house(120)); assert_eq!(8, find_lowest_house(121)); } // part 2 fn find_lowest_house2(min_presents: u32) -> u32 { (1u32..).find(|x| count_presents2(*x) >= min_presents).unwrap() } fn count_presents2(house: u32) -> u32 { assert!(house > 0); let v = tcorp_math_mods::factors::factors_for(house); // skip the factors that are less than house/50 let mut split_idx = 0; for x in v.iter() { if *x * 50 >= house { break; } split_idx += 1; } let (_, factors) = v.split_at(split_idx); 11 * factors.iter().fold(0, |acc, x| acc + x) } #[test] fn test_count_presents2() { assert_eq!(11, count_presents2(1)); assert_eq!(33, count_presents2(2)); assert_eq!(44, count_presents2(3)); assert_eq!(77, count_presents2(4)); assert_eq!(66, count_presents2(5)); assert_eq!(132, count_presents2(6)); assert_eq!(88, count_presents2(7)); assert_eq!(165, count_presents2(8)); assert_eq!(143, count_presents2(9)); assert_eq!(count_presents(50) / 10 * 11, count_presents2(50)); assert_eq!(count_presents(51) / 10 * 11 - 11, count_presents2(51)); } #[test] fn test_find_lowest_house2() { assert_eq!(6, find_lowest_house2(100)); assert_eq!(6, find_lowest_house2(132)); assert_eq!(8, find_lowest_house2(133)); }
test_count_presents
identifier_name
advent20.rs
// advent20.rs // factorizing // Used the first crate I found that did what I needed; turned out to be quite slow, oh well extern crate tcorp_math_mods; use std::io; fn main() { let mut input = String::new(); io::stdin().read_line(&mut input) .ok() .expect("Failed to read line"); let presents = input.trim().parse::<u32>().unwrap(); println!("first house: {}", find_lowest_house(presents)); println!("first house part 2: {}", find_lowest_house2(presents)); } fn find_lowest_house(min_presents: u32) -> u32 { (1u32..).find(|x| count_presents(*x) >= min_presents).unwrap() } fn count_presents(house: u32) -> u32 { assert!(house > 0); 10 * tcorp_math_mods::factors::factors_for(house).iter().fold(0, |acc, x| acc + x) } #[test] fn test_count_presents() { assert_eq!(10, count_presents(1)); assert_eq!(30, count_presents(2)); assert_eq!(40, count_presents(3)); assert_eq!(70, count_presents(4)); assert_eq!(60, count_presents(5)); assert_eq!(120, count_presents(6)); assert_eq!(80, count_presents(7)); assert_eq!(150, count_presents(8)); assert_eq!(130, count_presents(9)); } #[test] fn test_find_lowest_house() { assert_eq!(6, find_lowest_house(100)); assert_eq!(6, find_lowest_house(120)); assert_eq!(8, find_lowest_house(121)); } // part 2 fn find_lowest_house2(min_presents: u32) -> u32
fn count_presents2(house: u32) -> u32 { assert!(house > 0); let v = tcorp_math_mods::factors::factors_for(house); // skip the factors that are less than house/50 let mut split_idx = 0; for x in v.iter() { if *x * 50 >= house { break; } split_idx += 1; } let (_, factors) = v.split_at(split_idx); 11 * factors.iter().fold(0, |acc, x| acc + x) } #[test] fn test_count_presents2() { assert_eq!(11, count_presents2(1)); assert_eq!(33, count_presents2(2)); assert_eq!(44, count_presents2(3)); assert_eq!(77, count_presents2(4)); assert_eq!(66, count_presents2(5)); assert_eq!(132, count_presents2(6)); assert_eq!(88, count_presents2(7)); assert_eq!(165, count_presents2(8)); assert_eq!(143, count_presents2(9)); assert_eq!(count_presents(50) / 10 * 11, count_presents2(50)); assert_eq!(count_presents(51) / 10 * 11 - 11, count_presents2(51)); } #[test] fn test_find_lowest_house2() { assert_eq!(6, find_lowest_house2(100)); assert_eq!(6, find_lowest_house2(132)); assert_eq!(8, find_lowest_house2(133)); }
{ (1u32..).find(|x| count_presents2(*x) >= min_presents).unwrap() }
identifier_body
advent20.rs
// advent20.rs // factorizing // Used the first crate I found that did what I needed; turned out to be quite slow, oh well extern crate tcorp_math_mods; use std::io; fn main() { let mut input = String::new(); io::stdin().read_line(&mut input) .ok() .expect("Failed to read line"); let presents = input.trim().parse::<u32>().unwrap(); println!("first house: {}", find_lowest_house(presents)); println!("first house part 2: {}", find_lowest_house2(presents)); } fn find_lowest_house(min_presents: u32) -> u32 { (1u32..).find(|x| count_presents(*x) >= min_presents).unwrap() } fn count_presents(house: u32) -> u32 { assert!(house > 0); 10 * tcorp_math_mods::factors::factors_for(house).iter().fold(0, |acc, x| acc + x) } #[test] fn test_count_presents() { assert_eq!(10, count_presents(1)); assert_eq!(30, count_presents(2)); assert_eq!(40, count_presents(3)); assert_eq!(70, count_presents(4)); assert_eq!(60, count_presents(5)); assert_eq!(120, count_presents(6)); assert_eq!(80, count_presents(7)); assert_eq!(150, count_presents(8)); assert_eq!(130, count_presents(9)); } #[test] fn test_find_lowest_house() { assert_eq!(6, find_lowest_house(100)); assert_eq!(6, find_lowest_house(120)); assert_eq!(8, find_lowest_house(121)); } // part 2 fn find_lowest_house2(min_presents: u32) -> u32 { (1u32..).find(|x| count_presents2(*x) >= min_presents).unwrap() } fn count_presents2(house: u32) -> u32 { assert!(house > 0); let v = tcorp_math_mods::factors::factors_for(house); // skip the factors that are less than house/50 let mut split_idx = 0; for x in v.iter() { if *x * 50 >= house
split_idx += 1; } let (_, factors) = v.split_at(split_idx); 11 * factors.iter().fold(0, |acc, x| acc + x) } #[test] fn test_count_presents2() { assert_eq!(11, count_presents2(1)); assert_eq!(33, count_presents2(2)); assert_eq!(44, count_presents2(3)); assert_eq!(77, count_presents2(4)); assert_eq!(66, count_presents2(5)); assert_eq!(132, count_presents2(6)); assert_eq!(88, count_presents2(7)); assert_eq!(165, count_presents2(8)); assert_eq!(143, count_presents2(9)); assert_eq!(count_presents(50) / 10 * 11, count_presents2(50)); assert_eq!(count_presents(51) / 10 * 11 - 11, count_presents2(51)); } #[test] fn test_find_lowest_house2() { assert_eq!(6, find_lowest_house2(100)); assert_eq!(6, find_lowest_house2(132)); assert_eq!(8, find_lowest_house2(133)); }
{ break; }
conditional_block
advent20.rs
// advent20.rs // factorizing // Used the first crate I found that did what I needed; turned out to be quite slow, oh well extern crate tcorp_math_mods; use std::io; fn main() { let mut input = String::new(); io::stdin().read_line(&mut input) .ok() .expect("Failed to read line"); let presents = input.trim().parse::<u32>().unwrap(); println!("first house: {}", find_lowest_house(presents)); println!("first house part 2: {}", find_lowest_house2(presents)); } fn find_lowest_house(min_presents: u32) -> u32 { (1u32..).find(|x| count_presents(*x) >= min_presents).unwrap() } fn count_presents(house: u32) -> u32 { assert!(house > 0); 10 * tcorp_math_mods::factors::factors_for(house).iter().fold(0, |acc, x| acc + x) } #[test] fn test_count_presents() { assert_eq!(10, count_presents(1)); assert_eq!(30, count_presents(2)); assert_eq!(40, count_presents(3)); assert_eq!(70, count_presents(4)); assert_eq!(60, count_presents(5)); assert_eq!(120, count_presents(6)); assert_eq!(80, count_presents(7)); assert_eq!(150, count_presents(8)); assert_eq!(130, count_presents(9)); } #[test] fn test_find_lowest_house() { assert_eq!(6, find_lowest_house(100)); assert_eq!(6, find_lowest_house(120));
fn find_lowest_house2(min_presents: u32) -> u32 { (1u32..).find(|x| count_presents2(*x) >= min_presents).unwrap() } fn count_presents2(house: u32) -> u32 { assert!(house > 0); let v = tcorp_math_mods::factors::factors_for(house); // skip the factors that are less than house/50 let mut split_idx = 0; for x in v.iter() { if *x * 50 >= house { break; } split_idx += 1; } let (_, factors) = v.split_at(split_idx); 11 * factors.iter().fold(0, |acc, x| acc + x) } #[test] fn test_count_presents2() { assert_eq!(11, count_presents2(1)); assert_eq!(33, count_presents2(2)); assert_eq!(44, count_presents2(3)); assert_eq!(77, count_presents2(4)); assert_eq!(66, count_presents2(5)); assert_eq!(132, count_presents2(6)); assert_eq!(88, count_presents2(7)); assert_eq!(165, count_presents2(8)); assert_eq!(143, count_presents2(9)); assert_eq!(count_presents(50) / 10 * 11, count_presents2(50)); assert_eq!(count_presents(51) / 10 * 11 - 11, count_presents2(51)); } #[test] fn test_find_lowest_house2() { assert_eq!(6, find_lowest_house2(100)); assert_eq!(6, find_lowest_house2(132)); assert_eq!(8, find_lowest_house2(133)); }
assert_eq!(8, find_lowest_house(121)); } // part 2
random_line_split
transform.rs
// Copyright (C) 2011 The Android Open Source Project // // 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. #pragma version(1) #pragma rs java_package_name(com.android.modelviewer) #include "scenegraph_objects.rsh" rs_script gTransformScript; typedef struct { int changed; rs_matrix4x4 *mat; } ParentData; //#define DEBUG_TRANSFORMS static void debugTransform(SgTransform *data, const ParentData *parent) { rsDebug("****** <Transform> ******", (int)data); printName(data->name); rsDebug("isDirty", data->isDirty); rsDebug("parent", (int)parent); rsDebug("child ", rsIsObject(data->children)); // Refresh matrices if dirty if (data->isDirty && rsIsObject(data->components)) { uint32_t numComponenets = rsAllocationGetDimX(data->components); for (int i = 0; i < numComponenets; i ++) { const SgTransformComponent *comp = NULL; comp = (const SgTransformComponent *)rsGetElementAt(data->components, i); if (rsIsObject(comp->name)) { rsDebug((const char*)rsGetElementAt(comp->name, 0), comp->value); rsDebug("Type", comp->type); } else { rsDebug("no name", comp->value); rsDebug("Type", comp->type); } } } rsDebug("timestamp", data->timestamp); rsDebug("****** </Transform> ******", (int)data); } static void appendTransformation(int type, float4 data, rs_matrix4x4 *mat) { rs_matrix4x4 temp; switch (type) { case TRANSFORM_TRANSLATE: rsMatrixLoadTranslate(&temp, data.x, data.y, data.z); break; case TRANSFORM_ROTATE: rsMatrixLoadRotate(&temp, data.w, data.x, data.y, data.z); break; case TRANSFORM_SCALE: rsMatrixLoadScale(&temp, data.x, data.y, data.z); break; } rsMatrixMultiply(mat, &temp); } void root(const rs_allocation *v_in, rs_allocation *v_out, const void *usrData) { SgTransform *data = (SgTransform *)rsGetElementAt(*v_in, 0); const ParentData *parent = (const ParentData *)usrData; #ifdef DEBUG_TRANSFORMS debugTransform(data, parent); #endif //DEBUG_TRANSFORMS rs_matrix4x4 *localMat = &data->localMat; rs_matrix4x4 *globalMat = &data->globalMat; // Refresh matrices if dirty if (data->isDirty && rsIsObject(data->components)) { bool resetLocal = false; uint32_t numComponenets = rsAllocationGetDimX(data->components); for (int i = 0; i < numComponenets; i ++) { if (!resetLocal) { // Reset our local matrix only for component transforms rsMatrixLoadIdentity(localMat); resetLocal = true; } const SgTransformComponent *comp = NULL; comp = (const SgTransformComponent *)rsGetElementAt(data->components, i); appendTransformation(comp->type, comp->value, localMat); } } if (parent) { data->isDirty = (parent->changed || data->isDirty)? 1 : 0; if (data->isDirty) { rsMatrixLoad(globalMat, parent->mat); rsMatrixMultiply(globalMat, localMat); } } else if (data->isDirty) { rsMatrixLoad(globalMat, localMat); } ParentData toChild; toChild.changed = 0; toChild.mat = globalMat; if (data->isDirty)
if (rsIsObject(data->children)) { rs_allocation nullAlloc; rsForEach(gTransformScript, data->children, nullAlloc, &toChild, sizeof(toChild)); } data->isDirty = 0; }
{ toChild.changed = 1; data->timestamp ++; }
conditional_block
transform.rs
// Copyright (C) 2011 The Android Open Source Project // // 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. #pragma version(1) #pragma rs java_package_name(com.android.modelviewer) #include "scenegraph_objects.rsh" rs_script gTransformScript; typedef struct { int changed; rs_matrix4x4 *mat; } ParentData; //#define DEBUG_TRANSFORMS static void debugTransform(SgTransform *data, const ParentData *parent) { rsDebug("****** <Transform> ******", (int)data); printName(data->name); rsDebug("isDirty", data->isDirty); rsDebug("parent", (int)parent); rsDebug("child ", rsIsObject(data->children)); // Refresh matrices if dirty if (data->isDirty && rsIsObject(data->components)) { uint32_t numComponenets = rsAllocationGetDimX(data->components); for (int i = 0; i < numComponenets; i ++) { const SgTransformComponent *comp = NULL; comp = (const SgTransformComponent *)rsGetElementAt(data->components, i); if (rsIsObject(comp->name)) { rsDebug((const char*)rsGetElementAt(comp->name, 0), comp->value); rsDebug("Type", comp->type); } else { rsDebug("no name", comp->value); rsDebug("Type", comp->type); } } } rsDebug("timestamp", data->timestamp); rsDebug("****** </Transform> ******", (int)data); } static void appendTransformation(int type, float4 data, rs_matrix4x4 *mat) { rs_matrix4x4 temp; switch (type) {
rsMatrixLoadRotate(&temp, data.w, data.x, data.y, data.z); break; case TRANSFORM_SCALE: rsMatrixLoadScale(&temp, data.x, data.y, data.z); break; } rsMatrixMultiply(mat, &temp); } void root(const rs_allocation *v_in, rs_allocation *v_out, const void *usrData) { SgTransform *data = (SgTransform *)rsGetElementAt(*v_in, 0); const ParentData *parent = (const ParentData *)usrData; #ifdef DEBUG_TRANSFORMS debugTransform(data, parent); #endif //DEBUG_TRANSFORMS rs_matrix4x4 *localMat = &data->localMat; rs_matrix4x4 *globalMat = &data->globalMat; // Refresh matrices if dirty if (data->isDirty && rsIsObject(data->components)) { bool resetLocal = false; uint32_t numComponenets = rsAllocationGetDimX(data->components); for (int i = 0; i < numComponenets; i ++) { if (!resetLocal) { // Reset our local matrix only for component transforms rsMatrixLoadIdentity(localMat); resetLocal = true; } const SgTransformComponent *comp = NULL; comp = (const SgTransformComponent *)rsGetElementAt(data->components, i); appendTransformation(comp->type, comp->value, localMat); } } if (parent) { data->isDirty = (parent->changed || data->isDirty)? 1 : 0; if (data->isDirty) { rsMatrixLoad(globalMat, parent->mat); rsMatrixMultiply(globalMat, localMat); } } else if (data->isDirty) { rsMatrixLoad(globalMat, localMat); } ParentData toChild; toChild.changed = 0; toChild.mat = globalMat; if (data->isDirty) { toChild.changed = 1; data->timestamp ++; } if (rsIsObject(data->children)) { rs_allocation nullAlloc; rsForEach(gTransformScript, data->children, nullAlloc, &toChild, sizeof(toChild)); } data->isDirty = 0; }
case TRANSFORM_TRANSLATE: rsMatrixLoadTranslate(&temp, data.x, data.y, data.z); break; case TRANSFORM_ROTATE:
random_line_split
regions-infer-invariance-due-to-mutability-4.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. struct Invariant<'a> { f: Box<for<'b> FnOnce() -> &'b mut &'a isize +'static>, } fn to_same_lifetime<'r>(bi: Invariant<'r>) { let bj: Invariant<'r> = bi; } fn to_longer_lifetime<'r>(bi: Invariant<'r>) -> Invariant<'static> { bi //~ ERROR mismatched types }
fn main() { }
random_line_split
regions-infer-invariance-due-to-mutability-4.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. struct Invariant<'a> { f: Box<for<'b> FnOnce() -> &'b mut &'a isize +'static>, } fn to_same_lifetime<'r>(bi: Invariant<'r>) { let bj: Invariant<'r> = bi; } fn to_longer_lifetime<'r>(bi: Invariant<'r>) -> Invariant<'static>
fn main() { }
{ bi //~ ERROR mismatched types }
identifier_body
regions-infer-invariance-due-to-mutability-4.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. struct Invariant<'a> { f: Box<for<'b> FnOnce() -> &'b mut &'a isize +'static>, } fn to_same_lifetime<'r>(bi: Invariant<'r>) { let bj: Invariant<'r> = bi; } fn
<'r>(bi: Invariant<'r>) -> Invariant<'static> { bi //~ ERROR mismatched types } fn main() { }
to_longer_lifetime
identifier_name
lint.rs
use conf; use itertools::Itertools; use lisp::LispExpr; use lisp; use rusqlite as sql; use rustc::hir::*; use rustc::hir::map::Node; use rustc::lint::{LateContext, LintArray, LintContext, LintPass, LateLintPass}; use rustc::ty::TypeVariants; use std::borrow::Cow; use std::io::{Read, Write}; use std::process::{Command, Stdio}; use std::time::Duration; use std; use syntax::ast::MetaItemKind; use syntax::ast::{Attribute, FloatTy}; use wait_timeout::ChildExt; #[derive(Debug, Default)] pub struct Herbie { conf: Option<conf::Conf>, initialized: bool, subs: Vec<(LispExpr, LispExpr)>, } #[derive(Debug)] pub enum InitError { Conf { error: conf::ConfError, }, SQL { error: sql::Error, }, } impl From<conf::ConfError> for InitError { fn from(err: conf::ConfError) -> InitError { InitError::Conf { error: err } } } impl From<sql::Error> for InitError { fn from(err: sql::Error) -> InitError { InitError::SQL { error: err } } } impl std::fmt::Display for InitError { fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { match *self { InitError::Conf { ref error } => write!(f, "Configuration error: {}", error), InitError::SQL { ref error } => write!(f, "Got SQL error: {}", error), } } } impl Herbie { pub fn new() -> Herbie { Herbie::default() } pub fn init(&mut self) -> Result<(), InitError> { if self.initialized { return Ok(()) } self.initialized = true; let conf = try!(conf::read_conf()); let connection = try!(sql::Connection::open_with_flags( conf.db_path.as_ref(), sql::SQLITE_OPEN_READ_ONLY )); let mut query = try!(connection.prepare("SELECT * FROM HerbieResults")); self.subs = try!(query.query(&[])).filter_map(|row| { match row { Ok(row) => { let cmdin : String = row.get(1); let cmdout : String = row.get(2); // row.get(3) is opts ↔ Herbies options let errin = row.get_checked(4).unwrap_or(0.); let errout = row.get_checked(5).unwrap_or(0.); if cmdin == cmdout || errin <= errout { return None; } let mut parser = lisp::Parser::new(); match parser.parse(&cmdin) { Ok(cmdin) => { match parser.parse(&cmdout) { Ok(cmdout) => { Some((cmdin, cmdout)) } Err(..) => None, } } Err(..) => None, } } Err(..) => None, } }).collect(); self.conf = Some(conf); Ok(()) } } declare_lint!(pub HERBIE, Warn, "checks for numerical instability"); impl LintPass for Herbie { fn get_lints(&self) -> LintArray { lint_array!(HERBIE) } } impl LateLintPass for Herbie { fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { fn is
ttr: &Attribute) -> bool { if let MetaItemKind::Word(ref word) = attr.node.value.node { word == &"herbie_ignore" } else { false } } let attrs = match cx.tcx.map.find(cx.tcx.map.get_parent(expr.id)) { Some(Node::NodeItem(item)) => &item.attrs, Some(Node::NodeTraitItem(item)) => &item.attrs, Some(Node::NodeImplItem(item)) => &item.attrs, _ => panic!("In herbie-lint: how did I get there?"), }; if attrs.iter().any(is_herbie_ignore) { return; } let ty = cx.tcx.expr_ty(expr); if ty.sty!= TypeVariants::TyFloat(FloatTy::F64) { return; } if let Err(err) = self.init() { cx.span_lint_note( HERBIE, cx.krate.span, "Could not initialize Herbie-Lint", cx.krate.span, &err.to_string() ); return; } let mut got_match = false; for &(ref cmdin, ref cmdout) in &self.subs { if let Some(bindings) = LispExpr::match_expr(expr, cmdin) { report(cx, expr, cmdout, &bindings); got_match = true; } } let conf = self.conf.as_ref().expect("Configuration should be read by now"); if!got_match && conf.use_herbie!= conf::UseHerbieConf::No { if let Err(err) = try_with_herbie(cx, expr, &conf) { cx.span_lint(HERBIE, expr.span, &err); } } } } fn try_with_herbie(cx: &LateContext, expr: &Expr, conf: &conf::Conf) -> Result<(), Cow<'static, str>> { let (lisp_expr, nb_ids, bindings) = match LispExpr::from_expr(expr) { Some(r) => r, // not an error, the expression might for example contain a function unknown to Herbie None => return Ok(()), }; if lisp_expr.depth() <= 2 { return Ok(()); } let seed: &str = &conf.herbie_seed; let mut command = Command::new("herbie-inout"); let command = command .arg("--seed").arg(seed) .arg("-o").arg("rules:numerics") .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::piped()) ; let mut child = match command.spawn() { Ok(child) => child, Err(err) => { return if conf.use_herbie == conf::UseHerbieConf::Yes { // TODO: wiki Err(format!("Could not call Herbie: {}", err).into()) } else { Ok(()) }; } }; // TODO: link to wiki about Herbie.toml cx.sess().diagnostic().span_note_without_error( expr.span, "Calling Herbie on the following expression, it might take a while" ); let params = (0..nb_ids).map(|id| format!("herbie{}", id)).join(" "); let cmdin = lisp_expr.to_lisp("herbie"); let lisp_expr = format!("(lambda ({}) {})\n", params, cmdin); let lisp_expr = lisp_expr.as_bytes(); child.stdin .as_mut().expect("Herbie-inout's stdin not captured") .write(lisp_expr).expect("Could not write on herbie-inout's stdin") ; match conf.timeout { Some(timeout) => { match child.wait_timeout(Duration::from_secs(timeout as u64)) { Ok(Some(status)) if status.success() => (), Ok(Some(status)) => { return Err(format!("herbie-inout did not return successfully: status={}", status).into()); } Ok(None) => { cx.sess().diagnostic().span_note_without_error(expr.span, "Herbie timed out"); return Ok(()); } Err(err) => { return Err(format!("herbie-inout did not return successfully: {}", err).into()); } } } None => { match child.wait() { Ok(status) if status.success() => (), Ok(status) => { return Err(format!("herbie-inout did not return successfully: status={}", status).into()); } Err(err) => { return Err(format!("herbie-inout did not return successfully: {}", err).into()); } } } } let mut stdout = if let Some(output) = child.stdout { output } else { return Err("cannot capture herbie-inout output".into()); }; let mut output = String::new(); if let Err(err) = stdout.read_to_string(&mut output) { return Err(format!("cannot read output: {}", err).into()); } let mut output = output.lines(); let parse_error = |s: Option<&str>| -> Option<f64> { match s { Some(s) => { match s.split(' ').last().map(str::parse::<f64>) { Some(Ok(f)) => Some(f), _ => None, } } _ => None, } }; let (errin, errout, cmdout) = match (parse_error(output.next()), parse_error(output.next()), output.next()) { (Some(errin), Some(errout), Some(cmdout)) => { (errin, errout, cmdout) } _ => { return Err("Could not parse herbie-inout output".into()) } }; if errin <= errout { return Ok(()); } let mut parser = lisp::Parser::new(); let cmdout = match parser.parse(cmdout) { Ok(cmdout) => cmdout, _ => return Err("Could not understand herbie-inout cmdout".into()), }; report(cx, expr, &cmdout, &bindings); save(conf, &cmdin, &cmdout, "", errin, errout) .map_err(|err| format!("Could not save database, got SQL error {}", err).into()) } fn report(cx: &LateContext, expr: &Expr, cmdout: &LispExpr, bindings: &lisp::MatchBindings) { cx.struct_span_lint(HERBIE, expr.span, "Numerically unstable expression") .span_suggestion(expr.span, "Try this", cmdout.to_rust(cx, &bindings)) .emit(); } fn save( conf: &conf::Conf, cmdin: &str, cmdout: &LispExpr, seed: &str, errin: f64, errout: f64 ) -> Result<(), sql::Error> { let connection = try!(sql::Connection::open_with_flags( conf.db_path.as_ref(), sql::SQLITE_OPEN_READ_WRITE )); try!(connection.execute("INSERT INTO HerbieResults (cmdin, cmdout, opts, errin, errout) VALUES ($1, $2, $3, $4, $5)", &[&cmdin, &cmdout.to_lisp("herbie"), &seed, &errin, &errout])); Ok(()) }
_herbie_ignore(a
identifier_name
lint.rs
use conf; use itertools::Itertools; use lisp::LispExpr; use lisp; use rusqlite as sql; use rustc::hir::*; use rustc::hir::map::Node; use rustc::lint::{LateContext, LintArray, LintContext, LintPass, LateLintPass}; use rustc::ty::TypeVariants; use std::borrow::Cow; use std::io::{Read, Write}; use std::process::{Command, Stdio}; use std::time::Duration; use std; use syntax::ast::MetaItemKind; use syntax::ast::{Attribute, FloatTy}; use wait_timeout::ChildExt; #[derive(Debug, Default)] pub struct Herbie { conf: Option<conf::Conf>, initialized: bool, subs: Vec<(LispExpr, LispExpr)>, } #[derive(Debug)] pub enum InitError { Conf { error: conf::ConfError, }, SQL { error: sql::Error, }, } impl From<conf::ConfError> for InitError { fn from(err: conf::ConfError) -> InitError { InitError::Conf { error: err } } } impl From<sql::Error> for InitError { fn from(err: sql::Error) -> InitError { InitError::SQL { error: err } } } impl std::fmt::Display for InitError { fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { match *self { InitError::Conf { ref error } => write!(f, "Configuration error: {}", error), InitError::SQL { ref error } => write!(f, "Got SQL error: {}", error), } } } impl Herbie { pub fn new() -> Herbie { Herbie::default() } pub fn init(&mut self) -> Result<(), InitError> { if self.initialized { return Ok(()) } self.initialized = true; let conf = try!(conf::read_conf()); let connection = try!(sql::Connection::open_with_flags( conf.db_path.as_ref(), sql::SQLITE_OPEN_READ_ONLY )); let mut query = try!(connection.prepare("SELECT * FROM HerbieResults")); self.subs = try!(query.query(&[])).filter_map(|row| { match row { Ok(row) => { let cmdin : String = row.get(1); let cmdout : String = row.get(2); // row.get(3) is opts ↔ Herbies options let errin = row.get_checked(4).unwrap_or(0.); let errout = row.get_checked(5).unwrap_or(0.); if cmdin == cmdout || errin <= errout { return None; } let mut parser = lisp::Parser::new(); match parser.parse(&cmdin) { Ok(cmdin) => { match parser.parse(&cmdout) { Ok(cmdout) => { Some((cmdin, cmdout)) } Err(..) => None, } } Err(..) => None, } } Err(..) => None, } }).collect(); self.conf = Some(conf); Ok(()) } } declare_lint!(pub HERBIE, Warn, "checks for numerical instability"); impl LintPass for Herbie { fn get_lints(&self) -> LintArray { lint_array!(HERBIE) } } impl LateLintPass for Herbie { fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { fn is_herbie_ignore(attr: &Attribute) -> bool { if let MetaItemKind::Word(ref word) = attr.node.value.node { word == &"herbie_ignore" } else { false } } let attrs = match cx.tcx.map.find(cx.tcx.map.get_parent(expr.id)) { Some(Node::NodeItem(item)) => &item.attrs, Some(Node::NodeTraitItem(item)) => &item.attrs, Some(Node::NodeImplItem(item)) => &item.attrs, _ => panic!("In herbie-lint: how did I get there?"), }; if attrs.iter().any(is_herbie_ignore) { return; } let ty = cx.tcx.expr_ty(expr); if ty.sty!= TypeVariants::TyFloat(FloatTy::F64) { return; } if let Err(err) = self.init() { cx.span_lint_note( HERBIE, cx.krate.span, "Could not initialize Herbie-Lint", cx.krate.span, &err.to_string() ); return; } let mut got_match = false; for &(ref cmdin, ref cmdout) in &self.subs { if let Some(bindings) = LispExpr::match_expr(expr, cmdin) { report(cx, expr, cmdout, &bindings); got_match = true; } } let conf = self.conf.as_ref().expect("Configuration should be read by now"); if!got_match && conf.use_herbie!= conf::UseHerbieConf::No { if let Err(err) = try_with_herbie(cx, expr, &conf) { cx.span_lint(HERBIE, expr.span, &err); } } } } fn try_with_herbie(cx: &LateContext, expr: &Expr, conf: &conf::Conf) -> Result<(), Cow<'static, str>> { let (lisp_expr, nb_ids, bindings) = match LispExpr::from_expr(expr) { Some(r) => r, // not an error, the expression might for example contain a function unknown to Herbie None => return Ok(()), }; if lisp_expr.depth() <= 2 { return Ok(()); } let seed: &str = &conf.herbie_seed; let mut command = Command::new("herbie-inout"); let command = command .arg("--seed").arg(seed) .arg("-o").arg("rules:numerics") .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::piped()) ; let mut child = match command.spawn() { Ok(child) => child, Err(err) => { return if conf.use_herbie == conf::UseHerbieConf::Yes { // TODO: wiki Err(format!("Could not call Herbie: {}", err).into()) } else { Ok(()) }; } }; // TODO: link to wiki about Herbie.toml cx.sess().diagnostic().span_note_without_error( expr.span, "Calling Herbie on the following expression, it might take a while" ); let params = (0..nb_ids).map(|id| format!("herbie{}", id)).join(" "); let cmdin = lisp_expr.to_lisp("herbie"); let lisp_expr = format!("(lambda ({}) {})\n", params, cmdin); let lisp_expr = lisp_expr.as_bytes(); child.stdin .as_mut().expect("Herbie-inout's stdin not captured") .write(lisp_expr).expect("Could not write on herbie-inout's stdin") ; match conf.timeout { Some(timeout) => { match child.wait_timeout(Duration::from_secs(timeout as u64)) { Ok(Some(status)) if status.success() => (), Ok(Some(status)) => { return Err(format!("herbie-inout did not return successfully: status={}", status).into()); } Ok(None) => { cx.sess().diagnostic().span_note_without_error(expr.span, "Herbie timed out"); return Ok(()); } Err(err) => { return Err(format!("herbie-inout did not return successfully: {}", err).into()); } } } None => { match child.wait() { Ok(status) if status.success() => (), Ok(status) => { return Err(format!("herbie-inout did not return successfully: status={}", status).into()); } Err(err) => { return Err(format!("herbie-inout did not return successfully: {}", err).into()); } } } } let mut stdout = if let Some(output) = child.stdout { output } else { return Err("cannot capture herbie-inout output".into()); }; let mut output = String::new();
} let mut output = output.lines(); let parse_error = |s: Option<&str>| -> Option<f64> { match s { Some(s) => { match s.split(' ').last().map(str::parse::<f64>) { Some(Ok(f)) => Some(f), _ => None, } } _ => None, } }; let (errin, errout, cmdout) = match (parse_error(output.next()), parse_error(output.next()), output.next()) { (Some(errin), Some(errout), Some(cmdout)) => { (errin, errout, cmdout) } _ => { return Err("Could not parse herbie-inout output".into()) } }; if errin <= errout { return Ok(()); } let mut parser = lisp::Parser::new(); let cmdout = match parser.parse(cmdout) { Ok(cmdout) => cmdout, _ => return Err("Could not understand herbie-inout cmdout".into()), }; report(cx, expr, &cmdout, &bindings); save(conf, &cmdin, &cmdout, "", errin, errout) .map_err(|err| format!("Could not save database, got SQL error {}", err).into()) } fn report(cx: &LateContext, expr: &Expr, cmdout: &LispExpr, bindings: &lisp::MatchBindings) { cx.struct_span_lint(HERBIE, expr.span, "Numerically unstable expression") .span_suggestion(expr.span, "Try this", cmdout.to_rust(cx, &bindings)) .emit(); } fn save( conf: &conf::Conf, cmdin: &str, cmdout: &LispExpr, seed: &str, errin: f64, errout: f64 ) -> Result<(), sql::Error> { let connection = try!(sql::Connection::open_with_flags( conf.db_path.as_ref(), sql::SQLITE_OPEN_READ_WRITE )); try!(connection.execute("INSERT INTO HerbieResults (cmdin, cmdout, opts, errin, errout) VALUES ($1, $2, $3, $4, $5)", &[&cmdin, &cmdout.to_lisp("herbie"), &seed, &errin, &errout])); Ok(()) }
if let Err(err) = stdout.read_to_string(&mut output) { return Err(format!("cannot read output: {}", err).into());
random_line_split
lint.rs
use conf; use itertools::Itertools; use lisp::LispExpr; use lisp; use rusqlite as sql; use rustc::hir::*; use rustc::hir::map::Node; use rustc::lint::{LateContext, LintArray, LintContext, LintPass, LateLintPass}; use rustc::ty::TypeVariants; use std::borrow::Cow; use std::io::{Read, Write}; use std::process::{Command, Stdio}; use std::time::Duration; use std; use syntax::ast::MetaItemKind; use syntax::ast::{Attribute, FloatTy}; use wait_timeout::ChildExt; #[derive(Debug, Default)] pub struct Herbie { conf: Option<conf::Conf>, initialized: bool, subs: Vec<(LispExpr, LispExpr)>, } #[derive(Debug)] pub enum InitError { Conf { error: conf::ConfError, }, SQL { error: sql::Error, }, } impl From<conf::ConfError> for InitError { fn from(err: conf::ConfError) -> InitError { InitError::Conf { error: err } } } impl From<sql::Error> for InitError { fn from(err: sql::Error) -> InitError { InitError::SQL { error: err } } } impl std::fmt::Display for InitError { fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error>
} impl Herbie { pub fn new() -> Herbie { Herbie::default() } pub fn init(&mut self) -> Result<(), InitError> { if self.initialized { return Ok(()) } self.initialized = true; let conf = try!(conf::read_conf()); let connection = try!(sql::Connection::open_with_flags( conf.db_path.as_ref(), sql::SQLITE_OPEN_READ_ONLY )); let mut query = try!(connection.prepare("SELECT * FROM HerbieResults")); self.subs = try!(query.query(&[])).filter_map(|row| { match row { Ok(row) => { let cmdin : String = row.get(1); let cmdout : String = row.get(2); // row.get(3) is opts ↔ Herbies options let errin = row.get_checked(4).unwrap_or(0.); let errout = row.get_checked(5).unwrap_or(0.); if cmdin == cmdout || errin <= errout { return None; } let mut parser = lisp::Parser::new(); match parser.parse(&cmdin) { Ok(cmdin) => { match parser.parse(&cmdout) { Ok(cmdout) => { Some((cmdin, cmdout)) } Err(..) => None, } } Err(..) => None, } } Err(..) => None, } }).collect(); self.conf = Some(conf); Ok(()) } } declare_lint!(pub HERBIE, Warn, "checks for numerical instability"); impl LintPass for Herbie { fn get_lints(&self) -> LintArray { lint_array!(HERBIE) } } impl LateLintPass for Herbie { fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { fn is_herbie_ignore(attr: &Attribute) -> bool { if let MetaItemKind::Word(ref word) = attr.node.value.node { word == &"herbie_ignore" } else { false } } let attrs = match cx.tcx.map.find(cx.tcx.map.get_parent(expr.id)) { Some(Node::NodeItem(item)) => &item.attrs, Some(Node::NodeTraitItem(item)) => &item.attrs, Some(Node::NodeImplItem(item)) => &item.attrs, _ => panic!("In herbie-lint: how did I get there?"), }; if attrs.iter().any(is_herbie_ignore) { return; } let ty = cx.tcx.expr_ty(expr); if ty.sty!= TypeVariants::TyFloat(FloatTy::F64) { return; } if let Err(err) = self.init() { cx.span_lint_note( HERBIE, cx.krate.span, "Could not initialize Herbie-Lint", cx.krate.span, &err.to_string() ); return; } let mut got_match = false; for &(ref cmdin, ref cmdout) in &self.subs { if let Some(bindings) = LispExpr::match_expr(expr, cmdin) { report(cx, expr, cmdout, &bindings); got_match = true; } } let conf = self.conf.as_ref().expect("Configuration should be read by now"); if!got_match && conf.use_herbie!= conf::UseHerbieConf::No { if let Err(err) = try_with_herbie(cx, expr, &conf) { cx.span_lint(HERBIE, expr.span, &err); } } } } fn try_with_herbie(cx: &LateContext, expr: &Expr, conf: &conf::Conf) -> Result<(), Cow<'static, str>> { let (lisp_expr, nb_ids, bindings) = match LispExpr::from_expr(expr) { Some(r) => r, // not an error, the expression might for example contain a function unknown to Herbie None => return Ok(()), }; if lisp_expr.depth() <= 2 { return Ok(()); } let seed: &str = &conf.herbie_seed; let mut command = Command::new("herbie-inout"); let command = command .arg("--seed").arg(seed) .arg("-o").arg("rules:numerics") .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::piped()) ; let mut child = match command.spawn() { Ok(child) => child, Err(err) => { return if conf.use_herbie == conf::UseHerbieConf::Yes { // TODO: wiki Err(format!("Could not call Herbie: {}", err).into()) } else { Ok(()) }; } }; // TODO: link to wiki about Herbie.toml cx.sess().diagnostic().span_note_without_error( expr.span, "Calling Herbie on the following expression, it might take a while" ); let params = (0..nb_ids).map(|id| format!("herbie{}", id)).join(" "); let cmdin = lisp_expr.to_lisp("herbie"); let lisp_expr = format!("(lambda ({}) {})\n", params, cmdin); let lisp_expr = lisp_expr.as_bytes(); child.stdin .as_mut().expect("Herbie-inout's stdin not captured") .write(lisp_expr).expect("Could not write on herbie-inout's stdin") ; match conf.timeout { Some(timeout) => { match child.wait_timeout(Duration::from_secs(timeout as u64)) { Ok(Some(status)) if status.success() => (), Ok(Some(status)) => { return Err(format!("herbie-inout did not return successfully: status={}", status).into()); } Ok(None) => { cx.sess().diagnostic().span_note_without_error(expr.span, "Herbie timed out"); return Ok(()); } Err(err) => { return Err(format!("herbie-inout did not return successfully: {}", err).into()); } } } None => { match child.wait() { Ok(status) if status.success() => (), Ok(status) => { return Err(format!("herbie-inout did not return successfully: status={}", status).into()); } Err(err) => { return Err(format!("herbie-inout did not return successfully: {}", err).into()); } } } } let mut stdout = if let Some(output) = child.stdout { output } else { return Err("cannot capture herbie-inout output".into()); }; let mut output = String::new(); if let Err(err) = stdout.read_to_string(&mut output) { return Err(format!("cannot read output: {}", err).into()); } let mut output = output.lines(); let parse_error = |s: Option<&str>| -> Option<f64> { match s { Some(s) => { match s.split(' ').last().map(str::parse::<f64>) { Some(Ok(f)) => Some(f), _ => None, } } _ => None, } }; let (errin, errout, cmdout) = match (parse_error(output.next()), parse_error(output.next()), output.next()) { (Some(errin), Some(errout), Some(cmdout)) => { (errin, errout, cmdout) } _ => { return Err("Could not parse herbie-inout output".into()) } }; if errin <= errout { return Ok(()); } let mut parser = lisp::Parser::new(); let cmdout = match parser.parse(cmdout) { Ok(cmdout) => cmdout, _ => return Err("Could not understand herbie-inout cmdout".into()), }; report(cx, expr, &cmdout, &bindings); save(conf, &cmdin, &cmdout, "", errin, errout) .map_err(|err| format!("Could not save database, got SQL error {}", err).into()) } fn report(cx: &LateContext, expr: &Expr, cmdout: &LispExpr, bindings: &lisp::MatchBindings) { cx.struct_span_lint(HERBIE, expr.span, "Numerically unstable expression") .span_suggestion(expr.span, "Try this", cmdout.to_rust(cx, &bindings)) .emit(); } fn save( conf: &conf::Conf, cmdin: &str, cmdout: &LispExpr, seed: &str, errin: f64, errout: f64 ) -> Result<(), sql::Error> { let connection = try!(sql::Connection::open_with_flags( conf.db_path.as_ref(), sql::SQLITE_OPEN_READ_WRITE )); try!(connection.execute("INSERT INTO HerbieResults (cmdin, cmdout, opts, errin, errout) VALUES ($1, $2, $3, $4, $5)", &[&cmdin, &cmdout.to_lisp("herbie"), &seed, &errin, &errout])); Ok(()) }
{ match *self { InitError::Conf { ref error } => write!(f, "Configuration error: {}", error), InitError::SQL { ref error } => write!(f, "Got SQL error: {}", error), } }
identifier_body
coerce-bare-fn-to-closure-and-proc.rs
// Copyright 2014 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. fn foo() {} fn main()
{ let f = foo; let f_closure: || = f; //~^ ERROR: cannot coerce non-statically resolved bare fn to closure //~^^ HELP: consider embedding the function in a closure let f_proc: proc() = f; //~^ ERROR: cannot coerce non-statically resolved bare fn to closure //~^^ HELP: consider embedding the function in a closure }
identifier_body
coerce-bare-fn-to-closure-and-proc.rs
// Copyright 2014 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. fn foo() {}
//~^ ERROR: cannot coerce non-statically resolved bare fn to closure //~^^ HELP: consider embedding the function in a closure let f_proc: proc() = f; //~^ ERROR: cannot coerce non-statically resolved bare fn to closure //~^^ HELP: consider embedding the function in a closure }
fn main() { let f = foo; let f_closure: || = f;
random_line_split
coerce-bare-fn-to-closure-and-proc.rs
// Copyright 2014 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. fn
() {} fn main() { let f = foo; let f_closure: || = f; //~^ ERROR: cannot coerce non-statically resolved bare fn to closure //~^^ HELP: consider embedding the function in a closure let f_proc: proc() = f; //~^ ERROR: cannot coerce non-statically resolved bare fn to closure //~^^ HELP: consider embedding the function in a closure }
foo
identifier_name
file.rs
use std::io::{Read, Write}; use std::io::BufReader; use std::io::BufRead; use std::path::{PathBuf, Path}; use std::fs::{File, DirBuilder, OpenOptions}; pub fn read_file<P: AsRef<Path>>(file: P) -> Result<String, String> { let mut file = File::open(file) .map_err(error_err!()) .map_err(|_| "Can't read the file".to_string())?; let content = { let mut s = String::new(); file.read_to_string(&mut s) .map_err(error_err!()) .map_err(|err| format!("Can't read the file: {}", err))?; s }; Ok(content) } pub fn read_lines_from_file<P: AsRef<Path>>(file: P) -> Result<impl Iterator<Item=Result<String, ::std::io::Error>>, String> { let file = File::open(file) .map_err(error_err!()) .map_err(|_| "Can't read the file".to_string())?; let lines = BufReader::new(file).lines(); Ok(lines) } pub fn write_file<P: AsRef<Path>>(file: P, content: &str) -> Result<(), String> where P: std::convert::AsRef<std::ffi::OsStr> { let path = PathBuf::from(&file); if let Some(parent_path) = path.parent()
let mut file = OpenOptions::new() .write(true) .create(true) .open(path) .map_err(error_err!()) .map_err(|err| format!("Can't open the file: {}", err))?; file .write_all(content.as_bytes()) .map_err(error_err!()) .map_err(|err| format!("Can't write content: \"{}\" to the file: {}", content, err)) }
{ DirBuilder::new() .recursive(true) .create(parent_path) .map_err(error_err!()) .map_err(|err| format!("Can't create the file: {}", err))?; }
conditional_block
file.rs
use std::io::{Read, Write}; use std::io::BufReader; use std::io::BufRead; use std::path::{PathBuf, Path}; use std::fs::{File, DirBuilder, OpenOptions}; pub fn read_file<P: AsRef<Path>>(file: P) -> Result<String, String> { let mut file = File::open(file) .map_err(error_err!()) .map_err(|_| "Can't read the file".to_string())?; let content = {
.map_err(|err| format!("Can't read the file: {}", err))?; s }; Ok(content) } pub fn read_lines_from_file<P: AsRef<Path>>(file: P) -> Result<impl Iterator<Item=Result<String, ::std::io::Error>>, String> { let file = File::open(file) .map_err(error_err!()) .map_err(|_| "Can't read the file".to_string())?; let lines = BufReader::new(file).lines(); Ok(lines) } pub fn write_file<P: AsRef<Path>>(file: P, content: &str) -> Result<(), String> where P: std::convert::AsRef<std::ffi::OsStr> { let path = PathBuf::from(&file); if let Some(parent_path) = path.parent() { DirBuilder::new() .recursive(true) .create(parent_path) .map_err(error_err!()) .map_err(|err| format!("Can't create the file: {}", err))?; } let mut file = OpenOptions::new() .write(true) .create(true) .open(path) .map_err(error_err!()) .map_err(|err| format!("Can't open the file: {}", err))?; file .write_all(content.as_bytes()) .map_err(error_err!()) .map_err(|err| format!("Can't write content: \"{}\" to the file: {}", content, err)) }
let mut s = String::new(); file.read_to_string(&mut s) .map_err(error_err!())
random_line_split
file.rs
use std::io::{Read, Write}; use std::io::BufReader; use std::io::BufRead; use std::path::{PathBuf, Path}; use std::fs::{File, DirBuilder, OpenOptions}; pub fn read_file<P: AsRef<Path>>(file: P) -> Result<String, String> { let mut file = File::open(file) .map_err(error_err!()) .map_err(|_| "Can't read the file".to_string())?; let content = { let mut s = String::new(); file.read_to_string(&mut s) .map_err(error_err!()) .map_err(|err| format!("Can't read the file: {}", err))?; s }; Ok(content) } pub fn read_lines_from_file<P: AsRef<Path>>(file: P) -> Result<impl Iterator<Item=Result<String, ::std::io::Error>>, String> { let file = File::open(file) .map_err(error_err!()) .map_err(|_| "Can't read the file".to_string())?; let lines = BufReader::new(file).lines(); Ok(lines) } pub fn
<P: AsRef<Path>>(file: P, content: &str) -> Result<(), String> where P: std::convert::AsRef<std::ffi::OsStr> { let path = PathBuf::from(&file); if let Some(parent_path) = path.parent() { DirBuilder::new() .recursive(true) .create(parent_path) .map_err(error_err!()) .map_err(|err| format!("Can't create the file: {}", err))?; } let mut file = OpenOptions::new() .write(true) .create(true) .open(path) .map_err(error_err!()) .map_err(|err| format!("Can't open the file: {}", err))?; file .write_all(content.as_bytes()) .map_err(error_err!()) .map_err(|err| format!("Can't write content: \"{}\" to the file: {}", content, err)) }
write_file
identifier_name
file.rs
use std::io::{Read, Write}; use std::io::BufReader; use std::io::BufRead; use std::path::{PathBuf, Path}; use std::fs::{File, DirBuilder, OpenOptions}; pub fn read_file<P: AsRef<Path>>(file: P) -> Result<String, String>
pub fn read_lines_from_file<P: AsRef<Path>>(file: P) -> Result<impl Iterator<Item=Result<String, ::std::io::Error>>, String> { let file = File::open(file) .map_err(error_err!()) .map_err(|_| "Can't read the file".to_string())?; let lines = BufReader::new(file).lines(); Ok(lines) } pub fn write_file<P: AsRef<Path>>(file: P, content: &str) -> Result<(), String> where P: std::convert::AsRef<std::ffi::OsStr> { let path = PathBuf::from(&file); if let Some(parent_path) = path.parent() { DirBuilder::new() .recursive(true) .create(parent_path) .map_err(error_err!()) .map_err(|err| format!("Can't create the file: {}", err))?; } let mut file = OpenOptions::new() .write(true) .create(true) .open(path) .map_err(error_err!()) .map_err(|err| format!("Can't open the file: {}", err))?; file .write_all(content.as_bytes()) .map_err(error_err!()) .map_err(|err| format!("Can't write content: \"{}\" to the file: {}", content, err)) }
{ let mut file = File::open(file) .map_err(error_err!()) .map_err(|_| "Can't read the file".to_string())?; let content = { let mut s = String::new(); file.read_to_string(&mut s) .map_err(error_err!()) .map_err(|err| format!("Can't read the file: {}", err))?; s }; Ok(content) }
identifier_body
iostat.rs
use alloc::string::String; use alloc::vec::Vec; use core::fmt::Write; use core::str; use crate::context; use crate::scheme; use crate::syscall::error::Result; pub fn
() -> Result<Vec<u8>> { let mut string = String::new(); { let mut rows = Vec::new(); { let contexts = context::contexts(); for (id, context_lock) in contexts.iter() { let context = context_lock.read(); rows.push((*id, context.name.read().clone(), context.files.read().clone())); } } for row in rows.iter() { let id: usize = row.0.into(); let name = &row.1; let _ = writeln!(string, "{}: {}", id, name); for (fd, f) in row.2.iter().enumerate() { let file = match *f { None => continue, Some(ref file) => file.clone() }; let description = file.description.read(); let scheme = { let schemes = scheme::schemes(); match schemes.get(description.scheme) { Some(scheme) => scheme.clone(), None => { let _ = writeln!(string, " {:>4}: {:>8} {:>8} {:>08X}: no scheme", fd, description.scheme.into(), description.number, description.flags); continue; } } }; let mut fpath = [0; 4096]; match scheme.fpath(description.number, &mut fpath) { Ok(path_len) => { let fname = str::from_utf8(&fpath[..path_len]).unwrap_or("?"); let _ = writeln!(string, "{:>6}: {:>8} {:>8} {:>08X}: {}", fd, description.scheme.into(), description.number, description.flags, fname); }, Err(err) => { let _ = writeln!(string, "{:>6}: {:>8} {:>8} {:>08X}: {}", fd, description.scheme.into(), description.number, description.flags, err); } } } } } Ok(string.into_bytes()) }
resource
identifier_name
iostat.rs
use alloc::string::String; use alloc::vec::Vec; use core::fmt::Write; use core::str; use crate::context;
let mut string = String::new(); { let mut rows = Vec::new(); { let contexts = context::contexts(); for (id, context_lock) in contexts.iter() { let context = context_lock.read(); rows.push((*id, context.name.read().clone(), context.files.read().clone())); } } for row in rows.iter() { let id: usize = row.0.into(); let name = &row.1; let _ = writeln!(string, "{}: {}", id, name); for (fd, f) in row.2.iter().enumerate() { let file = match *f { None => continue, Some(ref file) => file.clone() }; let description = file.description.read(); let scheme = { let schemes = scheme::schemes(); match schemes.get(description.scheme) { Some(scheme) => scheme.clone(), None => { let _ = writeln!(string, " {:>4}: {:>8} {:>8} {:>08X}: no scheme", fd, description.scheme.into(), description.number, description.flags); continue; } } }; let mut fpath = [0; 4096]; match scheme.fpath(description.number, &mut fpath) { Ok(path_len) => { let fname = str::from_utf8(&fpath[..path_len]).unwrap_or("?"); let _ = writeln!(string, "{:>6}: {:>8} {:>8} {:>08X}: {}", fd, description.scheme.into(), description.number, description.flags, fname); }, Err(err) => { let _ = writeln!(string, "{:>6}: {:>8} {:>8} {:>08X}: {}", fd, description.scheme.into(), description.number, description.flags, err); } } } } } Ok(string.into_bytes()) }
use crate::scheme; use crate::syscall::error::Result; pub fn resource() -> Result<Vec<u8>> {
random_line_split
iostat.rs
use alloc::string::String; use alloc::vec::Vec; use core::fmt::Write; use core::str; use crate::context; use crate::scheme; use crate::syscall::error::Result; pub fn resource() -> Result<Vec<u8>>
None => continue, Some(ref file) => file.clone() }; let description = file.description.read(); let scheme = { let schemes = scheme::schemes(); match schemes.get(description.scheme) { Some(scheme) => scheme.clone(), None => { let _ = writeln!(string, " {:>4}: {:>8} {:>8} {:>08X}: no scheme", fd, description.scheme.into(), description.number, description.flags); continue; } } }; let mut fpath = [0; 4096]; match scheme.fpath(description.number, &mut fpath) { Ok(path_len) => { let fname = str::from_utf8(&fpath[..path_len]).unwrap_or("?"); let _ = writeln!(string, "{:>6}: {:>8} {:>8} {:>08X}: {}", fd, description.scheme.into(), description.number, description.flags, fname); }, Err(err) => { let _ = writeln!(string, "{:>6}: {:>8} {:>8} {:>08X}: {}", fd, description.scheme.into(), description.number, description.flags, err); } } } } } Ok(string.into_bytes()) }
{ let mut string = String::new(); { let mut rows = Vec::new(); { let contexts = context::contexts(); for (id, context_lock) in contexts.iter() { let context = context_lock.read(); rows.push((*id, context.name.read().clone(), context.files.read().clone())); } } for row in rows.iter() { let id: usize = row.0.into(); let name = &row.1; let _ = writeln!(string, "{}: {}", id, name); for (fd, f) in row.2.iter().enumerate() { let file = match *f {
identifier_body
resource_files.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/. */ use std::fs::File; use std::io::{self, Read}; use std::path::PathBuf; use std::sync::{Arc, Mutex}; lazy_static! { static ref CMD_RESOURCE_DIR: Arc<Mutex<Option<String>>> = { Arc::new(Mutex::new(None)) }; } pub fn set_resources_path(path: Option<String>) { let mut dir = CMD_RESOURCE_DIR.lock().unwrap(); *dir = path; } #[cfg(target_os = "android")] pub fn resources_dir_path() -> PathBuf { PathBuf::from("/sdcard/servo/") } #[cfg(not(target_os = "android"))] pub fn resources_dir_path() -> PathBuf { use std::env; match *CMD_RESOURCE_DIR.lock().unwrap() { Some(ref path) => PathBuf::from(path), None => { // FIXME: Find a way to not rely on the executable being // under `<servo source>[/$target_triple]/target/debug` // or `<servo source>[/$target_triple]/target/release`. let mut path = env::current_exe().expect("can't get exe path"); // Follow symlink path = path.canonicalize().expect("path does not exist"); path.pop(); path.push("resources"); if!path.is_dir()
path } } } pub fn read_resource_file(relative_path_components: &[&str]) -> io::Result<Vec<u8>> { let mut path = resources_dir_path(); for component in relative_path_components { path.push(component); } let mut file = try!(File::open(&path)); let mut data = Vec::new(); try!(file.read_to_end(&mut data)); Ok(data) }
{ // resources dir not in same dir as exe? // exe is probably in target/{debug,release} so we need to go back to topdir path.pop(); path.pop(); path.pop(); path.push("resources"); if !path.is_dir() { // exe is probably in target/$target_triple/{debug,release} so go back one more path.pop(); path.pop(); path.push("resources"); } }
conditional_block
resource_files.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/. */ use std::fs::File; use std::io::{self, Read}; use std::path::PathBuf; use std::sync::{Arc, Mutex}; lazy_static! { static ref CMD_RESOURCE_DIR: Arc<Mutex<Option<String>>> = { Arc::new(Mutex::new(None)) }; } pub fn set_resources_path(path: Option<String>) { let mut dir = CMD_RESOURCE_DIR.lock().unwrap(); *dir = path;
} #[cfg(target_os = "android")] pub fn resources_dir_path() -> PathBuf { PathBuf::from("/sdcard/servo/") } #[cfg(not(target_os = "android"))] pub fn resources_dir_path() -> PathBuf { use std::env; match *CMD_RESOURCE_DIR.lock().unwrap() { Some(ref path) => PathBuf::from(path), None => { // FIXME: Find a way to not rely on the executable being // under `<servo source>[/$target_triple]/target/debug` // or `<servo source>[/$target_triple]/target/release`. let mut path = env::current_exe().expect("can't get exe path"); // Follow symlink path = path.canonicalize().expect("path does not exist"); path.pop(); path.push("resources"); if!path.is_dir() { // resources dir not in same dir as exe? // exe is probably in target/{debug,release} so we need to go back to topdir path.pop(); path.pop(); path.pop(); path.push("resources"); if!path.is_dir() { // exe is probably in target/$target_triple/{debug,release} so go back one more path.pop(); path.pop(); path.push("resources"); } } path } } } pub fn read_resource_file(relative_path_components: &[&str]) -> io::Result<Vec<u8>> { let mut path = resources_dir_path(); for component in relative_path_components { path.push(component); } let mut file = try!(File::open(&path)); let mut data = Vec::new(); try!(file.read_to_end(&mut data)); Ok(data) }
random_line_split
resource_files.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/. */ use std::fs::File; use std::io::{self, Read}; use std::path::PathBuf; use std::sync::{Arc, Mutex}; lazy_static! { static ref CMD_RESOURCE_DIR: Arc<Mutex<Option<String>>> = { Arc::new(Mutex::new(None)) }; } pub fn set_resources_path(path: Option<String>) { let mut dir = CMD_RESOURCE_DIR.lock().unwrap(); *dir = path; } #[cfg(target_os = "android")] pub fn resources_dir_path() -> PathBuf { PathBuf::from("/sdcard/servo/") } #[cfg(not(target_os = "android"))] pub fn
() -> PathBuf { use std::env; match *CMD_RESOURCE_DIR.lock().unwrap() { Some(ref path) => PathBuf::from(path), None => { // FIXME: Find a way to not rely on the executable being // under `<servo source>[/$target_triple]/target/debug` // or `<servo source>[/$target_triple]/target/release`. let mut path = env::current_exe().expect("can't get exe path"); // Follow symlink path = path.canonicalize().expect("path does not exist"); path.pop(); path.push("resources"); if!path.is_dir() { // resources dir not in same dir as exe? // exe is probably in target/{debug,release} so we need to go back to topdir path.pop(); path.pop(); path.pop(); path.push("resources"); if!path.is_dir() { // exe is probably in target/$target_triple/{debug,release} so go back one more path.pop(); path.pop(); path.push("resources"); } } path } } } pub fn read_resource_file(relative_path_components: &[&str]) -> io::Result<Vec<u8>> { let mut path = resources_dir_path(); for component in relative_path_components { path.push(component); } let mut file = try!(File::open(&path)); let mut data = Vec::new(); try!(file.read_to_end(&mut data)); Ok(data) }
resources_dir_path
identifier_name
resource_files.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/. */ use std::fs::File; use std::io::{self, Read}; use std::path::PathBuf; use std::sync::{Arc, Mutex}; lazy_static! { static ref CMD_RESOURCE_DIR: Arc<Mutex<Option<String>>> = { Arc::new(Mutex::new(None)) }; } pub fn set_resources_path(path: Option<String>) { let mut dir = CMD_RESOURCE_DIR.lock().unwrap(); *dir = path; } #[cfg(target_os = "android")] pub fn resources_dir_path() -> PathBuf { PathBuf::from("/sdcard/servo/") } #[cfg(not(target_os = "android"))] pub fn resources_dir_path() -> PathBuf { use std::env; match *CMD_RESOURCE_DIR.lock().unwrap() { Some(ref path) => PathBuf::from(path), None => { // FIXME: Find a way to not rely on the executable being // under `<servo source>[/$target_triple]/target/debug` // or `<servo source>[/$target_triple]/target/release`. let mut path = env::current_exe().expect("can't get exe path"); // Follow symlink path = path.canonicalize().expect("path does not exist"); path.pop(); path.push("resources"); if!path.is_dir() { // resources dir not in same dir as exe? // exe is probably in target/{debug,release} so we need to go back to topdir path.pop(); path.pop(); path.pop(); path.push("resources"); if!path.is_dir() { // exe is probably in target/$target_triple/{debug,release} so go back one more path.pop(); path.pop(); path.push("resources"); } } path } } } pub fn read_resource_file(relative_path_components: &[&str]) -> io::Result<Vec<u8>>
{ let mut path = resources_dir_path(); for component in relative_path_components { path.push(component); } let mut file = try!(File::open(&path)); let mut data = Vec::new(); try!(file.read_to_end(&mut data)); Ok(data) }
identifier_body
where.rs
// Copyright 2014 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. #![crate_name = "foo"] pub trait MyTrait { fn dummy(&self) { } } // @has foo/struct.Alpha.html '//pre' "pub struct Alpha<A> where A: MyTrait" pub struct Alpha<A>(A) where A: MyTrait; // @has foo/trait.Bravo.html '//pre' "pub trait Bravo<B> where B: MyTrait" pub trait Bravo<B> where B: MyTrait { fn get(&self, B: B); } // @has foo/fn.charlie.html '//pre' "pub fn charlie<C>() where C: MyTrait" pub fn charlie<C>() where C: MyTrait {} pub struct Delta<D>(D); // @has foo/struct.Delta.html '//*[@class="impl"]//code' \ // "impl<D> Delta<D> where D: MyTrait" impl<D> Delta<D> where D: MyTrait { pub fn delta()
} pub struct Echo<E>(E); // @has foo/struct.Echo.html '//*[@class="impl"]//code' \ // "impl<E> MyTrait for Echo<E> where E: MyTrait" // @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \ // "impl<E> MyTrait for Echo<E> where E: MyTrait" impl<E> MyTrait for Echo<E> where E: MyTrait {} pub enum Foxtrot<F> { Foxtrot1(F) } // @has foo/enum.Foxtrot.html '//*[@class="impl"]//code' \ // "impl<F> MyTrait for Foxtrot<F> where F: MyTrait" // @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \ // "impl<F> MyTrait for Foxtrot<F> where F: MyTrait" impl<F> MyTrait for Foxtrot<F> where F: MyTrait {} // @has foo/type.Golf.html '//pre[@class="rust typedef"]' \ // "type Golf<T> where T: Clone = (T, T)" pub type Golf<T> where T: Clone = (T, T);
{}
identifier_body
where.rs
// Copyright 2014 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.
pub struct Alpha<A>(A) where A: MyTrait; // @has foo/trait.Bravo.html '//pre' "pub trait Bravo<B> where B: MyTrait" pub trait Bravo<B> where B: MyTrait { fn get(&self, B: B); } // @has foo/fn.charlie.html '//pre' "pub fn charlie<C>() where C: MyTrait" pub fn charlie<C>() where C: MyTrait {} pub struct Delta<D>(D); // @has foo/struct.Delta.html '//*[@class="impl"]//code' \ // "impl<D> Delta<D> where D: MyTrait" impl<D> Delta<D> where D: MyTrait { pub fn delta() {} } pub struct Echo<E>(E); // @has foo/struct.Echo.html '//*[@class="impl"]//code' \ // "impl<E> MyTrait for Echo<E> where E: MyTrait" // @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \ // "impl<E> MyTrait for Echo<E> where E: MyTrait" impl<E> MyTrait for Echo<E> where E: MyTrait {} pub enum Foxtrot<F> { Foxtrot1(F) } // @has foo/enum.Foxtrot.html '//*[@class="impl"]//code' \ // "impl<F> MyTrait for Foxtrot<F> where F: MyTrait" // @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \ // "impl<F> MyTrait for Foxtrot<F> where F: MyTrait" impl<F> MyTrait for Foxtrot<F> where F: MyTrait {} // @has foo/type.Golf.html '//pre[@class="rust typedef"]' \ // "type Golf<T> where T: Clone = (T, T)" pub type Golf<T> where T: Clone = (T, T);
#![crate_name = "foo"] pub trait MyTrait { fn dummy(&self) { } } // @has foo/struct.Alpha.html '//pre' "pub struct Alpha<A> where A: MyTrait"
random_line_split
where.rs
// Copyright 2014 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. #![crate_name = "foo"] pub trait MyTrait { fn dummy(&self) { } } // @has foo/struct.Alpha.html '//pre' "pub struct Alpha<A> where A: MyTrait" pub struct
<A>(A) where A: MyTrait; // @has foo/trait.Bravo.html '//pre' "pub trait Bravo<B> where B: MyTrait" pub trait Bravo<B> where B: MyTrait { fn get(&self, B: B); } // @has foo/fn.charlie.html '//pre' "pub fn charlie<C>() where C: MyTrait" pub fn charlie<C>() where C: MyTrait {} pub struct Delta<D>(D); // @has foo/struct.Delta.html '//*[@class="impl"]//code' \ // "impl<D> Delta<D> where D: MyTrait" impl<D> Delta<D> where D: MyTrait { pub fn delta() {} } pub struct Echo<E>(E); // @has foo/struct.Echo.html '//*[@class="impl"]//code' \ // "impl<E> MyTrait for Echo<E> where E: MyTrait" // @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \ // "impl<E> MyTrait for Echo<E> where E: MyTrait" impl<E> MyTrait for Echo<E> where E: MyTrait {} pub enum Foxtrot<F> { Foxtrot1(F) } // @has foo/enum.Foxtrot.html '//*[@class="impl"]//code' \ // "impl<F> MyTrait for Foxtrot<F> where F: MyTrait" // @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \ // "impl<F> MyTrait for Foxtrot<F> where F: MyTrait" impl<F> MyTrait for Foxtrot<F> where F: MyTrait {} // @has foo/type.Golf.html '//pre[@class="rust typedef"]' \ // "type Golf<T> where T: Clone = (T, T)" pub type Golf<T> where T: Clone = (T, T);
Alpha
identifier_name
authorized.rs
use session::game::{Session, GameState}; use session::game::chunk::{self, Ref}; use protocol::messages::authorized::*; use std::io::Result; use server::SERVER; #[register_handlers] impl Session { pub fn handle_admin_quiet_command_message<'a>(&mut self, chunk: Ref<'a>, msg: AdminQuietCommandMessage) -> Result<()>
chunk::teleport(chunk, ch, map_id, cell_id); } Ok(()) } }
{ let ch = match self.state { GameState::InContext(ref mut ch) => ch, _ => return Ok(()), }; if ch.movements.is_some() { return Ok(()); } let map_id: i32 = match msg.base.content.split(" ").last().map(|id| id.parse()) { Some(Ok(map_id)) => map_id, _ => return Ok(()), }; let cell_id = SERVER.with(|s| { s.maps.get(&map_id).map(|m| m.get_free_cell()).unwrap_or(None) }); if let Some(cell_id) = cell_id {
identifier_body
authorized.rs
use session::game::{Session, GameState}; use session::game::chunk::{self, Ref}; use protocol::messages::authorized::*; use std::io::Result; use server::SERVER; #[register_handlers] impl Session { pub fn
<'a>(&mut self, chunk: Ref<'a>, msg: AdminQuietCommandMessage) -> Result<()> { let ch = match self.state { GameState::InContext(ref mut ch) => ch, _ => return Ok(()), }; if ch.movements.is_some() { return Ok(()); } let map_id: i32 = match msg.base.content.split(" ").last().map(|id| id.parse()) { Some(Ok(map_id)) => map_id, _ => return Ok(()), }; let cell_id = SERVER.with(|s| { s.maps.get(&map_id).map(|m| m.get_free_cell()).unwrap_or(None) }); if let Some(cell_id) = cell_id { chunk::teleport(chunk, ch, map_id, cell_id); } Ok(()) } }
handle_admin_quiet_command_message
identifier_name
authorized.rs
use session::game::{Session, GameState}; use session::game::chunk::{self, Ref}; use protocol::messages::authorized::*; use std::io::Result; use server::SERVER; #[register_handlers] impl Session { pub fn handle_admin_quiet_command_message<'a>(&mut self, chunk: Ref<'a>, msg: AdminQuietCommandMessage) -> Result<()> { let ch = match self.state { GameState::InContext(ref mut ch) => ch, _ => return Ok(()), }; if ch.movements.is_some() { return Ok(()); } let map_id: i32 = match msg.base.content.split(" ").last().map(|id| id.parse()) { Some(Ok(map_id)) => map_id, _ => return Ok(()), }; let cell_id = SERVER.with(|s| { s.maps.get(&map_id).map(|m| m.get_free_cell()).unwrap_or(None) }); if let Some(cell_id) = cell_id
Ok(()) } }
{ chunk::teleport(chunk, ch, map_id, cell_id); }
conditional_block