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
msg_pong.rs
use std; use ::serialize::{self, Serializable}; use super::PingMessage; use super::BIP0031_VERSION; #[derive(Debug,Default,Clone)] pub struct
{ pub nonce: u64, } impl PongMessage { pub fn new(ping:&PingMessage) -> PongMessage { PongMessage{ nonce: ping.nonce } } } impl super::Message for PongMessage { fn get_command(&self) -> [u8; super::message_header::COMMAND_SIZE] { super::message_header::COMMAND_PONG } } impl std::fmt::Display for PongMessage { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { write!(f, "Pong(nonce={})", self.nonce) } } impl Serializable for PongMessage { fn get_serialize_size(&self, ser:&serialize::SerializeParam) -> usize { if BIP0031_VERSION < ser.version { self.nonce.get_serialize_size(ser) } else { 0usize } } fn serialize(&self, io:&mut std::io::Write, ser:&serialize::SerializeParam) -> serialize::Result { if BIP0031_VERSION < ser.version { self.nonce.serialize(io, ser) } else { Ok(0usize) } } fn deserialize(&mut self, io:&mut std::io::Read, ser:&serialize::SerializeParam) -> serialize::Result { if BIP0031_VERSION < ser.version { self.nonce.deserialize(io, ser) } else { Ok(0usize) } } }
PongMessage
identifier_name
msg_pong.rs
use std; use ::serialize::{self, Serializable}; use super::PingMessage; use super::BIP0031_VERSION; #[derive(Debug,Default,Clone)] pub struct PongMessage { pub nonce: u64, } impl PongMessage { pub fn new(ping:&PingMessage) -> PongMessage { PongMessage{ nonce: ping.nonce } } } impl super::Message for PongMessage { fn get_command(&self) -> [u8; super::message_header::COMMAND_SIZE] { super::message_header::COMMAND_PONG } } impl std::fmt::Display for PongMessage { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { write!(f, "Pong(nonce={})", self.nonce) } } impl Serializable for PongMessage { fn get_serialize_size(&self, ser:&serialize::SerializeParam) -> usize { if BIP0031_VERSION < ser.version { self.nonce.get_serialize_size(ser) } else { 0usize } } fn serialize(&self, io:&mut std::io::Write, ser:&serialize::SerializeParam) -> serialize::Result { if BIP0031_VERSION < ser.version { self.nonce.serialize(io, ser) } else { Ok(0usize) } } fn deserialize(&mut self, io:&mut std::io::Read, ser:&serialize::SerializeParam) -> serialize::Result { if BIP0031_VERSION < ser.version
else { Ok(0usize) } } }
{ self.nonce.deserialize(io, ser) }
conditional_block
msg_pong.rs
use std; use ::serialize::{self, Serializable}; use super::PingMessage; use super::BIP0031_VERSION; #[derive(Debug,Default,Clone)] pub struct PongMessage { pub nonce: u64, } impl PongMessage { pub fn new(ping:&PingMessage) -> PongMessage { PongMessage{ nonce: ping.nonce } } } impl super::Message for PongMessage { fn get_command(&self) -> [u8; super::message_header::COMMAND_SIZE] { super::message_header::COMMAND_PONG } } impl std::fmt::Display for PongMessage { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { write!(f, "Pong(nonce={})", self.nonce) } }
if BIP0031_VERSION < ser.version { self.nonce.get_serialize_size(ser) } else { 0usize } } fn serialize(&self, io:&mut std::io::Write, ser:&serialize::SerializeParam) -> serialize::Result { if BIP0031_VERSION < ser.version { self.nonce.serialize(io, ser) } else { Ok(0usize) } } fn deserialize(&mut self, io:&mut std::io::Read, ser:&serialize::SerializeParam) -> serialize::Result { if BIP0031_VERSION < ser.version { self.nonce.deserialize(io, ser) } else { Ok(0usize) } } }
impl Serializable for PongMessage { fn get_serialize_size(&self, ser:&serialize::SerializeParam) -> usize {
random_line_split
benchmarks.rs
extern crate ostrov; extern crate test; use ostrov::runtime::Runtime; use test::Bencher; static NESTED_IFS: &'static str = " (if (if (if (if (if (if (> 1 2 3 4 5 6 7 8 9 10) (= 2 2 2 2 2 2 2 2 2 2)
#f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) 2 3 ) "; #[bench] fn nested_evaluation(b: &mut Bencher) { let mut runtime = Runtime::new(); b.iter(|| { assert_eq!(runtime.eval_str(NESTED_IFS), runtime.eval_str("3")); }) } #[bench] fn nested_evaluation_bytecode(b: &mut Bencher) { let mut runtime = Runtime::new(); b.iter(|| { assert_eq!(runtime.eval_str(NESTED_IFS), runtime.eval_str("3")); }) } #[bench] fn procedure_evaluation(b: &mut Bencher) { let input = " (define (fact n) (if (= n 1) 1 (* n (fact (- n 1))))) (fact 5) "; let mut runtime = Runtime::new(); b.iter(|| { assert_eq!( runtime.eval_str(input).unwrap()[1], runtime.eval_str("120").unwrap()[0] ); }) }
#f ) (= 2 2 2 2 2 2 2 2 2 2)
random_line_split
benchmarks.rs
extern crate ostrov; extern crate test; use ostrov::runtime::Runtime; use test::Bencher; static NESTED_IFS: &'static str = " (if (if (if (if (if (if (> 1 2 3 4 5 6 7 8 9 10) (= 2 2 2 2 2 2 2 2 2 2) #f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) 2 3 ) "; #[bench] fn
(b: &mut Bencher) { let mut runtime = Runtime::new(); b.iter(|| { assert_eq!(runtime.eval_str(NESTED_IFS), runtime.eval_str("3")); }) } #[bench] fn nested_evaluation_bytecode(b: &mut Bencher) { let mut runtime = Runtime::new(); b.iter(|| { assert_eq!(runtime.eval_str(NESTED_IFS), runtime.eval_str("3")); }) } #[bench] fn procedure_evaluation(b: &mut Bencher) { let input = " (define (fact n) (if (= n 1) 1 (* n (fact (- n 1))))) (fact 5) "; let mut runtime = Runtime::new(); b.iter(|| { assert_eq!( runtime.eval_str(input).unwrap()[1], runtime.eval_str("120").unwrap()[0] ); }) }
nested_evaluation
identifier_name
benchmarks.rs
extern crate ostrov; extern crate test; use ostrov::runtime::Runtime; use test::Bencher; static NESTED_IFS: &'static str = " (if (if (if (if (if (if (> 1 2 3 4 5 6 7 8 9 10) (= 2 2 2 2 2 2 2 2 2 2) #f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) (= 2 2 2 2 2 2 2 2 2 2) #f ) 2 3 ) "; #[bench] fn nested_evaluation(b: &mut Bencher)
#[bench] fn nested_evaluation_bytecode(b: &mut Bencher) { let mut runtime = Runtime::new(); b.iter(|| { assert_eq!(runtime.eval_str(NESTED_IFS), runtime.eval_str("3")); }) } #[bench] fn procedure_evaluation(b: &mut Bencher) { let input = " (define (fact n) (if (= n 1) 1 (* n (fact (- n 1))))) (fact 5) "; let mut runtime = Runtime::new(); b.iter(|| { assert_eq!( runtime.eval_str(input).unwrap()[1], runtime.eval_str("120").unwrap()[0] ); }) }
{ let mut runtime = Runtime::new(); b.iter(|| { assert_eq!(runtime.eval_str(NESTED_IFS), runtime.eval_str("3")); }) }
identifier_body
string_list.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 libc::{c_int}; use std::mem; use string::{cef_string_userfree_utf16_alloc,cef_string_userfree_utf16_free,cef_string_utf16_set}; use types::{cef_string_list_t,cef_string_t}; fn string_list_to_vec(lt: *mut cef_string_list_t) -> *mut Vec<*mut cef_string_t> { lt as *mut Vec<*mut cef_string_t> } //cef_string_list #[no_mangle] pub extern "C" fn cef_string_list_alloc() -> *mut cef_string_list_t { unsafe { let lt: Box<Vec<*mut cef_string_t>> = box vec!(); mem::transmute(lt) } } #[no_mangle] pub extern "C" fn cef_string_list_size(lt: *mut cef_string_list_t) -> c_int { unsafe { if lt.is_null() { return 0; } let v = string_list_to_vec(lt); (*v).len() as c_int } } #[no_mangle] pub extern "C" fn cef_string_list_append(lt: *mut cef_string_list_t, value: *const cef_string_t) { unsafe { if lt.is_null() { return; } let v = string_list_to_vec(lt); let cs = cef_string_userfree_utf16_alloc(); cef_string_utf16_set(mem::transmute((*value).str), (*value).length, cs, 1); (*v).push(cs); } } #[no_mangle] pub extern "C" fn cef_string_list_value(lt: *mut cef_string_list_t, index: c_int, value: *mut cef_string_t) -> c_int { unsafe { if index < 0 || lt.is_null() { return 0; } let v = string_list_to_vec(lt); if index as usize > (*v).len() - 1 { return 0; } let cs = (*v)[index as usize]; cef_string_utf16_set(mem::transmute((*cs).str), (*cs).length, value, 1) } } #[no_mangle] pub extern "C" fn cef_string_list_clear(lt: *mut cef_string_list_t) { unsafe { if lt.is_null() { return; } let v = string_list_to_vec(lt); if (*v).len() == 0 { return; } let mut cs; while (*v).len()!= 0 { cs = (*v).pop(); cef_string_userfree_utf16_free(cs.unwrap()); } } } #[no_mangle] pub extern "C" fn cef_string_list_free(lt: *mut cef_string_list_t) { unsafe { if lt.is_null()
let v: Box<Vec<*mut cef_string_t>> = mem::transmute(lt); cef_string_list_clear(lt); drop(v); } } #[no_mangle] pub extern "C" fn cef_string_list_copy(lt: *mut cef_string_list_t) -> *mut cef_string_list_t { unsafe { if lt.is_null() { return 0 as *mut cef_string_list_t; } let v = string_list_to_vec(lt); let lt2 = cef_string_list_alloc(); for cs in (*v).iter() { cef_string_list_append(lt2, mem::transmute((*cs))); } lt2 } }
{ return; }
conditional_block
string_list.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 libc::{c_int}; use std::mem; use string::{cef_string_userfree_utf16_alloc,cef_string_userfree_utf16_free,cef_string_utf16_set}; use types::{cef_string_list_t,cef_string_t}; fn string_list_to_vec(lt: *mut cef_string_list_t) -> *mut Vec<*mut cef_string_t> { lt as *mut Vec<*mut cef_string_t> } //cef_string_list #[no_mangle] pub extern "C" fn cef_string_list_alloc() -> *mut cef_string_list_t { unsafe { let lt: Box<Vec<*mut cef_string_t>> = box vec!(); mem::transmute(lt) } } #[no_mangle] pub extern "C" fn cef_string_list_size(lt: *mut cef_string_list_t) -> c_int { unsafe { if lt.is_null() { return 0; } let v = string_list_to_vec(lt); (*v).len() as c_int } } #[no_mangle] pub extern "C" fn cef_string_list_append(lt: *mut cef_string_list_t, value: *const cef_string_t) { unsafe { if lt.is_null() { return; } let v = string_list_to_vec(lt); let cs = cef_string_userfree_utf16_alloc(); cef_string_utf16_set(mem::transmute((*value).str), (*value).length, cs, 1); (*v).push(cs); } } #[no_mangle] pub extern "C" fn cef_string_list_value(lt: *mut cef_string_list_t, index: c_int, value: *mut cef_string_t) -> c_int { unsafe { if index < 0 || lt.is_null() { return 0; } let v = string_list_to_vec(lt); if index as usize > (*v).len() - 1 { return 0; } let cs = (*v)[index as usize]; cef_string_utf16_set(mem::transmute((*cs).str), (*cs).length, value, 1) } } #[no_mangle] pub extern "C" fn cef_string_list_clear(lt: *mut cef_string_list_t) {
unsafe { if lt.is_null() { return; } let v = string_list_to_vec(lt); if (*v).len() == 0 { return; } let mut cs; while (*v).len()!= 0 { cs = (*v).pop(); cef_string_userfree_utf16_free(cs.unwrap()); } } } #[no_mangle] pub extern "C" fn cef_string_list_free(lt: *mut cef_string_list_t) { unsafe { if lt.is_null() { return; } let v: Box<Vec<*mut cef_string_t>> = mem::transmute(lt); cef_string_list_clear(lt); drop(v); } } #[no_mangle] pub extern "C" fn cef_string_list_copy(lt: *mut cef_string_list_t) -> *mut cef_string_list_t { unsafe { if lt.is_null() { return 0 as *mut cef_string_list_t; } let v = string_list_to_vec(lt); let lt2 = cef_string_list_alloc(); for cs in (*v).iter() { cef_string_list_append(lt2, mem::transmute((*cs))); } lt2 } }
random_line_split
string_list.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 libc::{c_int}; use std::mem; use string::{cef_string_userfree_utf16_alloc,cef_string_userfree_utf16_free,cef_string_utf16_set}; use types::{cef_string_list_t,cef_string_t}; fn string_list_to_vec(lt: *mut cef_string_list_t) -> *mut Vec<*mut cef_string_t> { lt as *mut Vec<*mut cef_string_t> } //cef_string_list #[no_mangle] pub extern "C" fn cef_string_list_alloc() -> *mut cef_string_list_t { unsafe { let lt: Box<Vec<*mut cef_string_t>> = box vec!(); mem::transmute(lt) } } #[no_mangle] pub extern "C" fn cef_string_list_size(lt: *mut cef_string_list_t) -> c_int { unsafe { if lt.is_null() { return 0; } let v = string_list_to_vec(lt); (*v).len() as c_int } } #[no_mangle] pub extern "C" fn
(lt: *mut cef_string_list_t, value: *const cef_string_t) { unsafe { if lt.is_null() { return; } let v = string_list_to_vec(lt); let cs = cef_string_userfree_utf16_alloc(); cef_string_utf16_set(mem::transmute((*value).str), (*value).length, cs, 1); (*v).push(cs); } } #[no_mangle] pub extern "C" fn cef_string_list_value(lt: *mut cef_string_list_t, index: c_int, value: *mut cef_string_t) -> c_int { unsafe { if index < 0 || lt.is_null() { return 0; } let v = string_list_to_vec(lt); if index as usize > (*v).len() - 1 { return 0; } let cs = (*v)[index as usize]; cef_string_utf16_set(mem::transmute((*cs).str), (*cs).length, value, 1) } } #[no_mangle] pub extern "C" fn cef_string_list_clear(lt: *mut cef_string_list_t) { unsafe { if lt.is_null() { return; } let v = string_list_to_vec(lt); if (*v).len() == 0 { return; } let mut cs; while (*v).len()!= 0 { cs = (*v).pop(); cef_string_userfree_utf16_free(cs.unwrap()); } } } #[no_mangle] pub extern "C" fn cef_string_list_free(lt: *mut cef_string_list_t) { unsafe { if lt.is_null() { return; } let v: Box<Vec<*mut cef_string_t>> = mem::transmute(lt); cef_string_list_clear(lt); drop(v); } } #[no_mangle] pub extern "C" fn cef_string_list_copy(lt: *mut cef_string_list_t) -> *mut cef_string_list_t { unsafe { if lt.is_null() { return 0 as *mut cef_string_list_t; } let v = string_list_to_vec(lt); let lt2 = cef_string_list_alloc(); for cs in (*v).iter() { cef_string_list_append(lt2, mem::transmute((*cs))); } lt2 } }
cef_string_list_append
identifier_name
string_list.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 libc::{c_int}; use std::mem; use string::{cef_string_userfree_utf16_alloc,cef_string_userfree_utf16_free,cef_string_utf16_set}; use types::{cef_string_list_t,cef_string_t}; fn string_list_to_vec(lt: *mut cef_string_list_t) -> *mut Vec<*mut cef_string_t> { lt as *mut Vec<*mut cef_string_t> } //cef_string_list #[no_mangle] pub extern "C" fn cef_string_list_alloc() -> *mut cef_string_list_t { unsafe { let lt: Box<Vec<*mut cef_string_t>> = box vec!(); mem::transmute(lt) } } #[no_mangle] pub extern "C" fn cef_string_list_size(lt: *mut cef_string_list_t) -> c_int { unsafe { if lt.is_null() { return 0; } let v = string_list_to_vec(lt); (*v).len() as c_int } } #[no_mangle] pub extern "C" fn cef_string_list_append(lt: *mut cef_string_list_t, value: *const cef_string_t) { unsafe { if lt.is_null() { return; } let v = string_list_to_vec(lt); let cs = cef_string_userfree_utf16_alloc(); cef_string_utf16_set(mem::transmute((*value).str), (*value).length, cs, 1); (*v).push(cs); } } #[no_mangle] pub extern "C" fn cef_string_list_value(lt: *mut cef_string_list_t, index: c_int, value: *mut cef_string_t) -> c_int { unsafe { if index < 0 || lt.is_null() { return 0; } let v = string_list_to_vec(lt); if index as usize > (*v).len() - 1 { return 0; } let cs = (*v)[index as usize]; cef_string_utf16_set(mem::transmute((*cs).str), (*cs).length, value, 1) } } #[no_mangle] pub extern "C" fn cef_string_list_clear(lt: *mut cef_string_list_t)
#[no_mangle] pub extern "C" fn cef_string_list_free(lt: *mut cef_string_list_t) { unsafe { if lt.is_null() { return; } let v: Box<Vec<*mut cef_string_t>> = mem::transmute(lt); cef_string_list_clear(lt); drop(v); } } #[no_mangle] pub extern "C" fn cef_string_list_copy(lt: *mut cef_string_list_t) -> *mut cef_string_list_t { unsafe { if lt.is_null() { return 0 as *mut cef_string_list_t; } let v = string_list_to_vec(lt); let lt2 = cef_string_list_alloc(); for cs in (*v).iter() { cef_string_list_append(lt2, mem::transmute((*cs))); } lt2 } }
{ unsafe { if lt.is_null() { return; } let v = string_list_to_vec(lt); if (*v).len() == 0 { return; } let mut cs; while (*v).len() != 0 { cs = (*v).pop(); cef_string_userfree_utf16_free(cs.unwrap()); } } }
identifier_body
deadlock.rs
// Zeming Lin // For CS4414, probably generates a deadlock. // Inspired by David Evans code from class 13 for CS4414, Fall '13 // This works on an AMD cpu running ubuntu LTS 12.04, // but it fails on an Intel Atom netbook. // Rust tasks also don't like to run concurrently on the same netbook // so it probably isn't the code's fault. type Semaphore = Option<uint> ; // either None (available) or owner static mut count: uint = 0; // protected by lock static mut lock1: Semaphore = None; static mut lock2: Semaphore = None; fn grab_lock(id: uint) { unsafe { println(fmt!("%u is grabbing lock...", id)); while (lock1.is_some() && lock2.is_some()) { ; // wait for lock } if!lock1.is_some() { lock1 = Some(id); print(fmt!("Process %u grabbed lock1!\n", id)); while (lock2.is_some()) { ; } lock2 = Some(id); print(fmt!("Process %u grabbed lock2!\n", id)); } else if!lock2.is_some()
else { // Oops, another process grabbed the locks grab_lock(id); } } } fn release_locks() { unsafe { lock1 = None; lock2 = None } } fn update_count(id: uint) { unsafe { grab_lock(id); count += 1; println(fmt!("Count updated by %?: %?", id, count)); release_locks(); } } fn main() { for num in range(0u, 10) { do spawn { for _ in range(0u, 1000) { update_count(num); } } } }
{ lock2 = Some(id); print(fmt!("Process %u grabbed lock2!\n", id)); while (lock1.is_some()) { ; } lock1 = Some(id); print(fmt!("Process %u grabbed lock1!\n", id)); }
conditional_block
deadlock.rs
// but it fails on an Intel Atom netbook. // Rust tasks also don't like to run concurrently on the same netbook // so it probably isn't the code's fault. type Semaphore = Option<uint> ; // either None (available) or owner static mut count: uint = 0; // protected by lock static mut lock1: Semaphore = None; static mut lock2: Semaphore = None; fn grab_lock(id: uint) { unsafe { println(fmt!("%u is grabbing lock...", id)); while (lock1.is_some() && lock2.is_some()) { ; // wait for lock } if!lock1.is_some() { lock1 = Some(id); print(fmt!("Process %u grabbed lock1!\n", id)); while (lock2.is_some()) { ; } lock2 = Some(id); print(fmt!("Process %u grabbed lock2!\n", id)); } else if!lock2.is_some() { lock2 = Some(id); print(fmt!("Process %u grabbed lock2!\n", id)); while (lock1.is_some()) { ; } lock1 = Some(id); print(fmt!("Process %u grabbed lock1!\n", id)); } else { // Oops, another process grabbed the locks grab_lock(id); } } } fn release_locks() { unsafe { lock1 = None; lock2 = None } } fn update_count(id: uint) { unsafe { grab_lock(id); count += 1; println(fmt!("Count updated by %?: %?", id, count)); release_locks(); } } fn main() { for num in range(0u, 10) { do spawn { for _ in range(0u, 1000) { update_count(num); } } } }
// Zeming Lin // For CS4414, probably generates a deadlock. // Inspired by David Evans code from class 13 for CS4414, Fall '13 // This works on an AMD cpu running ubuntu LTS 12.04,
random_line_split
deadlock.rs
// Zeming Lin // For CS4414, probably generates a deadlock. // Inspired by David Evans code from class 13 for CS4414, Fall '13 // This works on an AMD cpu running ubuntu LTS 12.04, // but it fails on an Intel Atom netbook. // Rust tasks also don't like to run concurrently on the same netbook // so it probably isn't the code's fault. type Semaphore = Option<uint> ; // either None (available) or owner static mut count: uint = 0; // protected by lock static mut lock1: Semaphore = None; static mut lock2: Semaphore = None; fn grab_lock(id: uint) { unsafe { println(fmt!("%u is grabbing lock...", id)); while (lock1.is_some() && lock2.is_some()) { ; // wait for lock } if!lock1.is_some() { lock1 = Some(id); print(fmt!("Process %u grabbed lock1!\n", id)); while (lock2.is_some()) { ; } lock2 = Some(id); print(fmt!("Process %u grabbed lock2!\n", id)); } else if!lock2.is_some() { lock2 = Some(id); print(fmt!("Process %u grabbed lock2!\n", id)); while (lock1.is_some()) { ; } lock1 = Some(id); print(fmt!("Process %u grabbed lock1!\n", id)); } else { // Oops, another process grabbed the locks grab_lock(id); } } } fn release_locks() { unsafe { lock1 = None; lock2 = None } } fn update_count(id: uint)
fn main() { for num in range(0u, 10) { do spawn { for _ in range(0u, 1000) { update_count(num); } } } }
{ unsafe { grab_lock(id); count += 1; println(fmt!("Count updated by %?: %?", id, count)); release_locks(); } }
identifier_body
deadlock.rs
// Zeming Lin // For CS4414, probably generates a deadlock. // Inspired by David Evans code from class 13 for CS4414, Fall '13 // This works on an AMD cpu running ubuntu LTS 12.04, // but it fails on an Intel Atom netbook. // Rust tasks also don't like to run concurrently on the same netbook // so it probably isn't the code's fault. type Semaphore = Option<uint> ; // either None (available) or owner static mut count: uint = 0; // protected by lock static mut lock1: Semaphore = None; static mut lock2: Semaphore = None; fn grab_lock(id: uint) { unsafe { println(fmt!("%u is grabbing lock...", id)); while (lock1.is_some() && lock2.is_some()) { ; // wait for lock } if!lock1.is_some() { lock1 = Some(id); print(fmt!("Process %u grabbed lock1!\n", id)); while (lock2.is_some()) { ; } lock2 = Some(id); print(fmt!("Process %u grabbed lock2!\n", id)); } else if!lock2.is_some() { lock2 = Some(id); print(fmt!("Process %u grabbed lock2!\n", id)); while (lock1.is_some()) { ; } lock1 = Some(id); print(fmt!("Process %u grabbed lock1!\n", id)); } else { // Oops, another process grabbed the locks grab_lock(id); } } } fn release_locks() { unsafe { lock1 = None; lock2 = None } } fn
(id: uint) { unsafe { grab_lock(id); count += 1; println(fmt!("Count updated by %?: %?", id, count)); release_locks(); } } fn main() { for num in range(0u, 10) { do spawn { for _ in range(0u, 1000) { update_count(num); } } } }
update_count
identifier_name
env.rs
// except according to those terms. use std::collections::hashmap::HashMap; use expr::{Expr, ExprResult}; use result::SchemerResult; pub type EnvResult = SchemerResult<Env>; pub type EnvSetResult = SchemerResult<()>; #[deriving(Clone)] pub struct Env { entries: HashMap<String, Expr>, outer: Option<Box<Env>> } impl Env { pub fn new_empty() -> Env { Env { entries: HashMap::new(), outer: None } } pub fn new( params: Option<Vec<String>>, args: Option<Vec<Expr>>, outer: Option<Env>) -> EnvResult { let mut entries = HashMap::new(); if params.is_some() && args.is_some() { let params = match params { Some(p) => p, None => return Err("Env::new(): params should be a value".to_string()) }; let args = match args { Some(p) => p, None => return Err("Env::new(): args should be a value".to_string()) }; if params.len() == args.len() { for ctr in range(0,params.len()) { let var_name = params[ctr].to_string(); let arg = args[ctr].clone(); entries.insert(var_name, arg); } } else { return Err("Env::new(): params and args length doesn't match".to_string()) } } else if params.is_none() && args.is_none() { if outer.is_none() { return Ok(Env::new_empty()) } } else { return Err("Env::new(): cannot have params & args unset".to_string()) } Ok(Env { entries: entries, outer: match outer { Some(e) => Some(box e), None => None } }) } pub fn set(&mut self, symbol: String, val: Expr) -> EnvSetResult { match self.entries.contains_key(&symbol) { true => { self.define(symbol, val); Ok(()) }, false => match self.outer { Some(ref mut outer_env) => outer_env.set(symbol, val), None => Err( format!("Env.set(): Symbol '{}' is not defined in this Env scope chain", symbol)) } } } pub fn define(&mut self, symbol: String, val: Expr) { self.entries.insert(symbol, val); } pub fn find<'b>(&'b self, symbol: &String) -> ExprResult { match self.entries.find(symbol) { Some(v) => Ok(v.clone()), None => { match &self.outer { &Some(ref outer_env) => outer_env.find(symbol), &None => Err(format!("No variable named {} defined in the environment." , *symbol)) } } } } pub fn enclose(&mut self, base: Env) { match self.outer { Some(ref mut outer) => outer.enclose(base), None => self.outer = Some(box base) } } pub fn into_parent(self) -> Option<Env> { self.outer.map(|x| *x) } }
// Copyright 2014 Jeffery Olson // // Licensed under the 3-Clause BSD License, see LICENSE.txt // at the top-level of this repository. // This file may not be copied, modified, or distributed
random_line_split
env.rs
// Copyright 2014 Jeffery Olson // // Licensed under the 3-Clause BSD License, see LICENSE.txt // at the top-level of this repository. // This file may not be copied, modified, or distributed // except according to those terms. use std::collections::hashmap::HashMap; use expr::{Expr, ExprResult}; use result::SchemerResult; pub type EnvResult = SchemerResult<Env>; pub type EnvSetResult = SchemerResult<()>; #[deriving(Clone)] pub struct Env { entries: HashMap<String, Expr>, outer: Option<Box<Env>> } impl Env { pub fn new_empty() -> Env { Env { entries: HashMap::new(), outer: None } } pub fn new( params: Option<Vec<String>>, args: Option<Vec<Expr>>, outer: Option<Env>) -> EnvResult { let mut entries = HashMap::new(); if params.is_some() && args.is_some() { let params = match params { Some(p) => p, None => return Err("Env::new(): params should be a value".to_string()) }; let args = match args { Some(p) => p, None => return Err("Env::new(): args should be a value".to_string()) }; if params.len() == args.len() { for ctr in range(0,params.len()) { let var_name = params[ctr].to_string(); let arg = args[ctr].clone(); entries.insert(var_name, arg); } } else { return Err("Env::new(): params and args length doesn't match".to_string()) } } else if params.is_none() && args.is_none() { if outer.is_none() { return Ok(Env::new_empty()) } } else { return Err("Env::new(): cannot have params & args unset".to_string()) } Ok(Env { entries: entries, outer: match outer { Some(e) => Some(box e), None => None } }) } pub fn set(&mut self, symbol: String, val: Expr) -> EnvSetResult { match self.entries.contains_key(&symbol) { true => { self.define(symbol, val); Ok(()) }, false => match self.outer { Some(ref mut outer_env) => outer_env.set(symbol, val), None => Err( format!("Env.set(): Symbol '{}' is not defined in this Env scope chain", symbol)) } } } pub fn define(&mut self, symbol: String, val: Expr) { self.entries.insert(symbol, val); } pub fn find<'b>(&'b self, symbol: &String) -> ExprResult
pub fn enclose(&mut self, base: Env) { match self.outer { Some(ref mut outer) => outer.enclose(base), None => self.outer = Some(box base) } } pub fn into_parent(self) -> Option<Env> { self.outer.map(|x| *x) } }
{ match self.entries.find(symbol) { Some(v) => Ok(v.clone()), None => { match &self.outer { &Some(ref outer_env) => outer_env.find(symbol), &None => Err(format!("No variable named {} defined in the environment." , *symbol)) } } } }
identifier_body
env.rs
// Copyright 2014 Jeffery Olson // // Licensed under the 3-Clause BSD License, see LICENSE.txt // at the top-level of this repository. // This file may not be copied, modified, or distributed // except according to those terms. use std::collections::hashmap::HashMap; use expr::{Expr, ExprResult}; use result::SchemerResult; pub type EnvResult = SchemerResult<Env>; pub type EnvSetResult = SchemerResult<()>; #[deriving(Clone)] pub struct Env { entries: HashMap<String, Expr>, outer: Option<Box<Env>> } impl Env { pub fn new_empty() -> Env { Env { entries: HashMap::new(), outer: None } } pub fn new( params: Option<Vec<String>>, args: Option<Vec<Expr>>, outer: Option<Env>) -> EnvResult { let mut entries = HashMap::new(); if params.is_some() && args.is_some() { let params = match params { Some(p) => p, None => return Err("Env::new(): params should be a value".to_string()) }; let args = match args { Some(p) => p, None => return Err("Env::new(): args should be a value".to_string()) }; if params.len() == args.len() { for ctr in range(0,params.len()) { let var_name = params[ctr].to_string(); let arg = args[ctr].clone(); entries.insert(var_name, arg); } } else { return Err("Env::new(): params and args length doesn't match".to_string()) } } else if params.is_none() && args.is_none() { if outer.is_none() { return Ok(Env::new_empty()) } } else { return Err("Env::new(): cannot have params & args unset".to_string()) } Ok(Env { entries: entries, outer: match outer { Some(e) => Some(box e), None => None } }) } pub fn set(&mut self, symbol: String, val: Expr) -> EnvSetResult { match self.entries.contains_key(&symbol) { true => { self.define(symbol, val); Ok(()) }, false => match self.outer { Some(ref mut outer_env) => outer_env.set(symbol, val), None => Err( format!("Env.set(): Symbol '{}' is not defined in this Env scope chain", symbol)) } } } pub fn define(&mut self, symbol: String, val: Expr) { self.entries.insert(symbol, val); } pub fn
<'b>(&'b self, symbol: &String) -> ExprResult { match self.entries.find(symbol) { Some(v) => Ok(v.clone()), None => { match &self.outer { &Some(ref outer_env) => outer_env.find(symbol), &None => Err(format!("No variable named {} defined in the environment." , *symbol)) } } } } pub fn enclose(&mut self, base: Env) { match self.outer { Some(ref mut outer) => outer.enclose(base), None => self.outer = Some(box base) } } pub fn into_parent(self) -> Option<Env> { self.outer.map(|x| *x) } }
find
identifier_name
main.rs
extern crate osmpbfreader; extern crate serde; #[macro_use] extern crate serde_derive; #[macro_use(bson, doc)] extern crate bson; extern crate mongodb; use std::collections::HashMap; use std::env::args; use mongodb::coll::options::WriteModel; use mongodb::{Client, ThreadedClient}; use mongodb::db::ThreadedDatabase; use std::mem; // Structure holding a river, used for bson serialization #[derive(Serialize, Deserialize, Debug)] pub struct River { pub paths: Vec<(f64,f64)> } fn process_file(filename : &String, rivers_coll : &mongodb::coll::Collection) { let r = std::fs::File::open(&std::path::Path::new(filename)).unwrap(); println!("Parsing {:?}...",filename); let mut pbf = osmpbfreader::OsmPbfReader::new(r); let objs = pbf.get_objs_and_deps(|obj| { obj.is_way() && obj.tags().contains_key("waterway") && ( obj.tags().get("waterway").unwrap()=="river" || obj.tags().get("waterway").unwrap()=="stream" || obj.tags().get("waterway").unwrap()=="canal" ) && obj.tags().contains_key("name") && obj.tags().get("name").unwrap().len()>0 }).unwrap(); println!("Objs got"); let mut nodes = HashMap::new(); let mut bulk = Vec::new(); for (_id, obj) in &objs { match obj { osmpbfreader::OsmObj::Node(n) =>
osmpbfreader::OsmObj::Way(w) => { let mut path = Vec::new(); for node_id in &w.nodes { match nodes.get(&node_id) { Some(node) => path.push((node.0,node.1)), None => { panic!(); } } } // Insert into MongoDB let river = River { paths: path }; let names : Vec<String> = obj.tags().iter().filter(|tag| tag.0.starts_with("name:")).map(|tag| tag.1.clone()).collect(); let serialized_river = bson::to_bson(&river); // Serialize match serialized_river { Ok(sr) => { if let bson::Bson::Document(docu) = sr { // Documentize bulk.push(WriteModel::UpdateOne { filter: doc!{"_id": obj.tags().get("name").unwrap().to_string()}, update: doc!{"$push": docu, "$addToSet": {"names": {"$each": bson::to_bson(&names).unwrap()}}}, upsert: Some(true) }); if bulk.len()>100 { println!("Insert into db... {}",bulk.len()); let mut bulk2 = Vec::new(); // create new empty bulk mem::swap(&mut bulk, &mut bulk2); // bulk <-> bulk2 let result = rivers_coll.bulk_write(bulk2, true); // send full bulk println!("Number of rivers inserted: ins:{} match:{} modif:{} del:{} upset:{}",result.inserted_count,result.matched_count,result.modified_count,result.deleted_count,result.upserted_count); match result.bulk_write_exception { Some(exception) => { if exception.message.len()>0 { println!("ERROR: {}",exception.message); } } None => () } //bulk.clear(); // bulk is now a new empty bulk thanks to swaping, clear is unecessary } // Compiler will drop bulk2 (the full bulk) at this point } else { println!("Error converting the BSON object into a MongoDB document"); } }, Err(_) => println!("Error serializing the River as a BSON object") } }, osmpbfreader::OsmObj::Relation(_) => () } } if bulk.len()>0 { println!("Insert into db... {} river(s)",bulk.len()); let result = rivers_coll.bulk_write(bulk, true); // send remaining bulk println!("Number of rivers inserted: match:{} ins:{} modif:{} del:{} upsert:{}",result.matched_count,result.inserted_count,result.modified_count,result.deleted_count,result.upserted_count); match result.bulk_write_exception { Some(exception) => { if exception.message.len()>0 { println!("ERROR(s): {}",exception.message); } } None => () } } } fn main() { // Connect to MongoDB client and select collection let client = Client::connect("localhost", 27017).ok().expect("Failed to initialize client."); let rivers_coll = client.db("wwsupdb").collection("osm"); match rivers_coll.drop() { Ok(_) => println!("Collection droped"), Err(_) => panic!() } for arg in args().skip(1) { process_file(&arg, &rivers_coll); } }
{ nodes.insert( n.id, (n.lat(),n.lon()) ); }
conditional_block
main.rs
extern crate osmpbfreader; extern crate serde; #[macro_use] extern crate serde_derive; #[macro_use(bson, doc)] extern crate bson; extern crate mongodb; use std::collections::HashMap; use std::env::args; use mongodb::coll::options::WriteModel; use mongodb::{Client, ThreadedClient}; use mongodb::db::ThreadedDatabase; use std::mem; // Structure holding a river, used for bson serialization #[derive(Serialize, Deserialize, Debug)] pub struct River { pub paths: Vec<(f64,f64)> } fn process_file(filename : &String, rivers_coll : &mongodb::coll::Collection) { let r = std::fs::File::open(&std::path::Path::new(filename)).unwrap(); println!("Parsing {:?}...",filename); let mut pbf = osmpbfreader::OsmPbfReader::new(r); let objs = pbf.get_objs_and_deps(|obj| { obj.is_way() && obj.tags().contains_key("waterway") && ( obj.tags().get("waterway").unwrap()=="river" || obj.tags().get("waterway").unwrap()=="stream" || obj.tags().get("waterway").unwrap()=="canal" ) && obj.tags().contains_key("name") && obj.tags().get("name").unwrap().len()>0 }).unwrap(); println!("Objs got"); let mut nodes = HashMap::new(); let mut bulk = Vec::new(); for (_id, obj) in &objs { match obj { osmpbfreader::OsmObj::Node(n) => { nodes.insert( n.id, (n.lat(),n.lon()) ); } osmpbfreader::OsmObj::Way(w) => { let mut path = Vec::new(); for node_id in &w.nodes { match nodes.get(&node_id) { Some(node) => path.push((node.0,node.1)), None => { panic!(); } } } // Insert into MongoDB let river = River { paths: path }; let names : Vec<String> = obj.tags().iter().filter(|tag| tag.0.starts_with("name:")).map(|tag| tag.1.clone()).collect(); let serialized_river = bson::to_bson(&river); // Serialize match serialized_river { Ok(sr) => { if let bson::Bson::Document(docu) = sr { // Documentize bulk.push(WriteModel::UpdateOne { filter: doc!{"_id": obj.tags().get("name").unwrap().to_string()}, update: doc!{"$push": docu, "$addToSet": {"names": {"$each": bson::to_bson(&names).unwrap()}}}, upsert: Some(true) }); if bulk.len()>100 { println!("Insert into db... {}",bulk.len()); let mut bulk2 = Vec::new(); // create new empty bulk mem::swap(&mut bulk, &mut bulk2); // bulk <-> bulk2 let result = rivers_coll.bulk_write(bulk2, true); // send full bulk println!("Number of rivers inserted: ins:{} match:{} modif:{} del:{} upset:{}",result.inserted_count,result.matched_count,result.modified_count,result.deleted_count,result.upserted_count); match result.bulk_write_exception { Some(exception) => { if exception.message.len()>0 { println!("ERROR: {}",exception.message); } } None => () } //bulk.clear(); // bulk is now a new empty bulk thanks to swaping, clear is unecessary } // Compiler will drop bulk2 (the full bulk) at this point } else { println!("Error converting the BSON object into a MongoDB document"); } }, Err(_) => println!("Error serializing the River as a BSON object") } }, osmpbfreader::OsmObj::Relation(_) => () } } if bulk.len()>0 { println!("Insert into db... {} river(s)",bulk.len()); let result = rivers_coll.bulk_write(bulk, true); // send remaining bulk println!("Number of rivers inserted: match:{} ins:{} modif:{} del:{} upsert:{}",result.matched_count,result.inserted_count,result.modified_count,result.deleted_count,result.upserted_count); match result.bulk_write_exception { Some(exception) => {
if exception.message.len()>0 { println!("ERROR(s): {}",exception.message); } } None => () } } } fn main() { // Connect to MongoDB client and select collection let client = Client::connect("localhost", 27017).ok().expect("Failed to initialize client."); let rivers_coll = client.db("wwsupdb").collection("osm"); match rivers_coll.drop() { Ok(_) => println!("Collection droped"), Err(_) => panic!() } for arg in args().skip(1) { process_file(&arg, &rivers_coll); } }
random_line_split
main.rs
extern crate osmpbfreader; extern crate serde; #[macro_use] extern crate serde_derive; #[macro_use(bson, doc)] extern crate bson; extern crate mongodb; use std::collections::HashMap; use std::env::args; use mongodb::coll::options::WriteModel; use mongodb::{Client, ThreadedClient}; use mongodb::db::ThreadedDatabase; use std::mem; // Structure holding a river, used for bson serialization #[derive(Serialize, Deserialize, Debug)] pub struct River { pub paths: Vec<(f64,f64)> } fn process_file(filename : &String, rivers_coll : &mongodb::coll::Collection) { let r = std::fs::File::open(&std::path::Path::new(filename)).unwrap(); println!("Parsing {:?}...",filename); let mut pbf = osmpbfreader::OsmPbfReader::new(r); let objs = pbf.get_objs_and_deps(|obj| { obj.is_way() && obj.tags().contains_key("waterway") && ( obj.tags().get("waterway").unwrap()=="river" || obj.tags().get("waterway").unwrap()=="stream" || obj.tags().get("waterway").unwrap()=="canal" ) && obj.tags().contains_key("name") && obj.tags().get("name").unwrap().len()>0 }).unwrap(); println!("Objs got"); let mut nodes = HashMap::new(); let mut bulk = Vec::new(); for (_id, obj) in &objs { match obj { osmpbfreader::OsmObj::Node(n) => { nodes.insert( n.id, (n.lat(),n.lon()) ); } osmpbfreader::OsmObj::Way(w) => { let mut path = Vec::new(); for node_id in &w.nodes { match nodes.get(&node_id) { Some(node) => path.push((node.0,node.1)), None => { panic!(); } } } // Insert into MongoDB let river = River { paths: path }; let names : Vec<String> = obj.tags().iter().filter(|tag| tag.0.starts_with("name:")).map(|tag| tag.1.clone()).collect(); let serialized_river = bson::to_bson(&river); // Serialize match serialized_river { Ok(sr) => { if let bson::Bson::Document(docu) = sr { // Documentize bulk.push(WriteModel::UpdateOne { filter: doc!{"_id": obj.tags().get("name").unwrap().to_string()}, update: doc!{"$push": docu, "$addToSet": {"names": {"$each": bson::to_bson(&names).unwrap()}}}, upsert: Some(true) }); if bulk.len()>100 { println!("Insert into db... {}",bulk.len()); let mut bulk2 = Vec::new(); // create new empty bulk mem::swap(&mut bulk, &mut bulk2); // bulk <-> bulk2 let result = rivers_coll.bulk_write(bulk2, true); // send full bulk println!("Number of rivers inserted: ins:{} match:{} modif:{} del:{} upset:{}",result.inserted_count,result.matched_count,result.modified_count,result.deleted_count,result.upserted_count); match result.bulk_write_exception { Some(exception) => { if exception.message.len()>0 { println!("ERROR: {}",exception.message); } } None => () } //bulk.clear(); // bulk is now a new empty bulk thanks to swaping, clear is unecessary } // Compiler will drop bulk2 (the full bulk) at this point } else { println!("Error converting the BSON object into a MongoDB document"); } }, Err(_) => println!("Error serializing the River as a BSON object") } }, osmpbfreader::OsmObj::Relation(_) => () } } if bulk.len()>0 { println!("Insert into db... {} river(s)",bulk.len()); let result = rivers_coll.bulk_write(bulk, true); // send remaining bulk println!("Number of rivers inserted: match:{} ins:{} modif:{} del:{} upsert:{}",result.matched_count,result.inserted_count,result.modified_count,result.deleted_count,result.upserted_count); match result.bulk_write_exception { Some(exception) => { if exception.message.len()>0 { println!("ERROR(s): {}",exception.message); } } None => () } } } fn
() { // Connect to MongoDB client and select collection let client = Client::connect("localhost", 27017).ok().expect("Failed to initialize client."); let rivers_coll = client.db("wwsupdb").collection("osm"); match rivers_coll.drop() { Ok(_) => println!("Collection droped"), Err(_) => panic!() } for arg in args().skip(1) { process_file(&arg, &rivers_coll); } }
main
identifier_name
mod.rs
use anyhow::Result; use pueue_lib::network::message::Message; use pueue_lib::network::protocol::*; use pueue_lib::state::State; mod edit; mod format_state; mod local_follow; mod restart; mod wait; pub use edit::edit; pub use format_state::format_state; pub use local_follow::local_follow; pub use restart::restart; pub use wait::wait; // This is a helper function for easy retrieval of the current daemon state. // The current daemon state is often needed in more complex commands. pub async fn get_state(stream: &mut GenericStream) -> Result<State>
{ // Create the message payload and send it to the daemon. send_message(Message::Status, stream).await?; // Check if we can receive the response from the daemon let message = receive_message(stream).await?; match message { Message::StatusResponse(state) => Ok(*state), _ => unreachable!(), } }
identifier_body
mod.rs
use pueue_lib::state::State; mod edit; mod format_state; mod local_follow; mod restart; mod wait; pub use edit::edit; pub use format_state::format_state; pub use local_follow::local_follow; pub use restart::restart; pub use wait::wait; // This is a helper function for easy retrieval of the current daemon state. // The current daemon state is often needed in more complex commands. pub async fn get_state(stream: &mut GenericStream) -> Result<State> { // Create the message payload and send it to the daemon. send_message(Message::Status, stream).await?; // Check if we can receive the response from the daemon let message = receive_message(stream).await?; match message { Message::StatusResponse(state) => Ok(*state), _ => unreachable!(), } }
use anyhow::Result; use pueue_lib::network::message::Message; use pueue_lib::network::protocol::*;
random_line_split
mod.rs
use anyhow::Result; use pueue_lib::network::message::Message; use pueue_lib::network::protocol::*; use pueue_lib::state::State; mod edit; mod format_state; mod local_follow; mod restart; mod wait; pub use edit::edit; pub use format_state::format_state; pub use local_follow::local_follow; pub use restart::restart; pub use wait::wait; // This is a helper function for easy retrieval of the current daemon state. // The current daemon state is often needed in more complex commands. pub async fn
(stream: &mut GenericStream) -> Result<State> { // Create the message payload and send it to the daemon. send_message(Message::Status, stream).await?; // Check if we can receive the response from the daemon let message = receive_message(stream).await?; match message { Message::StatusResponse(state) => Ok(*state), _ => unreachable!(), } }
get_state
identifier_name
du.rs
#![crate_name = "du"] #![feature(collections, core, old_io, old_path, rustc_private, std_misc, unicode)] /* * This file is part of the uutils coreutils package. * * (c) Derek Chiang <[email protected]> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ #![allow(non_snake_case)] extern crate getopts; extern crate libc; extern crate time; use std::old_io::{stderr, fs, FileStat, FileType}; use std::num::Float; use std::option::Option; use std::old_path::Path; use std::sync::{Arc, Future}; use time::Timespec; #[path = "../common/util.rs"] #[macro_use] mod util; static NAME: &'static str = "du"; static VERSION: &'static str = "1.0.0"; struct Options { all: bool, program_name: String, max_depth: Option<usize>, total: bool, separate_dirs: bool, } struct Stat { path: Path, fstat: FileStat, } // this takes `my_stat` to avoid having to stat files multiple times. fn du(path: &Path, mut my_stat: Stat, options: Arc<Options>, depth: usize) -> Vec<Arc<Stat>>
my_stat.fstat.size += this_stat.fstat.size; my_stat.fstat.unstable.blocks += this_stat.fstat.unstable.blocks; if options.all { stats.push(Arc::new(this_stat)) } } } } for future in futures.iter_mut() { for stat in future.get().into_iter().rev() { if!options.separate_dirs && stat.path.dir_path() == my_stat.path { my_stat.fstat.size += stat.fstat.size; my_stat.fstat.unstable.blocks += stat.fstat.unstable.blocks; } if options.max_depth == None || depth < options.max_depth.unwrap() { stats.push(stat.clone()); } } } stats.push(Arc::new(my_stat)); stats } pu b fn uumain(args: Vec<String>) -> i32 { let program = args[0].as_slice(); let opts = [ // In task getopts::optflag("a", "all", " write counts for all files, not just directories"), // In main getopts::optflag("", "apparent-size", "print apparent sizes, rather than disk usage; although the apparent size is usually smaller, it may be larger due to holes in ('sparse') files, internal fragmentation, indirect blocks, and the like"), // In main getopts::optopt("B", "block-size", "scale sizes by SIZE before printing them. E.g., '-BM' prints sizes in units of 1,048,576 bytes. See SIZE format below.", "SIZE"), // In main getopts::optflag("b", "bytes", "equivalent to '--apparent-size --block-size=1'"), // In main getopts::optflag("c", "total", "produce a grand total"), // In task // getopts::optflag("D", "dereference-args", "dereference only symlinks that are listed // on the command line"), // In main // getopts::optopt("", "files0-from", "summarize disk usage of the NUL-terminated file // names specified in file F; // If F is - then read names from standard input", "F"), // // In task // getopts::optflag("H", "", "equivalent to --dereference-args (-D)"), // In main getopts::optflag("h", "human-readable", "print sizes in human readable format (e.g., 1K 234M 2G)"), // In main getopts::optflag("", "si", "like -h, but use powers of 1000 not 1024"), // In main getopts::optflag("k", "", "like --block-size=1K"), // In task getopts::optflag("l", "count-links", "count sizes many times if hard linked"), // // In main getopts::optflag("m", "", "like --block-size=1M"), // // In task // getopts::optflag("L", "dereference", "dereference all symbolic links"), // // In task // getopts::optflag("P", "no-dereference", "don't follow any symbolic links (this is the default)"), // // In main getopts::optflag("0", "null", "end each output line with 0 byte rather than newline"), // In main getopts::optflag("S", "separate-dirs", "do not include size of subdirectories"), // In main getopts::optflag("s", "summarize", "display only a total for each argument"), // // In task // getopts::optflag("x", "one-file-system", "skip directories on different file systems"), // // In task // getopts::optopt("X", "exclude-from", "exclude files that match any pattern in FILE", "FILE"), // // In task // getopts::optopt("", "exclude", "exclude files that match PATTERN", "PATTERN"), // In main getopts::optopt("d", "max-depth", "print the total for a directory (or file, with --all) only if it is N or fewer levels below the command line argument; --max-depth=0 is the same as --summarize", "N"), // In main getopts::optflagopt("", "time", "show time of the last modification of any file in the directory, or any of its subdirectories. If WORD is given, show time as WORD instead of modification time: atime, access, use, ctime or status", "WORD"), // In main getopts::optopt("", "time-style", "show times using style STYLE: full-iso, long-iso, iso, +FORMAT FORMAT is interpreted like 'date'", "STYLE"), getopts::optflag("", "help", "display this help and exit"), getopts::optflag("V", "version", "output version information and exit"), ]; let matches = match getopts::getopts(args.tail(), &opts) { Ok(m) => m, Err(f) => { show_error!("Invalid options\n{}", f); return 1; } }; if matches.opt_present("help") { println!("{program} {version} - estimate file space usage Usage {program} [OPTION]... [FILE]... {program} [OPTION]... --files0-from=F {usage} Display values are in units of the first available SIZE from --block-size, and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environ‐ ment variables. Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set). SIZE is an integer and optional unit (example: 10M is 10*1024*1024). Units are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB,... (pow‐ ers of 1000).", program = program, version = VERSION, usage = getopts::usage("Summarize disk usage of each FILE, recursively for directories.", &opts)); return 0; } else if matches.opt_present("version") { println!("{} version: {}", program, VERSION); return 0; } let summarize = matches.opt_present("summarize"); let max_depth_str = matches.opt_str("max-depth"); let max_depth = max_depth_str.as_ref().and_then(|s| s.parse::<usize>().ok()); match (max_depth_str, max_depth) { (Some(ref s), _) if summarize => { show_error!("summarizing conflicts with --max-depth={}", *s); return 1; } (Some(ref s), None) => { show_error!("invalid maximum depth '{}'", *s); return 1; } (Some(_), Some(_)) | (None, _) => { /* valid */ } } let options = Options { all: matches.opt_present("all"), program_name: program.to_string(), max_depth: max_depth, total: matches.opt_present("total"), separate_dirs: matches.opt_present("S"), }; let strs = if matches.free.is_empty() {vec!("./".to_string())} else {matches.free.clone()}; let options_arc = Arc::new(options); let MB = match matches.opt_present("si") { true => 1000 * 1000, false => 1024 * 1024, }; let KB = match matches.opt_present("si") { true => 1000, false => 1024, }; let block_size = match matches.opt_str("block-size") { Some(s) => { let mut found_number = false; let mut found_letter = false; let mut numbers = String::new(); let mut letters = String::new(); for c in s.as_slice().chars() { if found_letter && c.is_digit(10) ||!found_number &&!c.is_digit(10) { show_error!("invalid --block-size argument '{}'", s); return 1; } else if c.is_digit(10) { found_number = true; numbers.push(c); } else if c.is_alphabetic() { found_letter = true; letters.push(c); } } let number = numbers.parse::<usize>().unwrap(); let multiple = match letters.as_slice() { "K" => 1024, "M" => 1024 * 1024, "G" => 1024 * 1024 * 1024, "T" => 1024 * 1024 * 1024 * 1024, "P" => 1024 * 1024 * 1024 * 1024 * 1024, "E" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "Z" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "Y" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "KB" => 1000, "MB" => 1000 * 1000, "GB" => 1000 * 1000 * 1000, "TB" => 1000 * 1000 * 1000 * 1000, "PB" => 1000 * 1000 * 1000 * 1000 * 1000, "EB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000, "ZB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000, "YB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000, _ => { show_error!("invalid --block-size argument '{}'", s); return 1; } }; number * multiple }, None => 1024 }; let convert_size = |size: u64| -> String { if matches.opt_present("human-readable") || matches.opt_present("si") { if size >= MB { format!("{:.1}M", (size as f64) / (MB as f64)) } else if size >= KB { format!("{:.1}K", (size as f64) / (KB as f64)) } else { format!("{}B", size) } } else if matches.opt_present("k") { format!("{}", ((size as f64) / (KB as f64)).ceil()) } else if matches.opt_present("m") { format!("{}", ((size as f64) / (MB as f64)).ceil()) } else { format!("{}", ((size as f64) / (block_size as f64)).ceil()) } }; let time_format_str = match matches.opt_str("time-style") { Some(s) => { match s.as_slice() { "full-iso" => "%Y-%m-%d %H:%M:%S.%f %z", "long-iso" => "%Y-%m-%d %H:%M", "iso" => "%Y-%m-%d", _ => { show_error!("invalid argument '{}' for 'time style' Valid arguments are: - 'full-iso' - 'long-iso' - 'iso' Try '{} --help' for more information.", s, program); return 1; } } }, None => "%Y-%m-%d %H:%M" }; let line_separator = match matches.opt_present("0") { true => "\0", false => "\n", }; let mut grand_total = 0; for path_str in strs.into_iter() { let path = Path::new(path_str); let stat = safe_unwrap!(fs::lstat(&path)); let iter = du(&path, Stat{path: path.clone(), fstat: stat}, options_arc.clone(), 0).into_iter(); let (_, len) = iter.size_hint(); let len = len.unwrap(); for (index, stat) in iter.enumerate() { let size = match matches.opt_present("apparent-size") { true => stat.fstat.unstable.nlink * stat.fstat.size, // C's stat is such that each block is assume to be 512 bytes // See: http://linux.die.net/man/2/stat false => stat.fstat.unstable.blocks * 512, }; if matches.opt_present("time") { let tm = { let (secs, nsecs) = { let time = match matches.opt_str("time") { Some(s) => match s.as_slice() { "accessed" => stat.fstat.accessed, "created" => stat.fstat.created, "modified" => stat.fstat.modified, _ => { show_error!("invalid argument'modified' for '--time' Valid arguments are: - 'accessed', 'created','modified' Try '{} --help' for more information.", program); return 1; } }, None => stat.fstat.modified }; ((time / 1000) as i64, (time % 1000 * 1000000) as i32) }; time::at(Timespec::new(secs, nsecs)) }; if!summarize || (summarize && index == len-1) { let time_str = tm.strftime(time_format_str).unwrap(); print!("{}\t{}\t{}{}", convert_size(size), time_str, stat.path.display(), line_separator); } } else { if!summarize || (summarize && index == len-1) { print!("{}\t{}{}", convert_size(size), stat.path.display(), line_separator); } } if options_arc.total && index == (len - 1) { // The last element will be the total size of the the path under // path_str. We add it to the grand total. grand_total += size; } } } if options_arc.total { print!("{}\ttotal", convert_size(grand_total)); print!("{}", line_separator); } 0 }
{ let mut stats = vec!(); let mut futures = vec!(); if my_stat.fstat.kind == FileType::Directory { let read = match fs::readdir(path) { Ok(read) => read, Err(e) => { safe_writeln!(&mut stderr(), "{}: cannot read directory ‘{}‘: {}", options.program_name, path.display(), e); return vec!(Arc::new(my_stat)) } }; for f in read.into_iter() { let this_stat = Stat{path: f.clone(), fstat: safe_unwrap!(fs::lstat(&f))}; if this_stat.fstat.kind == FileType::Directory { let oa_clone = options.clone(); futures.push(Future::spawn(move || { du(&f, this_stat, oa_clone, depth + 1) })) } else {
identifier_body
du.rs
#![crate_name = "du"] #![feature(collections, core, old_io, old_path, rustc_private, std_misc, unicode)] /* * This file is part of the uutils coreutils package. * * (c) Derek Chiang <[email protected]> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ #![allow(non_snake_case)] extern crate getopts; extern crate libc; extern crate time; use std::old_io::{stderr, fs, FileStat, FileType}; use std::num::Float; use std::option::Option; use std::old_path::Path; use std::sync::{Arc, Future}; use time::Timespec; #[path = "../common/util.rs"] #[macro_use] mod util; static NAME: &'static str = "du"; static VERSION: &'static str = "1.0.0"; struct Options { all: bool, program_name: String, max_depth: Option<usize>, total: bool, separate_dirs: bool, } struct Stat { path: Path, fstat: FileStat, } // this takes `my_stat` to avoid having to stat files multiple times. fn du(path: &Path, mut my_stat: Stat, options: Arc<Options>, depth: usize) -> Vec<Arc<Stat>> { let mut stats = vec!(); let mut futures = vec!(); if my_stat.fstat.kind == FileType::Directory { let read = match fs::readdir(path) { Ok(read) => read, Err(e) => { safe_writeln!(&mut stderr(), "{}: cannot read directory ‘{}‘: {}", options.program_name, path.display(), e); return vec!(Arc::new(my_stat)) } }; for f in read.into_iter() { let this_stat = Stat{path: f.clone(), fstat: safe_unwrap!(fs::lstat(&f))}; if this_stat.fstat.kind == FileType::Directory { let oa_clone = options.clone(); futures.push(Future::spawn(move || { du(&f, this_stat, oa_clone, depth + 1) })) } else { my_stat.fstat.size += this_stat.fstat.size; my_stat.fstat.unstable.blocks += this_stat.fstat.unstable.blocks; if options.all { stats.push(Arc::new(this_stat)) } } } } for future in futures.iter_mut() { for stat in future.get().into_iter().rev() { if!options.separate_dirs && stat.path.dir_path() == my_stat.path { my_stat.fstat.size += stat.fstat.size; my_stat.fstat.unstable.blocks += stat.fstat.unstable.blocks; } if options.max_depth == None || depth < options.max_depth.unwrap() { stats.push(stat.clone()); } } } stats.push(Arc::new(my_stat)); stats } pub fn uumain(args: Vec<String>) -> i32 { let program = args[0].as_slice(); let opts = [ // In task getopts::optflag("a", "all", " write counts for all files, not just directories"), // In main getopts::optflag("", "apparent-size", "print apparent sizes, rather than disk usage; although the apparent size is usually smaller, it may be larger due to holes in ('sparse') files, internal fragmentation, indirect blocks, and the like"), // In main getopts::optopt("B", "block-size", "scale sizes by SIZE before printing them. E.g., '-BM' prints sizes in units of 1,048,576 bytes. See SIZE format below.", "SIZE"), // In main getopts::optflag("b", "bytes", "equivalent to '--apparent-size --block-size=1'"), // In main getopts::optflag("c", "total", "produce a grand total"), // In task // getopts::optflag("D", "dereference-args", "dereference only symlinks that are listed // on the command line"), // In main // getopts::optopt("", "files0-from", "summarize disk usage of the NUL-terminated file // names specified in file F; // If F is - then read names from standard input", "F"), // // In task // getopts::optflag("H", "", "equivalent to --dereference-args (-D)"), // In main getopts::optflag("h", "human-readable", "print sizes in human readable format (e.g., 1K 234M 2G)"), // In main getopts::optflag("", "si", "like -h, but use powers of 1000 not 1024"), // In main getopts::optflag("k", "", "like --block-size=1K"), // In task getopts::optflag("l", "count-links", "count sizes many times if hard linked"), // // In main getopts::optflag("m", "", "like --block-size=1M"), // // In task // getopts::optflag("L", "dereference", "dereference all symbolic links"), // // In task // getopts::optflag("P", "no-dereference", "don't follow any symbolic links (this is the default)"), // // In main getopts::optflag("0", "null", "end each output line with 0 byte rather than newline"), // In main getopts::optflag("S", "separate-dirs", "do not include size of subdirectories"), // In main getopts::optflag("s", "summarize", "display only a total for each argument"), // // In task // getopts::optflag("x", "one-file-system", "skip directories on different file systems"), // // In task // getopts::optopt("X", "exclude-from", "exclude files that match any pattern in FILE", "FILE"), // // In task // getopts::optopt("", "exclude", "exclude files that match PATTERN", "PATTERN"), // In main getopts::optopt("d", "max-depth", "print the total for a directory (or file, with --all) only if it is N or fewer levels below the command line argument; --max-depth=0 is the same as --summarize", "N"), // In main getopts::optflagopt("", "time", "show time of the last modification of any file in the directory, or any of its subdirectories. If WORD is given, show time as WORD instead of modification time: atime, access, use, ctime or status", "WORD"), // In main getopts::optopt("", "time-style", "show times using style STYLE: full-iso, long-iso, iso, +FORMAT FORMAT is interpreted like 'date'", "STYLE"), getopts::optflag("", "help", "display this help and exit"), getopts::optflag("V", "version", "output version information and exit"), ]; let matches = match getopts::getopts(args.tail(), &opts) { Ok(m) => m, Err(f) => { show_error!("Invalid options\n{}", f); return 1; } }; if matches.opt_present("help") { println!("{program} {version} - estimate file space usage Usage {program} [OPTION]... [FILE]... {program} [OPTION]... --files0-from=F {usage} Display values are in units of the first available SIZE from --block-size, and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environ‐ ment variables. Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set). SIZE is an integer and optional unit (example: 10M is 10*1024*1024). Units are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB,... (pow‐ ers of 1000).", program = program, version = VERSION, usage = getopts::usage("Summarize disk usage of each FILE, recursively for directories.", &opts)); return 0; } else if matches.opt_present("version") { println!("{} version: {}", program, VERSION); return 0; } let summarize = matches.opt_present("summarize"); let max_depth_str = matches.opt_str("max-depth"); let max_depth = max_depth_str.as_ref().and_then(|s| s.parse::<usize>().ok()); match (max_depth_str, max_depth) { (Some(ref s), _) if summarize => { show_error!("summarizing conflicts with --max-depth={}", *s); return 1; } (Some(ref s), None) => { show_error!("invalid maximum depth '{}'", *s); return 1; } (Some(_), Some(_)) | (None, _) => { /* valid */ } } let options = Options { all: matches.opt_present("all"), program_name: program.to_string(), max_depth: max_depth, total: matches.opt_present("total"), separate_dirs: matches.opt_present("S"), }; let strs = if matches.free.is_empty() {vec!("./".to_string())} else {matches.free.clone()}; let options_arc = Arc::new(options); let MB = match matches.opt_present("si") { true => 1000 * 1000, false => 1024 * 1024, }; let KB = match matches.opt_present("si") { true => 1000, false => 1024, }; let block_size = match matches.opt_str("block-size") { Some(s) => { let mut found_number = false; let mut found_letter = false;
let mut numbers = String::new(); let mut letters = String::new(); for c in s.as_slice().chars() { if found_letter && c.is_digit(10) ||!found_number &&!c.is_digit(10) { show_error!("invalid --block-size argument '{}'", s); return 1; } else if c.is_digit(10) { found_number = true; numbers.push(c); } else if c.is_alphabetic() { found_letter = true; letters.push(c); } } let number = numbers.parse::<usize>().unwrap(); let multiple = match letters.as_slice() { "K" => 1024, "M" => 1024 * 1024, "G" => 1024 * 1024 * 1024, "T" => 1024 * 1024 * 1024 * 1024, "P" => 1024 * 1024 * 1024 * 1024 * 1024, "E" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "Z" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "Y" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "KB" => 1000, "MB" => 1000 * 1000, "GB" => 1000 * 1000 * 1000, "TB" => 1000 * 1000 * 1000 * 1000, "PB" => 1000 * 1000 * 1000 * 1000 * 1000, "EB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000, "ZB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000, "YB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000, _ => { show_error!("invalid --block-size argument '{}'", s); return 1; } }; number * multiple }, None => 1024 }; let convert_size = |size: u64| -> String { if matches.opt_present("human-readable") || matches.opt_present("si") { if size >= MB { format!("{:.1}M", (size as f64) / (MB as f64)) } else if size >= KB { format!("{:.1}K", (size as f64) / (KB as f64)) } else { format!("{}B", size) } } else if matches.opt_present("k") { format!("{}", ((size as f64) / (KB as f64)).ceil()) } else if matches.opt_present("m") { format!("{}", ((size as f64) / (MB as f64)).ceil()) } else { format!("{}", ((size as f64) / (block_size as f64)).ceil()) } }; let time_format_str = match matches.opt_str("time-style") { Some(s) => { match s.as_slice() { "full-iso" => "%Y-%m-%d %H:%M:%S.%f %z", "long-iso" => "%Y-%m-%d %H:%M", "iso" => "%Y-%m-%d", _ => { show_error!("invalid argument '{}' for 'time style' Valid arguments are: - 'full-iso' - 'long-iso' - 'iso' Try '{} --help' for more information.", s, program); return 1; } } }, None => "%Y-%m-%d %H:%M" }; let line_separator = match matches.opt_present("0") { true => "\0", false => "\n", }; let mut grand_total = 0; for path_str in strs.into_iter() { let path = Path::new(path_str); let stat = safe_unwrap!(fs::lstat(&path)); let iter = du(&path, Stat{path: path.clone(), fstat: stat}, options_arc.clone(), 0).into_iter(); let (_, len) = iter.size_hint(); let len = len.unwrap(); for (index, stat) in iter.enumerate() { let size = match matches.opt_present("apparent-size") { true => stat.fstat.unstable.nlink * stat.fstat.size, // C's stat is such that each block is assume to be 512 bytes // See: http://linux.die.net/man/2/stat false => stat.fstat.unstable.blocks * 512, }; if matches.opt_present("time") { let tm = { let (secs, nsecs) = { let time = match matches.opt_str("time") { Some(s) => match s.as_slice() { "accessed" => stat.fstat.accessed, "created" => stat.fstat.created, "modified" => stat.fstat.modified, _ => { show_error!("invalid argument'modified' for '--time' Valid arguments are: - 'accessed', 'created','modified' Try '{} --help' for more information.", program); return 1; } }, None => stat.fstat.modified }; ((time / 1000) as i64, (time % 1000 * 1000000) as i32) }; time::at(Timespec::new(secs, nsecs)) }; if!summarize || (summarize && index == len-1) { let time_str = tm.strftime(time_format_str).unwrap(); print!("{}\t{}\t{}{}", convert_size(size), time_str, stat.path.display(), line_separator); } } else { if!summarize || (summarize && index == len-1) { print!("{}\t{}{}", convert_size(size), stat.path.display(), line_separator); } } if options_arc.total && index == (len - 1) { // The last element will be the total size of the the path under // path_str. We add it to the grand total. grand_total += size; } } } if options_arc.total { print!("{}\ttotal", convert_size(grand_total)); print!("{}", line_separator); } 0 }
random_line_split
du.rs
#![crate_name = "du"] #![feature(collections, core, old_io, old_path, rustc_private, std_misc, unicode)] /* * This file is part of the uutils coreutils package. * * (c) Derek Chiang <[email protected]> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ #![allow(non_snake_case)] extern crate getopts; extern crate libc; extern crate time; use std::old_io::{stderr, fs, FileStat, FileType}; use std::num::Float; use std::option::Option; use std::old_path::Path; use std::sync::{Arc, Future}; use time::Timespec; #[path = "../common/util.rs"] #[macro_use] mod util; static NAME: &'static str = "du"; static VERSION: &'static str = "1.0.0"; struct Options { all: bool, program_name: String, max_depth: Option<usize>, total: bool, separate_dirs: bool, } struct Stat { path: Path, fstat: FileStat, } // this takes `my_stat` to avoid having to stat files multiple times. fn du(path: &Path, mut my_stat: Stat, options: Arc<Options>, depth: usize) -> Vec<Arc<Stat>> { let mut stats = vec!(); let mut futures = vec!(); if my_stat.fstat.kind == FileType::Directory
} } } } for future in futures.iter_mut() { for stat in future.get().into_iter().rev() { if!options.separate_dirs && stat.path.dir_path() == my_stat.path { my_stat.fstat.size += stat.fstat.size; my_stat.fstat.unstable.blocks += stat.fstat.unstable.blocks; } if options.max_depth == None || depth < options.max_depth.unwrap() { stats.push(stat.clone()); } } } stats.push(Arc::new(my_stat)); stats } pub fn uumain(args: Vec<String>) -> i32 { let program = args[0].as_slice(); let opts = [ // In task getopts::optflag("a", "all", " write counts for all files, not just directories"), // In main getopts::optflag("", "apparent-size", "print apparent sizes, rather than disk usage; although the apparent size is usually smaller, it may be larger due to holes in ('sparse') files, internal fragmentation, indirect blocks, and the like"), // In main getopts::optopt("B", "block-size", "scale sizes by SIZE before printing them. E.g., '-BM' prints sizes in units of 1,048,576 bytes. See SIZE format below.", "SIZE"), // In main getopts::optflag("b", "bytes", "equivalent to '--apparent-size --block-size=1'"), // In main getopts::optflag("c", "total", "produce a grand total"), // In task // getopts::optflag("D", "dereference-args", "dereference only symlinks that are listed // on the command line"), // In main // getopts::optopt("", "files0-from", "summarize disk usage of the NUL-terminated file // names specified in file F; // If F is - then read names from standard input", "F"), // // In task // getopts::optflag("H", "", "equivalent to --dereference-args (-D)"), // In main getopts::optflag("h", "human-readable", "print sizes in human readable format (e.g., 1K 234M 2G)"), // In main getopts::optflag("", "si", "like -h, but use powers of 1000 not 1024"), // In main getopts::optflag("k", "", "like --block-size=1K"), // In task getopts::optflag("l", "count-links", "count sizes many times if hard linked"), // // In main getopts::optflag("m", "", "like --block-size=1M"), // // In task // getopts::optflag("L", "dereference", "dereference all symbolic links"), // // In task // getopts::optflag("P", "no-dereference", "don't follow any symbolic links (this is the default)"), // // In main getopts::optflag("0", "null", "end each output line with 0 byte rather than newline"), // In main getopts::optflag("S", "separate-dirs", "do not include size of subdirectories"), // In main getopts::optflag("s", "summarize", "display only a total for each argument"), // // In task // getopts::optflag("x", "one-file-system", "skip directories on different file systems"), // // In task // getopts::optopt("X", "exclude-from", "exclude files that match any pattern in FILE", "FILE"), // // In task // getopts::optopt("", "exclude", "exclude files that match PATTERN", "PATTERN"), // In main getopts::optopt("d", "max-depth", "print the total for a directory (or file, with --all) only if it is N or fewer levels below the command line argument; --max-depth=0 is the same as --summarize", "N"), // In main getopts::optflagopt("", "time", "show time of the last modification of any file in the directory, or any of its subdirectories. If WORD is given, show time as WORD instead of modification time: atime, access, use, ctime or status", "WORD"), // In main getopts::optopt("", "time-style", "show times using style STYLE: full-iso, long-iso, iso, +FORMAT FORMAT is interpreted like 'date'", "STYLE"), getopts::optflag("", "help", "display this help and exit"), getopts::optflag("V", "version", "output version information and exit"), ]; let matches = match getopts::getopts(args.tail(), &opts) { Ok(m) => m, Err(f) => { show_error!("Invalid options\n{}", f); return 1; } }; if matches.opt_present("help") { println!("{program} {version} - estimate file space usage Usage {program} [OPTION]... [FILE]... {program} [OPTION]... --files0-from=F {usage} Display values are in units of the first available SIZE from --block-size, and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environ‐ ment variables. Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set). SIZE is an integer and optional unit (example: 10M is 10*1024*1024). Units are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB,... (pow‐ ers of 1000).", program = program, version = VERSION, usage = getopts::usage("Summarize disk usage of each FILE, recursively for directories.", &opts)); return 0; } else if matches.opt_present("version") { println!("{} version: {}", program, VERSION); return 0; } let summarize = matches.opt_present("summarize"); let max_depth_str = matches.opt_str("max-depth"); let max_depth = max_depth_str.as_ref().and_then(|s| s.parse::<usize>().ok()); match (max_depth_str, max_depth) { (Some(ref s), _) if summarize => { show_error!("summarizing conflicts with --max-depth={}", *s); return 1; } (Some(ref s), None) => { show_error!("invalid maximum depth '{}'", *s); return 1; } (Some(_), Some(_)) | (None, _) => { /* valid */ } } let options = Options { all: matches.opt_present("all"), program_name: program.to_string(), max_depth: max_depth, total: matches.opt_present("total"), separate_dirs: matches.opt_present("S"), }; let strs = if matches.free.is_empty() {vec!("./".to_string())} else {matches.free.clone()}; let options_arc = Arc::new(options); let MB = match matches.opt_present("si") { true => 1000 * 1000, false => 1024 * 1024, }; let KB = match matches.opt_present("si") { true => 1000, false => 1024, }; let block_size = match matches.opt_str("block-size") { Some(s) => { let mut found_number = false; let mut found_letter = false; let mut numbers = String::new(); let mut letters = String::new(); for c in s.as_slice().chars() { if found_letter && c.is_digit(10) ||!found_number &&!c.is_digit(10) { show_error!("invalid --block-size argument '{}'", s); return 1; } else if c.is_digit(10) { found_number = true; numbers.push(c); } else if c.is_alphabetic() { found_letter = true; letters.push(c); } } let number = numbers.parse::<usize>().unwrap(); let multiple = match letters.as_slice() { "K" => 1024, "M" => 1024 * 1024, "G" => 1024 * 1024 * 1024, "T" => 1024 * 1024 * 1024 * 1024, "P" => 1024 * 1024 * 1024 * 1024 * 1024, "E" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "Z" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "Y" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "KB" => 1000, "MB" => 1000 * 1000, "GB" => 1000 * 1000 * 1000, "TB" => 1000 * 1000 * 1000 * 1000, "PB" => 1000 * 1000 * 1000 * 1000 * 1000, "EB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000, "ZB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000, "YB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000, _ => { show_error!("invalid --block-size argument '{}'", s); return 1; } }; number * multiple }, None => 1024 }; let convert_size = |size: u64| -> String { if matches.opt_present("human-readable") || matches.opt_present("si") { if size >= MB { format!("{:.1}M", (size as f64) / (MB as f64)) } else if size >= KB { format!("{:.1}K", (size as f64) / (KB as f64)) } else { format!("{}B", size) } } else if matches.opt_present("k") { format!("{}", ((size as f64) / (KB as f64)).ceil()) } else if matches.opt_present("m") { format!("{}", ((size as f64) / (MB as f64)).ceil()) } else { format!("{}", ((size as f64) / (block_size as f64)).ceil()) } }; let time_format_str = match matches.opt_str("time-style") { Some(s) => { match s.as_slice() { "full-iso" => "%Y-%m-%d %H:%M:%S.%f %z", "long-iso" => "%Y-%m-%d %H:%M", "iso" => "%Y-%m-%d", _ => { show_error!("invalid argument '{}' for 'time style' Valid arguments are: - 'full-iso' - 'long-iso' - 'iso' Try '{} --help' for more information.", s, program); return 1; } } }, None => "%Y-%m-%d %H:%M" }; let line_separator = match matches.opt_present("0") { true => "\0", false => "\n", }; let mut grand_total = 0; for path_str in strs.into_iter() { let path = Path::new(path_str); let stat = safe_unwrap!(fs::lstat(&path)); let iter = du(&path, Stat{path: path.clone(), fstat: stat}, options_arc.clone(), 0).into_iter(); let (_, len) = iter.size_hint(); let len = len.unwrap(); for (index, stat) in iter.enumerate() { let size = match matches.opt_present("apparent-size") { true => stat.fstat.unstable.nlink * stat.fstat.size, // C's stat is such that each block is assume to be 512 bytes // See: http://linux.die.net/man/2/stat false => stat.fstat.unstable.blocks * 512, }; if matches.opt_present("time") { let tm = { let (secs, nsecs) = { let time = match matches.opt_str("time") { Some(s) => match s.as_slice() { "accessed" => stat.fstat.accessed, "created" => stat.fstat.created, "modified" => stat.fstat.modified, _ => { show_error!("invalid argument'modified' for '--time' Valid arguments are: - 'accessed', 'created','modified' Try '{} --help' for more information.", program); return 1; } }, None => stat.fstat.modified }; ((time / 1000) as i64, (time % 1000 * 1000000) as i32) }; time::at(Timespec::new(secs, nsecs)) }; if!summarize || (summarize && index == len-1) { let time_str = tm.strftime(time_format_str).unwrap(); print!("{}\t{}\t{}{}", convert_size(size), time_str, stat.path.display(), line_separator); } } else { if!summarize || (summarize && index == len-1) { print!("{}\t{}{}", convert_size(size), stat.path.display(), line_separator); } } if options_arc.total && index == (len - 1) { // The last element will be the total size of the the path under // path_str. We add it to the grand total. grand_total += size; } } } if options_arc.total { print!("{}\ttotal", convert_size(grand_total)); print!("{}", line_separator); } 0 }
{ let read = match fs::readdir(path) { Ok(read) => read, Err(e) => { safe_writeln!(&mut stderr(), "{}: cannot read directory ‘{}‘: {}", options.program_name, path.display(), e); return vec!(Arc::new(my_stat)) } }; for f in read.into_iter() { let this_stat = Stat{path: f.clone(), fstat: safe_unwrap!(fs::lstat(&f))}; if this_stat.fstat.kind == FileType::Directory { let oa_clone = options.clone(); futures.push(Future::spawn(move || { du(&f, this_stat, oa_clone, depth + 1) })) } else { my_stat.fstat.size += this_stat.fstat.size; my_stat.fstat.unstable.blocks += this_stat.fstat.unstable.blocks; if options.all { stats.push(Arc::new(this_stat))
conditional_block
du.rs
#![crate_name = "du"] #![feature(collections, core, old_io, old_path, rustc_private, std_misc, unicode)] /* * This file is part of the uutils coreutils package. * * (c) Derek Chiang <[email protected]> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ #![allow(non_snake_case)] extern crate getopts; extern crate libc; extern crate time; use std::old_io::{stderr, fs, FileStat, FileType}; use std::num::Float; use std::option::Option; use std::old_path::Path; use std::sync::{Arc, Future}; use time::Timespec; #[path = "../common/util.rs"] #[macro_use] mod util; static NAME: &'static str = "du"; static VERSION: &'static str = "1.0.0"; struct Options { all: bool, program_name: String, max_depth: Option<usize>, total: bool, separate_dirs: bool, } struct Stat { path: Path, fstat: FileStat, } // this takes `my_stat` to avoid having to stat files multiple times. fn
(path: &Path, mut my_stat: Stat, options: Arc<Options>, depth: usize) -> Vec<Arc<Stat>> { let mut stats = vec!(); let mut futures = vec!(); if my_stat.fstat.kind == FileType::Directory { let read = match fs::readdir(path) { Ok(read) => read, Err(e) => { safe_writeln!(&mut stderr(), "{}: cannot read directory ‘{}‘: {}", options.program_name, path.display(), e); return vec!(Arc::new(my_stat)) } }; for f in read.into_iter() { let this_stat = Stat{path: f.clone(), fstat: safe_unwrap!(fs::lstat(&f))}; if this_stat.fstat.kind == FileType::Directory { let oa_clone = options.clone(); futures.push(Future::spawn(move || { du(&f, this_stat, oa_clone, depth + 1) })) } else { my_stat.fstat.size += this_stat.fstat.size; my_stat.fstat.unstable.blocks += this_stat.fstat.unstable.blocks; if options.all { stats.push(Arc::new(this_stat)) } } } } for future in futures.iter_mut() { for stat in future.get().into_iter().rev() { if!options.separate_dirs && stat.path.dir_path() == my_stat.path { my_stat.fstat.size += stat.fstat.size; my_stat.fstat.unstable.blocks += stat.fstat.unstable.blocks; } if options.max_depth == None || depth < options.max_depth.unwrap() { stats.push(stat.clone()); } } } stats.push(Arc::new(my_stat)); stats } pub fn uumain(args: Vec<String>) -> i32 { let program = args[0].as_slice(); let opts = [ // In task getopts::optflag("a", "all", " write counts for all files, not just directories"), // In main getopts::optflag("", "apparent-size", "print apparent sizes, rather than disk usage; although the apparent size is usually smaller, it may be larger due to holes in ('sparse') files, internal fragmentation, indirect blocks, and the like"), // In main getopts::optopt("B", "block-size", "scale sizes by SIZE before printing them. E.g., '-BM' prints sizes in units of 1,048,576 bytes. See SIZE format below.", "SIZE"), // In main getopts::optflag("b", "bytes", "equivalent to '--apparent-size --block-size=1'"), // In main getopts::optflag("c", "total", "produce a grand total"), // In task // getopts::optflag("D", "dereference-args", "dereference only symlinks that are listed // on the command line"), // In main // getopts::optopt("", "files0-from", "summarize disk usage of the NUL-terminated file // names specified in file F; // If F is - then read names from standard input", "F"), // // In task // getopts::optflag("H", "", "equivalent to --dereference-args (-D)"), // In main getopts::optflag("h", "human-readable", "print sizes in human readable format (e.g., 1K 234M 2G)"), // In main getopts::optflag("", "si", "like -h, but use powers of 1000 not 1024"), // In main getopts::optflag("k", "", "like --block-size=1K"), // In task getopts::optflag("l", "count-links", "count sizes many times if hard linked"), // // In main getopts::optflag("m", "", "like --block-size=1M"), // // In task // getopts::optflag("L", "dereference", "dereference all symbolic links"), // // In task // getopts::optflag("P", "no-dereference", "don't follow any symbolic links (this is the default)"), // // In main getopts::optflag("0", "null", "end each output line with 0 byte rather than newline"), // In main getopts::optflag("S", "separate-dirs", "do not include size of subdirectories"), // In main getopts::optflag("s", "summarize", "display only a total for each argument"), // // In task // getopts::optflag("x", "one-file-system", "skip directories on different file systems"), // // In task // getopts::optopt("X", "exclude-from", "exclude files that match any pattern in FILE", "FILE"), // // In task // getopts::optopt("", "exclude", "exclude files that match PATTERN", "PATTERN"), // In main getopts::optopt("d", "max-depth", "print the total for a directory (or file, with --all) only if it is N or fewer levels below the command line argument; --max-depth=0 is the same as --summarize", "N"), // In main getopts::optflagopt("", "time", "show time of the last modification of any file in the directory, or any of its subdirectories. If WORD is given, show time as WORD instead of modification time: atime, access, use, ctime or status", "WORD"), // In main getopts::optopt("", "time-style", "show times using style STYLE: full-iso, long-iso, iso, +FORMAT FORMAT is interpreted like 'date'", "STYLE"), getopts::optflag("", "help", "display this help and exit"), getopts::optflag("V", "version", "output version information and exit"), ]; let matches = match getopts::getopts(args.tail(), &opts) { Ok(m) => m, Err(f) => { show_error!("Invalid options\n{}", f); return 1; } }; if matches.opt_present("help") { println!("{program} {version} - estimate file space usage Usage {program} [OPTION]... [FILE]... {program} [OPTION]... --files0-from=F {usage} Display values are in units of the first available SIZE from --block-size, and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environ‐ ment variables. Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set). SIZE is an integer and optional unit (example: 10M is 10*1024*1024). Units are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB,... (pow‐ ers of 1000).", program = program, version = VERSION, usage = getopts::usage("Summarize disk usage of each FILE, recursively for directories.", &opts)); return 0; } else if matches.opt_present("version") { println!("{} version: {}", program, VERSION); return 0; } let summarize = matches.opt_present("summarize"); let max_depth_str = matches.opt_str("max-depth"); let max_depth = max_depth_str.as_ref().and_then(|s| s.parse::<usize>().ok()); match (max_depth_str, max_depth) { (Some(ref s), _) if summarize => { show_error!("summarizing conflicts with --max-depth={}", *s); return 1; } (Some(ref s), None) => { show_error!("invalid maximum depth '{}'", *s); return 1; } (Some(_), Some(_)) | (None, _) => { /* valid */ } } let options = Options { all: matches.opt_present("all"), program_name: program.to_string(), max_depth: max_depth, total: matches.opt_present("total"), separate_dirs: matches.opt_present("S"), }; let strs = if matches.free.is_empty() {vec!("./".to_string())} else {matches.free.clone()}; let options_arc = Arc::new(options); let MB = match matches.opt_present("si") { true => 1000 * 1000, false => 1024 * 1024, }; let KB = match matches.opt_present("si") { true => 1000, false => 1024, }; let block_size = match matches.opt_str("block-size") { Some(s) => { let mut found_number = false; let mut found_letter = false; let mut numbers = String::new(); let mut letters = String::new(); for c in s.as_slice().chars() { if found_letter && c.is_digit(10) ||!found_number &&!c.is_digit(10) { show_error!("invalid --block-size argument '{}'", s); return 1; } else if c.is_digit(10) { found_number = true; numbers.push(c); } else if c.is_alphabetic() { found_letter = true; letters.push(c); } } let number = numbers.parse::<usize>().unwrap(); let multiple = match letters.as_slice() { "K" => 1024, "M" => 1024 * 1024, "G" => 1024 * 1024 * 1024, "T" => 1024 * 1024 * 1024 * 1024, "P" => 1024 * 1024 * 1024 * 1024 * 1024, "E" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "Z" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "Y" => 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "KB" => 1000, "MB" => 1000 * 1000, "GB" => 1000 * 1000 * 1000, "TB" => 1000 * 1000 * 1000 * 1000, "PB" => 1000 * 1000 * 1000 * 1000 * 1000, "EB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000, "ZB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000, "YB" => 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000, _ => { show_error!("invalid --block-size argument '{}'", s); return 1; } }; number * multiple }, None => 1024 }; let convert_size = |size: u64| -> String { if matches.opt_present("human-readable") || matches.opt_present("si") { if size >= MB { format!("{:.1}M", (size as f64) / (MB as f64)) } else if size >= KB { format!("{:.1}K", (size as f64) / (KB as f64)) } else { format!("{}B", size) } } else if matches.opt_present("k") { format!("{}", ((size as f64) / (KB as f64)).ceil()) } else if matches.opt_present("m") { format!("{}", ((size as f64) / (MB as f64)).ceil()) } else { format!("{}", ((size as f64) / (block_size as f64)).ceil()) } }; let time_format_str = match matches.opt_str("time-style") { Some(s) => { match s.as_slice() { "full-iso" => "%Y-%m-%d %H:%M:%S.%f %z", "long-iso" => "%Y-%m-%d %H:%M", "iso" => "%Y-%m-%d", _ => { show_error!("invalid argument '{}' for 'time style' Valid arguments are: - 'full-iso' - 'long-iso' - 'iso' Try '{} --help' for more information.", s, program); return 1; } } }, None => "%Y-%m-%d %H:%M" }; let line_separator = match matches.opt_present("0") { true => "\0", false => "\n", }; let mut grand_total = 0; for path_str in strs.into_iter() { let path = Path::new(path_str); let stat = safe_unwrap!(fs::lstat(&path)); let iter = du(&path, Stat{path: path.clone(), fstat: stat}, options_arc.clone(), 0).into_iter(); let (_, len) = iter.size_hint(); let len = len.unwrap(); for (index, stat) in iter.enumerate() { let size = match matches.opt_present("apparent-size") { true => stat.fstat.unstable.nlink * stat.fstat.size, // C's stat is such that each block is assume to be 512 bytes // See: http://linux.die.net/man/2/stat false => stat.fstat.unstable.blocks * 512, }; if matches.opt_present("time") { let tm = { let (secs, nsecs) = { let time = match matches.opt_str("time") { Some(s) => match s.as_slice() { "accessed" => stat.fstat.accessed, "created" => stat.fstat.created, "modified" => stat.fstat.modified, _ => { show_error!("invalid argument'modified' for '--time' Valid arguments are: - 'accessed', 'created','modified' Try '{} --help' for more information.", program); return 1; } }, None => stat.fstat.modified }; ((time / 1000) as i64, (time % 1000 * 1000000) as i32) }; time::at(Timespec::new(secs, nsecs)) }; if!summarize || (summarize && index == len-1) { let time_str = tm.strftime(time_format_str).unwrap(); print!("{}\t{}\t{}{}", convert_size(size), time_str, stat.path.display(), line_separator); } } else { if!summarize || (summarize && index == len-1) { print!("{}\t{}{}", convert_size(size), stat.path.display(), line_separator); } } if options_arc.total && index == (len - 1) { // The last element will be the total size of the the path under // path_str. We add it to the grand total. grand_total += size; } } } if options_arc.total { print!("{}\ttotal", convert_size(grand_total)); print!("{}", line_separator); } 0 }
du
identifier_name
input.rs
use std::f64; use std::collections::HashMap; use std::ops::{Index, IndexMut}; use glutin; use glutin::{ElementState, EventsLoop, VirtualKeyCode}; use glutin::WindowEvent::*; pub const INPUT_UP: usize = 0; pub const INPUT_DOWN: usize = 1; pub const INPUT_LEFT: usize = 2; pub const INPUT_RIGHT: usize = 3; enum MouseState { Released, JustPressed, Held{ prev_x: f64, prev_y: f64 }, } pub struct Input { pub move_forward: bool, pub move_backward: bool, pub strafe_left: bool, pub strafe_right: bool, mouse: MouseState, pub delta_x: f64, pub delta_y: f64, bindings: HashMap<VirtualKeyCode, usize>, } impl Input { pub fn new() -> Self { Input { move_forward: false, move_backward: false, strafe_left: false, strafe_right: false, mouse: MouseState::Released, delta_x: 0.0, delta_y: 0.0, bindings: HashMap::new(), } } fn set_mouse(&mut self, x: f64, y: f64) { match self.mouse { MouseState::Released => { self.delta_x = 0.0; self.delta_y = 0.0; }, MouseState::JustPressed => { self.mouse = MouseState::Held { prev_x: x, prev_y: y }; }, MouseState::Held{ prev_x, prev_y } => { self.delta_x += x - prev_x; self.delta_y += y - prev_y; self.mouse = MouseState::Held { prev_x: x, prev_y: y }; }, } } pub fn bind_key(&mut self, key: VirtualKeyCode, action: usize)
fn get_binding(&self, key: &VirtualKeyCode) -> Option<usize> { if let Some(action) = self.bindings.get(&key) { Some(*action) } else { None } } pub fn gather(&mut self, events_loop: &mut EventsLoop) -> bool { self.delta_x = 0.0; self.delta_y = 0.0; let mut continue_game = true; events_loop.poll_events(|event|{ if let glutin::Event::WindowEvent{event,..} = event { match event { Closed | KeyboardInput{ input: glutin::KeyboardInput{ virtual_keycode: Some(VirtualKeyCode::Escape),.. },.. } => continue_game = false, KeyboardInput{ input: glutin::KeyboardInput{ virtual_keycode: Some(key), state,.. },.. } => { if let Some(action) = self.get_binding(&key) { self[action] = ElementState::Pressed == state; } }, MouseInput{ state: glutin::ElementState::Pressed, button: glutin::MouseButton::Left,.. } => { if let MouseState::Released = self.mouse { self.mouse = MouseState::JustPressed; } }, MouseInput{ state: glutin::ElementState::Released, button: glutin::MouseButton::Left,.. } => { self.mouse = MouseState::Released; }, MouseMoved{ position: (x, y),.. } => self.set_mouse(x, y), _ => {}, } } }); continue_game } } impl Index<usize> for Input { type Output = bool; fn index<'a>(&'a self, index: usize) -> &'a bool { match index { INPUT_UP => &self.move_forward, INPUT_DOWN => &self.move_backward, INPUT_LEFT => &self.strafe_left, INPUT_RIGHT => &self.strafe_right, _ => unimplemented!(), } } } impl IndexMut<usize> for Input { fn index_mut<'a>(&'a mut self, index: usize) -> &'a mut bool { match index { INPUT_UP => &mut self.move_forward, INPUT_DOWN => &mut self.move_backward, INPUT_LEFT => &mut self.strafe_left, INPUT_RIGHT => &mut self.strafe_right, _ => unimplemented!(), } } }
{ self.bindings.insert(key, action); }
identifier_body
input.rs
use std::f64; use std::collections::HashMap; use std::ops::{Index, IndexMut}; use glutin; use glutin::{ElementState, EventsLoop, VirtualKeyCode}; use glutin::WindowEvent::*; pub const INPUT_UP: usize = 0; pub const INPUT_DOWN: usize = 1; pub const INPUT_LEFT: usize = 2; pub const INPUT_RIGHT: usize = 3; enum MouseState { Released, JustPressed, Held{ prev_x: f64, prev_y: f64 }, } pub struct Input { pub move_forward: bool, pub move_backward: bool, pub strafe_left: bool, pub strafe_right: bool, mouse: MouseState, pub delta_x: f64, pub delta_y: f64, bindings: HashMap<VirtualKeyCode, usize>, } impl Input { pub fn new() -> Self { Input { move_forward: false, move_backward: false, strafe_left: false, strafe_right: false, mouse: MouseState::Released, delta_x: 0.0, delta_y: 0.0, bindings: HashMap::new(), } } fn set_mouse(&mut self, x: f64, y: f64) { match self.mouse { MouseState::Released => { self.delta_x = 0.0; self.delta_y = 0.0; }, MouseState::JustPressed => { self.mouse = MouseState::Held { prev_x: x, prev_y: y }; }, MouseState::Held{ prev_x, prev_y } => { self.delta_x += x - prev_x; self.delta_y += y - prev_y; self.mouse = MouseState::Held { prev_x: x, prev_y: y }; }, } } pub fn bind_key(&mut self, key: VirtualKeyCode, action: usize) { self.bindings.insert(key, action); } fn
(&self, key: &VirtualKeyCode) -> Option<usize> { if let Some(action) = self.bindings.get(&key) { Some(*action) } else { None } } pub fn gather(&mut self, events_loop: &mut EventsLoop) -> bool { self.delta_x = 0.0; self.delta_y = 0.0; let mut continue_game = true; events_loop.poll_events(|event|{ if let glutin::Event::WindowEvent{event,..} = event { match event { Closed | KeyboardInput{ input: glutin::KeyboardInput{ virtual_keycode: Some(VirtualKeyCode::Escape),.. },.. } => continue_game = false, KeyboardInput{ input: glutin::KeyboardInput{ virtual_keycode: Some(key), state,.. },.. } => { if let Some(action) = self.get_binding(&key) { self[action] = ElementState::Pressed == state; } }, MouseInput{ state: glutin::ElementState::Pressed, button: glutin::MouseButton::Left,.. } => { if let MouseState::Released = self.mouse { self.mouse = MouseState::JustPressed; } }, MouseInput{ state: glutin::ElementState::Released, button: glutin::MouseButton::Left,.. } => { self.mouse = MouseState::Released; }, MouseMoved{ position: (x, y),.. } => self.set_mouse(x, y), _ => {}, } } }); continue_game } } impl Index<usize> for Input { type Output = bool; fn index<'a>(&'a self, index: usize) -> &'a bool { match index { INPUT_UP => &self.move_forward, INPUT_DOWN => &self.move_backward, INPUT_LEFT => &self.strafe_left, INPUT_RIGHT => &self.strafe_right, _ => unimplemented!(), } } } impl IndexMut<usize> for Input { fn index_mut<'a>(&'a mut self, index: usize) -> &'a mut bool { match index { INPUT_UP => &mut self.move_forward, INPUT_DOWN => &mut self.move_backward, INPUT_LEFT => &mut self.strafe_left, INPUT_RIGHT => &mut self.strafe_right, _ => unimplemented!(), } } }
get_binding
identifier_name
input.rs
use std::f64; use std::collections::HashMap; use std::ops::{Index, IndexMut}; use glutin; use glutin::{ElementState, EventsLoop, VirtualKeyCode}; use glutin::WindowEvent::*; pub const INPUT_UP: usize = 0; pub const INPUT_DOWN: usize = 1; pub const INPUT_LEFT: usize = 2; pub const INPUT_RIGHT: usize = 3; enum MouseState { Released, JustPressed, Held{ prev_x: f64, prev_y: f64 }, } pub struct Input { pub move_forward: bool, pub move_backward: bool, pub strafe_left: bool, pub strafe_right: bool, mouse: MouseState, pub delta_x: f64, pub delta_y: f64, bindings: HashMap<VirtualKeyCode, usize>, } impl Input { pub fn new() -> Self { Input { move_forward: false, move_backward: false, strafe_left: false, strafe_right: false, mouse: MouseState::Released, delta_x: 0.0, delta_y: 0.0, bindings: HashMap::new(), } } fn set_mouse(&mut self, x: f64, y: f64) { match self.mouse { MouseState::Released => { self.delta_x = 0.0; self.delta_y = 0.0; }, MouseState::JustPressed => { self.mouse = MouseState::Held { prev_x: x, prev_y: y }; }, MouseState::Held{ prev_x, prev_y } => { self.delta_x += x - prev_x; self.delta_y += y - prev_y; self.mouse = MouseState::Held { prev_x: x, prev_y: y }; }, } } pub fn bind_key(&mut self, key: VirtualKeyCode, action: usize) { self.bindings.insert(key, action); } fn get_binding(&self, key: &VirtualKeyCode) -> Option<usize> { if let Some(action) = self.bindings.get(&key) { Some(*action) } else { None } } pub fn gather(&mut self, events_loop: &mut EventsLoop) -> bool { self.delta_x = 0.0; self.delta_y = 0.0; let mut continue_game = true; events_loop.poll_events(|event|{ if let glutin::Event::WindowEvent{event,..} = event { match event { Closed | KeyboardInput{ input: glutin::KeyboardInput{ virtual_keycode: Some(VirtualKeyCode::Escape),.. },.. } => continue_game = false, KeyboardInput{ input: glutin::KeyboardInput{ virtual_keycode: Some(key), state,.. },.. } => { if let Some(action) = self.get_binding(&key) { self[action] = ElementState::Pressed == state; } }, MouseInput{ state: glutin::ElementState::Pressed, button: glutin::MouseButton::Left,.. } => { if let MouseState::Released = self.mouse { self.mouse = MouseState::JustPressed; } }, MouseInput{ state: glutin::ElementState::Released, button: glutin::MouseButton::Left,.. } => { self.mouse = MouseState::Released; }, MouseMoved{ position: (x, y),.. } => self.set_mouse(x, y), _ => {}, } } }); continue_game } } impl Index<usize> for Input { type Output = bool; fn index<'a>(&'a self, index: usize) -> &'a bool { match index { INPUT_UP => &self.move_forward, INPUT_DOWN => &self.move_backward, INPUT_LEFT => &self.strafe_left, INPUT_RIGHT => &self.strafe_right, _ => unimplemented!(), } } } impl IndexMut<usize> for Input {
INPUT_RIGHT => &mut self.strafe_right, _ => unimplemented!(), } } }
fn index_mut<'a>(&'a mut self, index: usize) -> &'a mut bool { match index { INPUT_UP => &mut self.move_forward, INPUT_DOWN => &mut self.move_backward, INPUT_LEFT => &mut self.strafe_left,
random_line_split
input.rs
use std::f64; use std::collections::HashMap; use std::ops::{Index, IndexMut}; use glutin; use glutin::{ElementState, EventsLoop, VirtualKeyCode}; use glutin::WindowEvent::*; pub const INPUT_UP: usize = 0; pub const INPUT_DOWN: usize = 1; pub const INPUT_LEFT: usize = 2; pub const INPUT_RIGHT: usize = 3; enum MouseState { Released, JustPressed, Held{ prev_x: f64, prev_y: f64 }, } pub struct Input { pub move_forward: bool, pub move_backward: bool, pub strafe_left: bool, pub strafe_right: bool, mouse: MouseState, pub delta_x: f64, pub delta_y: f64, bindings: HashMap<VirtualKeyCode, usize>, } impl Input { pub fn new() -> Self { Input { move_forward: false, move_backward: false, strafe_left: false, strafe_right: false, mouse: MouseState::Released, delta_x: 0.0, delta_y: 0.0, bindings: HashMap::new(), } } fn set_mouse(&mut self, x: f64, y: f64) { match self.mouse { MouseState::Released => { self.delta_x = 0.0; self.delta_y = 0.0; }, MouseState::JustPressed => { self.mouse = MouseState::Held { prev_x: x, prev_y: y }; }, MouseState::Held{ prev_x, prev_y } => { self.delta_x += x - prev_x; self.delta_y += y - prev_y; self.mouse = MouseState::Held { prev_x: x, prev_y: y }; }, } } pub fn bind_key(&mut self, key: VirtualKeyCode, action: usize) { self.bindings.insert(key, action); } fn get_binding(&self, key: &VirtualKeyCode) -> Option<usize> { if let Some(action) = self.bindings.get(&key) { Some(*action) } else { None } } pub fn gather(&mut self, events_loop: &mut EventsLoop) -> bool { self.delta_x = 0.0; self.delta_y = 0.0; let mut continue_game = true; events_loop.poll_events(|event|{ if let glutin::Event::WindowEvent{event,..} = event { match event { Closed | KeyboardInput{ input: glutin::KeyboardInput{ virtual_keycode: Some(VirtualKeyCode::Escape),.. },.. } => continue_game = false, KeyboardInput{ input: glutin::KeyboardInput{ virtual_keycode: Some(key), state,.. },.. } => { if let Some(action) = self.get_binding(&key) { self[action] = ElementState::Pressed == state; } }, MouseInput{ state: glutin::ElementState::Pressed, button: glutin::MouseButton::Left,.. } => { if let MouseState::Released = self.mouse { self.mouse = MouseState::JustPressed; } }, MouseInput{ state: glutin::ElementState::Released, button: glutin::MouseButton::Left,.. } =>
, MouseMoved{ position: (x, y),.. } => self.set_mouse(x, y), _ => {}, } } }); continue_game } } impl Index<usize> for Input { type Output = bool; fn index<'a>(&'a self, index: usize) -> &'a bool { match index { INPUT_UP => &self.move_forward, INPUT_DOWN => &self.move_backward, INPUT_LEFT => &self.strafe_left, INPUT_RIGHT => &self.strafe_right, _ => unimplemented!(), } } } impl IndexMut<usize> for Input { fn index_mut<'a>(&'a mut self, index: usize) -> &'a mut bool { match index { INPUT_UP => &mut self.move_forward, INPUT_DOWN => &mut self.move_backward, INPUT_LEFT => &mut self.strafe_left, INPUT_RIGHT => &mut self.strafe_right, _ => unimplemented!(), } } }
{ self.mouse = MouseState::Released; }
conditional_block
checkboxes.rs
/* * Copyright (c) 2017-2020 Boucher, Antoni <[email protected]> * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of * the Software, and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ use gtk::{ Inhibit, Window, WindowType, prelude::ButtonExt, prelude::ContainerExt, prelude::ToggleButtonExt, prelude::WidgetExt, }; use gtk::Orientation::Vertical; use relm::{ connect, Component, ContainerWidget, Relm, Update, Widget, WidgetTest, }; use relm_derive::Msg; use self::CheckMsg::*; use self::Msg::*; struct CheckModel { check: bool, label: &'static str, } #[derive(Msg)] enum CheckMsg { Check, Toggle, Uncheck, } struct CheckButton { button: gtk::CheckButton, model: CheckModel, relm: Relm<CheckButton>, } impl Update for CheckButton { type Model = CheckModel; type ModelParam = &'static str; type Msg = CheckMsg; fn model(_: &Relm<Self>, label: &'static str) -> CheckModel { CheckModel { check: false, label, } } fn update(&mut self, event: CheckMsg) { match event { Check => { self.model.check = true; // Lock the stream so that the call to set_active does not emit a Toggle message // because that would cause an infinite recursion // The Toggle message is emitted because the button connect signal is handled. let _lock = self.relm.stream().lock(); self.button.set_active(true); }, Toggle => { self.model.check =!self.model.check; self.button.set_active(self.model.check); }, Uncheck => { self.model.check = false; let _lock = self.relm.stream().lock(); self.button.set_active(false); }, } } } impl Widget for CheckButton { type Root = gtk::CheckButton; fn root(&self) -> Self::Root { self.button.clone() } fn view(relm: &Relm<Self>, model: Self::Model) -> Self { let button = gtk::CheckButton::with_label(model.label); connect!(relm, button, connect_clicked(_), Toggle); CheckButton { button, model, relm: relm.clone(), } } } #[derive(Msg)] enum Msg { MinusToggle, PlusToggle, Quit, } struct Components { minus_button: Component<CheckButton>, plus_button: Component<CheckButton>, } #[derive(Clone)] struct Widgets { minus_button: gtk::CheckButton, plus_button: gtk::CheckButton, window: Window, } struct Win { components: Components, widgets: Widgets, } impl Update for Win { type Model = (); type ModelParam = (); type Msg = Msg; fn model(_: &Relm<Self>, _: ()) -> () { } fn update(&mut self, event: Msg) { match event { Quit => gtk::main_quit(), MinusToggle => { if self.widgets.minus_button.is_active() { self.components.plus_button.emit(Uncheck); } else
}, PlusToggle => { if self.widgets.plus_button.is_active() { self.components.minus_button.emit(Uncheck); } else { self.components.minus_button.emit(Check); } }, } } } impl Widget for Win { type Root = Window; fn root(&self) -> Self::Root { self.widgets.window.clone() } fn view(relm: &Relm<Self>, _model: Self::Model) -> Self { let vbox = gtk::Box::new(Vertical, 0); let plus_button = vbox.add_widget::<CheckButton>("+"); let minus_button = vbox.add_widget::<CheckButton>("-"); let window = Window::new(WindowType::Toplevel); window.add(&vbox); window.show_all(); connect!(plus_button@Toggle, relm, PlusToggle); connect!(minus_button@Toggle, relm, MinusToggle); connect!(relm, window, connect_delete_event(_, _), return (Some(Quit), Inhibit(false))); Win { widgets: Widgets { minus_button: minus_button.widget().clone(), plus_button: plus_button.widget().clone(), window: window, }, components: Components { minus_button, plus_button, }, } } } impl WidgetTest for Win { type Streams = (); fn get_streams(&self) -> Self::Streams { } type Widgets = Widgets; fn get_widgets(&self) -> Self::Widgets { self.widgets.clone() } } fn main() { Win::run(()).expect("Win::run failed"); } #[cfg(test)] mod tests { use gtk::prelude::ToggleButtonExt; use relm_test::click; use crate::Win; #[test] fn check_uncheck() { let (_component, _, widgets) = relm::init_test::<Win>(()).expect("init_test failed"); let plus_button = &widgets.plus_button; let minus_button = &widgets.minus_button; assert!(!plus_button.is_active()); assert!(!minus_button.is_active()); click(plus_button); assert!(plus_button.is_active()); assert!(!minus_button.is_active()); click(plus_button); assert!(!plus_button.is_active()); assert!(minus_button.is_active()); click(minus_button); assert!(plus_button.is_active()); assert!(!minus_button.is_active()); click(minus_button); assert!(!plus_button.is_active()); assert!(minus_button.is_active()); } }
{ self.components.plus_button.emit(Check); }
conditional_block
checkboxes.rs
/* * Copyright (c) 2017-2020 Boucher, Antoni <[email protected]> * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of * the Software, and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ use gtk::{ Inhibit, Window, WindowType, prelude::ButtonExt, prelude::ContainerExt, prelude::ToggleButtonExt, prelude::WidgetExt, }; use gtk::Orientation::Vertical; use relm::{ connect, Component, ContainerWidget, Relm, Update, Widget, WidgetTest, }; use relm_derive::Msg; use self::CheckMsg::*; use self::Msg::*; struct CheckModel { check: bool, label: &'static str, } #[derive(Msg)] enum CheckMsg { Check, Toggle, Uncheck, } struct CheckButton { button: gtk::CheckButton, model: CheckModel, relm: Relm<CheckButton>, } impl Update for CheckButton { type Model = CheckModel; type ModelParam = &'static str; type Msg = CheckMsg; fn model(_: &Relm<Self>, label: &'static str) -> CheckModel { CheckModel { check: false, label, } } fn update(&mut self, event: CheckMsg) { match event { Check => { self.model.check = true; // Lock the stream so that the call to set_active does not emit a Toggle message // because that would cause an infinite recursion // The Toggle message is emitted because the button connect signal is handled. let _lock = self.relm.stream().lock(); self.button.set_active(true); }, Toggle => { self.model.check =!self.model.check; self.button.set_active(self.model.check); }, Uncheck => { self.model.check = false; let _lock = self.relm.stream().lock(); self.button.set_active(false); }, } } } impl Widget for CheckButton { type Root = gtk::CheckButton; fn root(&self) -> Self::Root { self.button.clone() } fn view(relm: &Relm<Self>, model: Self::Model) -> Self { let button = gtk::CheckButton::with_label(model.label); connect!(relm, button, connect_clicked(_), Toggle); CheckButton { button, model, relm: relm.clone(), } } } #[derive(Msg)] enum Msg { MinusToggle, PlusToggle, Quit, } struct Components { minus_button: Component<CheckButton>, plus_button: Component<CheckButton>, } #[derive(Clone)] struct Widgets { minus_button: gtk::CheckButton, plus_button: gtk::CheckButton, window: Window, } struct Win { components: Components, widgets: Widgets, } impl Update for Win { type Model = (); type ModelParam = (); type Msg = Msg; fn model(_: &Relm<Self>, _: ()) -> () { } fn update(&mut self, event: Msg) { match event { Quit => gtk::main_quit(), MinusToggle => { if self.widgets.minus_button.is_active() { self.components.plus_button.emit(Uncheck); } else { self.components.plus_button.emit(Check); } }, PlusToggle => { if self.widgets.plus_button.is_active() { self.components.minus_button.emit(Uncheck); } else { self.components.minus_button.emit(Check); } }, } } } impl Widget for Win { type Root = Window; fn root(&self) -> Self::Root { self.widgets.window.clone() } fn view(relm: &Relm<Self>, _model: Self::Model) -> Self { let vbox = gtk::Box::new(Vertical, 0); let plus_button = vbox.add_widget::<CheckButton>("+"); let minus_button = vbox.add_widget::<CheckButton>("-"); let window = Window::new(WindowType::Toplevel); window.add(&vbox); window.show_all(); connect!(plus_button@Toggle, relm, PlusToggle); connect!(minus_button@Toggle, relm, MinusToggle); connect!(relm, window, connect_delete_event(_, _), return (Some(Quit), Inhibit(false))); Win { widgets: Widgets { minus_button: minus_button.widget().clone(), plus_button: plus_button.widget().clone(), window: window, }, components: Components { minus_button, plus_button, }, } } } impl WidgetTest for Win { type Streams = (); fn get_streams(&self) -> Self::Streams { } type Widgets = Widgets; fn get_widgets(&self) -> Self::Widgets { self.widgets.clone() } } fn main() { Win::run(()).expect("Win::run failed"); } #[cfg(test)] mod tests { use gtk::prelude::ToggleButtonExt; use relm_test::click; use crate::Win; #[test] fn
() { let (_component, _, widgets) = relm::init_test::<Win>(()).expect("init_test failed"); let plus_button = &widgets.plus_button; let minus_button = &widgets.minus_button; assert!(!plus_button.is_active()); assert!(!minus_button.is_active()); click(plus_button); assert!(plus_button.is_active()); assert!(!minus_button.is_active()); click(plus_button); assert!(!plus_button.is_active()); assert!(minus_button.is_active()); click(minus_button); assert!(plus_button.is_active()); assert!(!minus_button.is_active()); click(minus_button); assert!(!plus_button.is_active()); assert!(minus_button.is_active()); } }
check_uncheck
identifier_name
checkboxes.rs
/* * Copyright (c) 2017-2020 Boucher, Antoni <[email protected]> * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of * the Software, and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ use gtk::{ Inhibit, Window, WindowType, prelude::ButtonExt, prelude::ContainerExt, prelude::ToggleButtonExt, prelude::WidgetExt, }; use gtk::Orientation::Vertical; use relm::{ connect, Component, ContainerWidget, Relm, Update, Widget, WidgetTest, }; use relm_derive::Msg; use self::CheckMsg::*; use self::Msg::*; struct CheckModel { check: bool, label: &'static str, } #[derive(Msg)] enum CheckMsg { Check, Toggle, Uncheck, } struct CheckButton { button: gtk::CheckButton, model: CheckModel, relm: Relm<CheckButton>, } impl Update for CheckButton { type Model = CheckModel; type ModelParam = &'static str; type Msg = CheckMsg; fn model(_: &Relm<Self>, label: &'static str) -> CheckModel { CheckModel { check: false, label, } } fn update(&mut self, event: CheckMsg) { match event { Check => { self.model.check = true; // Lock the stream so that the call to set_active does not emit a Toggle message // because that would cause an infinite recursion // The Toggle message is emitted because the button connect signal is handled. let _lock = self.relm.stream().lock(); self.button.set_active(true); }, Toggle => { self.model.check =!self.model.check; self.button.set_active(self.model.check); }, Uncheck => { self.model.check = false; let _lock = self.relm.stream().lock(); self.button.set_active(false); }, } } } impl Widget for CheckButton { type Root = gtk::CheckButton; fn root(&self) -> Self::Root { self.button.clone() } fn view(relm: &Relm<Self>, model: Self::Model) -> Self { let button = gtk::CheckButton::with_label(model.label); connect!(relm, button, connect_clicked(_), Toggle); CheckButton { button, model, relm: relm.clone(), } } } #[derive(Msg)] enum Msg { MinusToggle, PlusToggle, Quit, } struct Components { minus_button: Component<CheckButton>, plus_button: Component<CheckButton>, } #[derive(Clone)] struct Widgets { minus_button: gtk::CheckButton, plus_button: gtk::CheckButton, window: Window, } struct Win { components: Components, widgets: Widgets, } impl Update for Win { type Model = (); type ModelParam = (); type Msg = Msg; fn model(_: &Relm<Self>, _: ()) -> () { } fn update(&mut self, event: Msg) { match event { Quit => gtk::main_quit(), MinusToggle => { if self.widgets.minus_button.is_active() { self.components.plus_button.emit(Uncheck); } else { self.components.plus_button.emit(Check); } }, PlusToggle => { if self.widgets.plus_button.is_active() { self.components.minus_button.emit(Uncheck); } else { self.components.minus_button.emit(Check); } }, } } } impl Widget for Win { type Root = Window; fn root(&self) -> Self::Root { self.widgets.window.clone() } fn view(relm: &Relm<Self>, _model: Self::Model) -> Self { let vbox = gtk::Box::new(Vertical, 0); let plus_button = vbox.add_widget::<CheckButton>("+"); let minus_button = vbox.add_widget::<CheckButton>("-"); let window = Window::new(WindowType::Toplevel); window.add(&vbox); window.show_all(); connect!(plus_button@Toggle, relm, PlusToggle); connect!(minus_button@Toggle, relm, MinusToggle); connect!(relm, window, connect_delete_event(_, _), return (Some(Quit), Inhibit(false))); Win { widgets: Widgets { minus_button: minus_button.widget().clone(), plus_button: plus_button.widget().clone(), window: window, }, components: Components { minus_button, plus_button, }, } } } impl WidgetTest for Win { type Streams = (); fn get_streams(&self) -> Self::Streams { } type Widgets = Widgets; fn get_widgets(&self) -> Self::Widgets { self.widgets.clone() } } fn main() { Win::run(()).expect("Win::run failed"); } #[cfg(test)] mod tests { use gtk::prelude::ToggleButtonExt; use relm_test::click; use crate::Win; #[test] fn check_uncheck() { let (_component, _, widgets) = relm::init_test::<Win>(()).expect("init_test failed"); let plus_button = &widgets.plus_button; let minus_button = &widgets.minus_button; assert!(!plus_button.is_active()); assert!(!minus_button.is_active()); click(plus_button); assert!(plus_button.is_active()); assert!(!minus_button.is_active()); click(plus_button); assert!(!plus_button.is_active()); assert!(minus_button.is_active()); click(minus_button); assert!(plus_button.is_active()); assert!(!minus_button.is_active());
}
click(minus_button); assert!(!plus_button.is_active()); assert!(minus_button.is_active()); }
random_line_split
checkboxes.rs
/* * Copyright (c) 2017-2020 Boucher, Antoni <[email protected]> * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of * the Software, and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ use gtk::{ Inhibit, Window, WindowType, prelude::ButtonExt, prelude::ContainerExt, prelude::ToggleButtonExt, prelude::WidgetExt, }; use gtk::Orientation::Vertical; use relm::{ connect, Component, ContainerWidget, Relm, Update, Widget, WidgetTest, }; use relm_derive::Msg; use self::CheckMsg::*; use self::Msg::*; struct CheckModel { check: bool, label: &'static str, } #[derive(Msg)] enum CheckMsg { Check, Toggle, Uncheck, } struct CheckButton { button: gtk::CheckButton, model: CheckModel, relm: Relm<CheckButton>, } impl Update for CheckButton { type Model = CheckModel; type ModelParam = &'static str; type Msg = CheckMsg; fn model(_: &Relm<Self>, label: &'static str) -> CheckModel { CheckModel { check: false, label, } } fn update(&mut self, event: CheckMsg) { match event { Check => { self.model.check = true; // Lock the stream so that the call to set_active does not emit a Toggle message // because that would cause an infinite recursion // The Toggle message is emitted because the button connect signal is handled. let _lock = self.relm.stream().lock(); self.button.set_active(true); }, Toggle => { self.model.check =!self.model.check; self.button.set_active(self.model.check); }, Uncheck => { self.model.check = false; let _lock = self.relm.stream().lock(); self.button.set_active(false); }, } } } impl Widget for CheckButton { type Root = gtk::CheckButton; fn root(&self) -> Self::Root { self.button.clone() } fn view(relm: &Relm<Self>, model: Self::Model) -> Self { let button = gtk::CheckButton::with_label(model.label); connect!(relm, button, connect_clicked(_), Toggle); CheckButton { button, model, relm: relm.clone(), } } } #[derive(Msg)] enum Msg { MinusToggle, PlusToggle, Quit, } struct Components { minus_button: Component<CheckButton>, plus_button: Component<CheckButton>, } #[derive(Clone)] struct Widgets { minus_button: gtk::CheckButton, plus_button: gtk::CheckButton, window: Window, } struct Win { components: Components, widgets: Widgets, } impl Update for Win { type Model = (); type ModelParam = (); type Msg = Msg; fn model(_: &Relm<Self>, _: ()) -> () { } fn update(&mut self, event: Msg)
} } impl Widget for Win { type Root = Window; fn root(&self) -> Self::Root { self.widgets.window.clone() } fn view(relm: &Relm<Self>, _model: Self::Model) -> Self { let vbox = gtk::Box::new(Vertical, 0); let plus_button = vbox.add_widget::<CheckButton>("+"); let minus_button = vbox.add_widget::<CheckButton>("-"); let window = Window::new(WindowType::Toplevel); window.add(&vbox); window.show_all(); connect!(plus_button@Toggle, relm, PlusToggle); connect!(minus_button@Toggle, relm, MinusToggle); connect!(relm, window, connect_delete_event(_, _), return (Some(Quit), Inhibit(false))); Win { widgets: Widgets { minus_button: minus_button.widget().clone(), plus_button: plus_button.widget().clone(), window: window, }, components: Components { minus_button, plus_button, }, } } } impl WidgetTest for Win { type Streams = (); fn get_streams(&self) -> Self::Streams { } type Widgets = Widgets; fn get_widgets(&self) -> Self::Widgets { self.widgets.clone() } } fn main() { Win::run(()).expect("Win::run failed"); } #[cfg(test)] mod tests { use gtk::prelude::ToggleButtonExt; use relm_test::click; use crate::Win; #[test] fn check_uncheck() { let (_component, _, widgets) = relm::init_test::<Win>(()).expect("init_test failed"); let plus_button = &widgets.plus_button; let minus_button = &widgets.minus_button; assert!(!plus_button.is_active()); assert!(!minus_button.is_active()); click(plus_button); assert!(plus_button.is_active()); assert!(!minus_button.is_active()); click(plus_button); assert!(!plus_button.is_active()); assert!(minus_button.is_active()); click(minus_button); assert!(plus_button.is_active()); assert!(!minus_button.is_active()); click(minus_button); assert!(!plus_button.is_active()); assert!(minus_button.is_active()); } }
{ match event { Quit => gtk::main_quit(), MinusToggle => { if self.widgets.minus_button.is_active() { self.components.plus_button.emit(Uncheck); } else { self.components.plus_button.emit(Check); } }, PlusToggle => { if self.widgets.plus_button.is_active() { self.components.minus_button.emit(Uncheck); } else { self.components.minus_button.emit(Check); } }, }
identifier_body
cell.rs
// Copyright 2016 Joe Wilm, The Alacritty Project Contributors // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. use ansi::{NamedColor, Color}; use grid; use index::Column; bitflags! { #[derive(Serialize, Deserialize)] pub flags Flags: u32 { const INVERSE = 0b00000001, const BOLD = 0b00000010, const ITALIC = 0b00000100, const UNDERLINE = 0b00001000, const WRAPLINE = 0b00010000, } } #[derive(Copy, Clone, Debug, Serialize, Deserialize, Eq, PartialEq)] pub struct Cell { pub c: char, pub fg: Color, pub bg: Color, pub flags: Flags, } impl Default for Cell { fn default() -> Cell { Cell::new( '', Color::Named(NamedColor::Foreground), Color::Named(NamedColor::Background) ) } } /// Get the length of occupied cells in a line pub trait LineLength { /// Calculate the occupied line length fn line_length(&self) -> Column; } impl LineLength for grid::Row<Cell> { fn line_length(&self) -> Column { let mut length = Column(0); if self[Column(self.len() - 1)].flags.contains(WRAPLINE) { return Column(self.len()); } for (index, cell) in self[..].iter().rev().enumerate() { if cell.c!='' { length = Column(self.len() - index); break; } } length } } impl Cell { pub fn bold(&self) -> bool { self.flags.contains(BOLD) } pub fn
(c: char, fg: Color, bg: Color) -> Cell { Cell { c: c.into(), bg: bg, fg: fg, flags: Flags::empty(), } } #[inline] pub fn is_empty(&self) -> bool { self.c =='' && self.bg == Color::Named(NamedColor::Background) && !self.flags.contains(INVERSE) } #[inline] pub fn reset(&mut self, template: &Cell) { // memcpy template to self *self = *template; } } #[cfg(test)] mod tests { use super::{Cell, LineLength}; use grid::Row; use index::Column; #[test] fn line_length_works() { let template = Cell::default(); let mut row = Row::new(Column(10), &template); row[Column(5)].c = 'a'; assert_eq!(row.line_length(), Column(6)); } #[test] fn line_length_works_with_wrapline() { let template = Cell::default(); let mut row = Row::new(Column(10), &template); row[Column(9)].flags.insert(super::WRAPLINE); assert_eq!(row.line_length(), Column(10)); } } #[cfg(test)] mod benches { extern crate test; use super::Cell; #[bench] fn cell_reset(b: &mut test::Bencher) { b.iter(|| { let mut cell = Cell::default(); for _ in 0..100 { cell.reset(test::black_box(&Cell::default())); } test::black_box(cell); }); } }
new
identifier_name
cell.rs
// Copyright 2016 Joe Wilm, The Alacritty Project Contributors // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. use ansi::{NamedColor, Color}; use grid; use index::Column; bitflags! { #[derive(Serialize, Deserialize)] pub flags Flags: u32 { const INVERSE = 0b00000001, const BOLD = 0b00000010, const ITALIC = 0b00000100, const UNDERLINE = 0b00001000, const WRAPLINE = 0b00010000, } } #[derive(Copy, Clone, Debug, Serialize, Deserialize, Eq, PartialEq)] pub struct Cell { pub c: char, pub fg: Color, pub bg: Color, pub flags: Flags, } impl Default for Cell { fn default() -> Cell { Cell::new( '', Color::Named(NamedColor::Foreground), Color::Named(NamedColor::Background) ) } } /// Get the length of occupied cells in a line pub trait LineLength { /// Calculate the occupied line length fn line_length(&self) -> Column; } impl LineLength for grid::Row<Cell> { fn line_length(&self) -> Column
} impl Cell { pub fn bold(&self) -> bool { self.flags.contains(BOLD) } pub fn new(c: char, fg: Color, bg: Color) -> Cell { Cell { c: c.into(), bg: bg, fg: fg, flags: Flags::empty(), } } #[inline] pub fn is_empty(&self) -> bool { self.c =='' && self.bg == Color::Named(NamedColor::Background) && !self.flags.contains(INVERSE) } #[inline] pub fn reset(&mut self, template: &Cell) { // memcpy template to self *self = *template; } } #[cfg(test)] mod tests { use super::{Cell, LineLength}; use grid::Row; use index::Column; #[test] fn line_length_works() { let template = Cell::default(); let mut row = Row::new(Column(10), &template); row[Column(5)].c = 'a'; assert_eq!(row.line_length(), Column(6)); } #[test] fn line_length_works_with_wrapline() { let template = Cell::default(); let mut row = Row::new(Column(10), &template); row[Column(9)].flags.insert(super::WRAPLINE); assert_eq!(row.line_length(), Column(10)); } } #[cfg(test)] mod benches { extern crate test; use super::Cell; #[bench] fn cell_reset(b: &mut test::Bencher) { b.iter(|| { let mut cell = Cell::default(); for _ in 0..100 { cell.reset(test::black_box(&Cell::default())); } test::black_box(cell); }); } }
{ let mut length = Column(0); if self[Column(self.len() - 1)].flags.contains(WRAPLINE) { return Column(self.len()); } for (index, cell) in self[..].iter().rev().enumerate() { if cell.c != ' ' { length = Column(self.len() - index); break; } } length }
identifier_body
cell.rs
// Copyright 2016 Joe Wilm, The Alacritty Project Contributors // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. use ansi::{NamedColor, Color}; use grid; use index::Column; bitflags! { #[derive(Serialize, Deserialize)] pub flags Flags: u32 { const INVERSE = 0b00000001, const BOLD = 0b00000010, const ITALIC = 0b00000100, const UNDERLINE = 0b00001000, const WRAPLINE = 0b00010000, } } #[derive(Copy, Clone, Debug, Serialize, Deserialize, Eq, PartialEq)] pub struct Cell { pub c: char, pub fg: Color, pub bg: Color, pub flags: Flags, } impl Default for Cell { fn default() -> Cell { Cell::new( '', Color::Named(NamedColor::Foreground), Color::Named(NamedColor::Background) ) } } /// Get the length of occupied cells in a line pub trait LineLength { /// Calculate the occupied line length fn line_length(&self) -> Column; } impl LineLength for grid::Row<Cell> { fn line_length(&self) -> Column { let mut length = Column(0); if self[Column(self.len() - 1)].flags.contains(WRAPLINE) { return Column(self.len()); } for (index, cell) in self[..].iter().rev().enumerate() { if cell.c!=''
} length } } impl Cell { pub fn bold(&self) -> bool { self.flags.contains(BOLD) } pub fn new(c: char, fg: Color, bg: Color) -> Cell { Cell { c: c.into(), bg: bg, fg: fg, flags: Flags::empty(), } } #[inline] pub fn is_empty(&self) -> bool { self.c =='' && self.bg == Color::Named(NamedColor::Background) && !self.flags.contains(INVERSE) } #[inline] pub fn reset(&mut self, template: &Cell) { // memcpy template to self *self = *template; } } #[cfg(test)] mod tests { use super::{Cell, LineLength}; use grid::Row; use index::Column; #[test] fn line_length_works() { let template = Cell::default(); let mut row = Row::new(Column(10), &template); row[Column(5)].c = 'a'; assert_eq!(row.line_length(), Column(6)); } #[test] fn line_length_works_with_wrapline() { let template = Cell::default(); let mut row = Row::new(Column(10), &template); row[Column(9)].flags.insert(super::WRAPLINE); assert_eq!(row.line_length(), Column(10)); } } #[cfg(test)] mod benches { extern crate test; use super::Cell; #[bench] fn cell_reset(b: &mut test::Bencher) { b.iter(|| { let mut cell = Cell::default(); for _ in 0..100 { cell.reset(test::black_box(&Cell::default())); } test::black_box(cell); }); } }
{ length = Column(self.len() - index); break; }
conditional_block
cell.rs
// Copyright 2016 Joe Wilm, The Alacritty Project Contributors // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. use ansi::{NamedColor, Color}; use grid; use index::Column; bitflags! { #[derive(Serialize, Deserialize)] pub flags Flags: u32 { const INVERSE = 0b00000001, const BOLD = 0b00000010, const ITALIC = 0b00000100, const UNDERLINE = 0b00001000, const WRAPLINE = 0b00010000, } } #[derive(Copy, Clone, Debug, Serialize, Deserialize, Eq, PartialEq)] pub struct Cell { pub c: char, pub fg: Color, pub bg: Color, pub flags: Flags, } impl Default for Cell { fn default() -> Cell { Cell::new( '', Color::Named(NamedColor::Foreground), Color::Named(NamedColor::Background) ) } } /// Get the length of occupied cells in a line pub trait LineLength { /// Calculate the occupied line length fn line_length(&self) -> Column; } impl LineLength for grid::Row<Cell> { fn line_length(&self) -> Column { let mut length = Column(0); if self[Column(self.len() - 1)].flags.contains(WRAPLINE) { return Column(self.len()); } for (index, cell) in self[..].iter().rev().enumerate() { if cell.c!='' { length = Column(self.len() - index); break; } } length } } impl Cell { pub fn bold(&self) -> bool { self.flags.contains(BOLD) } pub fn new(c: char, fg: Color, bg: Color) -> Cell {
Cell { c: c.into(), bg: bg, fg: fg, flags: Flags::empty(), } } #[inline] pub fn is_empty(&self) -> bool { self.c =='' && self.bg == Color::Named(NamedColor::Background) && !self.flags.contains(INVERSE) } #[inline] pub fn reset(&mut self, template: &Cell) { // memcpy template to self *self = *template; } } #[cfg(test)] mod tests { use super::{Cell, LineLength}; use grid::Row; use index::Column; #[test] fn line_length_works() { let template = Cell::default(); let mut row = Row::new(Column(10), &template); row[Column(5)].c = 'a'; assert_eq!(row.line_length(), Column(6)); } #[test] fn line_length_works_with_wrapline() { let template = Cell::default(); let mut row = Row::new(Column(10), &template); row[Column(9)].flags.insert(super::WRAPLINE); assert_eq!(row.line_length(), Column(10)); } } #[cfg(test)] mod benches { extern crate test; use super::Cell; #[bench] fn cell_reset(b: &mut test::Bencher) { b.iter(|| { let mut cell = Cell::default(); for _ in 0..100 { cell.reset(test::black_box(&Cell::default())); } test::black_box(cell); }); } }
random_line_split
variance-regions-direct.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. // Test that we correctly infer variance for region parameters in // various self-contained types. // Regions that just appear in normal spots are contravariant: #[rustc_variance] struct Test2<'a, 'b, 'c> { //~ ERROR regions=[[-, -, -];[];[];[]] x: &'a int, y: &'b [int], c: &'c str } // Those same annotations in function arguments become covariant: #[rustc_variance] struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[+, +, +];[];[];[]] x: extern "Rust" fn(&'a int), y: extern "Rust" fn(&'b [int]), c: extern "Rust" fn(&'c str), } // Mutability induces invariance: #[rustc_variance] struct Test4<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[];[]] x: &'a mut &'b int, } // Mutability induces invariance, even when in a // contravariant context: #[rustc_variance] struct Test5<'a, 'b> { //~ ERROR regions=[[+, o];[];[];[]] x: extern "Rust" fn(&'a mut &'b int), } // Invariance is a trap from which NO ONE CAN ESCAPE. // In other words, even though the `&'b int` occurs in // a argument list (which is contravariant), that // argument list occurs in an invariant context. #[rustc_variance] struct Test6<'a, 'b> { //~ ERROR regions=[[-, o];[];[];[]] x: &'a mut extern "Rust" fn(&'b int), } // No uses at all is bivariant: #[rustc_variance] struct Test7<'a> { //~ ERROR regions=[[*];[];[];[]] x: int } // Try enums too. #[rustc_variance] enum Test8<'a, 'b, 'c:'b> { //~ ERROR regions=[[+, -, o];[];[];[]] Test8A(extern "Rust" fn(&'a int)), Test8B(&'b [int]), Test8C(&'b mut &'c str), } fn
() {}
main
identifier_name
variance-regions-direct.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. // Test that we correctly infer variance for region parameters in // various self-contained types. // Regions that just appear in normal spots are contravariant: #[rustc_variance] struct Test2<'a, 'b, 'c> { //~ ERROR regions=[[-, -, -];[];[];[]] x: &'a int, y: &'b [int], c: &'c str }
#[rustc_variance] struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[+, +, +];[];[];[]] x: extern "Rust" fn(&'a int), y: extern "Rust" fn(&'b [int]), c: extern "Rust" fn(&'c str), } // Mutability induces invariance: #[rustc_variance] struct Test4<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[];[]] x: &'a mut &'b int, } // Mutability induces invariance, even when in a // contravariant context: #[rustc_variance] struct Test5<'a, 'b> { //~ ERROR regions=[[+, o];[];[];[]] x: extern "Rust" fn(&'a mut &'b int), } // Invariance is a trap from which NO ONE CAN ESCAPE. // In other words, even though the `&'b int` occurs in // a argument list (which is contravariant), that // argument list occurs in an invariant context. #[rustc_variance] struct Test6<'a, 'b> { //~ ERROR regions=[[-, o];[];[];[]] x: &'a mut extern "Rust" fn(&'b int), } // No uses at all is bivariant: #[rustc_variance] struct Test7<'a> { //~ ERROR regions=[[*];[];[];[]] x: int } // Try enums too. #[rustc_variance] enum Test8<'a, 'b, 'c:'b> { //~ ERROR regions=[[+, -, o];[];[];[]] Test8A(extern "Rust" fn(&'a int)), Test8B(&'b [int]), Test8C(&'b mut &'c str), } fn main() {}
// Those same annotations in function arguments become covariant:
random_line_split
network_listener.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 bluetooth_traits::{BluetoothResponseListener, BluetoothResponseResult}; use net_traits::{Action, FetchResponseListener, FetchResponseMsg}; use script_thread::{Runnable, RunnableWrapper}; use std::sync::{Arc, Mutex}; use task_source::TaskSource; use task_source::networking::NetworkingTaskSource; /// An off-thread sink for async network event runnables. All such events are forwarded to /// a target thread, where they are invoked on the provided context object. pub struct NetworkListener<Listener: PreInvoke + Send +'static> { pub context: Arc<Mutex<Listener>>, pub task_source: NetworkingTaskSource, pub wrapper: Option<RunnableWrapper>,
impl<Listener: PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify<A: Action<Listener> + Send +'static>(&self, action: A) { let runnable = box ListenerRunnable { context: self.context.clone(), action: action, }; let result = if let Some(ref wrapper) = self.wrapper { self.task_source.queue_with_wrapper(runnable, wrapper) } else { self.task_source.queue_wrapperless(runnable) }; if let Err(err) = result { warn!("failed to deliver network data: {:?}", err); } } } // helps type inference impl<Listener: FetchResponseListener + PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify_fetch(&self, action: FetchResponseMsg) { self.notify(action); } } // helps type inference impl<Listener: BluetoothResponseListener + PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify_response(&self, action: BluetoothResponseResult) { self.notify(action); } } /// A gating mechanism that runs before invoking the runnable on the target thread. /// If the `should_invoke` method returns false, the runnable is discarded without /// being invoked. pub trait PreInvoke { fn should_invoke(&self) -> bool { true } } /// A runnable for moving the async network events between threads. struct ListenerRunnable<A: Action<Listener> + Send +'static, Listener: PreInvoke + Send> { context: Arc<Mutex<Listener>>, action: A, } impl<A: Action<Listener> + Send +'static, Listener: PreInvoke + Send> Runnable for ListenerRunnable<A, Listener> { fn handler(self: Box<ListenerRunnable<A, Listener>>) { let this = *self; let mut context = this.context.lock().unwrap(); if context.should_invoke() { this.action.process(&mut *context); } } }
}
random_line_split
network_listener.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 bluetooth_traits::{BluetoothResponseListener, BluetoothResponseResult}; use net_traits::{Action, FetchResponseListener, FetchResponseMsg}; use script_thread::{Runnable, RunnableWrapper}; use std::sync::{Arc, Mutex}; use task_source::TaskSource; use task_source::networking::NetworkingTaskSource; /// An off-thread sink for async network event runnables. All such events are forwarded to /// a target thread, where they are invoked on the provided context object. pub struct NetworkListener<Listener: PreInvoke + Send +'static> { pub context: Arc<Mutex<Listener>>, pub task_source: NetworkingTaskSource, pub wrapper: Option<RunnableWrapper>, } impl<Listener: PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify<A: Action<Listener> + Send +'static>(&self, action: A) { let runnable = box ListenerRunnable { context: self.context.clone(), action: action, }; let result = if let Some(ref wrapper) = self.wrapper { self.task_source.queue_with_wrapper(runnable, wrapper) } else { self.task_source.queue_wrapperless(runnable) }; if let Err(err) = result { warn!("failed to deliver network data: {:?}", err); } } } // helps type inference impl<Listener: FetchResponseListener + PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify_fetch(&self, action: FetchResponseMsg) { self.notify(action); } } // helps type inference impl<Listener: BluetoothResponseListener + PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify_response(&self, action: BluetoothResponseResult) { self.notify(action); } } /// A gating mechanism that runs before invoking the runnable on the target thread. /// If the `should_invoke` method returns false, the runnable is discarded without /// being invoked. pub trait PreInvoke { fn
(&self) -> bool { true } } /// A runnable for moving the async network events between threads. struct ListenerRunnable<A: Action<Listener> + Send +'static, Listener: PreInvoke + Send> { context: Arc<Mutex<Listener>>, action: A, } impl<A: Action<Listener> + Send +'static, Listener: PreInvoke + Send> Runnable for ListenerRunnable<A, Listener> { fn handler(self: Box<ListenerRunnable<A, Listener>>) { let this = *self; let mut context = this.context.lock().unwrap(); if context.should_invoke() { this.action.process(&mut *context); } } }
should_invoke
identifier_name
network_listener.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 bluetooth_traits::{BluetoothResponseListener, BluetoothResponseResult}; use net_traits::{Action, FetchResponseListener, FetchResponseMsg}; use script_thread::{Runnable, RunnableWrapper}; use std::sync::{Arc, Mutex}; use task_source::TaskSource; use task_source::networking::NetworkingTaskSource; /// An off-thread sink for async network event runnables. All such events are forwarded to /// a target thread, where they are invoked on the provided context object. pub struct NetworkListener<Listener: PreInvoke + Send +'static> { pub context: Arc<Mutex<Listener>>, pub task_source: NetworkingTaskSource, pub wrapper: Option<RunnableWrapper>, } impl<Listener: PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify<A: Action<Listener> + Send +'static>(&self, action: A) { let runnable = box ListenerRunnable { context: self.context.clone(), action: action, }; let result = if let Some(ref wrapper) = self.wrapper { self.task_source.queue_with_wrapper(runnable, wrapper) } else { self.task_source.queue_wrapperless(runnable) }; if let Err(err) = result { warn!("failed to deliver network data: {:?}", err); } } } // helps type inference impl<Listener: FetchResponseListener + PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify_fetch(&self, action: FetchResponseMsg) { self.notify(action); } } // helps type inference impl<Listener: BluetoothResponseListener + PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify_response(&self, action: BluetoothResponseResult)
} /// A gating mechanism that runs before invoking the runnable on the target thread. /// If the `should_invoke` method returns false, the runnable is discarded without /// being invoked. pub trait PreInvoke { fn should_invoke(&self) -> bool { true } } /// A runnable for moving the async network events between threads. struct ListenerRunnable<A: Action<Listener> + Send +'static, Listener: PreInvoke + Send> { context: Arc<Mutex<Listener>>, action: A, } impl<A: Action<Listener> + Send +'static, Listener: PreInvoke + Send> Runnable for ListenerRunnable<A, Listener> { fn handler(self: Box<ListenerRunnable<A, Listener>>) { let this = *self; let mut context = this.context.lock().unwrap(); if context.should_invoke() { this.action.process(&mut *context); } } }
{ self.notify(action); }
identifier_body
network_listener.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 bluetooth_traits::{BluetoothResponseListener, BluetoothResponseResult}; use net_traits::{Action, FetchResponseListener, FetchResponseMsg}; use script_thread::{Runnable, RunnableWrapper}; use std::sync::{Arc, Mutex}; use task_source::TaskSource; use task_source::networking::NetworkingTaskSource; /// An off-thread sink for async network event runnables. All such events are forwarded to /// a target thread, where they are invoked on the provided context object. pub struct NetworkListener<Listener: PreInvoke + Send +'static> { pub context: Arc<Mutex<Listener>>, pub task_source: NetworkingTaskSource, pub wrapper: Option<RunnableWrapper>, } impl<Listener: PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify<A: Action<Listener> + Send +'static>(&self, action: A) { let runnable = box ListenerRunnable { context: self.context.clone(), action: action, }; let result = if let Some(ref wrapper) = self.wrapper { self.task_source.queue_with_wrapper(runnable, wrapper) } else
; if let Err(err) = result { warn!("failed to deliver network data: {:?}", err); } } } // helps type inference impl<Listener: FetchResponseListener + PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify_fetch(&self, action: FetchResponseMsg) { self.notify(action); } } // helps type inference impl<Listener: BluetoothResponseListener + PreInvoke + Send +'static> NetworkListener<Listener> { pub fn notify_response(&self, action: BluetoothResponseResult) { self.notify(action); } } /// A gating mechanism that runs before invoking the runnable on the target thread. /// If the `should_invoke` method returns false, the runnable is discarded without /// being invoked. pub trait PreInvoke { fn should_invoke(&self) -> bool { true } } /// A runnable for moving the async network events between threads. struct ListenerRunnable<A: Action<Listener> + Send +'static, Listener: PreInvoke + Send> { context: Arc<Mutex<Listener>>, action: A, } impl<A: Action<Listener> + Send +'static, Listener: PreInvoke + Send> Runnable for ListenerRunnable<A, Listener> { fn handler(self: Box<ListenerRunnable<A, Listener>>) { let this = *self; let mut context = this.context.lock().unwrap(); if context.should_invoke() { this.action.process(&mut *context); } } }
{ self.task_source.queue_wrapperless(runnable) }
conditional_block
tree_gravity.rs
//! Simple integration tests oriented towards gravity computations extern crate acacia; extern crate approx; extern crate nalgebra; extern crate quickcheck; use acacia::partition::Ncube; use acacia::{AssociatedData, DataQuery, Node, Positioned, Tree}; use approx::Relative; use nalgebra::{distance, zero, Point2, Point3, Vector2, Vector3}; use quickcheck::{quickcheck, TestResult}; use std::fmt::Debug; #[test] fn tree_center_of_mass() { fn tree_center_of_mass(data: Vec<(f64, (f64, f64))>) -> TestResult { // Only test non-empty lists with positive masses if data.is_empty() || data.iter().any(|&(m, _)| m <= 0.0) { return TestResult::discard(); } // No two points should be in the same place for &(_, pi) in &data { for &(_, pj) in &data { if pi == pj { return TestResult::discard(); } } } // Compute center of mass in the traditional way let (mps, ms) = data .iter() .map(|&(m, (x, y))| (Vector2::new(x, y) * m, m)) .fold((zero::<Vector2<f64>>(), 0.0f64), |(mps, ms), (mp, m)| { (mps + mp, ms + m) }); let com = mps / ms; // Now use the tree let tree = Tree::new( data.iter().map(|&(m, (x, y))| Positioned { object: m, position: Point2::new(x, y), }), Ncube::new(Point2::origin(), 200.0f64), (zero(), 0.0), &|obj| ((obj.position - Point2::origin()) * obj.object, obj.object), &|&(mps, ms), &(mp, m)| (mps + mp, ms + m), ) .expect("Couldn't construct tree"); let (tree_mps, tree_ms) = *tree.data(); // …and compare TestResult::from_bool(Relative::default().eq(&(tree_mps / tree_ms), &com)) } quickcheck(tree_center_of_mass as fn(Vec<(f64, (f64, f64))>) -> TestResult); } #[test] fn tree_gravity_approx() { fn tree_gravity_approx( starfield: Vec<(f64, (f64, f64, f64))>, test_point: (f64, f64, f64), ) -> TestResult { // We want to have at least one star if starfield.is_empty() { return TestResult::discard(); } // Only test positive masses if starfield.iter().any(|&(m, _)| m <= 0.0) { return TestResult::discard(); } // The test point should not be in the same place as any star if starfield.iter().any(|&(_, p)| p == test_point) { return TestResult::discard(); } // No two stars should be in the same place for &(_, pi) in &starfield { for &(_, pj) in &starfield { if pi == pj { return TestResult::discard(); } } } // (T, T, T) -> Point3<T> fn pnt<T: Debug + PartialEq + Copy +'static>(p: (T, T, T)) -> Point3<T> { let (x, y, z) = p; Point3::new(x, y, z) } let test_point = pnt(test_point); // Newton's law of gravity for two point masses (with G = 1) let newton = |(m, p1): (f64, Point3<f64>), p2| { let diff: Vector3<f64> = p1 - p2; let r = diff.norm(); diff * (m / r.powi(3)) }; // Calculate gravity exactly let simple_gravity = starfield .iter() .map(|&(m, p)| newton((m, pnt(p)), test_point)) .fold(zero(), |a: Vector3<_>, b| a + b); // Calculate gravity using a tree let orig: Point3<f64> = Point3::origin(); let data_width = (test_point - orig).norm() * 2.0; let width = if data_width < 200.0 { 200.0 } else { data_width }; let tree = Tree::new( starfield.iter().map(|&(m, (x, y, z))| Positioned { object: m, position: Point3::new(x, y, z), }), Ncube::new(orig, width), (orig, zero()), &|obj| (obj.position, obj.object), &|&(com1, m1), &(com2, m2)| { if m1 + m2 > zero() { (com1 + (com2 - com1) * (m2 / (m1 + m2)), m1 + m2) } else { (orig, zero()) } }, ) .expect("Couldn't construct tree"); let theta = 0.5; // A bit arbitrary but this appears to work let tree_gravity = tree .query_data(|node| {
}) .map(|&(com, m)| newton((m, com), test_point)) .fold(zero::<Vector3<f64>>(), |a, b| a + b); // Now the tree gravity should approximate the exact one, within 10 % TestResult::from_bool( Relative::default() .epsilon(0.1 * simple_gravity.norm()) .eq(&simple_gravity, &tree_gravity), ) } quickcheck( tree_gravity_approx as fn(Vec<(f64, (f64, f64, f64))>, (f64, f64, f64)) -> TestResult, ) }
let &(ref center_of_mass, _) = node.data(); let d = distance(&test_point, center_of_mass); let delta = distance(&node.partition().center(), center_of_mass); d < node.partition().width() / theta + delta
random_line_split
tree_gravity.rs
//! Simple integration tests oriented towards gravity computations extern crate acacia; extern crate approx; extern crate nalgebra; extern crate quickcheck; use acacia::partition::Ncube; use acacia::{AssociatedData, DataQuery, Node, Positioned, Tree}; use approx::Relative; use nalgebra::{distance, zero, Point2, Point3, Vector2, Vector3}; use quickcheck::{quickcheck, TestResult}; use std::fmt::Debug; #[test] fn tree_center_of_mass() { fn tree_center_of_mass(data: Vec<(f64, (f64, f64))>) -> TestResult { // Only test non-empty lists with positive masses if data.is_empty() || data.iter().any(|&(m, _)| m <= 0.0) { return TestResult::discard(); } // No two points should be in the same place for &(_, pi) in &data { for &(_, pj) in &data { if pi == pj { return TestResult::discard(); } } } // Compute center of mass in the traditional way let (mps, ms) = data .iter() .map(|&(m, (x, y))| (Vector2::new(x, y) * m, m)) .fold((zero::<Vector2<f64>>(), 0.0f64), |(mps, ms), (mp, m)| { (mps + mp, ms + m) }); let com = mps / ms; // Now use the tree let tree = Tree::new( data.iter().map(|&(m, (x, y))| Positioned { object: m, position: Point2::new(x, y), }), Ncube::new(Point2::origin(), 200.0f64), (zero(), 0.0), &|obj| ((obj.position - Point2::origin()) * obj.object, obj.object), &|&(mps, ms), &(mp, m)| (mps + mp, ms + m), ) .expect("Couldn't construct tree"); let (tree_mps, tree_ms) = *tree.data(); // …and compare TestResult::from_bool(Relative::default().eq(&(tree_mps / tree_ms), &com)) } quickcheck(tree_center_of_mass as fn(Vec<(f64, (f64, f64))>) -> TestResult); } #[test] fn tree_gravity_approx() {
return TestResult::discard(); } } } // (T, T, T) -> Point3<T> fn pnt<T: Debug + PartialEq + Copy +'static>(p: (T, T, T)) -> Point3<T> { let (x, y, z) = p; Point3::new(x, y, z) } let test_point = pnt(test_point); // Newton's law of gravity for two point masses (with G = 1) let newton = |(m, p1): (f64, Point3<f64>), p2| { let diff: Vector3<f64> = p1 - p2; let r = diff.norm(); diff * (m / r.powi(3)) }; // Calculate gravity exactly let simple_gravity = starfield .iter() .map(|&(m, p)| newton((m, pnt(p)), test_point)) .fold(zero(), |a: Vector3<_>, b| a + b); // Calculate gravity using a tree let orig: Point3<f64> = Point3::origin(); let data_width = (test_point - orig).norm() * 2.0; let width = if data_width < 200.0 { 200.0 } else { data_width }; let tree = Tree::new( starfield.iter().map(|&(m, (x, y, z))| Positioned { object: m, position: Point3::new(x, y, z), }), Ncube::new(orig, width), (orig, zero()), &|obj| (obj.position, obj.object), &|&(com1, m1), &(com2, m2)| { if m1 + m2 > zero() { (com1 + (com2 - com1) * (m2 / (m1 + m2)), m1 + m2) } else { (orig, zero()) } }, ) .expect("Couldn't construct tree"); let theta = 0.5; // A bit arbitrary but this appears to work let tree_gravity = tree .query_data(|node| { let &(ref center_of_mass, _) = node.data(); let d = distance(&test_point, center_of_mass); let delta = distance(&node.partition().center(), center_of_mass); d < node.partition().width() / theta + delta }) .map(|&(com, m)| newton((m, com), test_point)) .fold(zero::<Vector3<f64>>(), |a, b| a + b); // Now the tree gravity should approximate the exact one, within 10 % TestResult::from_bool( Relative::default() .epsilon(0.1 * simple_gravity.norm()) .eq(&simple_gravity, &tree_gravity), ) } quickcheck( tree_gravity_approx as fn(Vec<(f64, (f64, f64, f64))>, (f64, f64, f64)) -> TestResult, ) }
fn tree_gravity_approx( starfield: Vec<(f64, (f64, f64, f64))>, test_point: (f64, f64, f64), ) -> TestResult { // We want to have at least one star if starfield.is_empty() { return TestResult::discard(); } // Only test positive masses if starfield.iter().any(|&(m, _)| m <= 0.0) { return TestResult::discard(); } // The test point should not be in the same place as any star if starfield.iter().any(|&(_, p)| p == test_point) { return TestResult::discard(); } // No two stars should be in the same place for &(_, pi) in &starfield { for &(_, pj) in &starfield { if pi == pj {
identifier_body
tree_gravity.rs
//! Simple integration tests oriented towards gravity computations extern crate acacia; extern crate approx; extern crate nalgebra; extern crate quickcheck; use acacia::partition::Ncube; use acacia::{AssociatedData, DataQuery, Node, Positioned, Tree}; use approx::Relative; use nalgebra::{distance, zero, Point2, Point3, Vector2, Vector3}; use quickcheck::{quickcheck, TestResult}; use std::fmt::Debug; #[test] fn tree_center_of_mass() { fn tree_center_of_mass(data: Vec<(f64, (f64, f64))>) -> TestResult { // Only test non-empty lists with positive masses if data.is_empty() || data.iter().any(|&(m, _)| m <= 0.0) { return TestResult::discard(); } // No two points should be in the same place for &(_, pi) in &data { for &(_, pj) in &data { if pi == pj { return TestResult::discard(); } } } // Compute center of mass in the traditional way let (mps, ms) = data .iter() .map(|&(m, (x, y))| (Vector2::new(x, y) * m, m)) .fold((zero::<Vector2<f64>>(), 0.0f64), |(mps, ms), (mp, m)| { (mps + mp, ms + m) }); let com = mps / ms; // Now use the tree let tree = Tree::new( data.iter().map(|&(m, (x, y))| Positioned { object: m, position: Point2::new(x, y), }), Ncube::new(Point2::origin(), 200.0f64), (zero(), 0.0), &|obj| ((obj.position - Point2::origin()) * obj.object, obj.object), &|&(mps, ms), &(mp, m)| (mps + mp, ms + m), ) .expect("Couldn't construct tree"); let (tree_mps, tree_ms) = *tree.data(); // …and compare TestResult::from_bool(Relative::default().eq(&(tree_mps / tree_ms), &com)) } quickcheck(tree_center_of_mass as fn(Vec<(f64, (f64, f64))>) -> TestResult); } #[test] fn tr
{ fn tree_gravity_approx( starfield: Vec<(f64, (f64, f64, f64))>, test_point: (f64, f64, f64), ) -> TestResult { // We want to have at least one star if starfield.is_empty() { return TestResult::discard(); } // Only test positive masses if starfield.iter().any(|&(m, _)| m <= 0.0) { return TestResult::discard(); } // The test point should not be in the same place as any star if starfield.iter().any(|&(_, p)| p == test_point) { return TestResult::discard(); } // No two stars should be in the same place for &(_, pi) in &starfield { for &(_, pj) in &starfield { if pi == pj { return TestResult::discard(); } } } // (T, T, T) -> Point3<T> fn pnt<T: Debug + PartialEq + Copy +'static>(p: (T, T, T)) -> Point3<T> { let (x, y, z) = p; Point3::new(x, y, z) } let test_point = pnt(test_point); // Newton's law of gravity for two point masses (with G = 1) let newton = |(m, p1): (f64, Point3<f64>), p2| { let diff: Vector3<f64> = p1 - p2; let r = diff.norm(); diff * (m / r.powi(3)) }; // Calculate gravity exactly let simple_gravity = starfield .iter() .map(|&(m, p)| newton((m, pnt(p)), test_point)) .fold(zero(), |a: Vector3<_>, b| a + b); // Calculate gravity using a tree let orig: Point3<f64> = Point3::origin(); let data_width = (test_point - orig).norm() * 2.0; let width = if data_width < 200.0 { 200.0 } else { data_width }; let tree = Tree::new( starfield.iter().map(|&(m, (x, y, z))| Positioned { object: m, position: Point3::new(x, y, z), }), Ncube::new(orig, width), (orig, zero()), &|obj| (obj.position, obj.object), &|&(com1, m1), &(com2, m2)| { if m1 + m2 > zero() { (com1 + (com2 - com1) * (m2 / (m1 + m2)), m1 + m2) } else { (orig, zero()) } }, ) .expect("Couldn't construct tree"); let theta = 0.5; // A bit arbitrary but this appears to work let tree_gravity = tree .query_data(|node| { let &(ref center_of_mass, _) = node.data(); let d = distance(&test_point, center_of_mass); let delta = distance(&node.partition().center(), center_of_mass); d < node.partition().width() / theta + delta }) .map(|&(com, m)| newton((m, com), test_point)) .fold(zero::<Vector3<f64>>(), |a, b| a + b); // Now the tree gravity should approximate the exact one, within 10 % TestResult::from_bool( Relative::default() .epsilon(0.1 * simple_gravity.norm()) .eq(&simple_gravity, &tree_gravity), ) } quickcheck( tree_gravity_approx as fn(Vec<(f64, (f64, f64, f64))>, (f64, f64, f64)) -> TestResult, ) }
ee_gravity_approx()
identifier_name
tree_gravity.rs
//! Simple integration tests oriented towards gravity computations extern crate acacia; extern crate approx; extern crate nalgebra; extern crate quickcheck; use acacia::partition::Ncube; use acacia::{AssociatedData, DataQuery, Node, Positioned, Tree}; use approx::Relative; use nalgebra::{distance, zero, Point2, Point3, Vector2, Vector3}; use quickcheck::{quickcheck, TestResult}; use std::fmt::Debug; #[test] fn tree_center_of_mass() { fn tree_center_of_mass(data: Vec<(f64, (f64, f64))>) -> TestResult { // Only test non-empty lists with positive masses if data.is_empty() || data.iter().any(|&(m, _)| m <= 0.0) { return TestResult::discard(); } // No two points should be in the same place for &(_, pi) in &data { for &(_, pj) in &data { if pi == pj { return TestResult::discard(); } } } // Compute center of mass in the traditional way let (mps, ms) = data .iter() .map(|&(m, (x, y))| (Vector2::new(x, y) * m, m)) .fold((zero::<Vector2<f64>>(), 0.0f64), |(mps, ms), (mp, m)| { (mps + mp, ms + m) }); let com = mps / ms; // Now use the tree let tree = Tree::new( data.iter().map(|&(m, (x, y))| Positioned { object: m, position: Point2::new(x, y), }), Ncube::new(Point2::origin(), 200.0f64), (zero(), 0.0), &|obj| ((obj.position - Point2::origin()) * obj.object, obj.object), &|&(mps, ms), &(mp, m)| (mps + mp, ms + m), ) .expect("Couldn't construct tree"); let (tree_mps, tree_ms) = *tree.data(); // …and compare TestResult::from_bool(Relative::default().eq(&(tree_mps / tree_ms), &com)) } quickcheck(tree_center_of_mass as fn(Vec<(f64, (f64, f64))>) -> TestResult); } #[test] fn tree_gravity_approx() { fn tree_gravity_approx( starfield: Vec<(f64, (f64, f64, f64))>, test_point: (f64, f64, f64), ) -> TestResult { // We want to have at least one star if starfield.is_empty() { return TestResult::discard(); } // Only test positive masses if starfield.iter().any(|&(m, _)| m <= 0.0) { return TestResult::discard(); } // The test point should not be in the same place as any star if starfield.iter().any(|&(_, p)| p == test_point) { return TestResult::discard(); } // No two stars should be in the same place for &(_, pi) in &starfield { for &(_, pj) in &starfield { if pi == pj { return TestResult::discard(); } } } // (T, T, T) -> Point3<T> fn pnt<T: Debug + PartialEq + Copy +'static>(p: (T, T, T)) -> Point3<T> { let (x, y, z) = p; Point3::new(x, y, z) } let test_point = pnt(test_point); // Newton's law of gravity for two point masses (with G = 1) let newton = |(m, p1): (f64, Point3<f64>), p2| { let diff: Vector3<f64> = p1 - p2; let r = diff.norm(); diff * (m / r.powi(3)) }; // Calculate gravity exactly let simple_gravity = starfield .iter() .map(|&(m, p)| newton((m, pnt(p)), test_point)) .fold(zero(), |a: Vector3<_>, b| a + b); // Calculate gravity using a tree let orig: Point3<f64> = Point3::origin(); let data_width = (test_point - orig).norm() * 2.0; let width = if data_width < 200.0 { 200.0 } else { data_width }; let tree = Tree::new( starfield.iter().map(|&(m, (x, y, z))| Positioned { object: m, position: Point3::new(x, y, z), }), Ncube::new(orig, width), (orig, zero()), &|obj| (obj.position, obj.object), &|&(com1, m1), &(com2, m2)| { if m1 + m2 > zero() {
lse { (orig, zero()) } }, ) .expect("Couldn't construct tree"); let theta = 0.5; // A bit arbitrary but this appears to work let tree_gravity = tree .query_data(|node| { let &(ref center_of_mass, _) = node.data(); let d = distance(&test_point, center_of_mass); let delta = distance(&node.partition().center(), center_of_mass); d < node.partition().width() / theta + delta }) .map(|&(com, m)| newton((m, com), test_point)) .fold(zero::<Vector3<f64>>(), |a, b| a + b); // Now the tree gravity should approximate the exact one, within 10 % TestResult::from_bool( Relative::default() .epsilon(0.1 * simple_gravity.norm()) .eq(&simple_gravity, &tree_gravity), ) } quickcheck( tree_gravity_approx as fn(Vec<(f64, (f64, f64, f64))>, (f64, f64, f64)) -> TestResult, ) }
(com1 + (com2 - com1) * (m2 / (m1 + m2)), m1 + m2) } e
conditional_block
derive_object.rs
use crate::{ result::{GraphQLScope, UnsupportedAttribute}, util::{self, span_container::SpanContainer, RenameRule}, }; use proc_macro2::TokenStream; use quote::quote; use syn::{self, ext::IdentExt, spanned::Spanned, Data, Fields}; pub fn build_derive_object(ast: syn::DeriveInput, error: GraphQLScope) -> syn::Result<TokenStream> { let ast_span = ast.span(); let struct_fields = match ast.data { Data::Struct(data) => match data.fields { Fields::Named(fields) => fields.named, _ => return Err(error.custom_error(ast_span, "only named fields are allowed")), }, _ => return Err(error.custom_error(ast_span, "can only be applied to structs")), }; // Parse attributes. let attrs = util::ObjectAttributes::from_attrs(&ast.attrs)?; let ident = &ast.ident; let name = attrs .name .clone() .map(SpanContainer::into_inner) .unwrap_or_else(|| ident.unraw().to_string()); let fields = struct_fields .into_iter() .filter_map(|field| { let span = field.span(); let field_attrs = match util::FieldAttributes::from_attrs( &field.attrs, util::FieldAttributeParseMode::Object, ) { Ok(attrs) => attrs, Err(e) => { proc_macro_error::emit_error!(e); return None; } }; if field_attrs.skip.is_some() { return None; } let field_name = &field.ident.unwrap(); let name = field_attrs .name .clone() .map(SpanContainer::into_inner) .unwrap_or_else(|| { attrs .rename .unwrap_or(RenameRule::CamelCase) .apply(&field_name.unraw().to_string()) }); if name.starts_with("__") { error.no_double_underscore(if let Some(name) = field_attrs.name { name.span_ident() } else { field_name.span() }); } if let Some(default) = field_attrs.default { error.unsupported_attribute_within( default.span_ident(), UnsupportedAttribute::Default, ); } let resolver_code = quote!( &self. #field_name ); Some(util::GraphQLTypeDefinitionField { name, _type: field.ty, args: Vec::new(), description: field_attrs.description.map(SpanContainer::into_inner), deprecation: field_attrs.deprecation.map(SpanContainer::into_inner), resolver_code, default: None, is_type_inferred: true, is_async: false, span, }) }) .collect::<Vec<_>>(); // Early abort after checking all fields proc_macro_error::abort_if_dirty();
} if!attrs.is_internal && name.starts_with("__") { error.no_double_underscore(if let Some(name) = attrs.name { name.span_ident() } else { ident.span() }); } if fields.is_empty() { error.not_empty(ast_span); } // Early abort after GraphQL properties proc_macro_error::abort_if_dirty(); let definition = util::GraphQLTypeDefiniton { name, _type: syn::parse_str(&ast.ident.to_string()).unwrap(), context: attrs.context.map(SpanContainer::into_inner), scalar: attrs.scalar.map(SpanContainer::into_inner), description: attrs.description.map(SpanContainer::into_inner), fields, generics: ast.generics, interfaces: attrs .interfaces .into_iter() .map(SpanContainer::into_inner) .collect(), include_type_generics: true, generic_scalar: true, no_async: attrs.no_async.is_some(), }; Ok(definition.into_tokens()) }
if let Some(duplicates) = crate::util::duplicate::Duplicate::find_by_key(&fields, |field| field.name.as_str()) { error.duplicate(duplicates.iter());
random_line_split
derive_object.rs
use crate::{ result::{GraphQLScope, UnsupportedAttribute}, util::{self, span_container::SpanContainer, RenameRule}, }; use proc_macro2::TokenStream; use quote::quote; use syn::{self, ext::IdentExt, spanned::Spanned, Data, Fields}; pub fn build_derive_object(ast: syn::DeriveInput, error: GraphQLScope) -> syn::Result<TokenStream> { let ast_span = ast.span(); let struct_fields = match ast.data { Data::Struct(data) => match data.fields { Fields::Named(fields) => fields.named, _ => return Err(error.custom_error(ast_span, "only named fields are allowed")), }, _ => return Err(error.custom_error(ast_span, "can only be applied to structs")), }; // Parse attributes. let attrs = util::ObjectAttributes::from_attrs(&ast.attrs)?; let ident = &ast.ident; let name = attrs .name .clone() .map(SpanContainer::into_inner) .unwrap_or_else(|| ident.unraw().to_string()); let fields = struct_fields .into_iter() .filter_map(|field| { let span = field.span(); let field_attrs = match util::FieldAttributes::from_attrs( &field.attrs, util::FieldAttributeParseMode::Object, ) { Ok(attrs) => attrs, Err(e) => { proc_macro_error::emit_error!(e); return None; } }; if field_attrs.skip.is_some()
let field_name = &field.ident.unwrap(); let name = field_attrs .name .clone() .map(SpanContainer::into_inner) .unwrap_or_else(|| { attrs .rename .unwrap_or(RenameRule::CamelCase) .apply(&field_name.unraw().to_string()) }); if name.starts_with("__") { error.no_double_underscore(if let Some(name) = field_attrs.name { name.span_ident() } else { field_name.span() }); } if let Some(default) = field_attrs.default { error.unsupported_attribute_within( default.span_ident(), UnsupportedAttribute::Default, ); } let resolver_code = quote!( &self. #field_name ); Some(util::GraphQLTypeDefinitionField { name, _type: field.ty, args: Vec::new(), description: field_attrs.description.map(SpanContainer::into_inner), deprecation: field_attrs.deprecation.map(SpanContainer::into_inner), resolver_code, default: None, is_type_inferred: true, is_async: false, span, }) }) .collect::<Vec<_>>(); // Early abort after checking all fields proc_macro_error::abort_if_dirty(); if let Some(duplicates) = crate::util::duplicate::Duplicate::find_by_key(&fields, |field| field.name.as_str()) { error.duplicate(duplicates.iter()); } if!attrs.is_internal && name.starts_with("__") { error.no_double_underscore(if let Some(name) = attrs.name { name.span_ident() } else { ident.span() }); } if fields.is_empty() { error.not_empty(ast_span); } // Early abort after GraphQL properties proc_macro_error::abort_if_dirty(); let definition = util::GraphQLTypeDefiniton { name, _type: syn::parse_str(&ast.ident.to_string()).unwrap(), context: attrs.context.map(SpanContainer::into_inner), scalar: attrs.scalar.map(SpanContainer::into_inner), description: attrs.description.map(SpanContainer::into_inner), fields, generics: ast.generics, interfaces: attrs .interfaces .into_iter() .map(SpanContainer::into_inner) .collect(), include_type_generics: true, generic_scalar: true, no_async: attrs.no_async.is_some(), }; Ok(definition.into_tokens()) }
{ return None; }
conditional_block
derive_object.rs
use crate::{ result::{GraphQLScope, UnsupportedAttribute}, util::{self, span_container::SpanContainer, RenameRule}, }; use proc_macro2::TokenStream; use quote::quote; use syn::{self, ext::IdentExt, spanned::Spanned, Data, Fields}; pub fn
(ast: syn::DeriveInput, error: GraphQLScope) -> syn::Result<TokenStream> { let ast_span = ast.span(); let struct_fields = match ast.data { Data::Struct(data) => match data.fields { Fields::Named(fields) => fields.named, _ => return Err(error.custom_error(ast_span, "only named fields are allowed")), }, _ => return Err(error.custom_error(ast_span, "can only be applied to structs")), }; // Parse attributes. let attrs = util::ObjectAttributes::from_attrs(&ast.attrs)?; let ident = &ast.ident; let name = attrs .name .clone() .map(SpanContainer::into_inner) .unwrap_or_else(|| ident.unraw().to_string()); let fields = struct_fields .into_iter() .filter_map(|field| { let span = field.span(); let field_attrs = match util::FieldAttributes::from_attrs( &field.attrs, util::FieldAttributeParseMode::Object, ) { Ok(attrs) => attrs, Err(e) => { proc_macro_error::emit_error!(e); return None; } }; if field_attrs.skip.is_some() { return None; } let field_name = &field.ident.unwrap(); let name = field_attrs .name .clone() .map(SpanContainer::into_inner) .unwrap_or_else(|| { attrs .rename .unwrap_or(RenameRule::CamelCase) .apply(&field_name.unraw().to_string()) }); if name.starts_with("__") { error.no_double_underscore(if let Some(name) = field_attrs.name { name.span_ident() } else { field_name.span() }); } if let Some(default) = field_attrs.default { error.unsupported_attribute_within( default.span_ident(), UnsupportedAttribute::Default, ); } let resolver_code = quote!( &self. #field_name ); Some(util::GraphQLTypeDefinitionField { name, _type: field.ty, args: Vec::new(), description: field_attrs.description.map(SpanContainer::into_inner), deprecation: field_attrs.deprecation.map(SpanContainer::into_inner), resolver_code, default: None, is_type_inferred: true, is_async: false, span, }) }) .collect::<Vec<_>>(); // Early abort after checking all fields proc_macro_error::abort_if_dirty(); if let Some(duplicates) = crate::util::duplicate::Duplicate::find_by_key(&fields, |field| field.name.as_str()) { error.duplicate(duplicates.iter()); } if!attrs.is_internal && name.starts_with("__") { error.no_double_underscore(if let Some(name) = attrs.name { name.span_ident() } else { ident.span() }); } if fields.is_empty() { error.not_empty(ast_span); } // Early abort after GraphQL properties proc_macro_error::abort_if_dirty(); let definition = util::GraphQLTypeDefiniton { name, _type: syn::parse_str(&ast.ident.to_string()).unwrap(), context: attrs.context.map(SpanContainer::into_inner), scalar: attrs.scalar.map(SpanContainer::into_inner), description: attrs.description.map(SpanContainer::into_inner), fields, generics: ast.generics, interfaces: attrs .interfaces .into_iter() .map(SpanContainer::into_inner) .collect(), include_type_generics: true, generic_scalar: true, no_async: attrs.no_async.is_some(), }; Ok(definition.into_tokens()) }
build_derive_object
identifier_name
derive_object.rs
use crate::{ result::{GraphQLScope, UnsupportedAttribute}, util::{self, span_container::SpanContainer, RenameRule}, }; use proc_macro2::TokenStream; use quote::quote; use syn::{self, ext::IdentExt, spanned::Spanned, Data, Fields}; pub fn build_derive_object(ast: syn::DeriveInput, error: GraphQLScope) -> syn::Result<TokenStream>
let fields = struct_fields .into_iter() .filter_map(|field| { let span = field.span(); let field_attrs = match util::FieldAttributes::from_attrs( &field.attrs, util::FieldAttributeParseMode::Object, ) { Ok(attrs) => attrs, Err(e) => { proc_macro_error::emit_error!(e); return None; } }; if field_attrs.skip.is_some() { return None; } let field_name = &field.ident.unwrap(); let name = field_attrs .name .clone() .map(SpanContainer::into_inner) .unwrap_or_else(|| { attrs .rename .unwrap_or(RenameRule::CamelCase) .apply(&field_name.unraw().to_string()) }); if name.starts_with("__") { error.no_double_underscore(if let Some(name) = field_attrs.name { name.span_ident() } else { field_name.span() }); } if let Some(default) = field_attrs.default { error.unsupported_attribute_within( default.span_ident(), UnsupportedAttribute::Default, ); } let resolver_code = quote!( &self. #field_name ); Some(util::GraphQLTypeDefinitionField { name, _type: field.ty, args: Vec::new(), description: field_attrs.description.map(SpanContainer::into_inner), deprecation: field_attrs.deprecation.map(SpanContainer::into_inner), resolver_code, default: None, is_type_inferred: true, is_async: false, span, }) }) .collect::<Vec<_>>(); // Early abort after checking all fields proc_macro_error::abort_if_dirty(); if let Some(duplicates) = crate::util::duplicate::Duplicate::find_by_key(&fields, |field| field.name.as_str()) { error.duplicate(duplicates.iter()); } if!attrs.is_internal && name.starts_with("__") { error.no_double_underscore(if let Some(name) = attrs.name { name.span_ident() } else { ident.span() }); } if fields.is_empty() { error.not_empty(ast_span); } // Early abort after GraphQL properties proc_macro_error::abort_if_dirty(); let definition = util::GraphQLTypeDefiniton { name, _type: syn::parse_str(&ast.ident.to_string()).unwrap(), context: attrs.context.map(SpanContainer::into_inner), scalar: attrs.scalar.map(SpanContainer::into_inner), description: attrs.description.map(SpanContainer::into_inner), fields, generics: ast.generics, interfaces: attrs .interfaces .into_iter() .map(SpanContainer::into_inner) .collect(), include_type_generics: true, generic_scalar: true, no_async: attrs.no_async.is_some(), }; Ok(definition.into_tokens()) }
{ let ast_span = ast.span(); let struct_fields = match ast.data { Data::Struct(data) => match data.fields { Fields::Named(fields) => fields.named, _ => return Err(error.custom_error(ast_span, "only named fields are allowed")), }, _ => return Err(error.custom_error(ast_span, "can only be applied to structs")), }; // Parse attributes. let attrs = util::ObjectAttributes::from_attrs(&ast.attrs)?; let ident = &ast.ident; let name = attrs .name .clone() .map(SpanContainer::into_inner) .unwrap_or_else(|| ident.unraw().to_string());
identifier_body
rscope.rs
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. use middle::ty; use std::vec; use syntax::ast; use syntax::codemap::Span; use syntax::opt_vec::OptVec; /// Defines strategies for handling regions that are omitted. For /// example, if one writes the type `&Foo`, then the lifetime of of /// this borrowed pointer has been omitted. When converting this /// type, the generic functions in astconv will invoke `anon_regions` /// on the provided region-scope to decide how to translate this /// omitted region. /// /// It is not always legal to omit regions, therefore `anon_regions` /// can return `Err(())` to indicate that this is not a scope in which /// regions can legally be omitted. pub trait RegionScope { fn anon_regions(&self, span: Span, count: uint) -> Result<~[ty::Region], ()>; } // A scope in which all regions must be explicitly named pub struct ExplicitRscope; impl RegionScope for ExplicitRscope { fn anon_regions(&self, _span: Span, _count: uint) -> Result<~[ty::Region], ()> { Err(()) } } /// A scope in which we generate anonymous, late-bound regions for /// omitted regions. This occurs in function signatures. pub struct BindingRscope { binder_id: ast::NodeId, anon_bindings: @mut uint } impl BindingRscope { pub fn new(binder_id: ast::NodeId) -> BindingRscope { BindingRscope { binder_id: binder_id, anon_bindings: @mut 0 } }
_: Span, count: uint) -> Result<~[ty::Region], ()> { let idx = *self.anon_bindings; *self.anon_bindings += count; Ok(vec::from_fn(count, |i| ty::ReLateBound(self.binder_id, ty::BrAnon(idx + i)))) } } pub fn bound_type_regions(defs: &[ty::RegionParameterDef]) -> OptVec<ty::Region> { assert!(defs.iter().all(|def| def.def_id.crate == ast::LOCAL_CRATE)); defs.iter().enumerate().map( |(i, def)| ty::ReEarlyBound(def.def_id.node, i, def.ident)).collect() }
} impl RegionScope for BindingRscope { fn anon_regions(&self,
random_line_split
rscope.rs
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. use middle::ty; use std::vec; use syntax::ast; use syntax::codemap::Span; use syntax::opt_vec::OptVec; /// Defines strategies for handling regions that are omitted. For /// example, if one writes the type `&Foo`, then the lifetime of of /// this borrowed pointer has been omitted. When converting this /// type, the generic functions in astconv will invoke `anon_regions` /// on the provided region-scope to decide how to translate this /// omitted region. /// /// It is not always legal to omit regions, therefore `anon_regions` /// can return `Err(())` to indicate that this is not a scope in which /// regions can legally be omitted. pub trait RegionScope { fn anon_regions(&self, span: Span, count: uint) -> Result<~[ty::Region], ()>; } // A scope in which all regions must be explicitly named pub struct ExplicitRscope; impl RegionScope for ExplicitRscope { fn anon_regions(&self, _span: Span, _count: uint) -> Result<~[ty::Region], ()> { Err(()) } } /// A scope in which we generate anonymous, late-bound regions for /// omitted regions. This occurs in function signatures. pub struct BindingRscope { binder_id: ast::NodeId, anon_bindings: @mut uint } impl BindingRscope { pub fn new(binder_id: ast::NodeId) -> BindingRscope { BindingRscope { binder_id: binder_id, anon_bindings: @mut 0 } } } impl RegionScope for BindingRscope { fn anon_regions(&self, _: Span, count: uint) -> Result<~[ty::Region], ()> { let idx = *self.anon_bindings; *self.anon_bindings += count; Ok(vec::from_fn(count, |i| ty::ReLateBound(self.binder_id, ty::BrAnon(idx + i)))) } } pub fn bound_type_regions(defs: &[ty::RegionParameterDef]) -> OptVec<ty::Region>
{ assert!(defs.iter().all(|def| def.def_id.crate == ast::LOCAL_CRATE)); defs.iter().enumerate().map( |(i, def)| ty::ReEarlyBound(def.def_id.node, i, def.ident)).collect() }
identifier_body
rscope.rs
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. use middle::ty; use std::vec; use syntax::ast; use syntax::codemap::Span; use syntax::opt_vec::OptVec; /// Defines strategies for handling regions that are omitted. For /// example, if one writes the type `&Foo`, then the lifetime of of /// this borrowed pointer has been omitted. When converting this /// type, the generic functions in astconv will invoke `anon_regions` /// on the provided region-scope to decide how to translate this /// omitted region. /// /// It is not always legal to omit regions, therefore `anon_regions` /// can return `Err(())` to indicate that this is not a scope in which /// regions can legally be omitted. pub trait RegionScope { fn anon_regions(&self, span: Span, count: uint) -> Result<~[ty::Region], ()>; } // A scope in which all regions must be explicitly named pub struct
; impl RegionScope for ExplicitRscope { fn anon_regions(&self, _span: Span, _count: uint) -> Result<~[ty::Region], ()> { Err(()) } } /// A scope in which we generate anonymous, late-bound regions for /// omitted regions. This occurs in function signatures. pub struct BindingRscope { binder_id: ast::NodeId, anon_bindings: @mut uint } impl BindingRscope { pub fn new(binder_id: ast::NodeId) -> BindingRscope { BindingRscope { binder_id: binder_id, anon_bindings: @mut 0 } } } impl RegionScope for BindingRscope { fn anon_regions(&self, _: Span, count: uint) -> Result<~[ty::Region], ()> { let idx = *self.anon_bindings; *self.anon_bindings += count; Ok(vec::from_fn(count, |i| ty::ReLateBound(self.binder_id, ty::BrAnon(idx + i)))) } } pub fn bound_type_regions(defs: &[ty::RegionParameterDef]) -> OptVec<ty::Region> { assert!(defs.iter().all(|def| def.def_id.crate == ast::LOCAL_CRATE)); defs.iter().enumerate().map( |(i, def)| ty::ReEarlyBound(def.def_id.node, i, def.ident)).collect() }
ExplicitRscope
identifier_name
lib.rs
//! EPUB library //! lib to read and navigate throught an epub file contents //! //! # Examples //! //! ## Opening //! //! ``` //! use epub::doc::EpubDoc; //! let doc = EpubDoc::new("test.epub"); //! assert!(doc.is_ok()); //! let doc = doc.unwrap(); //! //! ``` //! //! ## Getting doc metatada //! //! Metadata is a HashMap storing all metadata defined in the epub //! //! ``` //! # use epub::doc::EpubDoc; //! # let doc = EpubDoc::new("test.epub"); //! # let doc = doc.unwrap(); //! let title = doc.mdata("title"); //! assert_eq!(title.unwrap(), "Todo es mío"); //! ``` //! //! ## Accessing resources //! //! In the resources var is stored each resource defined //! in the epub indexed by the id and with the full internal //! path and mimetype. It's a HashMap<a: String, (b: String, c: String)> //! where 'a' is the resource id, 'b' is the resource full path and //! 'c' is the resource mimetype //! //! ``` //! # use epub::doc::EpubDoc; //! # use std::path::Path; //! # let doc = EpubDoc::new("test.epub"); //! # let doc = doc.unwrap(); //! assert_eq!(23, doc.resources.len()); //! let tpage = doc.resources.get("titlepage.xhtml"); //! assert_eq!(tpage.unwrap().0, Path::new("OEBPS/Text/titlepage.xhtml")); //! assert_eq!(tpage.unwrap().1, "application/xhtml+xml"); //! ``` //! //! ## Navigating using the spine //! //! Spine is a Vec<String> storing the epub spine as resources ids //! //! ``` //! # use epub::doc::EpubDoc; //! # let doc = EpubDoc::new("test.epub"); //! # let doc = doc.unwrap(); //! assert_eq!(17, doc.spine.len()); //! assert_eq!("titlepage.xhtml", doc.spine[0]); //! ``` //! //! ## Navigation using the doc internal state //! //! ``` //! use epub::doc::EpubDoc; //! let doc = EpubDoc::new("test.epub"); //! let mut doc = doc.unwrap(); //! assert_eq!(0, doc.get_current_page()); //! assert_eq!("application/xhtml+xml", doc.get_current_mime().unwrap());
//! doc.go_next(); //! assert_eq!("001.xhtml", doc.get_current_id().unwrap()); //! doc.go_prev(); //! assert_eq!("000.xhtml", doc.get_current_id().unwrap()); //! //! doc.set_current_page(2); //! assert_eq!("001.xhtml", doc.get_current_id().unwrap()); //! assert_eq!(2, doc.get_current_page()); //! assert!(doc.set_current_page(50).is_err()); //! //! // doc.get_current() will return a Vec<u8> with the current page content //! // doc.get_current_str() will return a String with the current page content //! ``` //! //! ## Getting the cover //! //! ```ignore //! use std::fs; //! use std::io::Write; //! use epub::doc::EpubDoc; //! //! let doc = EpubDoc::new("test.epub"); //! assert!(doc.is_ok()); //! let mut doc = doc.unwrap(); //! //! let cover_data = doc.get_cover().unwrap(); //! //! let f = fs::File::create("/tmp/cover.png"); //! assert!(f.is_ok()); //! let mut f = f.unwrap(); //! let resp = f.write_all(&cover_data); //! ``` mod xmlutils; pub mod archive; pub mod doc;
//! //! doc.go_next(); //! assert_eq!("000.xhtml", doc.get_current_id().unwrap());
random_line_split
replace_fallback.rs
use std::io; use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; use ogg::{OggTrackBuf}; use super::super::{RequestType, Request}; use ::proto::{self, Deserialize, Serialize}; /// Skips to the end of the currently playing track #[derive(Clone)] pub struct ReplaceFallbackRequest { pub track: OggTrackBuf, pub metadata: Option<Vec<(String, String)>>, } impl Deserialize for ReplaceFallbackRequest { fn read(buf: &mut io::Cursor<Vec<u8>>) -> io::Result<Self>
let track = match track { Some(track) => track, None => return Err(io::Error::new(io::ErrorKind::Other, "missing field: track")), }; let track = try!(OggTrackBuf::new(track) .map_err(|_| io::Error::new(io::ErrorKind::Other, "invalid ogg"))); Ok(ReplaceFallbackRequest { track: track, metadata: metadata, }) } } impl Serialize for ReplaceFallbackRequest { fn write(&self, buf: &mut io::Cursor<Vec<u8>>) -> io::Result<()> { try!(buf.write_u16::<BigEndian>(proto::TYPE_STRUCT)); let length = if self.metadata.is_some() { 2 } else { 1 }; try!(buf.write_u32::<BigEndian>(length)); try!(Serialize::write("track", buf)); try!(Serialize::write(self.track.as_u8_slice(), buf)); if let Some(ref metadata) = self.metadata { try!(Serialize::write("metadata", buf)); try!(Serialize::write(&metadata[..], buf)); } Ok(()) } } impl Request for ReplaceFallbackRequest { type Value = (); type Error = ReplaceFallbackError; fn req_type(&self) -> RequestType { RequestType::ReplaceFallback } } pub type ReplaceFallbackResult = Result<(), ReplaceFallbackError>; #[derive(Debug, Clone)] pub enum ReplaceFallbackError { InvalidTrack = 1, BadSampleRate = 2, Full = 3, } impl ReplaceFallbackError { pub fn to_u32(&self) -> u32 { self.clone() as u32 } pub fn from_u32(val: u32) -> Option<ReplaceFallbackError> { match val { 1 => Some(ReplaceFallbackError::InvalidTrack), 2 => Some(ReplaceFallbackError::BadSampleRate), 3 => Some(ReplaceFallbackError::Full), _ => None } } } impl Deserialize for ReplaceFallbackError { fn read(buf: &mut io::Cursor<Vec<u8>>) -> io::Result<Self> { let num: u32 = try!(Deserialize::read(buf)); ReplaceFallbackError::from_u32(num) .ok_or_else(|| { io::Error::new(io::ErrorKind::Other, "unexpected ReplaceFallbackError value") }) } } impl Serialize for ReplaceFallbackError { fn write(&self, buf: &mut io::Cursor<Vec<u8>>) -> io::Result<()> { try!(Serialize::write(&self.to_u32(), buf)); Ok(()) } }
{ try!(proto::expect_type(buf, proto::TYPE_STRUCT)); let field_count = try!(buf.read_u32::<BigEndian>()); let mut track: Option<Vec<u8>> = None; let mut metadata: Option<Vec<(String, String)>> = None; for _ in 0..field_count { let field_name: String = try!(Deserialize::read(buf)); match &field_name[..] { "track" => { track = Some(try!(Deserialize::read(buf))); }, "metadata" => { metadata = Some(try!(Deserialize::read(buf))); } _ => try!(proto::skip_entity(buf)), } }
identifier_body
replace_fallback.rs
use std::io; use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; use ogg::{OggTrackBuf}; use super::super::{RequestType, Request}; use ::proto::{self, Deserialize, Serialize}; /// Skips to the end of the currently playing track #[derive(Clone)] pub struct ReplaceFallbackRequest { pub track: OggTrackBuf, pub metadata: Option<Vec<(String, String)>>, } impl Deserialize for ReplaceFallbackRequest { fn read(buf: &mut io::Cursor<Vec<u8>>) -> io::Result<Self> { try!(proto::expect_type(buf, proto::TYPE_STRUCT)); let field_count = try!(buf.read_u32::<BigEndian>()); let mut track: Option<Vec<u8>> = None; let mut metadata: Option<Vec<(String, String)>> = None; for _ in 0..field_count { let field_name: String = try!(Deserialize::read(buf)); match &field_name[..] { "track" => { track = Some(try!(Deserialize::read(buf))); }, "metadata" => { metadata = Some(try!(Deserialize::read(buf))); } _ => try!(proto::skip_entity(buf)), } } let track = match track { Some(track) => track, None => return Err(io::Error::new(io::ErrorKind::Other, "missing field: track")), }; let track = try!(OggTrackBuf::new(track) .map_err(|_| io::Error::new(io::ErrorKind::Other, "invalid ogg"))); Ok(ReplaceFallbackRequest { track: track, metadata: metadata, }) } } impl Serialize for ReplaceFallbackRequest { fn write(&self, buf: &mut io::Cursor<Vec<u8>>) -> io::Result<()> { try!(buf.write_u16::<BigEndian>(proto::TYPE_STRUCT)); let length = if self.metadata.is_some() { 2 } else { 1 }; try!(buf.write_u32::<BigEndian>(length)); try!(Serialize::write("track", buf)); try!(Serialize::write(self.track.as_u8_slice(), buf)); if let Some(ref metadata) = self.metadata { try!(Serialize::write("metadata", buf)); try!(Serialize::write(&metadata[..], buf)); } Ok(())
type Value = (); type Error = ReplaceFallbackError; fn req_type(&self) -> RequestType { RequestType::ReplaceFallback } } pub type ReplaceFallbackResult = Result<(), ReplaceFallbackError>; #[derive(Debug, Clone)] pub enum ReplaceFallbackError { InvalidTrack = 1, BadSampleRate = 2, Full = 3, } impl ReplaceFallbackError { pub fn to_u32(&self) -> u32 { self.clone() as u32 } pub fn from_u32(val: u32) -> Option<ReplaceFallbackError> { match val { 1 => Some(ReplaceFallbackError::InvalidTrack), 2 => Some(ReplaceFallbackError::BadSampleRate), 3 => Some(ReplaceFallbackError::Full), _ => None } } } impl Deserialize for ReplaceFallbackError { fn read(buf: &mut io::Cursor<Vec<u8>>) -> io::Result<Self> { let num: u32 = try!(Deserialize::read(buf)); ReplaceFallbackError::from_u32(num) .ok_or_else(|| { io::Error::new(io::ErrorKind::Other, "unexpected ReplaceFallbackError value") }) } } impl Serialize for ReplaceFallbackError { fn write(&self, buf: &mut io::Cursor<Vec<u8>>) -> io::Result<()> { try!(Serialize::write(&self.to_u32(), buf)); Ok(()) } }
} } impl Request for ReplaceFallbackRequest {
random_line_split
replace_fallback.rs
use std::io; use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; use ogg::{OggTrackBuf}; use super::super::{RequestType, Request}; use ::proto::{self, Deserialize, Serialize}; /// Skips to the end of the currently playing track #[derive(Clone)] pub struct ReplaceFallbackRequest { pub track: OggTrackBuf, pub metadata: Option<Vec<(String, String)>>, } impl Deserialize for ReplaceFallbackRequest { fn read(buf: &mut io::Cursor<Vec<u8>>) -> io::Result<Self> { try!(proto::expect_type(buf, proto::TYPE_STRUCT)); let field_count = try!(buf.read_u32::<BigEndian>()); let mut track: Option<Vec<u8>> = None; let mut metadata: Option<Vec<(String, String)>> = None; for _ in 0..field_count { let field_name: String = try!(Deserialize::read(buf)); match &field_name[..] { "track" => { track = Some(try!(Deserialize::read(buf))); }, "metadata" => { metadata = Some(try!(Deserialize::read(buf))); } _ => try!(proto::skip_entity(buf)), } } let track = match track { Some(track) => track, None => return Err(io::Error::new(io::ErrorKind::Other, "missing field: track")), }; let track = try!(OggTrackBuf::new(track) .map_err(|_| io::Error::new(io::ErrorKind::Other, "invalid ogg"))); Ok(ReplaceFallbackRequest { track: track, metadata: metadata, }) } } impl Serialize for ReplaceFallbackRequest { fn
(&self, buf: &mut io::Cursor<Vec<u8>>) -> io::Result<()> { try!(buf.write_u16::<BigEndian>(proto::TYPE_STRUCT)); let length = if self.metadata.is_some() { 2 } else { 1 }; try!(buf.write_u32::<BigEndian>(length)); try!(Serialize::write("track", buf)); try!(Serialize::write(self.track.as_u8_slice(), buf)); if let Some(ref metadata) = self.metadata { try!(Serialize::write("metadata", buf)); try!(Serialize::write(&metadata[..], buf)); } Ok(()) } } impl Request for ReplaceFallbackRequest { type Value = (); type Error = ReplaceFallbackError; fn req_type(&self) -> RequestType { RequestType::ReplaceFallback } } pub type ReplaceFallbackResult = Result<(), ReplaceFallbackError>; #[derive(Debug, Clone)] pub enum ReplaceFallbackError { InvalidTrack = 1, BadSampleRate = 2, Full = 3, } impl ReplaceFallbackError { pub fn to_u32(&self) -> u32 { self.clone() as u32 } pub fn from_u32(val: u32) -> Option<ReplaceFallbackError> { match val { 1 => Some(ReplaceFallbackError::InvalidTrack), 2 => Some(ReplaceFallbackError::BadSampleRate), 3 => Some(ReplaceFallbackError::Full), _ => None } } } impl Deserialize for ReplaceFallbackError { fn read(buf: &mut io::Cursor<Vec<u8>>) -> io::Result<Self> { let num: u32 = try!(Deserialize::read(buf)); ReplaceFallbackError::from_u32(num) .ok_or_else(|| { io::Error::new(io::ErrorKind::Other, "unexpected ReplaceFallbackError value") }) } } impl Serialize for ReplaceFallbackError { fn write(&self, buf: &mut io::Cursor<Vec<u8>>) -> io::Result<()> { try!(Serialize::write(&self.to_u32(), buf)); Ok(()) } }
write
identifier_name
angle.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ //! Computed angles. use crate::values::distance::{ComputeSquaredDistance, SquaredDistance}; use crate::values::CSSFloat; use num_traits::Zero; use std::f64::consts::PI; use std::fmt::{self, Write}; use std::ops::Add; use std::{f32, f64}; use style_traits::{CssWriter, ToCss}; /// A computed angle in degrees. #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))] #[derive(Animate, Clone, Copy, Debug, MallocSizeOf, PartialEq, PartialOrd, ToAnimatedZero)] pub struct Angle(CSSFloat); impl ToCss for Angle { fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result where W: Write, { self.degrees().to_css(dest)?; dest.write_str("deg") } } const RAD_PER_DEG: f64 = PI / 180.0; impl Angle { /// Creates a computed `Angle` value from a radian amount. pub fn from_radians(radians: CSSFloat) -> Self { Angle(radians / RAD_PER_DEG as f32) } /// Creates a computed `Angle` value from a degrees amount. #[inline] pub fn from_degrees(degrees: CSSFloat) -> Self { Angle(degrees)
#[inline] pub fn radians(&self) -> CSSFloat { self.radians64().min(f32::MAX as f64).max(f32::MIN as f64) as f32 } /// Returns the amount of radians this angle represents as a `f64`. /// /// Gecko stores angles as singles, but does this computation using doubles. /// /// This is significant enough to mess up rounding to the nearest /// quarter-turn for 225 degrees, for example. #[inline] pub fn radians64(&self) -> f64 { self.0 as f64 * RAD_PER_DEG } /// Return the value in degrees. #[inline] pub fn degrees(&self) -> CSSFloat { self.0 } } impl Add for Angle { type Output = Self; #[inline] fn add(self, rhs: Self) -> Self { Angle(self.0 + rhs.0) } } impl Zero for Angle { #[inline] fn zero() -> Self { Angle(0.0) } #[inline] fn is_zero(&self) -> bool { self.0 == 0. } } impl ComputeSquaredDistance for Angle { #[inline] fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> { // Use the formula for calculating the distance between angles defined in SVG: // https://www.w3.org/TR/SVG/animate.html#complexDistances self.radians64() .compute_squared_distance(&other.radians64()) } }
} /// Returns the amount of radians this angle represents.
random_line_split
angle.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ //! Computed angles. use crate::values::distance::{ComputeSquaredDistance, SquaredDistance}; use crate::values::CSSFloat; use num_traits::Zero; use std::f64::consts::PI; use std::fmt::{self, Write}; use std::ops::Add; use std::{f32, f64}; use style_traits::{CssWriter, ToCss}; /// A computed angle in degrees. #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))] #[derive(Animate, Clone, Copy, Debug, MallocSizeOf, PartialEq, PartialOrd, ToAnimatedZero)] pub struct Angle(CSSFloat); impl ToCss for Angle { fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result where W: Write, { self.degrees().to_css(dest)?; dest.write_str("deg") } } const RAD_PER_DEG: f64 = PI / 180.0; impl Angle { /// Creates a computed `Angle` value from a radian amount. pub fn from_radians(radians: CSSFloat) -> Self { Angle(radians / RAD_PER_DEG as f32) } /// Creates a computed `Angle` value from a degrees amount. #[inline] pub fn from_degrees(degrees: CSSFloat) -> Self { Angle(degrees) } /// Returns the amount of radians this angle represents. #[inline] pub fn radians(&self) -> CSSFloat { self.radians64().min(f32::MAX as f64).max(f32::MIN as f64) as f32 } /// Returns the amount of radians this angle represents as a `f64`. /// /// Gecko stores angles as singles, but does this computation using doubles. /// /// This is significant enough to mess up rounding to the nearest /// quarter-turn for 225 degrees, for example. #[inline] pub fn radians64(&self) -> f64 { self.0 as f64 * RAD_PER_DEG } /// Return the value in degrees. #[inline] pub fn degrees(&self) -> CSSFloat { self.0 } } impl Add for Angle { type Output = Self; #[inline] fn add(self, rhs: Self) -> Self { Angle(self.0 + rhs.0) } } impl Zero for Angle { #[inline] fn zero() -> Self { Angle(0.0) } #[inline] fn is_zero(&self) -> bool { self.0 == 0. } } impl ComputeSquaredDistance for Angle { #[inline] fn
(&self, other: &Self) -> Result<SquaredDistance, ()> { // Use the formula for calculating the distance between angles defined in SVG: // https://www.w3.org/TR/SVG/animate.html#complexDistances self.radians64() .compute_squared_distance(&other.radians64()) } }
compute_squared_distance
identifier_name
angle.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ //! Computed angles. use crate::values::distance::{ComputeSquaredDistance, SquaredDistance}; use crate::values::CSSFloat; use num_traits::Zero; use std::f64::consts::PI; use std::fmt::{self, Write}; use std::ops::Add; use std::{f32, f64}; use style_traits::{CssWriter, ToCss}; /// A computed angle in degrees. #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))] #[derive(Animate, Clone, Copy, Debug, MallocSizeOf, PartialEq, PartialOrd, ToAnimatedZero)] pub struct Angle(CSSFloat); impl ToCss for Angle { fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result where W: Write,
} const RAD_PER_DEG: f64 = PI / 180.0; impl Angle { /// Creates a computed `Angle` value from a radian amount. pub fn from_radians(radians: CSSFloat) -> Self { Angle(radians / RAD_PER_DEG as f32) } /// Creates a computed `Angle` value from a degrees amount. #[inline] pub fn from_degrees(degrees: CSSFloat) -> Self { Angle(degrees) } /// Returns the amount of radians this angle represents. #[inline] pub fn radians(&self) -> CSSFloat { self.radians64().min(f32::MAX as f64).max(f32::MIN as f64) as f32 } /// Returns the amount of radians this angle represents as a `f64`. /// /// Gecko stores angles as singles, but does this computation using doubles. /// /// This is significant enough to mess up rounding to the nearest /// quarter-turn for 225 degrees, for example. #[inline] pub fn radians64(&self) -> f64 { self.0 as f64 * RAD_PER_DEG } /// Return the value in degrees. #[inline] pub fn degrees(&self) -> CSSFloat { self.0 } } impl Add for Angle { type Output = Self; #[inline] fn add(self, rhs: Self) -> Self { Angle(self.0 + rhs.0) } } impl Zero for Angle { #[inline] fn zero() -> Self { Angle(0.0) } #[inline] fn is_zero(&self) -> bool { self.0 == 0. } } impl ComputeSquaredDistance for Angle { #[inline] fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> { // Use the formula for calculating the distance between angles defined in SVG: // https://www.w3.org/TR/SVG/animate.html#complexDistances self.radians64() .compute_squared_distance(&other.radians64()) } }
{ self.degrees().to_css(dest)?; dest.write_str("deg") }
identifier_body
multilevel-path-1.rs
// edition:2021 #![feature(rustc_attrs)] #![allow(unused)] struct Point { x: i32, y: i32, } struct Wrapper { p: Point, } fn main() { let mut w = Wrapper { p: Point { x: 10, y: 10 } }; // Only paths that appears within the closure that directly start off // a variable defined outside the closure are captured. // // Therefore `w.p` is captured // Note that `wp.x` doesn't start off a variable defined outside the closure. let c = #[rustc_capture_analysis] //~^ ERROR: attributes on expressions are experimental //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> || { //~^ ERROR: First Pass analysis includes: //~| ERROR: Min Capture analysis includes: let wp = &w.p; //~^ NOTE: Capturing w[(0, 0)] -> ImmBorrow //~| NOTE: Min Capture w[(0, 0)] -> ImmBorrow println!("{}", wp.x); }; // Since `c` captures `w.p` by an ImmBorrow, `w.p.y` can't be mutated. let py = &mut w.p.y; c();
*py = 20 }
random_line_split
multilevel-path-1.rs
// edition:2021 #![feature(rustc_attrs)] #![allow(unused)] struct Point { x: i32, y: i32, } struct Wrapper { p: Point, } fn
() { let mut w = Wrapper { p: Point { x: 10, y: 10 } }; // Only paths that appears within the closure that directly start off // a variable defined outside the closure are captured. // // Therefore `w.p` is captured // Note that `wp.x` doesn't start off a variable defined outside the closure. let c = #[rustc_capture_analysis] //~^ ERROR: attributes on expressions are experimental //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> || { //~^ ERROR: First Pass analysis includes: //~| ERROR: Min Capture analysis includes: let wp = &w.p; //~^ NOTE: Capturing w[(0, 0)] -> ImmBorrow //~| NOTE: Min Capture w[(0, 0)] -> ImmBorrow println!("{}", wp.x); }; // Since `c` captures `w.p` by an ImmBorrow, `w.p.y` can't be mutated. let py = &mut w.p.y; c(); *py = 20 }
main
identifier_name
set2.rs
extern crate openssl; extern crate serialize; use serialize::base64::{FromBase64}; use std::rand::{task_rng, Rng}; use std::io::BufferedReader; use std::io::File; use openssl::crypto::symm::{encrypt, decrypt, AES_128_ECB, AES_128_CBC}; fn xor(v1 : &[u8], v2 : &[u8]) -> Vec<u8> { v1.iter().zip(v2.iter()).map(|(&b1, &b2)| b1 ^ b2).collect::<Vec<u8>>() } fn bytes_to_string(bytes : Vec<u8>) -> String { match String::from_utf8(bytes) { Ok(s) => s, Err(_) => String::new() } } fn pkcs7_pad(data : &mut Vec<u8>, block_size : uint) { let n = block_size - (data.len() % block_size); data.grow(n, &(n as u8)); } fn aes_decrypt(k : &[u8], data : &[u8]) -> Vec<u8> { let mut padded_data = Vec::from_slice(data); pkcs7_pad(&mut padded_data, 16); decrypt(AES_128_ECB, k, Vec::new(), padded_data.as_slice()) } fn decrypt_aes_cbc(k : &[u8], c : &[u8], iv : &[u8]) -> Vec<u8> { let n = c.len()/16; let blocks = range(0, n).map(|i| c.slice(i*16, (i+1)*16) ); let mut m1 = Vec::from_slice(iv); blocks.flat_map(|b| { let m = aes_decrypt(k, b); let xord = xor(m.as_slice(), m1.as_slice()); m1 = Vec::from_slice(b); xord.move_iter() }).collect::<Vec<u8>>() } fn gen_key() -> Vec<u8> { let mut key = [0u8,..16]; task_rng().fill_bytes(key); Vec::from_slice(key) } fn gen_random_size_vec(min : uint, max : uint) -> Vec<u8> { let size = task_rng().gen_range(min, max); let mut vec = Vec::new(); vec.grow(size, &(0)); task_rng().fill_bytes(vec.as_mut_slice()); vec } fn crypto_service(input : &[u8]) -> Vec<u8>
fn ch9() { println!("------- 9 ---------"); let mut data = Vec::from_slice("YELLOW SUBMARINE".as_bytes()); pkcs7_pad(&mut data, 20); println!("Padded data: {}", data); println!("Padded message: {}", bytes_to_string(data.clone())); assert!("YELLOW SUBMARINE\x04\x04\x04\x04".as_bytes() == data.as_slice()); } fn ch10() { println!("------- 10 ---------"); let path = Path::new("./10.txt"); let mut file = BufferedReader::new(File::open(&path)); let c = file.read_to_string().unwrap().as_slice().from_base64().unwrap(); let iv : [u8,..16] = [0,..16]; let k = "YELLOW SUBMARINE".as_bytes(); let m = decrypt_aes_cbc(k, c.as_slice(), iv); println!("Message: {}", bytes_to_string(m)); } fn ch11() { for _ in range(0u32, 10u32) { let input = ['a' as u8,..64]; let data = crypto_service(input); if data.slice(16, 32) == data.slice(32, 48) { println!("Guess ECB"); } else { println!("Guess CBC"); } } } fn main() { ch9(); ch10(); ch11(); }
{ let key = gen_key(); let iv = gen_key(); let prepend_bytes = gen_random_size_vec(5, 10); let append_bytes = gen_random_size_vec(5, 10); let data = prepend_bytes + input + append_bytes; let choices = [AES_128_ECB, AES_128_CBC]; let t = task_rng().choose(choices).unwrap(); println!("Used {}", (match *t { AES_128_ECB => "ECB", AES_128_CBC => "CBC", _ => "Unknown" })); encrypt(*t, key.as_slice(), iv, data.as_slice()) }
identifier_body
set2.rs
extern crate openssl; extern crate serialize; use serialize::base64::{FromBase64}; use std::rand::{task_rng, Rng}; use std::io::BufferedReader; use std::io::File; use openssl::crypto::symm::{encrypt, decrypt, AES_128_ECB, AES_128_CBC}; fn xor(v1 : &[u8], v2 : &[u8]) -> Vec<u8> { v1.iter().zip(v2.iter()).map(|(&b1, &b2)| b1 ^ b2).collect::<Vec<u8>>() } fn bytes_to_string(bytes : Vec<u8>) -> String { match String::from_utf8(bytes) { Ok(s) => s, Err(_) => String::new() } } fn pkcs7_pad(data : &mut Vec<u8>, block_size : uint) { let n = block_size - (data.len() % block_size); data.grow(n, &(n as u8)); } fn aes_decrypt(k : &[u8], data : &[u8]) -> Vec<u8> { let mut padded_data = Vec::from_slice(data); pkcs7_pad(&mut padded_data, 16); decrypt(AES_128_ECB, k, Vec::new(), padded_data.as_slice()) } fn decrypt_aes_cbc(k : &[u8], c : &[u8], iv : &[u8]) -> Vec<u8> { let n = c.len()/16; let blocks = range(0, n).map(|i| c.slice(i*16, (i+1)*16) ); let mut m1 = Vec::from_slice(iv); blocks.flat_map(|b| { let m = aes_decrypt(k, b); let xord = xor(m.as_slice(), m1.as_slice()); m1 = Vec::from_slice(b); xord.move_iter() }).collect::<Vec<u8>>() } fn gen_key() -> Vec<u8> { let mut key = [0u8,..16]; task_rng().fill_bytes(key); Vec::from_slice(key) } fn gen_random_size_vec(min : uint, max : uint) -> Vec<u8> { let size = task_rng().gen_range(min, max); let mut vec = Vec::new(); vec.grow(size, &(0)); task_rng().fill_bytes(vec.as_mut_slice()); vec } fn crypto_service(input : &[u8]) -> Vec<u8> { let key = gen_key(); let iv = gen_key(); let prepend_bytes = gen_random_size_vec(5, 10); let append_bytes = gen_random_size_vec(5, 10); let data = prepend_bytes + input + append_bytes; let choices = [AES_128_ECB, AES_128_CBC]; let t = task_rng().choose(choices).unwrap();
fn ch9() { println!("------- 9 ---------"); let mut data = Vec::from_slice("YELLOW SUBMARINE".as_bytes()); pkcs7_pad(&mut data, 20); println!("Padded data: {}", data); println!("Padded message: {}", bytes_to_string(data.clone())); assert!("YELLOW SUBMARINE\x04\x04\x04\x04".as_bytes() == data.as_slice()); } fn ch10() { println!("------- 10 ---------"); let path = Path::new("./10.txt"); let mut file = BufferedReader::new(File::open(&path)); let c = file.read_to_string().unwrap().as_slice().from_base64().unwrap(); let iv : [u8,..16] = [0,..16]; let k = "YELLOW SUBMARINE".as_bytes(); let m = decrypt_aes_cbc(k, c.as_slice(), iv); println!("Message: {}", bytes_to_string(m)); } fn ch11() { for _ in range(0u32, 10u32) { let input = ['a' as u8,..64]; let data = crypto_service(input); if data.slice(16, 32) == data.slice(32, 48) { println!("Guess ECB"); } else { println!("Guess CBC"); } } } fn main() { ch9(); ch10(); ch11(); }
println!("Used {}", (match *t { AES_128_ECB => "ECB", AES_128_CBC => "CBC", _ => "Unknown" })); encrypt(*t, key.as_slice(), iv, data.as_slice()) }
random_line_split
set2.rs
extern crate openssl; extern crate serialize; use serialize::base64::{FromBase64}; use std::rand::{task_rng, Rng}; use std::io::BufferedReader; use std::io::File; use openssl::crypto::symm::{encrypt, decrypt, AES_128_ECB, AES_128_CBC}; fn xor(v1 : &[u8], v2 : &[u8]) -> Vec<u8> { v1.iter().zip(v2.iter()).map(|(&b1, &b2)| b1 ^ b2).collect::<Vec<u8>>() } fn bytes_to_string(bytes : Vec<u8>) -> String { match String::from_utf8(bytes) { Ok(s) => s, Err(_) => String::new() } } fn pkcs7_pad(data : &mut Vec<u8>, block_size : uint) { let n = block_size - (data.len() % block_size); data.grow(n, &(n as u8)); } fn aes_decrypt(k : &[u8], data : &[u8]) -> Vec<u8> { let mut padded_data = Vec::from_slice(data); pkcs7_pad(&mut padded_data, 16); decrypt(AES_128_ECB, k, Vec::new(), padded_data.as_slice()) } fn decrypt_aes_cbc(k : &[u8], c : &[u8], iv : &[u8]) -> Vec<u8> { let n = c.len()/16; let blocks = range(0, n).map(|i| c.slice(i*16, (i+1)*16) ); let mut m1 = Vec::from_slice(iv); blocks.flat_map(|b| { let m = aes_decrypt(k, b); let xord = xor(m.as_slice(), m1.as_slice()); m1 = Vec::from_slice(b); xord.move_iter() }).collect::<Vec<u8>>() } fn gen_key() -> Vec<u8> { let mut key = [0u8,..16]; task_rng().fill_bytes(key); Vec::from_slice(key) } fn gen_random_size_vec(min : uint, max : uint) -> Vec<u8> { let size = task_rng().gen_range(min, max); let mut vec = Vec::new(); vec.grow(size, &(0)); task_rng().fill_bytes(vec.as_mut_slice()); vec } fn crypto_service(input : &[u8]) -> Vec<u8> { let key = gen_key(); let iv = gen_key(); let prepend_bytes = gen_random_size_vec(5, 10); let append_bytes = gen_random_size_vec(5, 10); let data = prepend_bytes + input + append_bytes; let choices = [AES_128_ECB, AES_128_CBC]; let t = task_rng().choose(choices).unwrap(); println!("Used {}", (match *t { AES_128_ECB => "ECB", AES_128_CBC => "CBC", _ => "Unknown" })); encrypt(*t, key.as_slice(), iv, data.as_slice()) } fn
() { println!("------- 9 ---------"); let mut data = Vec::from_slice("YELLOW SUBMARINE".as_bytes()); pkcs7_pad(&mut data, 20); println!("Padded data: {}", data); println!("Padded message: {}", bytes_to_string(data.clone())); assert!("YELLOW SUBMARINE\x04\x04\x04\x04".as_bytes() == data.as_slice()); } fn ch10() { println!("------- 10 ---------"); let path = Path::new("./10.txt"); let mut file = BufferedReader::new(File::open(&path)); let c = file.read_to_string().unwrap().as_slice().from_base64().unwrap(); let iv : [u8,..16] = [0,..16]; let k = "YELLOW SUBMARINE".as_bytes(); let m = decrypt_aes_cbc(k, c.as_slice(), iv); println!("Message: {}", bytes_to_string(m)); } fn ch11() { for _ in range(0u32, 10u32) { let input = ['a' as u8,..64]; let data = crypto_service(input); if data.slice(16, 32) == data.slice(32, 48) { println!("Guess ECB"); } else { println!("Guess CBC"); } } } fn main() { ch9(); ch10(); ch11(); }
ch9
identifier_name
lexical-scope-with-macro.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. // ignore-android: FIXME(#10381) // compile-flags:-g // debugger:rbreak zzz // debugger:run // debugger:finish // debugger:print a // check:$1 = 10 // debugger:print b // check:$2 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$3 = 890242 // debugger:print b // check:$4 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$5 = 10 // debugger:print b // check:$6 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$7 = 102 // debugger:print b // check:$8 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$9 = 110 // debugger:print b // check:$10 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$11 = 10 // debugger:print b // check:$12 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$13 = 10 // debugger:print b // check:$14 = 34 // debugger:print c // check:$15 = 400 // debugger:continue #[feature(macro_rules)]; macro_rules! trivial( ($e1:expr) => ($e1) ) macro_rules! no_new_scope( ($e1:expr) => (($e1 + 2) - 1) ) macro_rules! new_scope( () => ({ let a = 890242; zzz(); sentinel(); }) ) macro_rules! shadow_within_macro( ($e1:expr) => ({ let a = $e1 + 2; zzz(); sentinel(); let a = $e1 + 10; zzz(); sentinel(); }) ) macro_rules! dup_expr( ($e1:expr) => (($e1) + ($e1)) ) fn
() { let a = trivial!(10); let b = no_new_scope!(33); zzz(); sentinel(); new_scope!(); zzz(); sentinel(); shadow_within_macro!(100); zzz(); sentinel(); let c = dup_expr!(10 * 20); zzz(); sentinel(); } fn zzz() {()} fn sentinel() {()}
main
identifier_name
lexical-scope-with-macro.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. // ignore-android: FIXME(#10381) // compile-flags:-g // debugger:rbreak zzz // debugger:run // debugger:finish // debugger:print a // check:$1 = 10 // debugger:print b // check:$2 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$3 = 890242 // debugger:print b // check:$4 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$5 = 10 // debugger:print b // check:$6 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$7 = 102 // debugger:print b // check:$8 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$9 = 110 // debugger:print b // check:$10 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$11 = 10 // debugger:print b // check:$12 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$13 = 10 // debugger:print b // check:$14 = 34 // debugger:print c // check:$15 = 400 // debugger:continue #[feature(macro_rules)]; macro_rules! trivial( ($e1:expr) => ($e1) ) macro_rules! no_new_scope( ($e1:expr) => (($e1 + 2) - 1) ) macro_rules! new_scope( () => ({ let a = 890242; zzz(); sentinel(); }) ) macro_rules! shadow_within_macro( ($e1:expr) => ({ let a = $e1 + 2; zzz(); sentinel(); let a = $e1 + 10; zzz(); sentinel(); }) ) macro_rules! dup_expr( ($e1:expr) => (($e1) + ($e1)) ) fn main() { let a = trivial!(10); let b = no_new_scope!(33); zzz(); sentinel(); new_scope!(); zzz(); sentinel(); shadow_within_macro!(100); zzz(); sentinel(); let c = dup_expr!(10 * 20); zzz(); sentinel(); } fn zzz()
fn sentinel() {()}
{()}
identifier_body
lexical-scope-with-macro.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. // ignore-android: FIXME(#10381) // compile-flags:-g // debugger:rbreak zzz // debugger:run // debugger:finish // debugger:print a // check:$1 = 10 // debugger:print b // check:$2 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$3 = 890242 // debugger:print b // check:$4 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$5 = 10 // debugger:print b // check:$6 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$7 = 102 // debugger:print b // check:$8 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$9 = 110 // debugger:print b // check:$10 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$11 = 10 // debugger:print b // check:$12 = 34 // debugger:continue // debugger:finish // debugger:print a // check:$13 = 10 // debugger:print b // check:$14 = 34 // debugger:print c // check:$15 = 400 // debugger:continue #[feature(macro_rules)]; macro_rules! trivial( ($e1:expr) => ($e1) ) macro_rules! no_new_scope( ($e1:expr) => (($e1 + 2) - 1) ) macro_rules! new_scope( () => ({ let a = 890242; zzz(); sentinel(); }) ) macro_rules! shadow_within_macro( ($e1:expr) => ({ let a = $e1 + 2; zzz(); sentinel(); let a = $e1 + 10; zzz(); sentinel(); }) ) macro_rules! dup_expr( ($e1:expr) => (($e1) + ($e1)) ) fn main() { let a = trivial!(10); let b = no_new_scope!(33);
zzz(); sentinel(); new_scope!(); zzz(); sentinel(); shadow_within_macro!(100); zzz(); sentinel(); let c = dup_expr!(10 * 20); zzz(); sentinel(); } fn zzz() {()} fn sentinel() {()}
random_line_split
std_dirs.rs
// Copyright 2018 MaidSafe.net limited. // // This SAFE Network Software is licensed to you under The General Public License (GPL), version 3. // Unless required by applicable law or agreed to in writing, the SAFE Network Software distributed // under the GPL Licence is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY // KIND, either express or implied. Please review the Licences for the specific language governing // permissions and limitations relating to use of the SAFE Network Software. use crate::access_container::{self, AUTHENTICATOR_ENTRY}; use crate::client::AuthClient; use crate::config::KEY_APPS; use crate::{AuthError, AuthFuture}; use bincode::serialize; use futures::{future, Future}; use safe_core::ipc::access_container_enc_key; use safe_core::mdata_info; use safe_core::nfs::create_dir; use safe_core::utils::symmetric_encrypt; use safe_core::{Client, CoreError, FutureExt, MDataInfo, DIR_TAG}; use safe_nd::{Error as SndError, MDataKind, MDataSeqValue}; use std::collections::HashMap; /// Default directories to be created at registration. pub static DEFAULT_PRIVATE_DIRS: [&str; 6] = [ "_documents", "_downloads", "_music", "_pictures", "_videos", "_publicNames", ]; /// Publicly accessible default directories to be created upon registration. pub static DEFAULT_PUBLIC_DIRS: [&str; 1] = ["_public"]; /// Create the root directories and the standard directories for the access container. pub fn create(client: &AuthClient) -> Box<AuthFuture<()>> { let c2 = client.clone(); let c3 = client.clone(); let c4 = client.clone(); // Initialise standard directories let access_container = client.access_container(); let config_dir = client.config_root_dir(); // Try to get default dirs from the access container let access_cont_fut = access_container::fetch_authenticator_entry(&c2) .then(move |res| { match res { Ok((_, default_containers)) => { // Make sure that all default dirs have been created create_std_dirs(&c3, &default_containers) } Err(AuthError::CoreError(CoreError::DataError(SndError::NoSuchData))) => { // Access container hasn't been created yet let access_cont_value = fry!(random_std_dirs()) .into_iter() .map(|(name, md_info)| (String::from(name), md_info)) .collect(); let std_dirs_fut = create_std_dirs(&c3, &access_cont_value); let access_cont_fut = create_access_container(&c3, &access_container, &access_cont_value); future::join_all(vec![std_dirs_fut, access_cont_fut]) .map(|_| ()) .into_box() } Err(e) => err!(e), } }) .into_box(); future::join_all(vec![access_cont_fut, create_config_dir(&c2, &config_dir)]) .map_err(From::from) .and_then(move |_| { // Update account packet - root directories have been created successfully // (so we don't have to recover them after login). c4.set_std_dirs_created(true); c4.update_account_packet().map_err(From::from).into_box() }) .into_box() } fn create_config_dir(client: &AuthClient, config_dir: &MDataInfo) -> Box<AuthFuture<()>> { let config_dir_entries = btree_map![KEY_APPS.to_vec() => MDataSeqValue { data: Vec::new(), version: 0 }]; let config_dir_entries = fry!(mdata_info::encrypt_entries(config_dir, &config_dir_entries)); create_dir(client, config_dir, config_dir_entries, btree_map![]) .map_err(From::from) .into_box() } fn create_access_container( client: &AuthClient, access_container: &MDataInfo, default_entries: &HashMap<String, MDataInfo>, ) -> Box<AuthFuture<()>> { let enc_key = client.secret_symmetric_key(); // Create access container let authenticator_key = fry!(access_container_enc_key( AUTHENTICATOR_ENTRY, &enc_key, fry!(access_container.nonce().ok_or_else(|| AuthError::from( "Expected to have nonce on access container MDataInfo" ))), ) .map_err(AuthError::from)); let access_cont_value = fry!(symmetric_encrypt( &fry!(serialize(default_entries)), &enc_key,
create_dir( client, access_container, btree_map![ authenticator_key => MDataSeqValue { version: 0, data: access_cont_value } ], btree_map![], ) .map_err(From::from) .into_box() } /// Generates a list of `MDataInfo` for standard dirs. /// Returns a collection of standard dirs along with respective `MDataInfo`s. /// Doesn't actually put data onto the network. pub fn random_std_dirs() -> Result<Vec<(&'static str, MDataInfo)>, CoreError> { let pub_dirs = DEFAULT_PUBLIC_DIRS .iter() .map(|name| MDataInfo::random_public(MDataKind::Seq, DIR_TAG).map(|dir| (*name, dir))); let priv_dirs = DEFAULT_PRIVATE_DIRS .iter() .map(|name| MDataInfo::random_private(MDataKind::Seq, DIR_TAG).map(|dir| (*name, dir))); priv_dirs.chain(pub_dirs).collect() } /// A registration helper function to create the set of default dirs in the users root directory. pub fn create_std_dirs( client: &AuthClient, md_infos: &HashMap<String, MDataInfo>, ) -> Box<AuthFuture<()>> { let client = client.clone(); let creations: Vec<_> = md_infos .iter() .map(|(_, md_info)| { create_dir(&client, md_info, btree_map![], btree_map![]).map_err(AuthError::from) }) .collect(); future::join_all(creations).map(|_| ()).into_box() } #[cfg(test)] mod tests { use super::*; use crate::run; use crate::test_utils::create_account_and_login; use futures::Future; // Test creation of default dirs. #[test] fn creates_default_dirs() { let auth = create_account_and_login(); unwrap!(run(&auth, |client| { let client = client.clone(); create_std_dirs( &client, &unwrap!(random_std_dirs()) .into_iter() .map(|(k, v)| (k.to_owned(), v)) .collect(), ) .then(move |res| { assert!(res.is_ok()); access_container::fetch_authenticator_entry(&client) }) .then(move |res| { let (_, mdata_entries) = unwrap!(res); assert_eq!( mdata_entries.len(), DEFAULT_PUBLIC_DIRS.len() + DEFAULT_PRIVATE_DIRS.len() ); for key in DEFAULT_PUBLIC_DIRS .iter() .chain(DEFAULT_PRIVATE_DIRS.iter()) { // let's check whether all our entries have been created properly assert!(mdata_entries.contains_key(*key)); } Ok(()) }) })); } }
None, ));
random_line_split
std_dirs.rs
// Copyright 2018 MaidSafe.net limited. // // This SAFE Network Software is licensed to you under The General Public License (GPL), version 3. // Unless required by applicable law or agreed to in writing, the SAFE Network Software distributed // under the GPL Licence is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY // KIND, either express or implied. Please review the Licences for the specific language governing // permissions and limitations relating to use of the SAFE Network Software. use crate::access_container::{self, AUTHENTICATOR_ENTRY}; use crate::client::AuthClient; use crate::config::KEY_APPS; use crate::{AuthError, AuthFuture}; use bincode::serialize; use futures::{future, Future}; use safe_core::ipc::access_container_enc_key; use safe_core::mdata_info; use safe_core::nfs::create_dir; use safe_core::utils::symmetric_encrypt; use safe_core::{Client, CoreError, FutureExt, MDataInfo, DIR_TAG}; use safe_nd::{Error as SndError, MDataKind, MDataSeqValue}; use std::collections::HashMap; /// Default directories to be created at registration. pub static DEFAULT_PRIVATE_DIRS: [&str; 6] = [ "_documents", "_downloads", "_music", "_pictures", "_videos", "_publicNames", ]; /// Publicly accessible default directories to be created upon registration. pub static DEFAULT_PUBLIC_DIRS: [&str; 1] = ["_public"]; /// Create the root directories and the standard directories for the access container. pub fn create(client: &AuthClient) -> Box<AuthFuture<()>>
.into_iter() .map(|(name, md_info)| (String::from(name), md_info)) .collect(); let std_dirs_fut = create_std_dirs(&c3, &access_cont_value); let access_cont_fut = create_access_container(&c3, &access_container, &access_cont_value); future::join_all(vec![std_dirs_fut, access_cont_fut]) .map(|_| ()) .into_box() } Err(e) => err!(e), } }) .into_box(); future::join_all(vec![access_cont_fut, create_config_dir(&c2, &config_dir)]) .map_err(From::from) .and_then(move |_| { // Update account packet - root directories have been created successfully // (so we don't have to recover them after login). c4.set_std_dirs_created(true); c4.update_account_packet().map_err(From::from).into_box() }) .into_box() } fn create_config_dir(client: &AuthClient, config_dir: &MDataInfo) -> Box<AuthFuture<()>> { let config_dir_entries = btree_map![KEY_APPS.to_vec() => MDataSeqValue { data: Vec::new(), version: 0 }]; let config_dir_entries = fry!(mdata_info::encrypt_entries(config_dir, &config_dir_entries)); create_dir(client, config_dir, config_dir_entries, btree_map![]) .map_err(From::from) .into_box() } fn create_access_container( client: &AuthClient, access_container: &MDataInfo, default_entries: &HashMap<String, MDataInfo>, ) -> Box<AuthFuture<()>> { let enc_key = client.secret_symmetric_key(); // Create access container let authenticator_key = fry!(access_container_enc_key( AUTHENTICATOR_ENTRY, &enc_key, fry!(access_container.nonce().ok_or_else(|| AuthError::from( "Expected to have nonce on access container MDataInfo" ))), ) .map_err(AuthError::from)); let access_cont_value = fry!(symmetric_encrypt( &fry!(serialize(default_entries)), &enc_key, None, )); create_dir( client, access_container, btree_map![ authenticator_key => MDataSeqValue { version: 0, data: access_cont_value } ], btree_map![], ) .map_err(From::from) .into_box() } /// Generates a list of `MDataInfo` for standard dirs. /// Returns a collection of standard dirs along with respective `MDataInfo`s. /// Doesn't actually put data onto the network. pub fn random_std_dirs() -> Result<Vec<(&'static str, MDataInfo)>, CoreError> { let pub_dirs = DEFAULT_PUBLIC_DIRS .iter() .map(|name| MDataInfo::random_public(MDataKind::Seq, DIR_TAG).map(|dir| (*name, dir))); let priv_dirs = DEFAULT_PRIVATE_DIRS .iter() .map(|name| MDataInfo::random_private(MDataKind::Seq, DIR_TAG).map(|dir| (*name, dir))); priv_dirs.chain(pub_dirs).collect() } /// A registration helper function to create the set of default dirs in the users root directory. pub fn create_std_dirs( client: &AuthClient, md_infos: &HashMap<String, MDataInfo>, ) -> Box<AuthFuture<()>> { let client = client.clone(); let creations: Vec<_> = md_infos .iter() .map(|(_, md_info)| { create_dir(&client, md_info, btree_map![], btree_map![]).map_err(AuthError::from) }) .collect(); future::join_all(creations).map(|_| ()).into_box() } #[cfg(test)] mod tests { use super::*; use crate::run; use crate::test_utils::create_account_and_login; use futures::Future; // Test creation of default dirs. #[test] fn creates_default_dirs() { let auth = create_account_and_login(); unwrap!(run(&auth, |client| { let client = client.clone(); create_std_dirs( &client, &unwrap!(random_std_dirs()) .into_iter() .map(|(k, v)| (k.to_owned(), v)) .collect(), ) .then(move |res| { assert!(res.is_ok()); access_container::fetch_authenticator_entry(&client) }) .then(move |res| { let (_, mdata_entries) = unwrap!(res); assert_eq!( mdata_entries.len(), DEFAULT_PUBLIC_DIRS.len() + DEFAULT_PRIVATE_DIRS.len() ); for key in DEFAULT_PUBLIC_DIRS .iter() .chain(DEFAULT_PRIVATE_DIRS.iter()) { // let's check whether all our entries have been created properly assert!(mdata_entries.contains_key(*key)); } Ok(()) }) })); } }
{ let c2 = client.clone(); let c3 = client.clone(); let c4 = client.clone(); // Initialise standard directories let access_container = client.access_container(); let config_dir = client.config_root_dir(); // Try to get default dirs from the access container let access_cont_fut = access_container::fetch_authenticator_entry(&c2) .then(move |res| { match res { Ok((_, default_containers)) => { // Make sure that all default dirs have been created create_std_dirs(&c3, &default_containers) } Err(AuthError::CoreError(CoreError::DataError(SndError::NoSuchData))) => { // Access container hasn't been created yet let access_cont_value = fry!(random_std_dirs())
identifier_body
std_dirs.rs
// Copyright 2018 MaidSafe.net limited. // // This SAFE Network Software is licensed to you under The General Public License (GPL), version 3. // Unless required by applicable law or agreed to in writing, the SAFE Network Software distributed // under the GPL Licence is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY // KIND, either express or implied. Please review the Licences for the specific language governing // permissions and limitations relating to use of the SAFE Network Software. use crate::access_container::{self, AUTHENTICATOR_ENTRY}; use crate::client::AuthClient; use crate::config::KEY_APPS; use crate::{AuthError, AuthFuture}; use bincode::serialize; use futures::{future, Future}; use safe_core::ipc::access_container_enc_key; use safe_core::mdata_info; use safe_core::nfs::create_dir; use safe_core::utils::symmetric_encrypt; use safe_core::{Client, CoreError, FutureExt, MDataInfo, DIR_TAG}; use safe_nd::{Error as SndError, MDataKind, MDataSeqValue}; use std::collections::HashMap; /// Default directories to be created at registration. pub static DEFAULT_PRIVATE_DIRS: [&str; 6] = [ "_documents", "_downloads", "_music", "_pictures", "_videos", "_publicNames", ]; /// Publicly accessible default directories to be created upon registration. pub static DEFAULT_PUBLIC_DIRS: [&str; 1] = ["_public"]; /// Create the root directories and the standard directories for the access container. pub fn
(client: &AuthClient) -> Box<AuthFuture<()>> { let c2 = client.clone(); let c3 = client.clone(); let c4 = client.clone(); // Initialise standard directories let access_container = client.access_container(); let config_dir = client.config_root_dir(); // Try to get default dirs from the access container let access_cont_fut = access_container::fetch_authenticator_entry(&c2) .then(move |res| { match res { Ok((_, default_containers)) => { // Make sure that all default dirs have been created create_std_dirs(&c3, &default_containers) } Err(AuthError::CoreError(CoreError::DataError(SndError::NoSuchData))) => { // Access container hasn't been created yet let access_cont_value = fry!(random_std_dirs()) .into_iter() .map(|(name, md_info)| (String::from(name), md_info)) .collect(); let std_dirs_fut = create_std_dirs(&c3, &access_cont_value); let access_cont_fut = create_access_container(&c3, &access_container, &access_cont_value); future::join_all(vec![std_dirs_fut, access_cont_fut]) .map(|_| ()) .into_box() } Err(e) => err!(e), } }) .into_box(); future::join_all(vec![access_cont_fut, create_config_dir(&c2, &config_dir)]) .map_err(From::from) .and_then(move |_| { // Update account packet - root directories have been created successfully // (so we don't have to recover them after login). c4.set_std_dirs_created(true); c4.update_account_packet().map_err(From::from).into_box() }) .into_box() } fn create_config_dir(client: &AuthClient, config_dir: &MDataInfo) -> Box<AuthFuture<()>> { let config_dir_entries = btree_map![KEY_APPS.to_vec() => MDataSeqValue { data: Vec::new(), version: 0 }]; let config_dir_entries = fry!(mdata_info::encrypt_entries(config_dir, &config_dir_entries)); create_dir(client, config_dir, config_dir_entries, btree_map![]) .map_err(From::from) .into_box() } fn create_access_container( client: &AuthClient, access_container: &MDataInfo, default_entries: &HashMap<String, MDataInfo>, ) -> Box<AuthFuture<()>> { let enc_key = client.secret_symmetric_key(); // Create access container let authenticator_key = fry!(access_container_enc_key( AUTHENTICATOR_ENTRY, &enc_key, fry!(access_container.nonce().ok_or_else(|| AuthError::from( "Expected to have nonce on access container MDataInfo" ))), ) .map_err(AuthError::from)); let access_cont_value = fry!(symmetric_encrypt( &fry!(serialize(default_entries)), &enc_key, None, )); create_dir( client, access_container, btree_map![ authenticator_key => MDataSeqValue { version: 0, data: access_cont_value } ], btree_map![], ) .map_err(From::from) .into_box() } /// Generates a list of `MDataInfo` for standard dirs. /// Returns a collection of standard dirs along with respective `MDataInfo`s. /// Doesn't actually put data onto the network. pub fn random_std_dirs() -> Result<Vec<(&'static str, MDataInfo)>, CoreError> { let pub_dirs = DEFAULT_PUBLIC_DIRS .iter() .map(|name| MDataInfo::random_public(MDataKind::Seq, DIR_TAG).map(|dir| (*name, dir))); let priv_dirs = DEFAULT_PRIVATE_DIRS .iter() .map(|name| MDataInfo::random_private(MDataKind::Seq, DIR_TAG).map(|dir| (*name, dir))); priv_dirs.chain(pub_dirs).collect() } /// A registration helper function to create the set of default dirs in the users root directory. pub fn create_std_dirs( client: &AuthClient, md_infos: &HashMap<String, MDataInfo>, ) -> Box<AuthFuture<()>> { let client = client.clone(); let creations: Vec<_> = md_infos .iter() .map(|(_, md_info)| { create_dir(&client, md_info, btree_map![], btree_map![]).map_err(AuthError::from) }) .collect(); future::join_all(creations).map(|_| ()).into_box() } #[cfg(test)] mod tests { use super::*; use crate::run; use crate::test_utils::create_account_and_login; use futures::Future; // Test creation of default dirs. #[test] fn creates_default_dirs() { let auth = create_account_and_login(); unwrap!(run(&auth, |client| { let client = client.clone(); create_std_dirs( &client, &unwrap!(random_std_dirs()) .into_iter() .map(|(k, v)| (k.to_owned(), v)) .collect(), ) .then(move |res| { assert!(res.is_ok()); access_container::fetch_authenticator_entry(&client) }) .then(move |res| { let (_, mdata_entries) = unwrap!(res); assert_eq!( mdata_entries.len(), DEFAULT_PUBLIC_DIRS.len() + DEFAULT_PRIVATE_DIRS.len() ); for key in DEFAULT_PUBLIC_DIRS .iter() .chain(DEFAULT_PRIVATE_DIRS.iter()) { // let's check whether all our entries have been created properly assert!(mdata_entries.contains_key(*key)); } Ok(()) }) })); } }
create
identifier_name
shared_cache.rs
// Copyright 2015, 2016 Ethcore (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. use std::sync::Arc; use lru_cache::LruCache; use util::{H256, Mutex}; use util::sha3::*;
use bit_set::BitSet; use super::super::instructions; const INITIAL_CAPACITY: usize = 32; const DEFAULT_CACHE_SIZE: usize = 4 * 1024 * 1024; /// Global cache for EVM interpreter pub struct SharedCache { jump_destinations: Mutex<LruCache<H256, Arc<BitSet>>>, max_size: usize, cur_size: Mutex<usize>, } impl SharedCache { /// Create a jump destinations cache with a maximum size in bytes /// to cache. pub fn new(max_size: usize) -> Self { SharedCache { jump_destinations: Mutex::new(LruCache::new(INITIAL_CAPACITY)), max_size: max_size * 8, // dealing with bits here. cur_size: Mutex::new(0), } } /// Get jump destinations bitmap for a contract. pub fn jump_destinations(&self, code_hash: &H256, code: &[u8]) -> Arc<BitSet> { if code_hash == &SHA3_EMPTY { return Self::find_jump_destinations(code); } if let Some(d) = self.jump_destinations.lock().get_mut(code_hash) { return d.clone(); } let d = Self::find_jump_destinations(code); { let mut cur_size = self.cur_size.lock(); *cur_size += d.capacity(); let mut jump_dests = self.jump_destinations.lock(); let cap = jump_dests.capacity(); // grow the cache as necessary; it operates on amount of items // but we're working based on memory usage. if jump_dests.len() == cap && *cur_size < self.max_size { jump_dests.set_capacity(cap * 2); } // account for any element displaced from the cache. if let Some(lru) = jump_dests.insert(code_hash.clone(), d.clone()) { *cur_size -= lru.capacity(); } // remove elements until we are below the memory target. while *cur_size > self.max_size { match jump_dests.remove_lru() { Some((_, v)) => *cur_size -= v.capacity(), _ => break, } } } d } fn find_jump_destinations(code: &[u8]) -> Arc<BitSet> { let mut jump_dests = BitSet::with_capacity(code.len()); let mut position = 0; while position < code.len() { let instruction = code[position]; if instruction == instructions::JUMPDEST { jump_dests.insert(position); } else if instructions::is_push(instruction) { position += instructions::get_push_bytes(instruction); } position += 1; } jump_dests.shrink_to_fit(); Arc::new(jump_dests) } } impl Default for SharedCache { fn default() -> Self { SharedCache::new(DEFAULT_CACHE_SIZE) } } #[test] fn test_find_jump_destinations() { use util::FromHex; // given let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b01600055".from_hex().unwrap(); // when let valid_jump_destinations = SharedCache::find_jump_destinations(&code); // then assert!(valid_jump_destinations.contains(66)); }
random_line_split
shared_cache.rs
// Copyright 2015, 2016 Ethcore (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. use std::sync::Arc; use lru_cache::LruCache; use util::{H256, Mutex}; use util::sha3::*; use bit_set::BitSet; use super::super::instructions; const INITIAL_CAPACITY: usize = 32; const DEFAULT_CACHE_SIZE: usize = 4 * 1024 * 1024; /// Global cache for EVM interpreter pub struct SharedCache { jump_destinations: Mutex<LruCache<H256, Arc<BitSet>>>, max_size: usize, cur_size: Mutex<usize>, } impl SharedCache { /// Create a jump destinations cache with a maximum size in bytes /// to cache. pub fn
(max_size: usize) -> Self { SharedCache { jump_destinations: Mutex::new(LruCache::new(INITIAL_CAPACITY)), max_size: max_size * 8, // dealing with bits here. cur_size: Mutex::new(0), } } /// Get jump destinations bitmap for a contract. pub fn jump_destinations(&self, code_hash: &H256, code: &[u8]) -> Arc<BitSet> { if code_hash == &SHA3_EMPTY { return Self::find_jump_destinations(code); } if let Some(d) = self.jump_destinations.lock().get_mut(code_hash) { return d.clone(); } let d = Self::find_jump_destinations(code); { let mut cur_size = self.cur_size.lock(); *cur_size += d.capacity(); let mut jump_dests = self.jump_destinations.lock(); let cap = jump_dests.capacity(); // grow the cache as necessary; it operates on amount of items // but we're working based on memory usage. if jump_dests.len() == cap && *cur_size < self.max_size { jump_dests.set_capacity(cap * 2); } // account for any element displaced from the cache. if let Some(lru) = jump_dests.insert(code_hash.clone(), d.clone()) { *cur_size -= lru.capacity(); } // remove elements until we are below the memory target. while *cur_size > self.max_size { match jump_dests.remove_lru() { Some((_, v)) => *cur_size -= v.capacity(), _ => break, } } } d } fn find_jump_destinations(code: &[u8]) -> Arc<BitSet> { let mut jump_dests = BitSet::with_capacity(code.len()); let mut position = 0; while position < code.len() { let instruction = code[position]; if instruction == instructions::JUMPDEST { jump_dests.insert(position); } else if instructions::is_push(instruction) { position += instructions::get_push_bytes(instruction); } position += 1; } jump_dests.shrink_to_fit(); Arc::new(jump_dests) } } impl Default for SharedCache { fn default() -> Self { SharedCache::new(DEFAULT_CACHE_SIZE) } } #[test] fn test_find_jump_destinations() { use util::FromHex; // given let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b01600055".from_hex().unwrap(); // when let valid_jump_destinations = SharedCache::find_jump_destinations(&code); // then assert!(valid_jump_destinations.contains(66)); }
new
identifier_name
shared_cache.rs
// Copyright 2015, 2016 Ethcore (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. use std::sync::Arc; use lru_cache::LruCache; use util::{H256, Mutex}; use util::sha3::*; use bit_set::BitSet; use super::super::instructions; const INITIAL_CAPACITY: usize = 32; const DEFAULT_CACHE_SIZE: usize = 4 * 1024 * 1024; /// Global cache for EVM interpreter pub struct SharedCache { jump_destinations: Mutex<LruCache<H256, Arc<BitSet>>>, max_size: usize, cur_size: Mutex<usize>, } impl SharedCache { /// Create a jump destinations cache with a maximum size in bytes /// to cache. pub fn new(max_size: usize) -> Self
/// Get jump destinations bitmap for a contract. pub fn jump_destinations(&self, code_hash: &H256, code: &[u8]) -> Arc<BitSet> { if code_hash == &SHA3_EMPTY { return Self::find_jump_destinations(code); } if let Some(d) = self.jump_destinations.lock().get_mut(code_hash) { return d.clone(); } let d = Self::find_jump_destinations(code); { let mut cur_size = self.cur_size.lock(); *cur_size += d.capacity(); let mut jump_dests = self.jump_destinations.lock(); let cap = jump_dests.capacity(); // grow the cache as necessary; it operates on amount of items // but we're working based on memory usage. if jump_dests.len() == cap && *cur_size < self.max_size { jump_dests.set_capacity(cap * 2); } // account for any element displaced from the cache. if let Some(lru) = jump_dests.insert(code_hash.clone(), d.clone()) { *cur_size -= lru.capacity(); } // remove elements until we are below the memory target. while *cur_size > self.max_size { match jump_dests.remove_lru() { Some((_, v)) => *cur_size -= v.capacity(), _ => break, } } } d } fn find_jump_destinations(code: &[u8]) -> Arc<BitSet> { let mut jump_dests = BitSet::with_capacity(code.len()); let mut position = 0; while position < code.len() { let instruction = code[position]; if instruction == instructions::JUMPDEST { jump_dests.insert(position); } else if instructions::is_push(instruction) { position += instructions::get_push_bytes(instruction); } position += 1; } jump_dests.shrink_to_fit(); Arc::new(jump_dests) } } impl Default for SharedCache { fn default() -> Self { SharedCache::new(DEFAULT_CACHE_SIZE) } } #[test] fn test_find_jump_destinations() { use util::FromHex; // given let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b01600055".from_hex().unwrap(); // when let valid_jump_destinations = SharedCache::find_jump_destinations(&code); // then assert!(valid_jump_destinations.contains(66)); }
{ SharedCache { jump_destinations: Mutex::new(LruCache::new(INITIAL_CAPACITY)), max_size: max_size * 8, // dealing with bits here. cur_size: Mutex::new(0), } }
identifier_body
shared_cache.rs
// Copyright 2015, 2016 Ethcore (UK) Ltd. // This file is part of Parity. // Parity is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Parity is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Parity. If not, see <http://www.gnu.org/licenses/>. use std::sync::Arc; use lru_cache::LruCache; use util::{H256, Mutex}; use util::sha3::*; use bit_set::BitSet; use super::super::instructions; const INITIAL_CAPACITY: usize = 32; const DEFAULT_CACHE_SIZE: usize = 4 * 1024 * 1024; /// Global cache for EVM interpreter pub struct SharedCache { jump_destinations: Mutex<LruCache<H256, Arc<BitSet>>>, max_size: usize, cur_size: Mutex<usize>, } impl SharedCache { /// Create a jump destinations cache with a maximum size in bytes /// to cache. pub fn new(max_size: usize) -> Self { SharedCache { jump_destinations: Mutex::new(LruCache::new(INITIAL_CAPACITY)), max_size: max_size * 8, // dealing with bits here. cur_size: Mutex::new(0), } } /// Get jump destinations bitmap for a contract. pub fn jump_destinations(&self, code_hash: &H256, code: &[u8]) -> Arc<BitSet> { if code_hash == &SHA3_EMPTY
if let Some(d) = self.jump_destinations.lock().get_mut(code_hash) { return d.clone(); } let d = Self::find_jump_destinations(code); { let mut cur_size = self.cur_size.lock(); *cur_size += d.capacity(); let mut jump_dests = self.jump_destinations.lock(); let cap = jump_dests.capacity(); // grow the cache as necessary; it operates on amount of items // but we're working based on memory usage. if jump_dests.len() == cap && *cur_size < self.max_size { jump_dests.set_capacity(cap * 2); } // account for any element displaced from the cache. if let Some(lru) = jump_dests.insert(code_hash.clone(), d.clone()) { *cur_size -= lru.capacity(); } // remove elements until we are below the memory target. while *cur_size > self.max_size { match jump_dests.remove_lru() { Some((_, v)) => *cur_size -= v.capacity(), _ => break, } } } d } fn find_jump_destinations(code: &[u8]) -> Arc<BitSet> { let mut jump_dests = BitSet::with_capacity(code.len()); let mut position = 0; while position < code.len() { let instruction = code[position]; if instruction == instructions::JUMPDEST { jump_dests.insert(position); } else if instructions::is_push(instruction) { position += instructions::get_push_bytes(instruction); } position += 1; } jump_dests.shrink_to_fit(); Arc::new(jump_dests) } } impl Default for SharedCache { fn default() -> Self { SharedCache::new(DEFAULT_CACHE_SIZE) } } #[test] fn test_find_jump_destinations() { use util::FromHex; // given let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b01600055".from_hex().unwrap(); // when let valid_jump_destinations = SharedCache::find_jump_destinations(&code); // then assert!(valid_jump_destinations.contains(66)); }
{ return Self::find_jump_destinations(code); }
conditional_block
mod.rs
/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ use common::SourceLocationKey; use dependency_analyzer::{get_reachable_ast, ReachableAst}; use fixture_tests::Fixture;
pub fn transform_fixture(fixture: &Fixture<'_>) -> Result<String, String> { let parts: Vec<&str> = fixture.content.split("%definitions%").collect(); let source_location = SourceLocationKey::standalone(fixture.file_name); let definitions = parse_executable(parts[0], source_location).unwrap(); let base_definitions = parts .iter() .skip(1) .flat_map(|part| parse_executable(part, source_location).unwrap().definitions) .collect(); let ReachableAst { definitions: result, base_fragment_names, } = get_reachable_ast(definitions.definitions, base_definitions); let mut texts = result .into_iter() .map(|def| def.name().unwrap().to_string()) .collect::<Vec<_>>(); texts.sort_unstable(); texts.push("========== Base definitions ==========".to_string()); let mut defs = base_fragment_names .iter() .map(|key| key.lookup()) .collect::<Vec<_>>(); defs.sort_unstable(); texts.push(defs.join(", ")); Ok(texts.join("\n")) }
use graphql_syntax::*;
random_line_split
mod.rs
/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ use common::SourceLocationKey; use dependency_analyzer::{get_reachable_ast, ReachableAst}; use fixture_tests::Fixture; use graphql_syntax::*; pub fn
(fixture: &Fixture<'_>) -> Result<String, String> { let parts: Vec<&str> = fixture.content.split("%definitions%").collect(); let source_location = SourceLocationKey::standalone(fixture.file_name); let definitions = parse_executable(parts[0], source_location).unwrap(); let base_definitions = parts .iter() .skip(1) .flat_map(|part| parse_executable(part, source_location).unwrap().definitions) .collect(); let ReachableAst { definitions: result, base_fragment_names, } = get_reachable_ast(definitions.definitions, base_definitions); let mut texts = result .into_iter() .map(|def| def.name().unwrap().to_string()) .collect::<Vec<_>>(); texts.sort_unstable(); texts.push("========== Base definitions ==========".to_string()); let mut defs = base_fragment_names .iter() .map(|key| key.lookup()) .collect::<Vec<_>>(); defs.sort_unstable(); texts.push(defs.join(", ")); Ok(texts.join("\n")) }
transform_fixture
identifier_name
mod.rs
/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ use common::SourceLocationKey; use dependency_analyzer::{get_reachable_ast, ReachableAst}; use fixture_tests::Fixture; use graphql_syntax::*; pub fn transform_fixture(fixture: &Fixture<'_>) -> Result<String, String>
texts.push("========== Base definitions ==========".to_string()); let mut defs = base_fragment_names .iter() .map(|key| key.lookup()) .collect::<Vec<_>>(); defs.sort_unstable(); texts.push(defs.join(", ")); Ok(texts.join("\n")) }
{ let parts: Vec<&str> = fixture.content.split("%definitions%").collect(); let source_location = SourceLocationKey::standalone(fixture.file_name); let definitions = parse_executable(parts[0], source_location).unwrap(); let base_definitions = parts .iter() .skip(1) .flat_map(|part| parse_executable(part, source_location).unwrap().definitions) .collect(); let ReachableAst { definitions: result, base_fragment_names, } = get_reachable_ast(definitions.definitions, base_definitions); let mut texts = result .into_iter() .map(|def| def.name().unwrap().to_string()) .collect::<Vec<_>>(); texts.sort_unstable();
identifier_body
lib.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ //! Calculate [specified][specified] and [computed values][computed] from a //! tree of DOM nodes and a set of stylesheets. //! //! [computed]: https://drafts.csswg.org/css-cascade/#computed //! [specified]: https://drafts.csswg.org/css-cascade/#specified //! //! In particular, this crate contains the definitions of supported properties, //! the code to parse them into specified values and calculate the computed //! values based on the specified values, as well as the code to serialize both //! specified and computed values. //! //! The main entry point is [`recalc_style_at`][recalc_style_at]. //! //! [recalc_style_at]: traversal/fn.recalc_style_at.html //! //! Major dependencies are the [cssparser][cssparser] and [selectors][selectors] //! crates. //! //! [cssparser]:../cssparser/index.html //! [selectors]:../selectors/index.html #![deny(missing_docs)] extern crate app_units; extern crate arrayvec; extern crate atomic_refcell; #[macro_use] extern crate bitflags; #[allow(unused_extern_crates)] extern crate byteorder; #[cfg(feature = "servo")] extern crate crossbeam_channel; #[macro_use] extern crate cssparser; #[macro_use] extern crate debug_unreachable; #[macro_use] extern crate derive_more; extern crate euclid; extern crate fallible; extern crate fxhash; #[cfg(feature = "gecko")] #[macro_use] pub mod gecko_string_cache; extern crate hashglobe; #[cfg(feature = "servo")] #[macro_use] extern crate html5ever; extern crate indexmap; extern crate itertools; extern crate itoa; #[macro_use] extern crate lazy_static; #[macro_use] extern crate log; #[macro_use] extern crate malloc_size_of; #[macro_use] extern crate malloc_size_of_derive; #[allow(unused_extern_crates)] #[macro_use] extern crate matches; #[cfg(feature = "gecko")] pub extern crate nsstring; #[cfg(feature = "gecko")] extern crate num_cpus; #[macro_use] extern crate num_derive; extern crate num_integer; extern crate num_traits; extern crate ordered_float; extern crate owning_ref; extern crate parking_lot; extern crate precomputed_hash; extern crate rayon; extern crate selectors; #[macro_use] extern crate serde; pub extern crate servo_arc; #[cfg(feature = "servo")] #[macro_use] extern crate servo_atoms; #[cfg(feature = "servo")] extern crate servo_config; #[cfg(feature = "servo")] extern crate servo_url; extern crate smallbitvec; extern crate smallvec; #[cfg(feature = "gecko")] extern crate static_prefs; #[cfg(feature = "servo")] extern crate string_cache; #[macro_use] extern crate style_derive; extern crate style_traits; #[cfg(feature = "gecko")] extern crate thin_slice; extern crate time; extern crate to_shmem; #[macro_use] extern crate to_shmem_derive; extern crate uluru; extern crate unicode_bidi; #[allow(unused_extern_crates)] extern crate unicode_segmentation; extern crate void; #[macro_use] mod macros; pub mod animation; pub mod applicable_declarations; #[allow(missing_docs)] // TODO. #[cfg(feature = "servo")] pub mod attr; pub mod author_styles; pub mod bezier; pub mod bloom; pub mod context; pub mod counter_style; pub mod custom_properties; pub mod data; pub mod dom; pub mod dom_apis; pub mod driver; pub mod element_state; #[cfg(feature = "servo")] mod encoding_support; pub mod error_reporting; pub mod font_face; pub mod font_metrics; #[cfg(feature = "gecko")] #[allow(unsafe_code)] pub mod gecko_bindings; pub mod global_style_data; pub mod hash; pub mod invalidation; #[allow(missing_docs)] // TODO. pub mod logical_geometry; pub mod matching; #[macro_use] pub mod media_queries; pub mod parallel; pub mod parser; pub mod rule_cache; pub mod rule_collector; pub mod rule_tree; pub mod scoped_tls; pub mod selector_map; pub mod selector_parser; pub mod shared_lock; pub mod sharing; pub mod str; pub mod style_adjuster; pub mod style_resolver; pub mod stylesheet_set; pub mod stylesheets; pub mod stylist; pub mod thread_state; pub mod timer; pub mod traversal; pub mod traversal_flags; pub mod use_counters; #[macro_use] #[allow(non_camel_case_types)] pub mod values; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache as string_cache; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Atom; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Atom as Prefix; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Atom as LocalName; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Namespace; #[cfg(feature = "servo")] pub use html5ever::LocalName; #[cfg(feature = "servo")] pub use html5ever::Namespace; #[cfg(feature = "servo")] pub use html5ever::Prefix; #[cfg(feature = "servo")] pub use servo_atoms::Atom; pub use style_traits::arc_slice::ArcSlice; pub use style_traits::owned_slice::OwnedSlice; pub use style_traits::owned_str::OwnedStr; /// The CSS properties supported by the style system. /// Generated from the properties.mako.rs template by build.rs #[macro_use] #[allow(unsafe_code)] #[deny(missing_docs)] pub mod properties { include!(concat!(env!("OUT_DIR"), "/properties.rs")); } #[cfg(feature = "gecko")] #[allow(unsafe_code)] pub mod gecko; // uses a macro from properties #[cfg(feature = "servo")] #[allow(unsafe_code)] pub mod servo; #[cfg(feature = "gecko")] #[allow(unsafe_code, missing_docs)] pub mod gecko_properties { include!(concat!(env!("OUT_DIR"), "/gecko_properties.rs")); } macro_rules! reexport_computed_values { ( $( { $name: ident, $boxed: expr } )+ ) => { /// Types for [computed values][computed]. /// /// [computed]: https://drafts.csswg.org/css-cascade/#computed pub mod computed_values { $( pub use crate::properties::longhands::$name::computed_value as $name; )+ // Don't use a side-specific name needlessly: pub use crate::properties::longhands::border_top_style::computed_value as border_style; } } } longhand_properties_idents!(reexport_computed_values); #[cfg(feature = "gecko")] use crate::gecko_string_cache::WeakAtom; #[cfg(feature = "servo")] use servo_atoms::Atom as WeakAtom; /// Extension methods for selectors::attr::CaseSensitivity pub trait CaseSensitivityExt { /// Return whether two atoms compare equal according to this case sensitivity. fn eq_atom(self, a: &WeakAtom, b: &WeakAtom) -> bool; } impl CaseSensitivityExt for selectors::attr::CaseSensitivity { fn eq_atom(self, a: &WeakAtom, b: &WeakAtom) -> bool { match self { selectors::attr::CaseSensitivity::CaseSensitive => a == b, selectors::attr::CaseSensitivity::AsciiCaseInsensitive => a.eq_ignore_ascii_case(b), } } } /// A trait pretty much similar to num_traits::Zero, but without the need of /// implementing `Add`. pub trait Zero { /// Returns the zero value. fn zero() -> Self; /// Returns whether this value is zero. fn is_zero(&self) -> bool; } impl<T> Zero for T where T: num_traits::Zero, { fn zero() -> Self { <Self as num_traits::Zero>::zero() } fn
(&self) -> bool { <Self as num_traits::Zero>::is_zero(self) } }
is_zero
identifier_name
lib.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ //! Calculate [specified][specified] and [computed values][computed] from a //! tree of DOM nodes and a set of stylesheets. //! //! [computed]: https://drafts.csswg.org/css-cascade/#computed //! [specified]: https://drafts.csswg.org/css-cascade/#specified //! //! In particular, this crate contains the definitions of supported properties, //! the code to parse them into specified values and calculate the computed //! values based on the specified values, as well as the code to serialize both //! specified and computed values. //! //! The main entry point is [`recalc_style_at`][recalc_style_at]. //! //! [recalc_style_at]: traversal/fn.recalc_style_at.html //! //! Major dependencies are the [cssparser][cssparser] and [selectors][selectors] //! crates. //! //! [cssparser]:../cssparser/index.html //! [selectors]:../selectors/index.html #![deny(missing_docs)] extern crate app_units; extern crate arrayvec; extern crate atomic_refcell; #[macro_use] extern crate bitflags; #[allow(unused_extern_crates)] extern crate byteorder; #[cfg(feature = "servo")] extern crate crossbeam_channel; #[macro_use] extern crate cssparser; #[macro_use] extern crate debug_unreachable; #[macro_use] extern crate derive_more; extern crate euclid; extern crate fallible; extern crate fxhash; #[cfg(feature = "gecko")] #[macro_use] pub mod gecko_string_cache; extern crate hashglobe; #[cfg(feature = "servo")] #[macro_use] extern crate html5ever; extern crate indexmap; extern crate itertools; extern crate itoa; #[macro_use] extern crate lazy_static; #[macro_use] extern crate log; #[macro_use] extern crate malloc_size_of; #[macro_use] extern crate malloc_size_of_derive; #[allow(unused_extern_crates)] #[macro_use] extern crate matches; #[cfg(feature = "gecko")] pub extern crate nsstring; #[cfg(feature = "gecko")] extern crate num_cpus; #[macro_use] extern crate num_derive; extern crate num_integer; extern crate num_traits; extern crate ordered_float; extern crate owning_ref; extern crate parking_lot; extern crate precomputed_hash; extern crate rayon; extern crate selectors; #[macro_use] extern crate serde; pub extern crate servo_arc; #[cfg(feature = "servo")] #[macro_use] extern crate servo_atoms; #[cfg(feature = "servo")] extern crate servo_config; #[cfg(feature = "servo")] extern crate servo_url; extern crate smallbitvec; extern crate smallvec; #[cfg(feature = "gecko")] extern crate static_prefs; #[cfg(feature = "servo")] extern crate string_cache; #[macro_use] extern crate style_derive; extern crate style_traits; #[cfg(feature = "gecko")] extern crate thin_slice; extern crate time; extern crate to_shmem; #[macro_use] extern crate to_shmem_derive; extern crate uluru; extern crate unicode_bidi; #[allow(unused_extern_crates)] extern crate unicode_segmentation; extern crate void; #[macro_use] mod macros; pub mod animation; pub mod applicable_declarations; #[allow(missing_docs)] // TODO. #[cfg(feature = "servo")] pub mod attr; pub mod author_styles; pub mod bezier; pub mod bloom; pub mod context; pub mod counter_style; pub mod custom_properties; pub mod data; pub mod dom; pub mod dom_apis; pub mod driver; pub mod element_state; #[cfg(feature = "servo")] mod encoding_support; pub mod error_reporting; pub mod font_face; pub mod font_metrics; #[cfg(feature = "gecko")] #[allow(unsafe_code)] pub mod gecko_bindings; pub mod global_style_data; pub mod hash; pub mod invalidation; #[allow(missing_docs)] // TODO. pub mod logical_geometry; pub mod matching; #[macro_use] pub mod media_queries; pub mod parallel; pub mod parser; pub mod rule_cache; pub mod rule_collector; pub mod rule_tree; pub mod scoped_tls; pub mod selector_map; pub mod selector_parser; pub mod shared_lock; pub mod sharing; pub mod str; pub mod style_adjuster; pub mod style_resolver; pub mod stylesheet_set; pub mod stylesheets; pub mod stylist; pub mod thread_state; pub mod timer; pub mod traversal; pub mod traversal_flags; pub mod use_counters; #[macro_use] #[allow(non_camel_case_types)] pub mod values; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache as string_cache; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Atom; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Atom as Prefix; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Atom as LocalName; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Namespace; #[cfg(feature = "servo")] pub use html5ever::LocalName; #[cfg(feature = "servo")] pub use html5ever::Namespace; #[cfg(feature = "servo")] pub use html5ever::Prefix; #[cfg(feature = "servo")] pub use servo_atoms::Atom; pub use style_traits::arc_slice::ArcSlice; pub use style_traits::owned_slice::OwnedSlice; pub use style_traits::owned_str::OwnedStr; /// The CSS properties supported by the style system. /// Generated from the properties.mako.rs template by build.rs #[macro_use] #[allow(unsafe_code)] #[deny(missing_docs)] pub mod properties { include!(concat!(env!("OUT_DIR"), "/properties.rs")); } #[cfg(feature = "gecko")] #[allow(unsafe_code)] pub mod gecko; // uses a macro from properties #[cfg(feature = "servo")] #[allow(unsafe_code)] pub mod servo; #[cfg(feature = "gecko")] #[allow(unsafe_code, missing_docs)] pub mod gecko_properties { include!(concat!(env!("OUT_DIR"), "/gecko_properties.rs")); } macro_rules! reexport_computed_values { ( $( { $name: ident, $boxed: expr } )+ ) => { /// Types for [computed values][computed]. /// /// [computed]: https://drafts.csswg.org/css-cascade/#computed pub mod computed_values { $( pub use crate::properties::longhands::$name::computed_value as $name; )+ // Don't use a side-specific name needlessly: pub use crate::properties::longhands::border_top_style::computed_value as border_style; } } } longhand_properties_idents!(reexport_computed_values); #[cfg(feature = "gecko")] use crate::gecko_string_cache::WeakAtom; #[cfg(feature = "servo")] use servo_atoms::Atom as WeakAtom; /// Extension methods for selectors::attr::CaseSensitivity pub trait CaseSensitivityExt { /// Return whether two atoms compare equal according to this case sensitivity. fn eq_atom(self, a: &WeakAtom, b: &WeakAtom) -> bool; } impl CaseSensitivityExt for selectors::attr::CaseSensitivity { fn eq_atom(self, a: &WeakAtom, b: &WeakAtom) -> bool { match self { selectors::attr::CaseSensitivity::CaseSensitive => a == b, selectors::attr::CaseSensitivity::AsciiCaseInsensitive => a.eq_ignore_ascii_case(b), } } } /// A trait pretty much similar to num_traits::Zero, but without the need of
/// Returns whether this value is zero. fn is_zero(&self) -> bool; } impl<T> Zero for T where T: num_traits::Zero, { fn zero() -> Self { <Self as num_traits::Zero>::zero() } fn is_zero(&self) -> bool { <Self as num_traits::Zero>::is_zero(self) } }
/// implementing `Add`. pub trait Zero { /// Returns the zero value. fn zero() -> Self;
random_line_split
lib.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ //! Calculate [specified][specified] and [computed values][computed] from a //! tree of DOM nodes and a set of stylesheets. //! //! [computed]: https://drafts.csswg.org/css-cascade/#computed //! [specified]: https://drafts.csswg.org/css-cascade/#specified //! //! In particular, this crate contains the definitions of supported properties, //! the code to parse them into specified values and calculate the computed //! values based on the specified values, as well as the code to serialize both //! specified and computed values. //! //! The main entry point is [`recalc_style_at`][recalc_style_at]. //! //! [recalc_style_at]: traversal/fn.recalc_style_at.html //! //! Major dependencies are the [cssparser][cssparser] and [selectors][selectors] //! crates. //! //! [cssparser]:../cssparser/index.html //! [selectors]:../selectors/index.html #![deny(missing_docs)] extern crate app_units; extern crate arrayvec; extern crate atomic_refcell; #[macro_use] extern crate bitflags; #[allow(unused_extern_crates)] extern crate byteorder; #[cfg(feature = "servo")] extern crate crossbeam_channel; #[macro_use] extern crate cssparser; #[macro_use] extern crate debug_unreachable; #[macro_use] extern crate derive_more; extern crate euclid; extern crate fallible; extern crate fxhash; #[cfg(feature = "gecko")] #[macro_use] pub mod gecko_string_cache; extern crate hashglobe; #[cfg(feature = "servo")] #[macro_use] extern crate html5ever; extern crate indexmap; extern crate itertools; extern crate itoa; #[macro_use] extern crate lazy_static; #[macro_use] extern crate log; #[macro_use] extern crate malloc_size_of; #[macro_use] extern crate malloc_size_of_derive; #[allow(unused_extern_crates)] #[macro_use] extern crate matches; #[cfg(feature = "gecko")] pub extern crate nsstring; #[cfg(feature = "gecko")] extern crate num_cpus; #[macro_use] extern crate num_derive; extern crate num_integer; extern crate num_traits; extern crate ordered_float; extern crate owning_ref; extern crate parking_lot; extern crate precomputed_hash; extern crate rayon; extern crate selectors; #[macro_use] extern crate serde; pub extern crate servo_arc; #[cfg(feature = "servo")] #[macro_use] extern crate servo_atoms; #[cfg(feature = "servo")] extern crate servo_config; #[cfg(feature = "servo")] extern crate servo_url; extern crate smallbitvec; extern crate smallvec; #[cfg(feature = "gecko")] extern crate static_prefs; #[cfg(feature = "servo")] extern crate string_cache; #[macro_use] extern crate style_derive; extern crate style_traits; #[cfg(feature = "gecko")] extern crate thin_slice; extern crate time; extern crate to_shmem; #[macro_use] extern crate to_shmem_derive; extern crate uluru; extern crate unicode_bidi; #[allow(unused_extern_crates)] extern crate unicode_segmentation; extern crate void; #[macro_use] mod macros; pub mod animation; pub mod applicable_declarations; #[allow(missing_docs)] // TODO. #[cfg(feature = "servo")] pub mod attr; pub mod author_styles; pub mod bezier; pub mod bloom; pub mod context; pub mod counter_style; pub mod custom_properties; pub mod data; pub mod dom; pub mod dom_apis; pub mod driver; pub mod element_state; #[cfg(feature = "servo")] mod encoding_support; pub mod error_reporting; pub mod font_face; pub mod font_metrics; #[cfg(feature = "gecko")] #[allow(unsafe_code)] pub mod gecko_bindings; pub mod global_style_data; pub mod hash; pub mod invalidation; #[allow(missing_docs)] // TODO. pub mod logical_geometry; pub mod matching; #[macro_use] pub mod media_queries; pub mod parallel; pub mod parser; pub mod rule_cache; pub mod rule_collector; pub mod rule_tree; pub mod scoped_tls; pub mod selector_map; pub mod selector_parser; pub mod shared_lock; pub mod sharing; pub mod str; pub mod style_adjuster; pub mod style_resolver; pub mod stylesheet_set; pub mod stylesheets; pub mod stylist; pub mod thread_state; pub mod timer; pub mod traversal; pub mod traversal_flags; pub mod use_counters; #[macro_use] #[allow(non_camel_case_types)] pub mod values; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache as string_cache; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Atom; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Atom as Prefix; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Atom as LocalName; #[cfg(feature = "gecko")] pub use crate::gecko_string_cache::Namespace; #[cfg(feature = "servo")] pub use html5ever::LocalName; #[cfg(feature = "servo")] pub use html5ever::Namespace; #[cfg(feature = "servo")] pub use html5ever::Prefix; #[cfg(feature = "servo")] pub use servo_atoms::Atom; pub use style_traits::arc_slice::ArcSlice; pub use style_traits::owned_slice::OwnedSlice; pub use style_traits::owned_str::OwnedStr; /// The CSS properties supported by the style system. /// Generated from the properties.mako.rs template by build.rs #[macro_use] #[allow(unsafe_code)] #[deny(missing_docs)] pub mod properties { include!(concat!(env!("OUT_DIR"), "/properties.rs")); } #[cfg(feature = "gecko")] #[allow(unsafe_code)] pub mod gecko; // uses a macro from properties #[cfg(feature = "servo")] #[allow(unsafe_code)] pub mod servo; #[cfg(feature = "gecko")] #[allow(unsafe_code, missing_docs)] pub mod gecko_properties { include!(concat!(env!("OUT_DIR"), "/gecko_properties.rs")); } macro_rules! reexport_computed_values { ( $( { $name: ident, $boxed: expr } )+ ) => { /// Types for [computed values][computed]. /// /// [computed]: https://drafts.csswg.org/css-cascade/#computed pub mod computed_values { $( pub use crate::properties::longhands::$name::computed_value as $name; )+ // Don't use a side-specific name needlessly: pub use crate::properties::longhands::border_top_style::computed_value as border_style; } } } longhand_properties_idents!(reexport_computed_values); #[cfg(feature = "gecko")] use crate::gecko_string_cache::WeakAtom; #[cfg(feature = "servo")] use servo_atoms::Atom as WeakAtom; /// Extension methods for selectors::attr::CaseSensitivity pub trait CaseSensitivityExt { /// Return whether two atoms compare equal according to this case sensitivity. fn eq_atom(self, a: &WeakAtom, b: &WeakAtom) -> bool; } impl CaseSensitivityExt for selectors::attr::CaseSensitivity { fn eq_atom(self, a: &WeakAtom, b: &WeakAtom) -> bool
} /// A trait pretty much similar to num_traits::Zero, but without the need of /// implementing `Add`. pub trait Zero { /// Returns the zero value. fn zero() -> Self; /// Returns whether this value is zero. fn is_zero(&self) -> bool; } impl<T> Zero for T where T: num_traits::Zero, { fn zero() -> Self { <Self as num_traits::Zero>::zero() } fn is_zero(&self) -> bool { <Self as num_traits::Zero>::is_zero(self) } }
{ match self { selectors::attr::CaseSensitivity::CaseSensitive => a == b, selectors::attr::CaseSensitivity::AsciiCaseInsensitive => a.eq_ignore_ascii_case(b), } }
identifier_body
gated-quote.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 that `quote`-related macro are gated by `quote` feature gate. // (To sanity-check the code, uncomment this.) // #![feature(quote)] // FIXME the error message that is current emitted seems pretty bad. #![feature(rustc_private)] #![allow(dead_code, unused_imports, unused_variables)] #[macro_use] extern crate syntax; use syntax::ast; use syntax::codemap::Span; use syntax::parse; struct ParseSess; impl ParseSess { fn cfg(&self) -> ast::CrateConfig { loop { } } fn parse_sess<'a>(&'a self) -> &'a parse::ParseSess { loop { } } fn call_site(&self) -> Span { loop { } } fn ident_of(&self, st: &str) -> ast::Ident { loop { } } fn name_of(&self, st: &str) -> ast::Name { loop { } } } pub fn main()
{ let ecx = &ParseSess; let x = quote_tokens!(ecx, 3); //~ ERROR macro undefined: 'quote_tokens!' let x = quote_expr!(ecx, 3); //~ ERROR macro undefined: 'quote_expr!' let x = quote_ty!(ecx, 3); //~ ERROR macro undefined: 'quote_ty!' let x = quote_method!(ecx, 3); //~ ERROR macro undefined: 'quote_method!' let x = quote_item!(ecx, 3); //~ ERROR macro undefined: 'quote_item!' let x = quote_pat!(ecx, 3); //~ ERROR macro undefined: 'quote_pat!' let x = quote_arm!(ecx, 3); //~ ERROR macro undefined: 'quote_arm!' let x = quote_stmt!(ecx, 3); //~ ERROR macro undefined: 'quote_stmt!' let x = quote_matcher!(ecx, 3); //~ ERROR macro undefined: 'quote_matcher!' let x = quote_attr!(ecx, 3); //~ ERROR macro undefined: 'quote_attr!' }
identifier_body
gated-quote.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 that `quote`-related macro are gated by `quote` feature gate. // (To sanity-check the code, uncomment this.) // #![feature(quote)] // FIXME the error message that is current emitted seems pretty bad. #![feature(rustc_private)] #![allow(dead_code, unused_imports, unused_variables)] #[macro_use] extern crate syntax; use syntax::ast; use syntax::codemap::Span; use syntax::parse; struct ParseSess; impl ParseSess { fn cfg(&self) -> ast::CrateConfig { loop { } } fn
<'a>(&'a self) -> &'a parse::ParseSess { loop { } } fn call_site(&self) -> Span { loop { } } fn ident_of(&self, st: &str) -> ast::Ident { loop { } } fn name_of(&self, st: &str) -> ast::Name { loop { } } } pub fn main() { let ecx = &ParseSess; let x = quote_tokens!(ecx, 3); //~ ERROR macro undefined: 'quote_tokens!' let x = quote_expr!(ecx, 3); //~ ERROR macro undefined: 'quote_expr!' let x = quote_ty!(ecx, 3); //~ ERROR macro undefined: 'quote_ty!' let x = quote_method!(ecx, 3); //~ ERROR macro undefined: 'quote_method!' let x = quote_item!(ecx, 3); //~ ERROR macro undefined: 'quote_item!' let x = quote_pat!(ecx, 3); //~ ERROR macro undefined: 'quote_pat!' let x = quote_arm!(ecx, 3); //~ ERROR macro undefined: 'quote_arm!' let x = quote_stmt!(ecx, 3); //~ ERROR macro undefined: 'quote_stmt!' let x = quote_matcher!(ecx, 3); //~ ERROR macro undefined: 'quote_matcher!' let x = quote_attr!(ecx, 3); //~ ERROR macro undefined: 'quote_attr!' }
parse_sess
identifier_name
gated-quote.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 that `quote`-related macro are gated by `quote` feature gate. // (To sanity-check the code, uncomment this.) // #![feature(quote)] // FIXME the error message that is current emitted seems pretty bad. #![feature(rustc_private)]
use syntax::ast; use syntax::codemap::Span; use syntax::parse; struct ParseSess; impl ParseSess { fn cfg(&self) -> ast::CrateConfig { loop { } } fn parse_sess<'a>(&'a self) -> &'a parse::ParseSess { loop { } } fn call_site(&self) -> Span { loop { } } fn ident_of(&self, st: &str) -> ast::Ident { loop { } } fn name_of(&self, st: &str) -> ast::Name { loop { } } } pub fn main() { let ecx = &ParseSess; let x = quote_tokens!(ecx, 3); //~ ERROR macro undefined: 'quote_tokens!' let x = quote_expr!(ecx, 3); //~ ERROR macro undefined: 'quote_expr!' let x = quote_ty!(ecx, 3); //~ ERROR macro undefined: 'quote_ty!' let x = quote_method!(ecx, 3); //~ ERROR macro undefined: 'quote_method!' let x = quote_item!(ecx, 3); //~ ERROR macro undefined: 'quote_item!' let x = quote_pat!(ecx, 3); //~ ERROR macro undefined: 'quote_pat!' let x = quote_arm!(ecx, 3); //~ ERROR macro undefined: 'quote_arm!' let x = quote_stmt!(ecx, 3); //~ ERROR macro undefined: 'quote_stmt!' let x = quote_matcher!(ecx, 3); //~ ERROR macro undefined: 'quote_matcher!' let x = quote_attr!(ecx, 3); //~ ERROR macro undefined: 'quote_attr!' }
#![allow(dead_code, unused_imports, unused_variables)] #[macro_use] extern crate syntax;
random_line_split
lib.rs
// Copyright 2017 James Duley // // 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. #![feature(proc_macro)] extern crate proc_macro; extern crate syn; #[macro_use] extern crate quote; use proc_macro::TokenStream; use std::str::FromStr; use syn::{parse_token_trees, Token, TokenTree, Lit, DelimToken, StrStyle}; #[proc_macro] pub fn gcc_asm(token_stream: TokenStream) -> TokenStream { let tokens = token_stream.to_string(); let token_trees = parse_token_trees(&tokens).unwrap(); let mut parts = split_on_token(token_trees.as_slice(), &Token::Colon); let template = parts .next() .expect("error: template missing") .iter() .map(get_string_literal) // support C-style string literal concatenation .fold(String::new(), |acc, ref x| acc + &*x); let output_operands = parts.next().unwrap_or(&[]); let input_operands = parts.next().unwrap_or(&[]); let clobbers = parts.next().unwrap_or(&[]); assert!( clobbers.len() == 0usize, "error: clobbers not supported yet" ); assert!(parts.next().is_none(), "error: extra tokens after clobbers"); let mut symbolic_names = Vec::new(); let (new_output_operands, tied_input_operands) = split_on_token(output_operands, &Token::Comma) .map(|tts| extract_symbolic_name(&mut symbolic_names, tts)) .enumerate() .map(extract_tied_operands) .fold((Vec::new(), Vec::new()), |mut acc, x| { acc.0.push(x.0); if let Some(t) = x.1 { acc.1.push(t) }; acc }); let new_input_operands = split_on_token(input_operands, &Token::Comma) .map(|tts| extract_symbolic_name(&mut symbolic_names, tts)) .collect::<Vec<_>>(); let new_template = replace_template(template, symbolic_names.as_slice()); let all_new_input_operands = new_input_operands.iter().chain(tied_input_operands.iter()); let is_volatile = new_output_operands.len() == 0; let mut options = Vec::new(); if is_volatile { options.push("volatile"); } // println!( // "out: {:?}\nin: {:?}\ntied: {:?}", // new_output_operands, // new_input_operands, // tied_input_operands // ); let new_tokens = quote! { asm!( #new_template : #(#(#new_output_operands)*),* : #(#(#all_new_input_operands)*),* : : #(#options),* ) }; // println!("{}", new_tokens); TokenStream::from_str(new_tokens.as_str()).unwrap() } fn split_on_token<'a>( token_trees: &'a [TokenTree], separator: &'a Token, ) -> Box<Iterator<Item = &'a [TokenTree]> + 'a> { if token_trees.is_empty() { Box::new(std::iter::empty()) } else { Box::new(token_trees.split(move |tt| match *tt { TokenTree::Token(ref token) => token == separator, _ => false, })) } } fn replace_template(template: String, symbolic_names: &[Option<String>]) -> String { let with_dollars = template.replace("$", "\u{80}").replace("%", "$").replace( "$$", "%", ); symbolic_names .iter() .enumerate() .fold(with_dollars, |acc, ref number_and_name| { if let Some(ref x) = *number_and_name.1 { acc.replace( &("$[".to_string() + &x + "]"), &("$".to_string() + &number_and_name.0.to_string()), ) } else { acc } }) .replace("$=", "${:uid}") .replace("\u{80}", "$$") } fn extract_symbolic_name( ordered_list: &mut Vec<Option<String>>, tts: &[TokenTree], ) -> Vec<TokenTree>
without_name } fn extract_tied_operands( pos_and_tts: (usize, Vec<TokenTree>), ) -> (Vec<TokenTree>, Option<Vec<TokenTree>>) { { let constraint = get_string_literal(pos_and_tts.1.first().expect("error: empty operand")); if constraint.starts_with("+") { let lvalue = pos_and_tts.1.split_at(1).1; let new_input_constraint = pos_and_tts.0.to_string(); let mut input = Vec::new(); input.push(make_string_literal(new_input_constraint)); input.extend_from_slice(lvalue); let new_output_constraint = constraint.replace("+", "="); let mut output = Vec::new(); output.push(make_string_literal(new_output_constraint)); output.extend_from_slice(lvalue); return (output, Some(input)); } } (pos_and_tts.1, None) } fn get_string_literal(tt: &TokenTree) -> &String { match *tt { TokenTree::Token(Token::Literal(Lit::Str(ref string, _))) => string, _ => { panic!(format!( "error: expected a string literal but found {:?}", tt )) } } } fn make_string_literal(string: String) -> TokenTree { TokenTree::Token(Token::Literal(Lit::Str(string, StrStyle::Cooked))) }
{ let name_and_remaining = match *tts.first().expect("error: empty operand") { TokenTree::Delimited(ref d) => { assert!(d.delim == DelimToken::Bracket, "error: bad operand"); let name = if d.tts.len() == 1usize { match d.tts[0] { TokenTree::Token(Token::Ident(ref name)) => Some(name.to_string()), _ => None, } } else { None }; assert!(name.is_some(), "error: bad symbolic name"); (name, tts.split_at(1).1) } _ => (None, tts), }; ordered_list.push(name_and_remaining.0); let mut without_name = Vec::new(); without_name.extend_from_slice(name_and_remaining.1);
identifier_body
lib.rs
// Copyright 2017 James Duley // // 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. #![feature(proc_macro)] extern crate proc_macro; extern crate syn;
use syn::{parse_token_trees, Token, TokenTree, Lit, DelimToken, StrStyle}; #[proc_macro] pub fn gcc_asm(token_stream: TokenStream) -> TokenStream { let tokens = token_stream.to_string(); let token_trees = parse_token_trees(&tokens).unwrap(); let mut parts = split_on_token(token_trees.as_slice(), &Token::Colon); let template = parts .next() .expect("error: template missing") .iter() .map(get_string_literal) // support C-style string literal concatenation .fold(String::new(), |acc, ref x| acc + &*x); let output_operands = parts.next().unwrap_or(&[]); let input_operands = parts.next().unwrap_or(&[]); let clobbers = parts.next().unwrap_or(&[]); assert!( clobbers.len() == 0usize, "error: clobbers not supported yet" ); assert!(parts.next().is_none(), "error: extra tokens after clobbers"); let mut symbolic_names = Vec::new(); let (new_output_operands, tied_input_operands) = split_on_token(output_operands, &Token::Comma) .map(|tts| extract_symbolic_name(&mut symbolic_names, tts)) .enumerate() .map(extract_tied_operands) .fold((Vec::new(), Vec::new()), |mut acc, x| { acc.0.push(x.0); if let Some(t) = x.1 { acc.1.push(t) }; acc }); let new_input_operands = split_on_token(input_operands, &Token::Comma) .map(|tts| extract_symbolic_name(&mut symbolic_names, tts)) .collect::<Vec<_>>(); let new_template = replace_template(template, symbolic_names.as_slice()); let all_new_input_operands = new_input_operands.iter().chain(tied_input_operands.iter()); let is_volatile = new_output_operands.len() == 0; let mut options = Vec::new(); if is_volatile { options.push("volatile"); } // println!( // "out: {:?}\nin: {:?}\ntied: {:?}", // new_output_operands, // new_input_operands, // tied_input_operands // ); let new_tokens = quote! { asm!( #new_template : #(#(#new_output_operands)*),* : #(#(#all_new_input_operands)*),* : : #(#options),* ) }; // println!("{}", new_tokens); TokenStream::from_str(new_tokens.as_str()).unwrap() } fn split_on_token<'a>( token_trees: &'a [TokenTree], separator: &'a Token, ) -> Box<Iterator<Item = &'a [TokenTree]> + 'a> { if token_trees.is_empty() { Box::new(std::iter::empty()) } else { Box::new(token_trees.split(move |tt| match *tt { TokenTree::Token(ref token) => token == separator, _ => false, })) } } fn replace_template(template: String, symbolic_names: &[Option<String>]) -> String { let with_dollars = template.replace("$", "\u{80}").replace("%", "$").replace( "$$", "%", ); symbolic_names .iter() .enumerate() .fold(with_dollars, |acc, ref number_and_name| { if let Some(ref x) = *number_and_name.1 { acc.replace( &("$[".to_string() + &x + "]"), &("$".to_string() + &number_and_name.0.to_string()), ) } else { acc } }) .replace("$=", "${:uid}") .replace("\u{80}", "$$") } fn extract_symbolic_name( ordered_list: &mut Vec<Option<String>>, tts: &[TokenTree], ) -> Vec<TokenTree> { let name_and_remaining = match *tts.first().expect("error: empty operand") { TokenTree::Delimited(ref d) => { assert!(d.delim == DelimToken::Bracket, "error: bad operand"); let name = if d.tts.len() == 1usize { match d.tts[0] { TokenTree::Token(Token::Ident(ref name)) => Some(name.to_string()), _ => None, } } else { None }; assert!(name.is_some(), "error: bad symbolic name"); (name, tts.split_at(1).1) } _ => (None, tts), }; ordered_list.push(name_and_remaining.0); let mut without_name = Vec::new(); without_name.extend_from_slice(name_and_remaining.1); without_name } fn extract_tied_operands( pos_and_tts: (usize, Vec<TokenTree>), ) -> (Vec<TokenTree>, Option<Vec<TokenTree>>) { { let constraint = get_string_literal(pos_and_tts.1.first().expect("error: empty operand")); if constraint.starts_with("+") { let lvalue = pos_and_tts.1.split_at(1).1; let new_input_constraint = pos_and_tts.0.to_string(); let mut input = Vec::new(); input.push(make_string_literal(new_input_constraint)); input.extend_from_slice(lvalue); let new_output_constraint = constraint.replace("+", "="); let mut output = Vec::new(); output.push(make_string_literal(new_output_constraint)); output.extend_from_slice(lvalue); return (output, Some(input)); } } (pos_and_tts.1, None) } fn get_string_literal(tt: &TokenTree) -> &String { match *tt { TokenTree::Token(Token::Literal(Lit::Str(ref string, _))) => string, _ => { panic!(format!( "error: expected a string literal but found {:?}", tt )) } } } fn make_string_literal(string: String) -> TokenTree { TokenTree::Token(Token::Literal(Lit::Str(string, StrStyle::Cooked))) }
#[macro_use] extern crate quote; use proc_macro::TokenStream; use std::str::FromStr;
random_line_split
lib.rs
// Copyright 2017 James Duley // // 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. #![feature(proc_macro)] extern crate proc_macro; extern crate syn; #[macro_use] extern crate quote; use proc_macro::TokenStream; use std::str::FromStr; use syn::{parse_token_trees, Token, TokenTree, Lit, DelimToken, StrStyle}; #[proc_macro] pub fn
(token_stream: TokenStream) -> TokenStream { let tokens = token_stream.to_string(); let token_trees = parse_token_trees(&tokens).unwrap(); let mut parts = split_on_token(token_trees.as_slice(), &Token::Colon); let template = parts .next() .expect("error: template missing") .iter() .map(get_string_literal) // support C-style string literal concatenation .fold(String::new(), |acc, ref x| acc + &*x); let output_operands = parts.next().unwrap_or(&[]); let input_operands = parts.next().unwrap_or(&[]); let clobbers = parts.next().unwrap_or(&[]); assert!( clobbers.len() == 0usize, "error: clobbers not supported yet" ); assert!(parts.next().is_none(), "error: extra tokens after clobbers"); let mut symbolic_names = Vec::new(); let (new_output_operands, tied_input_operands) = split_on_token(output_operands, &Token::Comma) .map(|tts| extract_symbolic_name(&mut symbolic_names, tts)) .enumerate() .map(extract_tied_operands) .fold((Vec::new(), Vec::new()), |mut acc, x| { acc.0.push(x.0); if let Some(t) = x.1 { acc.1.push(t) }; acc }); let new_input_operands = split_on_token(input_operands, &Token::Comma) .map(|tts| extract_symbolic_name(&mut symbolic_names, tts)) .collect::<Vec<_>>(); let new_template = replace_template(template, symbolic_names.as_slice()); let all_new_input_operands = new_input_operands.iter().chain(tied_input_operands.iter()); let is_volatile = new_output_operands.len() == 0; let mut options = Vec::new(); if is_volatile { options.push("volatile"); } // println!( // "out: {:?}\nin: {:?}\ntied: {:?}", // new_output_operands, // new_input_operands, // tied_input_operands // ); let new_tokens = quote! { asm!( #new_template : #(#(#new_output_operands)*),* : #(#(#all_new_input_operands)*),* : : #(#options),* ) }; // println!("{}", new_tokens); TokenStream::from_str(new_tokens.as_str()).unwrap() } fn split_on_token<'a>( token_trees: &'a [TokenTree], separator: &'a Token, ) -> Box<Iterator<Item = &'a [TokenTree]> + 'a> { if token_trees.is_empty() { Box::new(std::iter::empty()) } else { Box::new(token_trees.split(move |tt| match *tt { TokenTree::Token(ref token) => token == separator, _ => false, })) } } fn replace_template(template: String, symbolic_names: &[Option<String>]) -> String { let with_dollars = template.replace("$", "\u{80}").replace("%", "$").replace( "$$", "%", ); symbolic_names .iter() .enumerate() .fold(with_dollars, |acc, ref number_and_name| { if let Some(ref x) = *number_and_name.1 { acc.replace( &("$[".to_string() + &x + "]"), &("$".to_string() + &number_and_name.0.to_string()), ) } else { acc } }) .replace("$=", "${:uid}") .replace("\u{80}", "$$") } fn extract_symbolic_name( ordered_list: &mut Vec<Option<String>>, tts: &[TokenTree], ) -> Vec<TokenTree> { let name_and_remaining = match *tts.first().expect("error: empty operand") { TokenTree::Delimited(ref d) => { assert!(d.delim == DelimToken::Bracket, "error: bad operand"); let name = if d.tts.len() == 1usize { match d.tts[0] { TokenTree::Token(Token::Ident(ref name)) => Some(name.to_string()), _ => None, } } else { None }; assert!(name.is_some(), "error: bad symbolic name"); (name, tts.split_at(1).1) } _ => (None, tts), }; ordered_list.push(name_and_remaining.0); let mut without_name = Vec::new(); without_name.extend_from_slice(name_and_remaining.1); without_name } fn extract_tied_operands( pos_and_tts: (usize, Vec<TokenTree>), ) -> (Vec<TokenTree>, Option<Vec<TokenTree>>) { { let constraint = get_string_literal(pos_and_tts.1.first().expect("error: empty operand")); if constraint.starts_with("+") { let lvalue = pos_and_tts.1.split_at(1).1; let new_input_constraint = pos_and_tts.0.to_string(); let mut input = Vec::new(); input.push(make_string_literal(new_input_constraint)); input.extend_from_slice(lvalue); let new_output_constraint = constraint.replace("+", "="); let mut output = Vec::new(); output.push(make_string_literal(new_output_constraint)); output.extend_from_slice(lvalue); return (output, Some(input)); } } (pos_and_tts.1, None) } fn get_string_literal(tt: &TokenTree) -> &String { match *tt { TokenTree::Token(Token::Literal(Lit::Str(ref string, _))) => string, _ => { panic!(format!( "error: expected a string literal but found {:?}", tt )) } } } fn make_string_literal(string: String) -> TokenTree { TokenTree::Token(Token::Literal(Lit::Str(string, StrStyle::Cooked))) }
gcc_asm
identifier_name
scan.rs
#![feature(core, unboxed_closures)] extern crate core; #[cfg(test)] mod tests { use core::iter::Iterator; use core::iter::Scan; struct A<T> { begin: T, end: T } macro_rules! Iterator_impl { ($T:ty) => { impl Iterator for A<$T> { type Item = $T; fn next(&mut self) -> Option<Self::Item> { if self.begin < self.end { let result = self.begin; self.begin = self.begin.wrapping_add(1); Some::<Self::Item>(result) } else { None::<Self::Item> } } // fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> // where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>, // { // Scan{iter: self, f: f, state: initial_state} // } } } } type T = i32; Iterator_impl!(T); struct F; type B = T; type St = T; type Item = T; type Args<'a> = (&'a mut St, Item); impl<'a> FnOnce<Args<'a>> for F { type Output = Option<B>; extern "rust-call" fn call_once(self, (st, item): Args) -> Self::Output { *st += item; Some::<B>(*st) } } impl<'a> FnMut<Args<'a>> for F { extern "rust-call" fn call_mut(&mut self, (st, item): Args) -> Self::Output { *st += item; Some::<B>(*st) } } #[test] fn scan_test1() { let a: A<T> = A { begin: 0, end: 10 }; let st: St = 0; let f: F = F; let mut scan: Scan<A<T>, B, F> = a.scan::<St, B, F>(st, f); for n in 0..10 { let x: Option<B> = scan.next(); match x { Some(v) =>
None => { assert!(false); } } } assert_eq!(scan.next(), None::<B>); } }
{ assert_eq!(v, n * (n + 1) / 2); }
conditional_block
scan.rs
#![feature(core, unboxed_closures)] extern crate core; #[cfg(test)] mod tests { use core::iter::Iterator; use core::iter::Scan; struct A<T> { begin: T, end: T } macro_rules! Iterator_impl { ($T:ty) => { impl Iterator for A<$T> { type Item = $T; fn next(&mut self) -> Option<Self::Item> { if self.begin < self.end { let result = self.begin; self.begin = self.begin.wrapping_add(1); Some::<Self::Item>(result) } else { None::<Self::Item> } } // fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> // where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>, // { // Scan{iter: self, f: f, state: initial_state} // } } } } type T = i32; Iterator_impl!(T); struct F; type B = T; type St = T; type Item = T; type Args<'a> = (&'a mut St, Item); impl<'a> FnOnce<Args<'a>> for F { type Output = Option<B>; extern "rust-call" fn call_once(self, (st, item): Args) -> Self::Output { *st += item; Some::<B>(*st) } } impl<'a> FnMut<Args<'a>> for F { extern "rust-call" fn
(&mut self, (st, item): Args) -> Self::Output { *st += item; Some::<B>(*st) } } #[test] fn scan_test1() { let a: A<T> = A { begin: 0, end: 10 }; let st: St = 0; let f: F = F; let mut scan: Scan<A<T>, B, F> = a.scan::<St, B, F>(st, f); for n in 0..10 { let x: Option<B> = scan.next(); match x { Some(v) => { assert_eq!(v, n * (n + 1) / 2); } None => { assert!(false); } } } assert_eq!(scan.next(), None::<B>); } }
call_mut
identifier_name
scan.rs
#![feature(core, unboxed_closures)] extern crate core; #[cfg(test)] mod tests { use core::iter::Iterator; use core::iter::Scan; struct A<T> { begin: T, end: T } macro_rules! Iterator_impl { ($T:ty) => { impl Iterator for A<$T> { type Item = $T; fn next(&mut self) -> Option<Self::Item> { if self.begin < self.end { let result = self.begin; self.begin = self.begin.wrapping_add(1); Some::<Self::Item>(result) } else { None::<Self::Item> } } // fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> // where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>, // { // Scan{iter: self, f: f, state: initial_state} // } } } } type T = i32; Iterator_impl!(T); struct F; type B = T; type St = T; type Item = T; type Args<'a> = (&'a mut St, Item); impl<'a> FnOnce<Args<'a>> for F { type Output = Option<B>; extern "rust-call" fn call_once(self, (st, item): Args) -> Self::Output { *st += item; Some::<B>(*st) } } impl<'a> FnMut<Args<'a>> for F { extern "rust-call" fn call_mut(&mut self, (st, item): Args) -> Self::Output { *st += item;
Some::<B>(*st) } } #[test] fn scan_test1() { let a: A<T> = A { begin: 0, end: 10 }; let st: St = 0; let f: F = F; let mut scan: Scan<A<T>, B, F> = a.scan::<St, B, F>(st, f); for n in 0..10 { let x: Option<B> = scan.next(); match x { Some(v) => { assert_eq!(v, n * (n + 1) / 2); } None => { assert!(false); } } } assert_eq!(scan.next(), None::<B>); } }
random_line_split
acquire_pessimistic_lock.rs
// Copyright 2020 TiKV Project Authors. Licensed under Apache-2.0. use kvproto::kvrpcpb::{ExtraOp, LockInfo}; use txn_types::{Key, OldValues, TimeStamp, TxnExtra}; use crate::storage::kv::WriteData; use crate::storage::lock_manager::{LockManager, WaitTimeout}; use crate::storage::mvcc::{ Error as MvccError, ErrorInner as MvccErrorInner, MvccTxn, SnapshotReader, }; use crate::storage::txn::commands::{ Command, CommandExt, ResponsePolicy, TypedCommand, WriteCommand, WriteContext, WriteResult, WriteResultLockInfo, }; use crate::storage::txn::{acquire_pessimistic_lock, Error, ErrorInner, Result}; use crate::storage::{ Error as StorageError, ErrorInner as StorageErrorInner, PessimisticLockRes, ProcessResult, Result as StorageResult, Snapshot, }; command! { /// Acquire a Pessimistic lock on the keys. /// /// This can be rolled back with a [`PessimisticRollback`](Command::PessimisticRollback) command. AcquirePessimisticLock: cmd_ty => StorageResult<PessimisticLockRes>, display => "kv::command::acquirepessimisticlock keys({}) @ {} {} | {:?}", (keys.len, start_ts, for_update_ts, ctx), content => { /// The set of keys to lock. keys: Vec<(Key, bool)>, /// The primary lock. Secondary locks (from `keys`) will refer to the primary lock. primary: Vec<u8>, /// The transaction timestamp. start_ts: TimeStamp, lock_ttl: u64, is_first_lock: bool, for_update_ts: TimeStamp, /// Time to wait for lock released in milliseconds when encountering locks. wait_timeout: Option<WaitTimeout>, /// If it is true, TiKV will return values of the keys if no error, so TiDB can cache the values for /// later read in the same transaction. return_values: bool, min_commit_ts: TimeStamp, old_values: OldValues, } } impl CommandExt for AcquirePessimisticLock { ctx!(); tag!(acquire_pessimistic_lock); ts!(start_ts); command_method!(can_be_pipelined, bool, true); fn write_bytes(&self) -> usize { self.keys .iter() .map(|(key, _)| key.as_encoded().len()) .sum() } gen_lock!(keys: multiple(|x| &x.0)); } fn extract_lock_info_from_result<T>(res: &StorageResult<T>) -> &LockInfo { match res { Err(StorageError(box StorageErrorInner::Txn(Error(box ErrorInner::Mvcc(MvccError( box MvccErrorInner::KeyIsLocked(info), )))))) => info, _ => panic!("unexpected mvcc error"), } } impl<S: Snapshot, L: LockManager> WriteCommand<S, L> for AcquirePessimisticLock { fn process_write(mut self, snapshot: S, context: WriteContext<'_, L>) -> Result<WriteResult> { let (start_ts, ctx, keys) = (self.start_ts, self.ctx, self.keys); let mut txn = MvccTxn::new(start_ts, context.concurrency_manager); let mut reader = SnapshotReader::new(start_ts, snapshot,!ctx.get_not_fill_cache()); let rows = keys.len(); let mut res = if self.return_values { Ok(PessimisticLockRes::Values(vec![])) } else { Ok(PessimisticLockRes::Empty) }; let need_old_value = context.extra_op == ExtraOp::ReadOldValue; for (k, should_not_exist) in keys { match acquire_pessimistic_lock( &mut txn, &mut reader, k.clone(), &self.primary, should_not_exist, self.lock_ttl, self.for_update_ts, self.return_values, self.min_commit_ts, need_old_value, ) { Ok((val, old_value)) => { if self.return_values { res.as_mut().unwrap().push(val); } if old_value.valid() { let key = k.append_ts(txn.start_ts); // MutationType is unknown in AcquirePessimisticLock stage. let mutation_type = None; self.old_values.insert(key, (old_value, mutation_type)); } } Err(e @ MvccError(box MvccErrorInner::KeyIsLocked {.. })) => { res = Err(e).map_err(Error::from).map_err(StorageError::from); break; } Err(e) => return Err(Error::from(e)), } } // Some values are read, update max_ts if let Ok(PessimisticLockRes::Values(values)) = &res { if!values.is_empty()
} context.statistics.add(&reader.take_statistics()); // no conflict let (pr, to_be_write, rows, ctx, lock_info) = if res.is_ok() { let pr = ProcessResult::PessimisticLockRes { res }; let extra = TxnExtra { old_values: self.old_values, // One pc status is unkown AcquirePessimisticLock stage. one_pc: false, }; let write_data = WriteData::new(txn.into_modifies(), extra); (pr, write_data, rows, ctx, None) } else { let lock_info_pb = extract_lock_info_from_result(&res); let lock_info = WriteResultLockInfo::from_lock_info_pb( lock_info_pb, self.is_first_lock, self.wait_timeout, ); let pr = ProcessResult::PessimisticLockRes { res }; // Wait for lock released (pr, WriteData::default(), 0, ctx, Some(lock_info)) }; Ok(WriteResult { ctx, to_be_write, rows, pr, lock_info, lock_guards: vec![], response_policy: ResponsePolicy::OnProposed, }) } } #[cfg(test)] mod tests { use super::*; #[test] fn test_gen_lock_info_from_result() { let raw_key = b"key".to_vec(); let key = Key::from_raw(&raw_key); let ts = 100; let is_first_lock = true; let wait_timeout = WaitTimeout::from_encoded(200); let mut info = LockInfo::default(); info.set_key(raw_key.clone()); info.set_lock_version(ts); info.set_lock_ttl(100); let case = StorageError::from(StorageErrorInner::Txn(Error::from(ErrorInner::Mvcc( MvccError::from(MvccErrorInner::KeyIsLocked(info)), )))); let lock_info = WriteResultLockInfo::from_lock_info_pb( extract_lock_info_from_result::<()>(&Err(case)), is_first_lock, wait_timeout, ); assert_eq!(lock_info.lock.ts, ts.into()); assert_eq!(lock_info.lock.hash, key.gen_hash()); assert_eq!(lock_info.key, raw_key); assert_eq!(lock_info.is_first_lock, is_first_lock); assert_eq!(lock_info.wait_timeout, wait_timeout); } }
{ txn.concurrency_manager.update_max_ts(self.for_update_ts); }
conditional_block
acquire_pessimistic_lock.rs
// Copyright 2020 TiKV Project Authors. Licensed under Apache-2.0. use kvproto::kvrpcpb::{ExtraOp, LockInfo}; use txn_types::{Key, OldValues, TimeStamp, TxnExtra}; use crate::storage::kv::WriteData; use crate::storage::lock_manager::{LockManager, WaitTimeout}; use crate::storage::mvcc::{ Error as MvccError, ErrorInner as MvccErrorInner, MvccTxn, SnapshotReader, }; use crate::storage::txn::commands::{ Command, CommandExt, ResponsePolicy, TypedCommand, WriteCommand, WriteContext, WriteResult, WriteResultLockInfo, }; use crate::storage::txn::{acquire_pessimistic_lock, Error, ErrorInner, Result}; use crate::storage::{ Error as StorageError, ErrorInner as StorageErrorInner, PessimisticLockRes, ProcessResult, Result as StorageResult, Snapshot, }; command! { /// Acquire a Pessimistic lock on the keys. /// /// This can be rolled back with a [`PessimisticRollback`](Command::PessimisticRollback) command. AcquirePessimisticLock: cmd_ty => StorageResult<PessimisticLockRes>, display => "kv::command::acquirepessimisticlock keys({}) @ {} {} | {:?}", (keys.len, start_ts, for_update_ts, ctx), content => { /// The set of keys to lock. keys: Vec<(Key, bool)>, /// The primary lock. Secondary locks (from `keys`) will refer to the primary lock. primary: Vec<u8>, /// The transaction timestamp. start_ts: TimeStamp, lock_ttl: u64, is_first_lock: bool, for_update_ts: TimeStamp, /// Time to wait for lock released in milliseconds when encountering locks. wait_timeout: Option<WaitTimeout>, /// If it is true, TiKV will return values of the keys if no error, so TiDB can cache the values for /// later read in the same transaction. return_values: bool, min_commit_ts: TimeStamp, old_values: OldValues, } } impl CommandExt for AcquirePessimisticLock { ctx!(); tag!(acquire_pessimistic_lock); ts!(start_ts);
fn write_bytes(&self) -> usize { self.keys .iter() .map(|(key, _)| key.as_encoded().len()) .sum() } gen_lock!(keys: multiple(|x| &x.0)); } fn extract_lock_info_from_result<T>(res: &StorageResult<T>) -> &LockInfo { match res { Err(StorageError(box StorageErrorInner::Txn(Error(box ErrorInner::Mvcc(MvccError( box MvccErrorInner::KeyIsLocked(info), )))))) => info, _ => panic!("unexpected mvcc error"), } } impl<S: Snapshot, L: LockManager> WriteCommand<S, L> for AcquirePessimisticLock { fn process_write(mut self, snapshot: S, context: WriteContext<'_, L>) -> Result<WriteResult> { let (start_ts, ctx, keys) = (self.start_ts, self.ctx, self.keys); let mut txn = MvccTxn::new(start_ts, context.concurrency_manager); let mut reader = SnapshotReader::new(start_ts, snapshot,!ctx.get_not_fill_cache()); let rows = keys.len(); let mut res = if self.return_values { Ok(PessimisticLockRes::Values(vec![])) } else { Ok(PessimisticLockRes::Empty) }; let need_old_value = context.extra_op == ExtraOp::ReadOldValue; for (k, should_not_exist) in keys { match acquire_pessimistic_lock( &mut txn, &mut reader, k.clone(), &self.primary, should_not_exist, self.lock_ttl, self.for_update_ts, self.return_values, self.min_commit_ts, need_old_value, ) { Ok((val, old_value)) => { if self.return_values { res.as_mut().unwrap().push(val); } if old_value.valid() { let key = k.append_ts(txn.start_ts); // MutationType is unknown in AcquirePessimisticLock stage. let mutation_type = None; self.old_values.insert(key, (old_value, mutation_type)); } } Err(e @ MvccError(box MvccErrorInner::KeyIsLocked {.. })) => { res = Err(e).map_err(Error::from).map_err(StorageError::from); break; } Err(e) => return Err(Error::from(e)), } } // Some values are read, update max_ts if let Ok(PessimisticLockRes::Values(values)) = &res { if!values.is_empty() { txn.concurrency_manager.update_max_ts(self.for_update_ts); } } context.statistics.add(&reader.take_statistics()); // no conflict let (pr, to_be_write, rows, ctx, lock_info) = if res.is_ok() { let pr = ProcessResult::PessimisticLockRes { res }; let extra = TxnExtra { old_values: self.old_values, // One pc status is unkown AcquirePessimisticLock stage. one_pc: false, }; let write_data = WriteData::new(txn.into_modifies(), extra); (pr, write_data, rows, ctx, None) } else { let lock_info_pb = extract_lock_info_from_result(&res); let lock_info = WriteResultLockInfo::from_lock_info_pb( lock_info_pb, self.is_first_lock, self.wait_timeout, ); let pr = ProcessResult::PessimisticLockRes { res }; // Wait for lock released (pr, WriteData::default(), 0, ctx, Some(lock_info)) }; Ok(WriteResult { ctx, to_be_write, rows, pr, lock_info, lock_guards: vec![], response_policy: ResponsePolicy::OnProposed, }) } } #[cfg(test)] mod tests { use super::*; #[test] fn test_gen_lock_info_from_result() { let raw_key = b"key".to_vec(); let key = Key::from_raw(&raw_key); let ts = 100; let is_first_lock = true; let wait_timeout = WaitTimeout::from_encoded(200); let mut info = LockInfo::default(); info.set_key(raw_key.clone()); info.set_lock_version(ts); info.set_lock_ttl(100); let case = StorageError::from(StorageErrorInner::Txn(Error::from(ErrorInner::Mvcc( MvccError::from(MvccErrorInner::KeyIsLocked(info)), )))); let lock_info = WriteResultLockInfo::from_lock_info_pb( extract_lock_info_from_result::<()>(&Err(case)), is_first_lock, wait_timeout, ); assert_eq!(lock_info.lock.ts, ts.into()); assert_eq!(lock_info.lock.hash, key.gen_hash()); assert_eq!(lock_info.key, raw_key); assert_eq!(lock_info.is_first_lock, is_first_lock); assert_eq!(lock_info.wait_timeout, wait_timeout); } }
command_method!(can_be_pipelined, bool, true);
random_line_split
acquire_pessimistic_lock.rs
// Copyright 2020 TiKV Project Authors. Licensed under Apache-2.0. use kvproto::kvrpcpb::{ExtraOp, LockInfo}; use txn_types::{Key, OldValues, TimeStamp, TxnExtra}; use crate::storage::kv::WriteData; use crate::storage::lock_manager::{LockManager, WaitTimeout}; use crate::storage::mvcc::{ Error as MvccError, ErrorInner as MvccErrorInner, MvccTxn, SnapshotReader, }; use crate::storage::txn::commands::{ Command, CommandExt, ResponsePolicy, TypedCommand, WriteCommand, WriteContext, WriteResult, WriteResultLockInfo, }; use crate::storage::txn::{acquire_pessimistic_lock, Error, ErrorInner, Result}; use crate::storage::{ Error as StorageError, ErrorInner as StorageErrorInner, PessimisticLockRes, ProcessResult, Result as StorageResult, Snapshot, }; command! { /// Acquire a Pessimistic lock on the keys. /// /// This can be rolled back with a [`PessimisticRollback`](Command::PessimisticRollback) command. AcquirePessimisticLock: cmd_ty => StorageResult<PessimisticLockRes>, display => "kv::command::acquirepessimisticlock keys({}) @ {} {} | {:?}", (keys.len, start_ts, for_update_ts, ctx), content => { /// The set of keys to lock. keys: Vec<(Key, bool)>, /// The primary lock. Secondary locks (from `keys`) will refer to the primary lock. primary: Vec<u8>, /// The transaction timestamp. start_ts: TimeStamp, lock_ttl: u64, is_first_lock: bool, for_update_ts: TimeStamp, /// Time to wait for lock released in milliseconds when encountering locks. wait_timeout: Option<WaitTimeout>, /// If it is true, TiKV will return values of the keys if no error, so TiDB can cache the values for /// later read in the same transaction. return_values: bool, min_commit_ts: TimeStamp, old_values: OldValues, } } impl CommandExt for AcquirePessimisticLock { ctx!(); tag!(acquire_pessimistic_lock); ts!(start_ts); command_method!(can_be_pipelined, bool, true); fn
(&self) -> usize { self.keys .iter() .map(|(key, _)| key.as_encoded().len()) .sum() } gen_lock!(keys: multiple(|x| &x.0)); } fn extract_lock_info_from_result<T>(res: &StorageResult<T>) -> &LockInfo { match res { Err(StorageError(box StorageErrorInner::Txn(Error(box ErrorInner::Mvcc(MvccError( box MvccErrorInner::KeyIsLocked(info), )))))) => info, _ => panic!("unexpected mvcc error"), } } impl<S: Snapshot, L: LockManager> WriteCommand<S, L> for AcquirePessimisticLock { fn process_write(mut self, snapshot: S, context: WriteContext<'_, L>) -> Result<WriteResult> { let (start_ts, ctx, keys) = (self.start_ts, self.ctx, self.keys); let mut txn = MvccTxn::new(start_ts, context.concurrency_manager); let mut reader = SnapshotReader::new(start_ts, snapshot,!ctx.get_not_fill_cache()); let rows = keys.len(); let mut res = if self.return_values { Ok(PessimisticLockRes::Values(vec![])) } else { Ok(PessimisticLockRes::Empty) }; let need_old_value = context.extra_op == ExtraOp::ReadOldValue; for (k, should_not_exist) in keys { match acquire_pessimistic_lock( &mut txn, &mut reader, k.clone(), &self.primary, should_not_exist, self.lock_ttl, self.for_update_ts, self.return_values, self.min_commit_ts, need_old_value, ) { Ok((val, old_value)) => { if self.return_values { res.as_mut().unwrap().push(val); } if old_value.valid() { let key = k.append_ts(txn.start_ts); // MutationType is unknown in AcquirePessimisticLock stage. let mutation_type = None; self.old_values.insert(key, (old_value, mutation_type)); } } Err(e @ MvccError(box MvccErrorInner::KeyIsLocked {.. })) => { res = Err(e).map_err(Error::from).map_err(StorageError::from); break; } Err(e) => return Err(Error::from(e)), } } // Some values are read, update max_ts if let Ok(PessimisticLockRes::Values(values)) = &res { if!values.is_empty() { txn.concurrency_manager.update_max_ts(self.for_update_ts); } } context.statistics.add(&reader.take_statistics()); // no conflict let (pr, to_be_write, rows, ctx, lock_info) = if res.is_ok() { let pr = ProcessResult::PessimisticLockRes { res }; let extra = TxnExtra { old_values: self.old_values, // One pc status is unkown AcquirePessimisticLock stage. one_pc: false, }; let write_data = WriteData::new(txn.into_modifies(), extra); (pr, write_data, rows, ctx, None) } else { let lock_info_pb = extract_lock_info_from_result(&res); let lock_info = WriteResultLockInfo::from_lock_info_pb( lock_info_pb, self.is_first_lock, self.wait_timeout, ); let pr = ProcessResult::PessimisticLockRes { res }; // Wait for lock released (pr, WriteData::default(), 0, ctx, Some(lock_info)) }; Ok(WriteResult { ctx, to_be_write, rows, pr, lock_info, lock_guards: vec![], response_policy: ResponsePolicy::OnProposed, }) } } #[cfg(test)] mod tests { use super::*; #[test] fn test_gen_lock_info_from_result() { let raw_key = b"key".to_vec(); let key = Key::from_raw(&raw_key); let ts = 100; let is_first_lock = true; let wait_timeout = WaitTimeout::from_encoded(200); let mut info = LockInfo::default(); info.set_key(raw_key.clone()); info.set_lock_version(ts); info.set_lock_ttl(100); let case = StorageError::from(StorageErrorInner::Txn(Error::from(ErrorInner::Mvcc( MvccError::from(MvccErrorInner::KeyIsLocked(info)), )))); let lock_info = WriteResultLockInfo::from_lock_info_pb( extract_lock_info_from_result::<()>(&Err(case)), is_first_lock, wait_timeout, ); assert_eq!(lock_info.lock.ts, ts.into()); assert_eq!(lock_info.lock.hash, key.gen_hash()); assert_eq!(lock_info.key, raw_key); assert_eq!(lock_info.is_first_lock, is_first_lock); assert_eq!(lock_info.wait_timeout, wait_timeout); } }
write_bytes
identifier_name
acquire_pessimistic_lock.rs
// Copyright 2020 TiKV Project Authors. Licensed under Apache-2.0. use kvproto::kvrpcpb::{ExtraOp, LockInfo}; use txn_types::{Key, OldValues, TimeStamp, TxnExtra}; use crate::storage::kv::WriteData; use crate::storage::lock_manager::{LockManager, WaitTimeout}; use crate::storage::mvcc::{ Error as MvccError, ErrorInner as MvccErrorInner, MvccTxn, SnapshotReader, }; use crate::storage::txn::commands::{ Command, CommandExt, ResponsePolicy, TypedCommand, WriteCommand, WriteContext, WriteResult, WriteResultLockInfo, }; use crate::storage::txn::{acquire_pessimistic_lock, Error, ErrorInner, Result}; use crate::storage::{ Error as StorageError, ErrorInner as StorageErrorInner, PessimisticLockRes, ProcessResult, Result as StorageResult, Snapshot, }; command! { /// Acquire a Pessimistic lock on the keys. /// /// This can be rolled back with a [`PessimisticRollback`](Command::PessimisticRollback) command. AcquirePessimisticLock: cmd_ty => StorageResult<PessimisticLockRes>, display => "kv::command::acquirepessimisticlock keys({}) @ {} {} | {:?}", (keys.len, start_ts, for_update_ts, ctx), content => { /// The set of keys to lock. keys: Vec<(Key, bool)>, /// The primary lock. Secondary locks (from `keys`) will refer to the primary lock. primary: Vec<u8>, /// The transaction timestamp. start_ts: TimeStamp, lock_ttl: u64, is_first_lock: bool, for_update_ts: TimeStamp, /// Time to wait for lock released in milliseconds when encountering locks. wait_timeout: Option<WaitTimeout>, /// If it is true, TiKV will return values of the keys if no error, so TiDB can cache the values for /// later read in the same transaction. return_values: bool, min_commit_ts: TimeStamp, old_values: OldValues, } } impl CommandExt for AcquirePessimisticLock { ctx!(); tag!(acquire_pessimistic_lock); ts!(start_ts); command_method!(can_be_pipelined, bool, true); fn write_bytes(&self) -> usize
gen_lock!(keys: multiple(|x| &x.0)); } fn extract_lock_info_from_result<T>(res: &StorageResult<T>) -> &LockInfo { match res { Err(StorageError(box StorageErrorInner::Txn(Error(box ErrorInner::Mvcc(MvccError( box MvccErrorInner::KeyIsLocked(info), )))))) => info, _ => panic!("unexpected mvcc error"), } } impl<S: Snapshot, L: LockManager> WriteCommand<S, L> for AcquirePessimisticLock { fn process_write(mut self, snapshot: S, context: WriteContext<'_, L>) -> Result<WriteResult> { let (start_ts, ctx, keys) = (self.start_ts, self.ctx, self.keys); let mut txn = MvccTxn::new(start_ts, context.concurrency_manager); let mut reader = SnapshotReader::new(start_ts, snapshot,!ctx.get_not_fill_cache()); let rows = keys.len(); let mut res = if self.return_values { Ok(PessimisticLockRes::Values(vec![])) } else { Ok(PessimisticLockRes::Empty) }; let need_old_value = context.extra_op == ExtraOp::ReadOldValue; for (k, should_not_exist) in keys { match acquire_pessimistic_lock( &mut txn, &mut reader, k.clone(), &self.primary, should_not_exist, self.lock_ttl, self.for_update_ts, self.return_values, self.min_commit_ts, need_old_value, ) { Ok((val, old_value)) => { if self.return_values { res.as_mut().unwrap().push(val); } if old_value.valid() { let key = k.append_ts(txn.start_ts); // MutationType is unknown in AcquirePessimisticLock stage. let mutation_type = None; self.old_values.insert(key, (old_value, mutation_type)); } } Err(e @ MvccError(box MvccErrorInner::KeyIsLocked {.. })) => { res = Err(e).map_err(Error::from).map_err(StorageError::from); break; } Err(e) => return Err(Error::from(e)), } } // Some values are read, update max_ts if let Ok(PessimisticLockRes::Values(values)) = &res { if!values.is_empty() { txn.concurrency_manager.update_max_ts(self.for_update_ts); } } context.statistics.add(&reader.take_statistics()); // no conflict let (pr, to_be_write, rows, ctx, lock_info) = if res.is_ok() { let pr = ProcessResult::PessimisticLockRes { res }; let extra = TxnExtra { old_values: self.old_values, // One pc status is unkown AcquirePessimisticLock stage. one_pc: false, }; let write_data = WriteData::new(txn.into_modifies(), extra); (pr, write_data, rows, ctx, None) } else { let lock_info_pb = extract_lock_info_from_result(&res); let lock_info = WriteResultLockInfo::from_lock_info_pb( lock_info_pb, self.is_first_lock, self.wait_timeout, ); let pr = ProcessResult::PessimisticLockRes { res }; // Wait for lock released (pr, WriteData::default(), 0, ctx, Some(lock_info)) }; Ok(WriteResult { ctx, to_be_write, rows, pr, lock_info, lock_guards: vec![], response_policy: ResponsePolicy::OnProposed, }) } } #[cfg(test)] mod tests { use super::*; #[test] fn test_gen_lock_info_from_result() { let raw_key = b"key".to_vec(); let key = Key::from_raw(&raw_key); let ts = 100; let is_first_lock = true; let wait_timeout = WaitTimeout::from_encoded(200); let mut info = LockInfo::default(); info.set_key(raw_key.clone()); info.set_lock_version(ts); info.set_lock_ttl(100); let case = StorageError::from(StorageErrorInner::Txn(Error::from(ErrorInner::Mvcc( MvccError::from(MvccErrorInner::KeyIsLocked(info)), )))); let lock_info = WriteResultLockInfo::from_lock_info_pb( extract_lock_info_from_result::<()>(&Err(case)), is_first_lock, wait_timeout, ); assert_eq!(lock_info.lock.ts, ts.into()); assert_eq!(lock_info.lock.hash, key.gen_hash()); assert_eq!(lock_info.key, raw_key); assert_eq!(lock_info.is_first_lock, is_first_lock); assert_eq!(lock_info.wait_timeout, wait_timeout); } }
{ self.keys .iter() .map(|(key, _)| key.as_encoded().len()) .sum() }
identifier_body
lib.rs
//! pokereval-rs currently contains a single way of evaluating poker hands (5,6 or 7 cards) //! to a HandRank, which is a number from 0 to 7461 inclusive, the higher the better the hand. //! Inside the modules, there are more efficient methods that don't need to convert cards //! to internal representations first. extern crate cards; extern crate holdem; mod lookups; pub mod original; //mod perfect; pub mod utils; use cards::card::{Card}; use holdem::{HandRank}; use utils::{card_to_deck_number}; /// Evalate a hand consisting of 5 cards. The cards are grouped in an array. /// This is quite inefficient, due to the arrays that need to be created. But convenient. pub fn eval_5cards(cards: &[&Card; 5]) -> HandRank { let c1 = card_to_deck_number(cards[0]); let c2 = card_to_deck_number(cards[1]); let c3 = card_to_deck_number(cards[2]); let c4 = card_to_deck_number(cards[3]); let c5 = card_to_deck_number(cards[4]); let converted_cards = [&c1, &c2, &c3, &c4, &c5]; original::eval_5cards_kev_array(&converted_cards) } /// Evalate a hand consisting of 6 cards. The cards are grouped in an array. /// This is quite inefficient, due to the arrays that need to be created. But convenient. pub fn
(cards: &[&Card; 6]) -> HandRank { let c1 = card_to_deck_number(cards[0]); let c2 = card_to_deck_number(cards[1]); let c3 = card_to_deck_number(cards[2]); let c4 = card_to_deck_number(cards[3]); let c5 = card_to_deck_number(cards[4]); let c6 = card_to_deck_number(cards[5]); let converted_cards = [&c1, &c2, &c3, &c4, &c5, &c6]; original::eval_6cards_kev_array(&converted_cards) } /// Evalate a hand consisting of 7 cards. The cards are grouped in an array. /// This is quite inefficient, due to the arrays that need to be created. But convenient. pub fn eval_7cards(cards: &[&Card; 7]) -> HandRank { let c1 = card_to_deck_number(cards[0]); let c2 = card_to_deck_number(cards[1]); let c3 = card_to_deck_number(cards[2]); let c4 = card_to_deck_number(cards[3]); let c5 = card_to_deck_number(cards[4]); let c6 = card_to_deck_number(cards[5]); let c7 = card_to_deck_number(cards[6]); let converted_cards = [&c1, &c2, &c3, &c4, &c5, &c6, &c7]; original::eval_7cards_kev_array(&converted_cards) } //TODO: this will be relevant, once the "perfect hash" method works //use cards::deck::{Deck}; //use pokereval::{original, perfect}; // two evaluation methods /* //TODO: as soon as both methods are expected to agree // this guy does not always pass #[test] fn both_evaluation_methods_agree() { let mut deck = Deck::new(); // try on 10 hands for _ in 0..10 { let c1 = deck.draw(); let c2 = deck.draw(); let c3 = deck.draw(); let c4 = deck.draw(); let c5 = deck.draw(); let rank_original = original::eval_5cards([&c1, &c2, &c3, &c4, &c5]); let rank_perfect = perfect::eval_5cards([&c1, &c2, &c3, &c4, &c5]); assert_eq!(rank_original, rank_perfect); } } */
eval_6cards
identifier_name
lib.rs
//! pokereval-rs currently contains a single way of evaluating poker hands (5,6 or 7 cards) //! to a HandRank, which is a number from 0 to 7461 inclusive, the higher the better the hand. //! Inside the modules, there are more efficient methods that don't need to convert cards //! to internal representations first. extern crate cards; extern crate holdem; mod lookups;
pub mod original; //mod perfect; pub mod utils; use cards::card::{Card}; use holdem::{HandRank}; use utils::{card_to_deck_number}; /// Evalate a hand consisting of 5 cards. The cards are grouped in an array. /// This is quite inefficient, due to the arrays that need to be created. But convenient. pub fn eval_5cards(cards: &[&Card; 5]) -> HandRank { let c1 = card_to_deck_number(cards[0]); let c2 = card_to_deck_number(cards[1]); let c3 = card_to_deck_number(cards[2]); let c4 = card_to_deck_number(cards[3]); let c5 = card_to_deck_number(cards[4]); let converted_cards = [&c1, &c2, &c3, &c4, &c5]; original::eval_5cards_kev_array(&converted_cards) } /// Evalate a hand consisting of 6 cards. The cards are grouped in an array. /// This is quite inefficient, due to the arrays that need to be created. But convenient. pub fn eval_6cards(cards: &[&Card; 6]) -> HandRank { let c1 = card_to_deck_number(cards[0]); let c2 = card_to_deck_number(cards[1]); let c3 = card_to_deck_number(cards[2]); let c4 = card_to_deck_number(cards[3]); let c5 = card_to_deck_number(cards[4]); let c6 = card_to_deck_number(cards[5]); let converted_cards = [&c1, &c2, &c3, &c4, &c5, &c6]; original::eval_6cards_kev_array(&converted_cards) } /// Evalate a hand consisting of 7 cards. The cards are grouped in an array. /// This is quite inefficient, due to the arrays that need to be created. But convenient. pub fn eval_7cards(cards: &[&Card; 7]) -> HandRank { let c1 = card_to_deck_number(cards[0]); let c2 = card_to_deck_number(cards[1]); let c3 = card_to_deck_number(cards[2]); let c4 = card_to_deck_number(cards[3]); let c5 = card_to_deck_number(cards[4]); let c6 = card_to_deck_number(cards[5]); let c7 = card_to_deck_number(cards[6]); let converted_cards = [&c1, &c2, &c3, &c4, &c5, &c6, &c7]; original::eval_7cards_kev_array(&converted_cards) } //TODO: this will be relevant, once the "perfect hash" method works //use cards::deck::{Deck}; //use pokereval::{original, perfect}; // two evaluation methods /* //TODO: as soon as both methods are expected to agree // this guy does not always pass #[test] fn both_evaluation_methods_agree() { let mut deck = Deck::new(); // try on 10 hands for _ in 0..10 { let c1 = deck.draw(); let c2 = deck.draw(); let c3 = deck.draw(); let c4 = deck.draw(); let c5 = deck.draw(); let rank_original = original::eval_5cards([&c1, &c2, &c3, &c4, &c5]); let rank_perfect = perfect::eval_5cards([&c1, &c2, &c3, &c4, &c5]); assert_eq!(rank_original, rank_perfect); } } */
random_line_split
lib.rs
//! pokereval-rs currently contains a single way of evaluating poker hands (5,6 or 7 cards) //! to a HandRank, which is a number from 0 to 7461 inclusive, the higher the better the hand. //! Inside the modules, there are more efficient methods that don't need to convert cards //! to internal representations first. extern crate cards; extern crate holdem; mod lookups; pub mod original; //mod perfect; pub mod utils; use cards::card::{Card}; use holdem::{HandRank}; use utils::{card_to_deck_number}; /// Evalate a hand consisting of 5 cards. The cards are grouped in an array. /// This is quite inefficient, due to the arrays that need to be created. But convenient. pub fn eval_5cards(cards: &[&Card; 5]) -> HandRank { let c1 = card_to_deck_number(cards[0]); let c2 = card_to_deck_number(cards[1]); let c3 = card_to_deck_number(cards[2]); let c4 = card_to_deck_number(cards[3]); let c5 = card_to_deck_number(cards[4]); let converted_cards = [&c1, &c2, &c3, &c4, &c5]; original::eval_5cards_kev_array(&converted_cards) } /// Evalate a hand consisting of 6 cards. The cards are grouped in an array. /// This is quite inefficient, due to the arrays that need to be created. But convenient. pub fn eval_6cards(cards: &[&Card; 6]) -> HandRank
/// Evalate a hand consisting of 7 cards. The cards are grouped in an array. /// This is quite inefficient, due to the arrays that need to be created. But convenient. pub fn eval_7cards(cards: &[&Card; 7]) -> HandRank { let c1 = card_to_deck_number(cards[0]); let c2 = card_to_deck_number(cards[1]); let c3 = card_to_deck_number(cards[2]); let c4 = card_to_deck_number(cards[3]); let c5 = card_to_deck_number(cards[4]); let c6 = card_to_deck_number(cards[5]); let c7 = card_to_deck_number(cards[6]); let converted_cards = [&c1, &c2, &c3, &c4, &c5, &c6, &c7]; original::eval_7cards_kev_array(&converted_cards) } //TODO: this will be relevant, once the "perfect hash" method works //use cards::deck::{Deck}; //use pokereval::{original, perfect}; // two evaluation methods /* //TODO: as soon as both methods are expected to agree // this guy does not always pass #[test] fn both_evaluation_methods_agree() { let mut deck = Deck::new(); // try on 10 hands for _ in 0..10 { let c1 = deck.draw(); let c2 = deck.draw(); let c3 = deck.draw(); let c4 = deck.draw(); let c5 = deck.draw(); let rank_original = original::eval_5cards([&c1, &c2, &c3, &c4, &c5]); let rank_perfect = perfect::eval_5cards([&c1, &c2, &c3, &c4, &c5]); assert_eq!(rank_original, rank_perfect); } } */
{ let c1 = card_to_deck_number(cards[0]); let c2 = card_to_deck_number(cards[1]); let c3 = card_to_deck_number(cards[2]); let c4 = card_to_deck_number(cards[3]); let c5 = card_to_deck_number(cards[4]); let c6 = card_to_deck_number(cards[5]); let converted_cards = [&c1, &c2, &c3, &c4, &c5, &c6]; original::eval_6cards_kev_array(&converted_cards) }
identifier_body