content
stringlengths 12
12.8k
| id
int64 0
359
|
|---|---|
fn main() -> ! {
let mut robot = init_peripherals(
stm32f446::Peripherals::take().unwrap(),
cortex_m::Peripherals::take().unwrap(),
);
init_servo(&mut robot);
let mut reader = TrameReader::new();
loop {
let b = block!(robot.pc_rx.read()).unwrap();
reader.step(b);
if let Some(trame) = reader.pop_trame() {
asm::bkpt();
}
/*
let mess = servos[0x05].stat();
for b in mess {
block!(robot.servo_tx.write(b)).unwrap();
}
robot.delay.delay_ms(70 as u16);
*/
/*
if let Ok(byte) = pc_rx.read() {
reader.step(byte);
}
if let Some(trame) = reader.pop_trame() {
if let Some(sent) = handle_trame(trame) {
let (arr, size): ([u8; 15], usize) = sent.into();
for b in arr[0..size].iter() {
block!(pc_tx.write(*b)).unwrap();
}
}
}*/
}
}
| 200
|
fn default_handler(irqn: i16) {
panic!("Unhandled exception (IRQn = {})", irqn);
}
| 201
|
pub fn number(n: i64) -> Value {
Rc::new(RefCell::new(V {
val: Value_::Number(n),
computed: true,
}))
}
| 202
|
fn init_finds_parent_project() {
let project = project("init_finds_parent_project").build();
project
.cargo_fuzz()
.current_dir(project.root().join("src"))
.arg("init")
.assert()
.success();
assert!(project.fuzz_dir().is_dir());
assert!(project.fuzz_cargo_toml().is_file());
assert!(project.fuzz_targets_dir().is_dir());
assert!(project.fuzz_target_path("fuzz_target_1").is_file());
}
| 203
|
fn build_dev() {
let project = project("build_dev").with_fuzz().build();
// Create some targets.
project
.cargo_fuzz()
.arg("add")
.arg("build_dev_a")
.assert()
.success();
project
.cargo_fuzz()
.arg("add")
.arg("build_dev_b")
.assert()
.success();
// Build to ensure that the build directory is created and
// `fuzz_build_dir()` won't panic.
project
.cargo_fuzz()
.arg("build")
.arg("--dev")
.assert()
.success();
let build_dir = project.fuzz_build_dir().join("debug");
let a_bin = build_dir.join("build_dev_a");
let b_bin = build_dir.join("build_dev_b");
// Remove the files we just built.
fs::remove_file(&a_bin).unwrap();
fs::remove_file(&b_bin).unwrap();
assert!(!a_bin.is_file());
assert!(!b_bin.is_file());
// Test that building all fuzz targets does in fact recreate the files.
project
.cargo_fuzz()
.arg("build")
.arg("--dev")
.assert()
.success();
assert!(a_bin.is_file());
assert!(b_bin.is_file());
}
| 204
|
fn main() {
if env::args().len() != 2 {
panic!("Incorrect number of arguments provided\n");
}
let input = BufReader::new(File::open(env::args().nth(1).unwrap()).unwrap());
let mut cols: Vec<BTreeMap<char, i32>> = vec![];
for line in input.lines() {
for (i, c) in line.unwrap().chars().enumerate() {
if i == cols.len() {
cols.push(BTreeMap::new());
}
*cols[i].entry(c).or_insert(0) += 1;
}
}
let mut most = String::new();
let mut least = String::new();
for c in cols {
let (m, l) = most_least_common(c);
most.push(m);
least.push(l);
}
println!("Most common message: {}", most);
println!("Least common message: {}", least);
}
| 205
|
pub fn star2(lines: &Vec<String>) -> String {
let days = initialize(lines);
let mut guard_map = HashMap::new();
for day in days {
guard_map.entry(day.guard_id)
.or_insert(vec![])
.push(day);
}
let mut max_guard_asleep_per_minute = vec![(0, None); 60];
for &guard_id in guard_map.keys() {
let mut guard_asleep_by_minute = vec![0; 60];
for day in &guard_map[&guard_id] {
for minute in 0..60 {
guard_asleep_by_minute[minute] += i32::from(!day.minutes[minute]);
}
}
for minute in 0..60 {
if max_guard_asleep_per_minute[minute].0 < guard_asleep_by_minute[minute] {
max_guard_asleep_per_minute[minute] = (guard_asleep_by_minute[minute], Some(guard_id));
}
}
}
if let Some((max_minute, (_, Some(max_guard_id)))) = max_guard_asleep_per_minute.iter().enumerate().max_by_key(|(_, (times, _))| times) {
return (max_minute as i32 * max_guard_id) .to_string();
}
panic!("No maximum found: Invalid input!");
}
| 206
|
pub fn list_dir() {
if let Ok(entries) = fs::read_dir(".") {
for entry in entries {
println!("entry:{:?}", entry);
if let Ok(entry) = entry {
println!("path:{:?}", entry.path());
println!("file_name:{:?}", entry.file_name());
println!("file_type:{:?}", entry.file_type());
}
}
}
}
| 207
|
fn is_aligned(value: usize, alignment: usize) -> bool {
(value & (alignment - 1)) == 0
}
| 208
|
pub fn test_nop() {
let buffer = fs::read("tests/programs/nop").unwrap().into();
let result = run::<u32, SparseMemory<u32>>(&buffer, &vec!["nop".into()]);
assert!(result.is_ok());
assert_eq!(result.unwrap(), 0);
}
| 209
|
pub fn parse(raw: &str) -> Option<game::Game> {
let game_raw: GameRaw = serde_json::from_str(raw).ok()?;
let even_initial_timelines = game_raw
.timelines
.iter()
.any(|tl| tl.index == -0.5 || tl.index == 0.5);
let min_timeline = game_raw.timelines
.iter()
.map(|tl| tl.index)
.min_by_key(|x| (*x) as isize)?;
let max_timeline = game_raw.timelines
.iter()
.map(|tl| tl.index)
.max_by_key(|x| (*x) as isize)?;
let timeline_width = ((-min_timeline).min(max_timeline) + 1.0).round();
let active_timelines = game_raw.timelines
.iter()
.filter(|tl| tl.index.abs() <= timeline_width);
let present = active_timelines
.map(|tl| tl.begins_at + (tl.states.len() as isize) - 1)
.min()?;
let mut res = game::Game::new(game_raw.width, game_raw.height);
res.info.present = present;
res.info.min_timeline = de_l(min_timeline, even_initial_timelines);
res.info.max_timeline = de_l(max_timeline, even_initial_timelines);
res.info.active_player = game_raw.active_player;
res.info.even_initial_timelines = even_initial_timelines;
for tl in game_raw.timelines.into_iter() {
res.timelines.insert(
de_l(tl.index, even_initial_timelines),
de_timeline(tl, even_initial_timelines),
);
}
Some(res)
}
| 210
|
fn desearlizer_client(req: &mut reqwest::Response) -> Result<Client, Error> {
let mut buffer = String::new();
match req.read_to_string(&mut buffer) {
Ok(_) => (),
Err(e) => println!("error : {}", e.to_string())
};
println!("buffer before serializaztion: {}", buffer);
let v = match serde_json::from_str::<Client>(&buffer){
Ok(v) => v,
Err(e) => return Err(e)
};
Ok(v)
}
| 211
|
pub fn retype_task(source: CAddr, target: CAddr) {
system_call(SystemCall::RetypeTask {
request: (source, target),
});
}
| 212
|
pub fn task_set_cpool(target: CAddr, cpool: CAddr) {
system_call(SystemCall::TaskSetCPool {
request: (target, cpool),
});
}
| 213
|
fn create_mesh_buffer_verts(
chunk: &Chunk,
device: &wgpu::Device,
queue: &wgpu::Queue,
) -> MeshBufferVerts {
// Calculate total length of buffer e.g. a full chunk of different voxels. This way a new buffer only has to be created when the voxel capacity is changed.
let verts = Mesh::verts(chunk);
let vert_len = verts.len();
let single_cube_verts = Mesh::cube_verts().len();
let single_cube_color_verts = (single_cube_verts / 3) * std::mem::size_of::<PaletteIndexType>(); // One PaletteIndexType per 3 verts
let max_voxels = {
let (x, y, z) = chunk.capacity();
x * y * z
};
let max_buf_size =
(single_cube_verts + single_cube_color_verts) * max_voxels * std::mem::size_of::<f32>();
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: None,
mapped_at_creation: false,
size: max_buf_size as u64,
usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
});
if vert_len > 0 {
queue.write_buffer(&buffer, 0, bytemuck::cast_slice(&verts));
}
MeshBufferVerts {
buffer,
vert_len,
max_capacity: chunk.capacity(),
}
}
| 214
|
fn part2(rules: &Vec<PasswordRule>) -> usize {
rules
.iter()
.filter(|rule| {
let first = if let Some(c) = rule.password.chars().nth(rule.min - 1) {
c == rule.letter
} else {
false
};
let second = if let Some(c) = rule.password.chars().nth(rule.max - 1) {
c == rule.letter
} else {
false
};
first ^ second
})
.count()
}
| 215
|
fn main() {
let re_top = Regex::new(r" {4}|\[([A-Z])\]").unwrap();
let re_action = Regex::new(r"move (\d+) from (\d+) to (\d+)").unwrap();
let mut stacks: Vec<Vec<char>> = Vec::new();
let mut input = io::stdin().lock().lines()
.flat_map(|l| l.ok());
for line in &mut input {
if line.trim().is_empty() { break }
for (ix, ch) in match_iter::<char>(&re_top, &line).enumerate() {
if let Some(ch) = ch {
ensure_size(&mut stacks, ix + 1);
stacks[ix].push(ch);
}
}
}
for stack in &mut stacks {
stack.reverse()
}
for line in input {
if let Some((num, src, dst)) = match_capture::<Action>(&re_action, &line) {
let (src, dst) = get_disjoint(&mut stacks, src - 1, dst - 1);
assert!(num <= src.len(), "Trying to pop {} from {}", num, src.len());
let pos = src.len() - num;
dst.extend_from_slice(&src[pos..]);
src.truncate(pos);
}
}
let letters = stacks.iter().map(|s| s.last().expect("Stack is empty"));
println!("{}", letters.collect::<String>());
}
| 216
|
fn rc_test() {
use std::rc::Rc;
let s: Rc<String> = Rc::new("shirataki".to_string());
let t: Rc<String> = s.clone();
let u: Rc<String> = s.clone();
assert!(s.contains("shira"));
assert_eq!(t.find("taki"), Some(5));
println!("{} are quite chewy, almost bouncy, but lack flavor", u);
// s.push_str(" noodles"); // error
}
| 217
|
fn ownership_test() {
let mut v = Vec::new();
for i in 101..106 {
v.push(i.to_string());
}
let fifth = v.pop().unwrap();
assert_eq!(fifth, "105");
let second = v.swap_remove(1);
assert_eq!(second, "102");
let third = std::mem::replace(&mut v[2], "substitute".to_string());
assert_eq!(third, "103");
assert_eq!(v, vec!["101", "104", "substitute"]);
struct Person {
name: Option<String>,
birth: Option<i32>,
};
let mut composers = Vec::new();
composers.push(Person {
name: Some("Palestrina".to_string()),
birth: Some(1525),
});
// let first_name = composers[0].name // error
let first_name = std::mem::replace(&mut composers[0].name, None);
assert_eq!(first_name, Some("Palestrina".to_string()));
assert_eq!(composers[0].name, None);
let birth = composers[0].birth.take();
assert_eq!(birth, Some(1525));
assert_eq!(composers[0].birth, None);
}
| 218
|
fn build_stripping_dead_code() {
let project = project("build_strip").with_fuzz().build();
// Create some targets.
project
.cargo_fuzz()
.arg("add")
.arg("build_strip_a")
.assert()
.success();
project
.cargo_fuzz()
.arg("build")
.arg("--strip-dead-code")
.arg("--dev")
.assert()
.success();
let build_dir = project.fuzz_build_dir().join("debug");
let a_bin = build_dir.join("build_strip_a");
assert!(a_bin.is_file(), "Not a file: {}", a_bin.display());
}
| 219
|
pub fn task_set_top_page_table(target: CAddr, table: CAddr) {
system_call(SystemCall::TaskSetTopPageTable {
request: (target, table),
});
}
| 220
|
fn app() -> App<
impl ServiceFactory<
ServiceRequest,
Response = ServiceResponse<impl MessageBody>,
Config = (),
InitError = (),
Error = Error,
>,
> {
App::new()
}
| 221
|
pub fn set_working_folder(working_folder: String) -> Result<(), ()> {
unsafe {
WORKING_FOLDER = working_folder;
}
Ok(())
}
| 222
|
fn set_privilege(handle: HANDLE, name: &str) -> Result<(), std::io::Error> {
let mut luid: LUID = LUID {
LowPart: 0,
HighPart: 0,
};
let name: U16CString = name.try_into().unwrap();
let r = unsafe {LookupPrivilegeValueW(std::ptr::null(),name.as_ptr(), &mut luid )};
if r == 0 {
return Err(std::io::Error::last_os_error());
}
let mut privilege = TOKEN_PRIVILEGES{
PrivilegeCount: 1,
Privileges: [LUID_AND_ATTRIBUTES {Luid: luid, Attributes: SE_PRIVILEGE_ENABLED}],
};
let r = unsafe {
AdjustTokenPrivileges(handle, false as i32, &mut privilege, std::mem::size_of::<TOKEN_PRIVILEGES>() as u32, std::ptr::null_mut(), std::ptr::null_mut())
};
if r == 0 {
return Err(std::io::Error::last_os_error());
}
Ok(())
}
| 223
|
pub fn get_home() -> Result<String, ()> {
match dirs::home_dir() {
None => Ok(String::new()),
Some(path) => Ok(path.to_str().unwrap().to_string()),
}
}
| 224
|
fn input(user_message: &str) -> io::Result<String> {
use std::io::Write;
print!("{}", user_message);
io::stdout().flush()?;
let mut buffer: String = String::new();
io::stdin().read_line(&mut buffer)?;
Ok(buffer.trim_right().to_owned())
}
| 225
|
fn get_versions(repo: &Repository) -> Result<Vec<VersionTag>, Box<dyn std::error::Error>> {
let tags = repo
.tag_names(None)?
.into_iter()
.filter_map(|v| v)
.map(|v| v.to_owned())
.collect::<Vec<_>>();
let mut versions = tags
.iter()
.filter_map(|tag| {
Version::parse(&tag)
.or_else(|_| Version::parse(&format!("{}.0", tag)))
.ok()
.map(|v| VersionTag {
name: format!("Rust {}", v),
version: v,
raw_tag: tag.clone(),
commit: repo
.revparse_single(&tag)
.unwrap()
.peel_to_commit()
.unwrap()
.id(),
in_progress: false,
})
})
.collect::<Vec<_>>();
versions.sort();
Ok(versions)
}
| 226
|
fn main() {
let mut prod_env = "".to_string();
let ws_server_thread = thread::Builder::new().name("ws_server".to_string()).spawn(move || {
println!("Starting websocket server..");
listen("127.0.0.1:3012", |out| { Server { out: out } }).unwrap()
}).unwrap();
thread::sleep(time::Duration::from_millis(1000));
match env::var("PROD_ENV".to_string()) {
Ok(val) => prod_env = val,
Err(e) => println!("Operating in dev mode due to: {}", e),
}
if prod_env != "" {
let app_router_thread = thread::Builder::new().name("app_router".to_string()).spawn(move || {
let mut app_router = Nickel::new();
println!("Starting app router..");
app_router.mount("/controller/", StaticFilesHandler::new("app/controller/"));
app_router.mount("/display/", StaticFilesHandler::new("app/display/"));
app_router.listen("127.0.0.1:6767").unwrap();
}).unwrap();
let _ = app_router_thread.join();
}
let _ = ws_server_thread.join();
println!("Server closing down..");
}
| 227
|
pub fn solve(input: &str) -> Option<Box<usize>> {
let sum_of_counts = input
.trim_end()
.split("\n\n")
.map(|group| group.chars().filter(|ch| *ch != '\n').collect::<HashSet<_>>().len())
.sum();
Some(Box::new(sum_of_counts))
}
| 228
|
fn channel_take_nonpayload(target: CAddr) -> ChannelMessage {
let result = system_call(SystemCall::ChannelTake {
request: target,
response: None
});
match result {
SystemCall::ChannelTake {
response, ..
} => {
return response.unwrap()
},
_ => panic!(),
};
}
| 229
|
async fn init() -> Result<Args> {
let mut log_on = false;
#[cfg(feature = "dev-console")]
match console_subscriber::try_init() {
Ok(_) => {
warn!("dev-console enabled");
log_on = true;
}
Err(e) => {
eprintln!("Failed to initialise tokio console, falling back to normal logging\n{e}")
}
}
if !log_on && var("RUST_LOG").is_ok() {
match tracing_subscriber::fmt::try_init() {
Ok(_) => {
warn!(RUST_LOG=%var("RUST_LOG").unwrap(), "logging configured from RUST_LOG");
log_on = true;
}
Err(e) => eprintln!("Failed to initialise logging with RUST_LOG, falling back\n{e}"),
}
}
let args = args::get_args();
let verbosity = args.verbose.unwrap_or(0);
if log_on {
warn!("ignoring logging options from args");
} else if verbosity > 0 {
let log_file = if let Some(file) = &args.log_file {
let is_dir = metadata(&file).await.map_or(false, |info| info.is_dir());
let path = if is_dir {
let filename = format!(
"watchexec.{}.log",
chrono::Utc::now().format("%Y-%m-%dT%H-%M-%SZ")
);
file.join(filename)
} else {
file.to_owned()
};
// TODO: use tracing-appender instead
Some(File::create(path).into_diagnostic()?)
} else {
None
};
let mut builder = tracing_subscriber::fmt().with_env_filter(match verbosity {
0 => unreachable!("checked by if earlier"),
1 => "warn",
2 => "info",
3 => "debug",
_ => "trace",
});
if verbosity > 2 {
use tracing_subscriber::fmt::format::FmtSpan;
builder = builder.with_span_events(FmtSpan::NEW | FmtSpan::CLOSE);
}
match if let Some(writer) = log_file {
builder.json().with_writer(Mutex::new(writer)).try_init()
} else if verbosity > 3 {
builder.pretty().try_init()
} else {
builder.try_init()
} {
Ok(_) => info!("logging initialised"),
Err(e) => eprintln!("Failed to initialise logging, continuing with none\n{e}"),
}
}
Ok(args)
}
| 230
|
pub fn get_driver(url: &str) -> MigrateResult<Box<Driver>> {
// Mysql driver does not allow to connect using a url so we need to parse it
let mut parser = UrlParser::new();
parser.scheme_type_mapper(db_scheme_type_mapper);
let parsed = parser.parse(url).unwrap();
match parsed.scheme.as_ref() {
"postgres" => postgres::Postgres::new(url).map(|d| Box::new(d) as Box<Driver>),
"mysql" => mysql::Mysql::new(parsed).map(|d| Box::new(d) as Box<Driver>),
_ => Err(invalid_url(url))
}
}
| 231
|
fn main() {
let mut build = cc::Build::new();
build.include("Vulkan-Headers/include");
build.include("VulkanMemoryAllocator/include");
build.file("vma.cpp");
let target = env::var("TARGET").unwrap();
if target.contains("darwin") {
build
.flag("-std=c++17")
.flag("-Wno-missing-field-initializers")
.flag("-Wno-unused-variable")
.flag("-Wno-unused-parameter")
.flag("-Wno-unused-private-field")
.flag("-Wno-reorder")
.flag("-Wno-nullability-completeness")
.cpp_link_stdlib("c++")
.cpp_set_stdlib("c++")
.cpp(true);
} else if target.contains("ios") {
build
.flag("-std=c++17")
.flag("-Wno-missing-field-initializers")
.flag("-Wno-unused-variable")
.flag("-Wno-unused-parameter")
.flag("-Wno-unused-private-field")
.flag("-Wno-reorder")
.cpp_link_stdlib("c++")
.cpp_set_stdlib("c++")
.cpp(true);
} else if target.contains("android") {
build
.flag("-std=c++17")
.flag("-Wno-missing-field-initializers")
.flag("-Wno-unused-variable")
.flag("-Wno-unused-parameter")
.flag("-Wno-unused-private-field")
.flag("-Wno-nullability-completeness")
.flag("-Wno-reorder")
.cpp_link_stdlib("c++")
.cpp(true);
} else if target.contains("linux") {
build
.flag("-std=c++17")
.flag("-Wno-missing-field-initializers")
.flag("-Wno-unused-variable")
.flag("-Wno-unused-parameter")
.flag("-Wno-unused-private-field")
.flag("-Wno-reorder")
.flag("-Wno-implicit-fallthrough")
.flag("-Wno-parentheses")
.cpp_link_stdlib("stdc++")
.cpp(true);
} else if target.contains("windows") && target.contains("gnu") {
build
.flag("-std=c++17")
.flag("-Wno-missing-field-initializers")
.flag("-Wno-unused-variable")
.flag("-Wno-unused-parameter")
.flag("-Wno-unused-private-field")
.flag("-Wno-reorder")
.flag("-Wno-type-limits")
.cpp_link_stdlib("stdc++")
.cpp(true);
}
build.compile("vma_cpp");
let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
generate_bindings(&out_path.join("bindings.rs"));
}
| 232
|
fn parse_file(file_name: &str) -> Vec<Instruction> {
let f = File::open(file_name).expect("Could not open the specified file.");
let reader = BufReader::new(f);
reader
.lines()
.map(|lr| lr.expect("Could not read a line."))
.map(|l| parse_instruction(&l))
.collect()
}
| 233
|
fn list_migration_directories_with_an_empty_migrations_folder_works(api: TestApi) {
let migrations_directory = api.create_migrations_directory();
api.list_migration_directories(&migrations_directory)
.send()
.assert_listed_directories(&[]);
}
| 234
|
fn print_expression(prefix: &str, exp: &IRExpression) {
let next_prefix = format!("{} ", prefix);
match exp {
&IRExpression::Value(ref value) => {
println!("{}Value: '{:?}'", prefix, value);
}
&IRExpression::Variable(ref name) => {
println!("{}Variable: '{:?}'", prefix, name);
}
&IRExpression::Operation(ref op, ref exps) => {
println!("{}Operation-'{:?}':", prefix, op);
for exp in exps {
print_expression(&next_prefix, exp);
}
}
&IRExpression::Call(ref name, ref exp) => {
println!("{}Call-'{}':", prefix, name);
for tmp in exp {
print_expression(&next_prefix, tmp);
}
}
&IRExpression::Noop => {
println!("{}Noop", prefix);
}
};
}
| 235
|
pub fn write_file(path: PathBuf, content: String) -> Result<(), String> {
fs::write(path, content).map_err(|e| e.to_string())
}
| 236
|
pub(crate) fn run(args: &ArgMatches) -> AppResult<()> {
let tap_info = create_tap()?;
let data_sock = create_data_sock()?;
let is_auto = args.is_present("auto");
// init peers from args
let init_peers = match args.value_of("peers") {
Some(peers_str) => parse_peers_str(peers_str)?,
None => Vec::new(),
};
let state = Arc::new(AppState {
name: env::var("HOSTNAME")
.or_else(|_| env::var("HOST"))
.unwrap_or("peer-01".to_owned()),
data_sock,
tap_dev: tap_info.tap_dev,
hw_addr: tap_info.hw_addr,
peers: RwLock::new(init_peers),
});
// heartbeats thread
{
let state = state.clone();
heartbeats_thread(state);
}
// discovery thread
if is_auto {
let state = state.clone();
discovery_thread(state);
}
// control thread
{
let state = state.clone();
control_thread(state);
}
// init peers hw addr
{
let state = state.clone();
let is_empty = { state.peers.read().unwrap().is_empty() };
if !is_empty {
init_peers_hw_addr(state);
}
}
// dispatch from peers
{
let state = state.clone();
std::thread::spawn(move || dispatch_from_peers(state));
}
let mut buff = vec![0; 1500];
let dispatch_routine = DispatchRoutine(state.clone());
loop {
let mut tap_dev = &state.tap_dev;
let size = tap_dev.read(&mut buff);
if size.is_err() {
continue;
}
let mut dst_mac = [0; 6];
dst_mac.copy_from_slice(&buff[0..6]);
let mut src_mac = [0; 6];
src_mac.copy_from_slice(&buff[6..12]);
let mut proto_type = [0; 2];
proto_type.copy_from_slice(&buff[12..14]);
let eth = EthV2 {
dst_mac,
src_mac,
proto_type: u16::from_be_bytes(proto_type),
data: &buff,
};
let result = dispatch_routine.dispatch_to_peers(eth);
match result {
Err(e) => error!("error dispatch to peers, {:?}", e),
_ => {}
}
}
}
| 237
|
fn broker(table: &mut Table, ntransfers: u32) {
let mut rng = thread_rng();
let mut ract = Range::new(0, 100);
let mut ramt = Range::new(0, 1000);
let mut nstale = 0;
for _ in 0..ntransfers {
let a1 = ract.sample(&mut rng);
let mut a2 = ract.sample(&mut rng);
while a2 == a1 {
a2 = ract.sample(&mut rng);
}
let n = ramt.sample(&mut rng);
let rt = table.time();
let mut vs = [Value::default(); 2];
table.read(rt, &[a1, a2], &mut vs);
let r1 = Row { k: a1, v: vs[0].v - n };
let r2 = Row { k: a2, v: vs[1].v + n };
match table.write(rt, &[r1, r2]) {
WriteResult::Stale { .. } => nstale += 1,
_ => ()
}
}
assert!(nstale < ntransfers / 2);
}
| 238
|
fn mailmap_from_repo(repo: &git2::Repository) -> Result<Mailmap, Box<dyn std::error::Error>> {
let file = String::from_utf8(
repo.revparse_single("master")?
.peel_to_commit()?
.tree()?
.get_name(".mailmap")
.unwrap()
.to_object(&repo)?
.peel_to_blob()?
.content()
.into(),
)?;
Mailmap::from_string(file)
}
| 239
|
fn build_serverprefix(s: ~str) -> Result<IRCToken, ~str> {
Ok(PrefixT(Prefix {nick: s, user: ~"", host: ~""}))
}
| 240
|
pub fn pretty_print(ir: &std::collections::HashMap<String, IRFunction>) {
for (_, func) in ir {
println!("Function-'{}':", func.name);
println!(" Arguments:");
for param in func.parameters.iter() {
println!(" {}: {:?}", param.name, param.param_type);
}
for statement in func.statements.iter() {
println!(" Statement:");
print_nodes(" ", statement);
}
}
}
| 241
|
pub fn acrn_is_file(path: &str) -> bool {
fs::metadata(path)
.map(|metadata| metadata.is_file())
.unwrap_or(false)
}
| 242
|
async fn main() -> tide::Result<()> {
let contents = get_config("~/data/british-english").await?;
let mut app = tide::new();
app.at("/orders/shoes").post(order_shoes);
app.listen("127.0.0.1:8080").await?;
Ok(())
}
| 243
|
fn main() {
// let name = String::from("rust");
let mut client = Client::new();
// now loop forever getting tasks every now and then
let duration = (&client.interval * 1000.0) as u64;
let sleep_duration = time::Duration::from_millis(duration);
let (channel_out, channel_in) = unbounded();
// sleep for duration given by server, every interval wake up and ask for new tasks
loop {
thread::sleep(sleep_duration);
// get new tasks from the server
// need to return success/failure so we know if we should send something into the thread or not
client.get_task();
// fuck me
let mut c = client.clone();
let out_c = channel_out.clone();
// spawn a thread to deal with the new tasks
let thread_hndl = thread::spawn(move || {
handle_task(&mut c, out_c);
});
if let Ok(resp_from_thread) = channel_in.try_recv() {
println!("yayyy from main {}", &resp_from_thread);
// need to send resp to server, and remvoe task from the queue
let resp_task_id = resp_from_thread.parse::<i32>().unwrap();
client.task_queue.retain(|x| x.task_id != resp_task_id);
}
}
}
| 244
|
fn run_no_crash() {
let project = project("run_no_crash")
.with_fuzz()
.fuzz_target(
"no_crash",
r#"
#![no_main]
use libfuzzer_sys::fuzz_target;
fuzz_target!(|data: &[u8]| {
#[cfg(fuzzing_repro)]
eprintln!("Reproducing a crash");
run_no_crash::pass_fuzzing(data);
});
"#,
)
.build();
project
.cargo_fuzz()
.arg("run")
.arg("no_crash")
.arg("--")
.arg("-runs=1000")
.assert()
.stderr(
predicate::str::contains("Done 1000 runs")
.and(predicate::str::contains("Reproducing a crash").not()),
)
.success();
}
| 245
|
fn debug_check_layout(layout: Layout) {
debug_assert!(layout.size() <= LARGEST_POWER_OF_TWO);
debug_assert!(layout.size() > 0);
}
| 246
|
fn main() {
println!("Common letters in the box ids: {}",
match find_common_id() {
Some(s) => s,
None => "NA".to_string()
});
}
| 247
|
fn openssl_dir() -> Result<String, FrumError> {
#[cfg(target_os = "macos")]
return Ok(String::from_utf8_lossy(
&Command::new("brew")
.arg("--prefix")
.arg("openssl")
.output()
.map_err(FrumError::IoError)?
.stdout,
)
.trim()
.to_string());
#[cfg(not(target_os = "macos"))]
return Ok("/usr/local".to_string());
}
| 248
|
fn initialize(lines: &Vec<String>) -> Vec<Day> {
let regex = Regex::new(r"(\d\d-\d\d) ((?:23|00):\d\d)\] (Guard #(\d*)|wakes|falls)").expect("Building Regex failed");
let mut events = lines.iter().map(|l| GuardEvent::from_line(l, ®ex)).collect::<Vec<GuardEvent>>();
events.sort_by(|GuardEvent {date: date1, minute: minute1, ..}, GuardEvent {date: date2, minute: minute2, ..}| {
date1.cmp(date2).then(minute1.cmp(minute2))
});
let mut days = Vec::new();
let mut events_iter = events.iter();
let mut event_option = events_iter.next();
while event_option.is_some() {
let event = event_option.unwrap();
assert_eq!(event.action, BeginsShift);
let mut current_day = Day::new(event.guard_id.unwrap());
let mut is_awake = true;
event_option = events_iter.next();
for minute in 0..60 {
if event_option.map_or(false, |e| e.action != BeginsShift && e.minute == minute) {
is_awake = !is_awake;
event_option = events_iter.next();
}
current_day.set_next_minute(is_awake);
}
days.push(current_day);
}
days
}
| 249
|
pub fn debug_log(msg: impl AsRef<str>) {
let msg = msg.as_ref();
eprintln!("{} - {}", Local::now().format("%Y%m%d %H:%M:%S"), msg);
}
| 250
|
pub fn bubble_sort<T: PartialOrd + Debug>(v: &mut [T]) {
for p in 0..v.len() {
// println!("{:?}", v);
let mut sorted = true;
for i in 0..(v.len()-1) - p{
if v[i] > v[i+1] {
v.swap(i, i+1);
sorted = false;
}
}
if sorted {
return;
}
}
}
| 251
|
async fn run_manpage(_args: Args) -> Result<()> {
info!(version=%env!("CARGO_PKG_VERSION"), "constructing manpage");
let man = Man::new(Args::command().long_version(None));
let mut buffer: Vec<u8> = Default::default();
man.render(&mut buffer).into_diagnostic()?;
if std::io::stdout().is_terminal() && which::which("man").is_ok() {
let mut child = Command::new("man")
.arg("-l")
.arg("-")
.stdin(Stdio::piped())
.stdout(Stdio::inherit())
.stderr(Stdio::inherit())
.group()
.kill_on_drop(true)
.spawn()
.into_diagnostic()?;
child
.inner()
.stdin
.as_mut()
.unwrap()
.write_all(&buffer)
.await
.into_diagnostic()?;
if let Some(code) = child
.wait()
.await
.into_diagnostic()?
.code()
.and_then(|code| if code == 0 { None } else { Some(code) })
{
return Err(miette::miette!("Exited with status code {}", code));
}
} else {
std::io::stdout()
.lock()
.write_all(&buffer)
.into_diagnostic()?;
}
Ok(())
}
| 252
|
fn
test_option
(
)
-
>
Result
<
(
)
>
{
let
db
=
checked_memory_handle
(
)
?
;
let
s
=
Some
(
"
hello
world
!
"
)
;
let
b
=
Some
(
vec
!
[
1u8
2
3
4
]
)
;
db
.
execute
(
"
INSERT
INTO
foo
(
t
)
VALUES
(
?
1
)
"
[
&
s
]
)
?
;
db
.
execute
(
"
INSERT
INTO
foo
(
b
)
VALUES
(
?
1
)
"
[
&
b
]
)
?
;
let
mut
stmt
=
db
.
prepare
(
"
SELECT
t
b
FROM
foo
ORDER
BY
ROWID
ASC
"
)
?
;
let
mut
rows
=
stmt
.
query
(
[
]
)
?
;
{
let
row1
=
rows
.
next
(
)
?
.
unwrap
(
)
;
let
s1
:
Option
<
String
>
=
row1
.
get_unwrap
(
0
)
;
let
b1
:
Option
<
Vec
<
u8
>
>
=
row1
.
get_unwrap
(
1
)
;
assert_eq
!
(
s
.
unwrap
(
)
s1
.
unwrap
(
)
)
;
assert
!
(
b1
.
is_none
(
)
)
;
}
{
let
row2
=
rows
.
next
(
)
?
.
unwrap
(
)
;
let
s2
:
Option
<
String
>
=
row2
.
get_unwrap
(
0
)
;
let
b2
:
Option
<
Vec
<
u8
>
>
=
row2
.
get_unwrap
(
1
)
;
assert
!
(
s2
.
is_none
(
)
)
;
assert_eq
!
(
b
b2
)
;
}
Ok
(
(
)
)
}
| 253
|
fn main() {
let input1 = vec![1,2,5];
let sol = Solution::coin_change(input1, 11);
println!("Result: {}, Expected: 3", sol);
}
| 254
|
fn print_fixed_acc(inss: &[Instruction], op: Operation, pc: usize) -> bool {
let mut fixed_inss = inss.to_vec();
fixed_inss[pc].op = op;
match Evaluator::new(&mut fixed_inss).eval_until_loop() {
(final_pc, final_acc, _) if final_pc == fixed_inss.len() => {
println!("{}", final_acc);
true
}
_ => false,
}
}
| 255
|
fn list() {
let project = project("add").with_fuzz().build();
// Create some targets.
project.cargo_fuzz().arg("add").arg("c").assert().success();
project.cargo_fuzz().arg("add").arg("b").assert().success();
project.cargo_fuzz().arg("add").arg("a").assert().success();
// Make sure that we can list our targets, and that they're always sorted.
project
.cargo_fuzz()
.arg("list")
.assert()
.stdout("a\nb\nc\n")
.success();
}
| 256
|
pub fn main() {
Opt::from_args();
let options = SkimOptionsBuilder::default()
.multi(true)
.bind(vec!["ctrl-k:kill-line"])
.build()
.unwrap();
let re = Regex::new(URL_REGEX).unwrap();
let mut buffer = String::new();
io::stdin().read_to_string(&mut buffer).unwrap();
let lines = buffer.split("\n");
let mut split_lines = false;
let mut split_line_buffer: Vec<&str> = Vec::new();
let mut merged_lines: Vec<String> = Vec::new();
for line in lines {
if line.len() == 0 {
continue
}
if line.ends_with(LINE_SPLITTER) {
let mergable = line.get(0..line.len() - 1).unwrap_or("");
split_line_buffer.push(mergable);
split_lines = true;
continue;
}
if split_lines {
split_lines = false;
split_line_buffer.push(line);
let merged_line = &split_line_buffer.join("");
merged_lines.push(merged_line.to_string());
split_line_buffer = Vec::new();
} else {
merged_lines.push(line.to_string());
}
}
let mut matches: HashMap<String, u8> = HashMap::new();
let mut match_index = 1;
for line in merged_lines {
let sanitized = line.replace("=3D", "=");
for capture in re.captures_iter(&sanitized) {
let url_match = capture.get(1).unwrap().as_str();
if matches.contains_key(url_match) {
continue;
}
matches.insert(url_match.to_string(), match_index);
match_index += 1;
}
}
let mut ordered_items: Vec<_> = matches.into_iter().collect();
ordered_items.sort_by(|a, b| a.1.cmp(&b.1));
let item_list: Vec<_> = ordered_items.iter().map(|item| item.0.as_str()).collect();
let items = item_list.join("\n");
let item_reader = SkimItemReader::default();
let items = item_reader.of_bufread(Cursor::new(items));
let output = Skim::run_with(&options, Some(items)).unwrap();
if output.is_abort {
return;
}
for item in output.selected_items.iter() {
let url = item.clone();
Command::new("firefox")
.arg(url.output().as_ref())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
.unwrap();
}
}
| 257
|
fn main() {
let argv = os::args();
let size = from_str::<uint>(argv[1]).unwrap();
// println!("{}",size);
let align = from_str::<uint>(argv[2]).unwrap();
// println!("{}", align);
let aligned = align_to(size,align);
println!("{} by {} = {}", size, align, aligned);
// print_uint(*argv[1]);
}
| 258
|
pub fn retype_raw_page_free(source: CAddr) -> CAddr {
let result = system_call(SystemCall::RetypeRawPageFree {
request: source,
response: None
});
match result {
SystemCall::RetypeRawPageFree {
response, ..
} => { return response.unwrap(); },
_ => panic!(),
};
}
| 259
|
fn active_entity(entity: Entity, world: &World) -> bool {
return world.masks[entity] & VOXEL_PASS_MASK == VOXEL_PASS_MASK;
}
| 260
|
fn run_with_different_fuzz_dir() {
let (fuzz_dir, mut project_builder) = project_with_fuzz_dir(
"project_likes_to_move_it",
Some("dir_likes_to_move_it_move_it"),
);
let project = project_builder
.with_fuzz()
.fuzz_target(
"you_like_to_move_it",
r#"
#![no_main]
use libfuzzer_sys::fuzz_target;
fuzz_target!(|_data: &[u8]| {
});
"#,
)
.build();
project
.cargo_fuzz()
.arg("run")
.arg("--fuzz-dir")
.arg(fuzz_dir)
.arg("you_like_to_move_it")
.arg("--")
.arg("-runs=1")
.assert()
.stderr(predicate::str::contains("Done 2 runs"))
.success();
}
| 261
|
fn buf_to_state(buf: &[u8]) -> Result<Engine, serde_json::Error> {
serde_json::from_slice(buf)
}
| 262
|
pub fn debug_time<T>(label: impl AsRef<str>, cb: impl FnOnce() -> T) -> T {
let label = label.as_ref();
let t0 = std::time::Instant::now();
debug_log(format!("Starting {}...", label));
let ret = cb();
debug_log(format!("Finished {}: {:?}", label, t0.elapsed()));
return ret;
}
| 263
|
pub fn channel_take<T: Any + Clone>(target: CAddr) -> T {
let (result, payload) = system_call_take_payload(SystemCall::ChannelTake {
request: target,
response: None
});
match result {
SystemCall::ChannelTake {
request: _,
response: Some(ChannelMessage::Payload),
} => {
return payload;
},
_ => panic!(),
};
}
| 264
|
async fn main() {
let start_url = std::env::args()
.skip(1)
.next()
.unwrap_or(START_URL.to_string());
let store = MemoryStore::new();
let mut agent = Agent::new(curiosity(), store.clone(), CachedHttp::default());
agent
.investigate(NamedNode::new(start_url).unwrap())
.await
.unwrap();
while !agent.next().await.unwrap() {
dbg!(store.len());
}
println!("{}", show(&store));
dbg!(store.len(), "done");
}
| 265
|
fn
test_string
(
)
-
>
Result
<
(
)
>
{
let
db
=
checked_memory_handle
(
)
?
;
let
s
=
"
hello
world
!
"
;
db
.
execute
(
"
INSERT
INTO
foo
(
t
)
VALUES
(
?
1
)
"
[
s
.
to_owned
(
)
]
)
?
;
let
from
:
String
=
db
.
one_column
(
"
SELECT
t
FROM
foo
"
)
?
;
assert_eq
!
(
from
s
)
;
Ok
(
(
)
)
}
| 266
|
pub fn merge_sort<T: PartialOrd + Debug>(mut v: Vec<T>) -> Vec<T> {
// sort the left half
// sort the right half O(n*ln(n))
// bring the sorted half together O(n)
if v.len() <= 1 {
return v;
}
let mut res = Vec::with_capacity(v.len());
let b = v.split_off(v.len()/2);
let a = merge_sort(v);
let b = merge_sort(b);
// bring them together again add whichever is lowest the front of a or the front of b
let mut a_it = a.into_iter();
let mut b_it = b.into_iter();
let mut a_peek = a_it.next();
let mut b_peek = b_it.next();
loop {
match a_peek {
Some(ref a_val) => match b_peek{
Some(ref b_val) =>{
if b_val < a_val {
res.push(b_peek.take().unwrap());
b_peek = b_it.next();
} else {
res.push(a_peek.take().unwrap());
a_peek = a_it.next();
}
}
None => {
res.push(a_peek.take().unwrap());
res.extend(a_it);
return res;
}
}
None => {
if let Some(b_val) = b_peek {
res.push(b_val);
}
res.extend(b_it);
return res;
}
}
}
}
| 267
|
pub fn day09_1(s : String) -> u32{
let mut running_total = 0;
let mut scope = 0;
let mut in_garbage = false;
let mut prev_cancel = false;
for c in s.chars(){
if in_garbage {
if c == '>' && !prev_cancel {
in_garbage = false;
prev_cancel = false;
}
else if c == '!' && !prev_cancel {
prev_cancel = true;
}
else {
prev_cancel = false;
}
}
else{
if c == '{' {
scope+=1;
running_total+=scope;
}
else if c == '}' {
scope -=1;
}
else if c == '<' {
in_garbage = true;
}
}
}
running_total
}
| 268
|
pub fn print(buffer: [u8; 32], size: usize) {
let _ = system_call(SystemCall::Print {
request: (buffer, size)
});
}
| 269
|
pub fn task_set_stack_pointer(target: CAddr, ptr: u64) {
system_call(SystemCall::TaskSetStackPointer {
request: (target, ptr),
});
}
| 270
|
pub fn test_outofcycles_in_syscall() {
let buffer = fs::read("tests/programs/syscall64").unwrap().into();
let core_machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::new(ISA_IMC, VERSION0, 20);
let mut machine = DefaultMachineBuilder::new(core_machine)
.instruction_cycle_func(Box::new(constant_cycles))
.syscall(Box::new(OutOfCyclesSyscall {}))
.build();
machine
.load_program(&buffer, &vec!["syscall".into()])
.unwrap();
let result = machine.run();
assert!(result.is_err());
assert_eq!(result.unwrap_err(), Error::CyclesExceeded);
assert_eq!(machine.cycles(), 108);
assert_eq!(machine.registers()[A0], 39);
}
| 271
|
fn criterion_benchmark(c: &mut Criterion) {
let mut group = c.benchmark_group("fyrstikker");
group.sampling_mode(SamplingMode::Flat).sample_size(10);
group.bench_function("fyrstikker 40", |b| {
b.iter(|| fyrstikk_tal_kombinasjonar(40))
});
group.bench_function("fyrstikker 2000", |b| {
b.iter(|| fyrstikk_tal_kombinasjonar(2000))
});
group.finish();
}
| 272
|
fn get_command(stream: &mut TcpStream, buf: &mut[u8]) -> Result<Task, Error> {
let buf_sz = stream.read(buf).expect("failed to read from stream");
let buf_usize = buf_sz as usize;
let v = match serde_json::from_slice::<Task>(&buf[..buf_usize]){
Ok(v) => v,
Err(e) => return Err(e)
};
Ok(v)
}
| 273
|
extern "C" fn gatt_svr_chr_access_heart_rate(
_conn_handle: u16,
_attr_handle: u16,
ctxt: *mut ble_gatt_access_ctxt,
_arg: *mut ::core::ffi::c_void,
) -> i32 {
/* Sensor location, set to "Chest" */
const BODY_SENS_LOC: u8 = 0x01;
let uuid: u16 = unsafe { ble_uuid_u16((*(*ctxt).__bindgen_anon_1.chr).uuid) };
if uuid == GATT_HRS_BODY_SENSOR_LOC_UUID {
let rc: i32 = unsafe {
os_mbuf_append(
(*ctxt).om,
&BODY_SENS_LOC as *const u8 as *const c_void,
size_of::<u8>() as u16,
)
};
return if rc == 0 {
0
} else {
BLE_ATT_ERR_INSUFFICIENT_RES as i32
};
}
return BLE_ATT_ERR_UNLIKELY as i32;
}
| 274
|
fn get_largest_register_value(registers: &HashMap<&str, i32>) -> i32 {
*registers
.iter()
.map(|(_, v)| v)
.max()
.unwrap_or(&0)
}
| 275
|
fn git(args: &[&str]) -> Result<String, Box<dyn std::error::Error>> {
let mut cmd = Command::new("git");
cmd.args(args);
cmd.stdout(Stdio::piped());
let out = cmd.spawn();
let mut out = match out {
Ok(v) => v,
Err(err) => {
panic!("Failed to spawn command `{:?}`: {:?}", cmd, err);
}
};
let status = out.wait().expect("waited");
if !status.success() {
eprintln!("failed to run `git {:?}`: {:?}", args, status);
return Err(std::io::Error::from(std::io::ErrorKind::Other).into());
}
let mut stdout = Vec::new();
out.stdout.unwrap().read_to_end(&mut stdout).unwrap();
Ok(String::from_utf8_lossy(&stdout).into_owned())
}
| 276
|
pub fn data_type<'a>() -> Parser<'a, char, DataType> {
ident().convert(|v| DataType::match_data_type(&v))
}
| 277
|
fn
test_str
(
)
-
>
Result
<
(
)
>
{
let
db
=
checked_memory_handle
(
)
?
;
let
s
=
"
hello
world
!
"
;
db
.
execute
(
"
INSERT
INTO
foo
(
t
)
VALUES
(
?
1
)
"
[
&
s
]
)
?
;
let
from
:
String
=
db
.
one_column
(
"
SELECT
t
FROM
foo
"
)
?
;
assert_eq
!
(
from
s
)
;
Ok
(
(
)
)
}
| 278
|
fn main() {
let nhits = 20;
let ntrials = 2000;
let nnanos = 60 * 1000 * 1000 * 1000;
let ntransfers = 1000;
let nbrokers = 8;
let tolerance = 0.05;
let ops = (ntransfers * nbrokers) as f64;
let million = (1000 * 1000) as f64;
let mut sum = 0.0;
let mut hits = 0;
let mut trial = 0;
let limit = time::precise_time_ns() + nnanos;
while hits < nhits && trial < ntrials && time::precise_time_ns() < limit {
let mut table = HashMapOfTreeMap::new();
let start = time::precise_time_ns();
for _ in 0..nbrokers {
broker(&mut table, ntransfers);
}
let end = time::precise_time_ns();
let ns = (end - start) as f64;
let x = ops / ns * million;
sum += x;
let n = (trial + 1) as f64;
let mean = sum / n;
let dev = (x - mean).abs() / mean;
if dev <= tolerance {
println!("{:5} {:8.2} ops/ms ({:8.2})", trial, x, mean);
hits += 1;
}
trial += 1;
}
}
| 279
|
pub fn write_board(board_name: String, contents: String) -> Result<(), String> {
let mut configurator = Configurator::new();
unsafe {
configurator.set_working_folder(WORKING_FOLDER.clone());
}
configurator.write_board(board_name, contents)
}
| 280
|
fn create_tap() -> AppResult<TapInfo> {
// create tap
inner_create_tap("tap0")
}
| 281
|
fn print_node(prefix: &str, node: &IRNode) {
let next_prefix = get_next_prefix(prefix);
match node {
&IRNode::Assignment(ref name, ref exp) => {
println!("{}Assignment-'{}':", prefix, name);
print_expression(&next_prefix, exp);
}
&IRNode::DeclareVariable(ref name, ref exp) => {
println!("{}DeclareVariable-'{}':", prefix, name);
println!("{}{:?}", next_prefix, exp);
}
&IRNode::Conditional(ref comparison, ref nodes) => {
println!("{}Conditional:", prefix);
println!("{}{:?}", next_prefix, comparison);
let n_next_prefix = get_next_prefix(&next_prefix);
for tmp in nodes {
print_nodes(&n_next_prefix, tmp);
}
}
&IRNode::Loop(ref comparison, ref nodes) => {
println!("{}Loop:", prefix);
println!("{}{:?}", next_prefix, comparison);
let n_next_prefix = get_next_prefix(&next_prefix);
for tmp in nodes {
print_nodes(&n_next_prefix, tmp);
}
}
&IRNode::Return(ref raw_exp) => {
match raw_exp {
Some(exp) => {
println!("{}Return:", prefix);
print_expression(&next_prefix, exp);
}
None => println!("{}Return", prefix),
};
}
&IRNode::SingleExpression(ref exp) => {
println!("{}Expression:", prefix);
print_expression(&next_prefix, exp);
}
};
}
| 282
|
pub fn task_set_instruction_pointer(target: CAddr, ptr: u64) {
system_call(SystemCall::TaskSetInstructionPointer {
request: (target, ptr),
});
}
| 283
|
fn extract_archive_into<P: AsRef<Path>>(
path: P,
response: reqwest::blocking::Response,
) -> Result<(), FrumError> {
#[cfg(unix)]
let extractor = archive::tar_xz::TarXz::new(response);
#[cfg(windows)]
let extractor = archive::zip::Zip::new(response);
extractor
.extract_into(path)
.map_err(|source| FrumError::ExtractError { source })?;
Ok(())
}
| 284
|
async fn server(url: &str) -> Result<!, String> {
let server = TcpServer::bind(url).await.map_err(|e| e.to_string())?;
let (op_reads, op_writes) = TcpServerOp::<RequestLatRepr>::new(server.clone())
// .debug("ingress")
.morphism_closure(|item| item.flatten_keyed::<tag::VEC>())
.morphism(Switch)
// .debug("split")
.switch();
type ReadsLatRepr = MapUnionRepr<tag::HASH_MAP, String, SetUnionRepr<tag::HASH_SET, SocketAddr>>;
let op_reads = op_reads
// .debug("read")
.lattice_default::<ReadsLatRepr>();
type WritesLatRepr = MapUnionRepr<tag::HASH_MAP, String, ValueLatRepr>;
let op_writes = op_writes
// .debug("write")
.lattice_default::<WritesLatRepr>();
let binary_func = HashPartitioned::<String, _>::new(
TableProduct::<_, _, _, MapUnionRepr<tag::VEC, _, _>>::new());
let comp = BinaryOp::new(op_reads, op_writes, binary_func)
.morphism_closure(|item| item.transpose::<tag::VEC, tag::VEC>())
.comp_tcp_server::<ResponseLatRepr, _>(server);
comp
.run()
.await
.map_err(|e| format!("TcpComp error: {:?}", e))?;
}
| 285
|
fn main() {
std::panic::set_hook(Box::new(console_error_panic_hook::hook));
console_log::init_with_level(log::Level::Warn).expect("could not initialize logger");
let fighter_bytes = include_bytes!("subaction_data.bin");
let subaction = bincode::deserialize(fighter_bytes).unwrap();
wasm_bindgen_futures::spawn_local(render_window_wasm(subaction));
}
| 286
|
fn handle_trame(trame: Trame) -> Option<Trame> {
match (
trame.id,
trame.cmd,
&trame.data[0..trame.data_length as usize],
) {
(0...5, 0x0, [0x55]) => Some(trame!(trame.id, 0x00, [0xAA])),
(_, _, _) => None,
}
}
| 287
|
fn soda(_py: Python, m: &PyModule) -> PyResult<()> {
m.add_class::<Soda>()?;
Ok(())
}
| 288
|
pub fn add_history(history_type: HistoryType, history_path: String) -> Result<(), &'static str> {
let path_buf = Path::new(&history_path);
if !(path_buf.is_dir() || path_buf.is_file()) {
return Err("Not a validate dir or file path.");
}
let mut configurator = Configurator::new();
configurator.add_history(history_type, path_buf);
configurator.save_config();
Ok(())
}
| 289
|
fn part1(rules: &Vec<PasswordRule>) -> usize {
rules
.iter()
.filter(|rule| (rule.min..=rule.max).contains(&rule.password.matches(rule.letter).count()))
.count()
}
| 290
|
fn decode_ppm_image(cursor: &mut Cursor<Vec<u8>>) -> Result<Image, Box<std::error::Error>> {
let mut image = Image {
width : 0,
height: 0,
pixels: vec![]
};
// read header
let mut c: [u8; 2] = [0; 2];
cursor.read(&mut c)?;
match &c {
b"P6" => { },
_ => { bail!("error") }
}
let w = read_num(cursor)?;
let h = read_num(cursor)?;
let cr = read_num(cursor)?;
print!("width: {}, height: {}, color range: {}\n", w, h, cr);
// TODO: Parse the image here
let mut pxls:Vec<Vec<Pixel>> = vec![];
let mut buff: [u8; 1] = [0];
loop{
cursor.read(&mut buff)?;
match &buff {
b" " | b"\t" | b"\n" => {},
_ => { cursor.seek(std::io::SeekFrom::Current(-1)); break; }
};
};
for x in 0..h {
let mut row: Vec<Pixel> = vec!();
for y in 0..w {
let mut mv: Vec<u8> = vec![];
for mut z in 0..3 {
mv.push(cursor.read_u8()?);
}
let px = Pixel {
R: mv[0] as u32,
G: mv[1] as u32,
B: mv[2] as u32
};
row.push(px);
}
pxls.insert(0, row);
}
image = Image {
width : w,
height: h,
pixels: pxls
};
Ok(image)
}
| 291
|
fn extract_ext_info(
info: &HandshakeControlInfo,
) -> Result<Option<&SrtControlPacket>, ConnectError> {
match &info.info {
HandshakeVsInfo::V5(hs) => Ok(hs.ext_hs.as_ref()),
_ => Err(UnsupportedProtocolVersion(4)),
}
}
| 292
|
async fn client<R: tokio::io::AsyncRead + std::marker::Unpin>(url: &str, input_read: R) -> Result<!, String> {
let (read, write) = TcpStream::connect(url).await.map_err(|e| e.to_string())?
.into_split();
let read_comp = TcpOp::<ResponseLatRepr>::new(read)
.comp_null();
// .comp_debug("read");
let write_comp = ReadOp::new(input_read)
.morphism(ParseKvsOperation)
.debottom()
.comp_tcp::<RequestLatRepr>(write);
#[allow(unreachable_code)]
let result = tokio::try_join!(
async {
read_comp.run().await.map_err(|_| format!("Read failed."))
},
async {
let err = write_comp.run().await.map_err(|e| e.to_string());
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
err
},
);
result?;
unreachable!();
// Err(format!("Read error: {:?}, Write error: {:?}",
// result.0.unwrap_err(), result.1.unwrap_err()))
}
| 293
|
pub fn task_set_active(target: CAddr) {
system_call(SystemCall::TaskSetActive {
request: target
});
}
| 294
|
fn state_from_snapshot<F>(
snapshot: ::fidl::InterfacePtr<PageSnapshot_Client>,
key: Vec<u8>,
done: F,
) where
F: Send + FnOnce(Result<Option<Engine>, ()>) + 'static,
{
assert_eq!(PageSnapshot_Metadata::VERSION, snapshot.version);
let mut snapshot_proxy = PageSnapshot_new_Proxy(snapshot.inner);
// TODO get a reference when too big
snapshot_proxy.get(key).with(move |raw_res| {
let state = match raw_res.map(|res| ledger::value_result(res)) {
// the .ok() has the behavior of acting like invalid state is empty
// and thus deleting invalid state and overwriting it with good state
Ok(Ok(Some(buf))) => Ok(buf_to_state(&buf).ok()),
Ok(Ok(None)) => {
info!("No state in conflicting page");
Ok(None)
}
Err(err) => {
warn!("FIDL failed on initial response: {:?}", err);
Err(())
}
Ok(Err(err)) => {
warn!("Ledger failed to retrieve key: {:?}", err);
Err(())
}
};
done(state);
});
}
| 295
|
fn get_submodules(
repo: &Repository,
at: &Commit,
) -> Result<Vec<Submodule>, Box<dyn std::error::Error>> {
let submodule_cfg = modules_file(&repo, &at)?;
let submodule_cfg = Config::parse(&submodule_cfg)?;
let mut path_to_url = HashMap::new();
let entries = submodule_cfg.entries(None)?;
for entry in &entries {
let entry = entry?;
let name = entry.name().unwrap();
if name.ends_with(".path") {
let url = name.replace(".path", ".url");
let url = submodule_cfg.get_string(&url).unwrap();
path_to_url.insert(entry.value().unwrap().to_owned(), url);
}
}
let mut submodules = Vec::new();
let tree = at.tree()?;
for (path, url) in &path_to_url {
let path = Path::new(&path);
let entry = tree.get_path(&path);
// the submodule may not actually exist
let entry = match entry {
Ok(e) => e,
Err(_) => continue,
};
assert_eq!(entry.kind().unwrap(), git2::ObjectType::Commit);
submodules.push(Submodule {
path: path.to_owned(),
commit: entry.id(),
repository: url.to_owned(),
});
}
submodules.retain(|s| {
let is_rust =
s.repository.contains("rust-lang") || s.repository.contains("rust-lang-nursery");
let exclude = vec![
"https://github.com/rust-lang/llvm.git",
"https://github.com/rust-lang/llvm-project.git",
"https://github.com/rust-lang/lld.git",
"https://github.com/rust-lang-nursery/clang.git",
"https://github.com/rust-lang-nursery/lldb.git",
"https://github.com/rust-lang/libuv.git",
"https://github.com/rust-lang/gyp.git",
"https://github.com/rust-lang/jemalloc.git",
"https://github.com/rust-lang/compiler-rt.git",
"https://github.com/rust-lang/hoedown.git",
];
is_rust
&& !exclude.contains(&s.repository.as_str())
&& !exclude.contains(&&*format!("{}.git", s.repository))
});
Ok(submodules)
}
| 296
|
pub fn var(v: Var) -> Value {
Rc::new(RefCell::new(V {
val: Value_::Var(v),
computed: false,
}))
}
| 297
|
async fn run_watchexec(args: Args) -> Result<()> {
info!(version=%env!("CARGO_PKG_VERSION"), "constructing Watchexec from CLI");
let init = config::init(&args);
let state = state::State::new()?;
let mut runtime = config::runtime(&args, &state)?;
runtime.filterer(filterer::globset(&args).await?);
info!("initialising Watchexec runtime");
let wx = Watchexec::new(init, runtime)?;
if !args.postpone {
debug!("kicking off with empty event");
wx.send_event(Event::default(), Priority::Urgent).await?;
}
info!("running main loop");
wx.main().await.into_diagnostic()??;
info!("done with main loop");
Ok(())
}
| 298
|
fn parseFromFile(file: &File) {
let mut reader = BufReader::new(file);
let mut buf = String::from("");
let line_index = 0;
let mut models: Vec<Model> = Vec::new();
let mut lights: Vec<Model> = Vec::new();
while (reader.read_line(&mut buf) != 0) {
if lien_index == 0 {
if line == 'm' {
//now we read the model data
reader.read_line(&mut buf);
let model_count = buf.trim().parse().expect("it's not a number");
let mut model_index = 0;
while model_index < model_count {
parseModelInfo(&mut reader, &mut buf, &mut models)
model_index += 1;
}
}
if line == 'l' {
reader.read_line(&mut buf);
let light_count = buf.trim().parse().expect("it's not a number");
let mut light_index = 0;
while light_index < light_count {
parseModelInfo(&mut reader, &mut buf, &mut models)
model_index += 1;
}
}
}
}
}
| 299
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.