content stringlengths 3 6.31k | id int64 0 123 |
|---|---|
{
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
(
(
)
)
} | 0 |
{
let p: Either<String, f64> = Deserialize::deserialize(de)?;
Ok(p.right())
} | 1 |
{
let mut mvoxels: Vec<Option<MetaVoxel>> = Vec::new();
let len: usize = (size.x as usize) * (size.y as usize) * (size.z as usize);
mvoxels.resize(len, None);
for (i, opt_voxel) in voxels.iter().enumerate()
{
match opt_voxel
{
Some(voxel) => {
let mut face... | 2 |
{
let mut col = col;
let mut writer = writer;
let mut v = Vec::<u8>::with_capacity(((input.len() as f64) * 1.04) as usize);
input.iter().for_each(|&b| {
let encoded = encode_byte(b);
v.push(encoded.0);
col += match encoded.0 {
ESCAPE => {
v.push(encode... | 3 |
{
accept_hdr_async(stream, NoCallback).await
} | 4 |
{
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
(
(
)
)
} | 5 |
{
for triangle in triangles
{
let normal_index: usize;
let a_position: usize;
let b_position: usize;
let c_position: usize;
match vertices.iter().position(|&x| x == triangle.a)
{
Some(idx) => {
a_position = idx;
},
... | 6 |
{
MessagePackSource(r)
} | 7 |
{
assert!(-32 <= val && val < 0);
write_fixval(wr, Marker::FixNeg(val))
} | 8 |
{
#
[
inline
]
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
... | 9 |
{
let input = input.into();
let output = input
.graph()
.new_node(input.shape())
.set_name_unique(&format!("softsign({})", input));
let _op = Softsign::new_default(input, output.clone()).build()?;
Ok(output)
} | 10 |
{
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 ... | 11 |
{
assert!(low_bound < high_bound);
Ok(move |ratio| (ratio > low_bound) && (ratio < high_bound))
} | 12 |
{
try!(write_marker(wr, Marker::I8));
write_data_i8(wr, val)
} | 13 |
{
} | 14 |
{
write_fixval(wr, Marker::Null)
} | 15 |
{
client_async_with_config(request, stream, None).await
} | 16 |
{
let boxes = grid_9x9_keys();
let values = s.chars().map(|c| match c {
'.' => None,
c => c.to_digit(10).map(|d| d as usize),
});
SudokuGrid::from_iter(boxes.zip(values))
} | 17 |
{
Sampling::<(MCLK, SrInvalid)> {
data: 0b1000 << 9,
t: PhantomData::<(MCLK, SrInvalid)>,
}
} | 18 |
{
let
a
=
unsafe
{
&
*
(
self
.
as_ptr
(
)
as
*
const
AtomicBool
)
}
;
a
.
fetch_nand
(
val
Ordering
:
:
AcqRel
)
} | 19 |
{
use std::convert::TryFrom;
let vx: i16 = voxel.x.into();
let vy: i16 = voxel.y.into();
let vz: i16 = voxel.z.into();
let pos = dot_vox::Voxel {
i: voxel.i,
x: u8::try_from(vx + x)?,
y: u8::try_from(vy + y)?,
z: u8::try_from(vz + z)?
};
let neighbor: Option... | 20 |
{
// width = 1+max(len(values[s]) for s in boxes)
// let width = 2;
let line = std::iter::repeat("-").take(9).collect::<String>();
let line = std::iter::repeat(line).take(3).collect::<Vec<String>>().join("+");
for r in 0..9
{
let value_str = (0..9).map(|c| (r, c))
... | 21 |
{
let compressed = comp(expected_dec);
assert_eq!(compressed, expected_comp);
} | 22 |
{
try!(write_bin_len(wr, data.len() as u32));
wr.write_all(data).map_err(|err| ValueWriteError::InvalidDataWrite(WriteError(err)))
} | 23 |
{
let parsed_vidx = download_vidx_list(vidx_list, client, logger);
let pdsc_list = parsed_vidx
.filter_map(move |vidx| vidx.map(|v| flatmap_pdscs(v, client, logger)))
.flatten();
download_stream(config, pdsc_list, client, logger, progress).collect()
} | 24 |
{
let metadata = if request.follow_symlink {
std::fs::metadata(&request.path)
} else {
std::fs::symlink_metadata(&request.path)
}.map_err(Error::Metadata)?;
let symlink = if metadata.file_type().is_symlink() {
ack! {
std::fs::read_link(&request.path),
war... | 25 |
{
try!(write_marker(wr, Marker::U8));
write_data_u8(wr, val)
} | 26 |
{
atomic
!
{
T
a
{
a
=
&
*
(
src
as
*
const
_
as
*
const
_
)
;
mem
:
:
transmute_copy
(
&
a
.
load
(
Ordering
:
:
Acquire
)
)
}
{
let
lock
=
lock
(
src
as
usize
)
;
/
/
Try
doing
an
optimistic
read
first
.
if
let
Some
(
stamp
)
=
lock
.
optimistic_read
(
)
{
/
/
We
need
a
volatile
read
here
because
other
threads
might
... | 27 |
{
#
[
allow
(
non_snake_case
)
]
let
MASK
:
__m128i
=
_mm_set_epi64x
(
0x0001_0203_0405_0607
0x0809_0A0B_0C0D_0E0F
)
;
let
mut
state_abcd
=
_mm_set_epi32
(
state
[
0
]
as
i32
state
[
1
]
as
i32
state
[
2
]
as
i32
state
[
3
]
as
i32
)
;
let
mut
state_e
=
_mm_set_epi32
(
state
[
4
]
as
i32
0
0
0
)
;
for
block
in
blocks
{... | 28 |
{
connect_async_with_tls_connector_and_config(request, connector, None).await
} | 29 |
{
use std::fs::OpenOptions;
let mut in_data = dot_vox::load(ifpath).unwrap();
let mut triangles: Vec<Triangle> = Vec::new();
for model in &mut in_data.models
{
let size = model.size;
let voxels = reorder_voxels(&mut model.voxels, &size);
let mvoxels = convert_meta_voxels(&vo... | 30 |
{
try!(write_marker(wr, Marker::F32));
write_data_f32(wr, val)
} | 31 |
{
return (vox.x as usize) +
((vox.y as usize) * (size.x as usize)) +
((vox.z as usize) * (size.x as usize) * (size.y as usize));
} | 32 |
{
accept_hdr_async_with_config(stream, callback, None).await
} | 33 |
{
Ok
(
(
)
)
} | 34 |
{
let
mut
prev
=
self
.
load
(
)
;
while
let
Some
(
next
)
=
f
(
prev
)
{
match
self
.
compare_exchange
(
prev
next
)
{
x
Ok
(
_
)
=
>
return
x
Err
(
next_prev
)
=
>
prev
=
next_prev
}
}
Err
(
prev
)
} | 35 |
{
fn
is_invalid_column_type
(
err
:
Error
)
-
>
bool
{
matches
!
(
err
Error
:
:
InvalidColumnType
(
.
.
)
)
}
let
db
=
checked_memory_handle
(
)
?
;
db
.
execute
(
"
INSERT
INTO
foo
(
b
t
i
f
)
VALUES
(
X
'
0102
'
'
text
'
1
1
.
5
)
"
[
]
)
?
;
let
mut
stmt
=
db
.
prepare
(
"
SELECT
b
t
i
f
n
FROM
foo
"
)
?
;
let
mut
... | 36 |
{
if
mem
:
:
needs_drop
:
:
<
T
>
(
)
{
unsafe
{
self
.
as_ptr
(
)
.
drop_in_place
(
)
;
}
}
} | 37 |
{
device_manager::register_driver(&s_pci_legacy_driver);
device_manager::register_driver(&s_pci_native_driver);
} | 38 |
{
match with_projects(dir, search_terms, |p| {f(p);Ok(())}){
Ok(_) => {},
Err(e) => error!("{}",e)
}
} | 39 |
{
if len < 256 {
try!(write_marker(wr, Marker::Bin8));
write_data_u8(wr, len as u8).and(Ok(Marker::Bin8))
} else if len < 65536 {
try!(write_marker(wr, Marker::Bin16));
write_data_u16(wr, len as u16).and(Ok(Marker::Bin16))
} else {
try!(write_marker(wr, Marker::Bin32)... | 40 |
{
if -32 <= val && val <= 0 {
let marker = Marker::FixNeg(val as i8);
try!(write_fixval(wr, marker));
Ok(marker)
} else if -128 <= val && val < 128 {
write_i8(wr, val as i8).and(Ok(Marker::I8))
} else if -32768 <= val && val < 32768 {
write_i16(wr, val as i16).and(O... | 41 |
{
let request: Request = request.into_client_request()?;
let domain = domain(&request)?;
let port = port(&request)?;
let try_socket = TcpStream::connect((domain.as_str(), port)).await;
let socket = try_socket.map_err(Error::Io)?;
client_async_tls_with_connector_and_config(request, socket, None... | 42 |
{
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
(
(
)
)
} | 43 |
{
use std::io::prelude::*;
let stdin = stdin();
let mut reader = BufReader::with_capacity(100 * 1024, stdin);
let mut line = String::with_capacity(100);
let mut matrix: Vec<Vec<T>> = Vec::new();
while reader.read_line(&mut line).unwrap() > 0 {
matrix.push(
line.trim()
... | 44 |
{
match File::create(&path) {
Err(_) => {
println!("cannot create file: {:?}", path.as_ref());
exit(1)
}
Ok(file) => file,
}
} | 45 |
{
let serialized: Vec<u8> =
SimpleSerializer::serialize(object).expect("Serialization should work");
let deserialized: T =
SimpleDeserializer::deserialize(&serialized).expect("Deserialization should work");
assert_eq!(*object, deserialized);
} | 46 |
{
let mut ret_voxels: Vec<Option<dot_vox::Voxel>> = Vec::new();
let len: usize = (size.x as usize) * (size.y as usize) * (size.z as usize);
ret_voxels.resize(len, None);
for voxel in voxels
{
let idx = get_voxel_idx(voxel, size);
ret_voxels[idx] = Some(*voxel);
}
return ret_... | 47 |
{
match val {
&Value::Nil => try!(write_nil(wr)),
&Value::Boolean(val) => try!(write_bool(wr, val)),
// TODO: Replace with generic write_int(...).
&Value::Integer(Integer::U64(val)) => {
try!(write_uint(wr, val));
}
&Value::Integer(Integer::I64(val)) => {
... | 48 |
{
let
db
=
checked_memory_handle
(
)
?
;
db
.
execute
(
"
INSERT
INTO
foo
(
i
)
VALUES
(
?
1
)
"
[
Value
:
:
Integer
(
10
)
]
)
?
;
assert_eq
!
(
10i64
db
.
one_column
:
:
<
i64
>
(
"
SELECT
i
FROM
foo
"
)
?
)
;
Ok
(
(
)
)
} | 49 |
{
atomic
!
{
T
a
{
a
=
&
*
(
dst
as
*
const
_
as
*
const
_
)
;
let
res
=
mem
:
:
transmute_copy
(
&
a
.
swap
(
mem
:
:
transmute_copy
(
&
val
)
Ordering
:
:
AcqRel
)
)
;
mem
:
:
forget
(
val
)
;
res
}
{
let
_guard
=
lock
(
dst
as
usize
)
.
write
(
)
;
ptr
:
:
replace
(
dst
val
)
}
}
} | 50 |
{
let obj: Root = serde_yaml::from_str(input).unwrap();
let id = obj.meta.id.clone().unwrap_or_else(|| "root".to_owned());
let scope: Vec<_> = scope.iter().map(|s| syn::parse_str(&s[..]).unwrap()).collect();
let ctx = parse_type("Context".to_string(), scope.clone(), obj.context);
let root = parse_... | 51 |
{
self
.
execute
(
fut
)
} | 52 |
{
let sdl = sdl2::init().unwrap();
let video_subsystem = sdl.video().unwrap();
let display_mode = video_subsystem.current_display_mode(0).unwrap();
let w = match display_mode.w as u32 > image.width {
true => image.width,
false => display_mode.w as u32
};
let h = ... | 53 |
{
let mut foot_children = layout.children();
let foot_background = Primitive::Quad {
bounds: layout.bounds(),
background: style.foot_background,
border_radius: style.border_radius,
border_width: 0.0,
border_color: Color::TRANSPARENT,
};
let (foot, foot_mouse_inte... | 54 |
{
let
a
=
unsafe
{
&
*
(
self
.
as_ptr
(
)
as
*
const
AtomicBool
)
}
;
a
.
fetch_xor
(
val
Ordering
:
:
AcqRel
)
} | 55 |
{
let mut parser = Parser::new(source, source_id, shebang);
let ast = parser.parse::<T>()?;
parser.eof()?;
Ok(ast)
} | 56 |
{
let
a
=
unsafe
{
&
*
(
self
.
as_ptr
(
)
as
*
const
AtomicBool
)
}
;
a
.
fetch_or
(
val
Ordering
:
:
AcqRel
)
} | 57 |
{
try!(write_marker(wr, Marker::I32));
write_data_i32(wr, val)
} | 58 |
{
fn
fmt
(
&
self
f
:
&
mut
fmt
:
:
Formatter
<
'
_
>
)
-
>
fmt
:
:
Result
{
f
.
debug_struct
(
"
AtomicCell
"
)
.
field
(
"
value
"
&
self
.
load
(
)
)
.
finish
(
)
}
} | 59 |
{
let
from
=
from
.
as_ref
(
)
.
to_owned
(
)
;
let
to
=
to
.
as_ref
(
)
.
to_owned
(
)
;
asyncify
(
move
|
|
std
:
:
fs
:
:
rename
(
from
to
)
)
.
await
} | 60 |
{
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, M... | 61 |
{
try!(write_marker(wr, Marker::U64));
write_data_u64(wr, val)
} | 62 |
{
MessagePackSink(w)
} | 63 |
{
trace!("with_projects({:?})", search_terms);
let luigi = try!(setup_luigi());
let projects = try!(luigi.search_projects_any(dir, search_terms));
if projects.is_empty() {
return Err(format!("Nothing found for {:?}", search_terms).into())
}
for project in &projects{
try!(f(projec... | 64 |
{
wr.write_u8(marker.to_u8()).map_err(|err| FixedValueWriteError(From::from(err)))
} | 65 |
{
let app = app::new_app();
let matches = app.get_matches();
let in_file = matches.value_of("input").unwrap_or(INPUT_FILEPATH);
let out_file: &str;
if matches.is_present("stl")
{
out_file = matches.value_of("output").unwrap_or(OUTPUT_STL_FILEPATH);
convert_vox_stl(in_file, out_f... | 66 |
{
let mut in_data = dot_vox::load(ifpath).unwrap();
let collada: collada_io::collada::Collada;
let mut geometries: Vec<collada_io::geometry::Geometry> = Vec::new();
for model in &mut in_data.models
{
let size = model.size;
let voxels = reorder_voxels(&mut model.voxels, &size);
... | 67 |
{
match
*
self
{
Exec
:
:
Default
=
>
{
#
[
cfg
(
feature
=
"
tcp
"
)
]
{
tokio
:
:
task
:
:
spawn
(
fut
)
;
}
#
[
cfg
(
not
(
feature
=
"
tcp
"
)
)
]
{
/
/
If
no
runtime
we
need
an
executor
!
panic
!
(
"
executor
must
be
set
"
)
}
}
Exec
:
:
Executor
(
ref
e
)
=
>
{
e
.
execute
(
Box
:
:
pin
(
fut
)
)
;
}
}
}
}
impl
f... | 68 |
{
let mut buf = String::new();
stdin().read_line(&mut buf).unwrap();
return buf.trim().parse().unwrap();
} | 69 |
{
unsafe
{
atomic_load
(
self
.
as_ptr
(
)
)
}
} | 70 |
{
if len < 16 {
let marker = Marker::FixMap(len as u8);
try!(write_fixval(wr, marker));
Ok(marker)
} else if len < 65536 {
try!(write_marker(wr, Marker::Map16));
write_data_u16(wr, len as u16).and(Ok(Marker::Map16))
} else {
try!(write_marker(wr, Marker::Map32... | 71 |
{
Box::new(e)
} | 72 |
{
let
a
=
unsafe
{
&
*
(
self
.
as_ptr
(
)
as
*
const
AtomicBool
)
}
;
a
.
fetch_and
(
val
Ordering
:
:
AcqRel
)
} | 73 |
{
match val {
val if -32 <= val && val < 0 => {
let marker = Marker::FixNeg(val as i8);
try!(write_fixval(wr, marker));
Ok(marker)
}
val if -128 <= val && val < -32 => {
write_i8(wr, val as i8).and(Ok(Marker::I8))
}
val if -3276... | 74 |
{
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
(
(
)
)
} | 75 |
{
let request: Request = request.into_client_request()?;
let domain = domain(&request)?;
let port = port(&request)?;
let try_socket = TcpStream::connect((domain.as_str(), port)).await;
let socket = try_socket.map_err(Error::Io)?;
client_async_tls_with_connector_and_config(request, socket, conn... | 76 |
{
let decompressed = dec(expected_comp).expect("Valid Decompress");
assert_eq!(decompressed, expected_dec);
} | 77 |
{
if val < 128 {
let marker = Marker::FixPos(val as u8);
try!(write_fixval(wr, marker));
Ok(marker)
} else if val < 256 {
write_u8(wr, val as u8).and(Ok(Marker::U8))
} else if val < 65536 {
write_u16(wr, val as u16).and(Ok(Marker::U16))
} else if val < 429496729... | 78 |
{
crate::client_async_with_config(request, TokioAdapter(stream), config).await
} | 79 |
{
accept_hdr_async_with_config(stream, NoCallback, config).await
} | 80 |
{
let mut triangles = Vec::new();
for opt_mvoxel in mvoxels
{
match opt_mvoxel
{
Some(mvoxel) => {
let vleft_back_top = Vertex {
x: mvoxel.voxel.x as f32 + 0.0,
y: mvoxel.voxel.y as f32 + 0.0,
z: mvoxel.... | 81 |
{
client_async_tls_with_connector_and_config(request, stream, None, config).await
} | 82 |
{
let mut buf = String::with_capacity(100);
stdin().read_line(&mut buf).unwrap();
return buf.split_whitespace().map(|s| s.parse().unwrap()).collect();
} | 83 |
{
let args: Vec<String> = std::env::args().collect();
if args.len() < 2 {
eprintln!("Syntax: {} <filename>", args[0]);
return;
}
let path = Path::new(&args[1]);
let display = path.display();
let mut file = match File::open(&path) {
Err(why) => panic!("Could not o... | 84 |
{
try!(write_marker(wr, Marker::I16));
write_data_i16(wr, val)
} | 85 |
{
f
.
debug_struct
(
"
AtomicCell
"
)
.
field
(
"
value
"
&
self
.
load
(
)
)
.
finish
(
)
} | 86 |
{
let
db
=
Connection
:
:
open_in_memory
(
)
?
;
db
.
execute_batch
(
"
CREATE
TABLE
foo
(
b
BLOB
t
TEXT
i
INTEGER
f
FLOAT
n
)
"
)
?
;
Ok
(
db
)
} | 87 |
{
let mut chars = i.chars();
if let Some(f) = chars.next() {
if f.is_alphabetic() || f == '_' {
let mut idx = 1;
for c in chars {
if !(c.is_alphanumeric() || c == '_') {
break;
}
idx += 1;
}
... | 88 |
{
try!(write_marker(wr, Marker::F64));
write_data_f64(wr, val)
} | 89 |
{
move |ratio| {
if ratio_checker(ratio) {
format!("{ratio:.3}")
} else {
format!("* {ratio:.3} *")
}
}
} | 90 |
{
for bases in sequence.as_ref().chunks(line_bases) {
writer.write_all(bases)?;
writeln!(writer)?;
}
Ok(())
} | 91 |
{
client_async_tls_with_connector_and_config(request, stream, None, None).await
} | 92 |
{
let mut head_children = layout.children();
let head_background = Primitive::Quad {
bounds: layout.bounds(),
background: style.head_background,
border_radius: style.border_radius,
border_width: 0.0,
border_color: Color::TRANSPARENT,
};
let (head, head_mouse_inte... | 93 |
{
assert!(val < 128);
write_fixval(wr, Marker::FixPos(val))
} | 94 |
{
wr.write_u8(marker.to_u8()).map_err(From::from)
} | 95 |
{
let boxes = iproduct!(0..9, 0..9);
boxes
} | 96 |
{
atomic
!
{
T
a
{
a
=
&
*
(
dst
as
*
const
_
as
*
const
_
)
;
a
.
store
(
mem
:
:
transmute_copy
(
&
val
)
Ordering
:
:
Release
)
;
mem
:
:
forget
(
val
)
;
}
{
let
_guard
=
lock
(
dst
as
usize
)
.
write
(
)
;
ptr
:
:
write
(
dst
val
)
;
}
}
} | 97 |
{
unsafe
{
atomic_compare_exchange_weak
(
self
.
as_ptr
(
)
current
new
)
}
} | 98 |
{
try!(write_marker(wr, Marker::U32));
write_data_u32(wr, val)
} | 99 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 4