content stringlengths 3 6.31k | id int64 0 123 |
|---|---|
{
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... | 0 |
{
unsafe
{
atomic_load
(
self
.
as_ptr
(
)
)
}
} | 1 |
{
accept_hdr_async(stream, NoCallback).await
} | 2 |
{
connect_async_with_tls_connector_and_config(request, connector, None).await
} | 3 |
{
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... | 4 |
{
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
(
(
)
)
} | 5 |
{
match File::open(&path) {
Err(_) => {
println!("cannot open file: {:?}", path.as_ref());
exit(1)
}
Ok(file) => file,
}
} | 6 |
{
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 ... | 7 |
{
client_async_with_config(request, stream, None).await
} | 8 |
{
assert!(-32 <= val && val < 0);
write_fixval(wr, Marker::FixNeg(val))
} | 9 |
{
let
a
=
unsafe
{
&
*
(
self
.
as_ptr
(
)
as
*
const
AtomicBool
)
}
;
a
.
fetch_or
(
val
Ordering
:
:
AcqRel
)
} | 10 |
{
let boxes = iproduct!(0..9, 0..9);
boxes
} | 11 |
{
try!(write_marker(wr, Marker::U16));
write_data_u16(wr, val)
} | 12 |
{
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... | 13 |
{
let
db
=
Connection
:
:
open_in_memory
(
)
?
;
db
.
execute_batch
(
"
CREATE
TABLE
foo
(
b
BLOB
t
TEXT
i
INTEGER
f
FLOAT
n
)
"
)
?
;
Ok
(
db
)
} | 14 |
{
pub
fn
load
(
&
self
)
-
>
T
{
unsafe
{
atomic_load
(
self
.
as_ptr
(
)
)
}
}
} | 15 |
{
let mut result = Vec::new();
for crates_diff in db_data.merge_join_by(index_data, |db, index| db.name.cmp(&index.name)) {
match crates_diff {
Both(db_crate, index_crate) => {
for release_diff in db_crate
.releases
.iter()
... | 16 |
{
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
... | 17 |
{
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... | 18 |
{
crate::client_async_with_config(request, TokioAdapter(stream), config).await
} | 19 |
{
#
[
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
... | 20 |
{
let
a
=
unsafe
{
&
*
(
self
.
as_ptr
(
)
as
*
const
AtomicBool
)
}
;
a
.
fetch_xor
(
val
Ordering
:
:
AcqRel
)
} | 21 |
{
if len < 16 {
let marker = Marker::FixArray(len as u8);
try!(write_fixval(wr, marker));
Ok(marker)
} else if len < 65536 {
try!(write_marker(wr, Marker::Array16));
write_data_u16(wr, len as u16).and(Ok(Marker::Array16))
} else {
try!(write_marker(wr, Marker:... | 22 |
{
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);
... | 23 |
{
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
)
} | 24 |
{
match val {
true => write_fixval(wr, Marker::True),
false => write_fixval(wr, Marker::False)
}
} | 25 |
{
Sampling::<(MCLK, SrInvalid)> {
data: 0b1000 << 9,
t: PhantomData::<(MCLK, SrInvalid)>,
}
} | 26 |
{
let decompressed = dec(expected_comp).expect("Valid Decompress");
assert_eq!(decompressed, expected_dec);
} | 27 |
{
crate::accept_hdr_async_with_config(TokioAdapter(stream), callback, config).await
} | 28 |
{
let
from
=
from
.
as_ref
(
)
.
to_owned
(
)
;
let
to
=
to
.
as_ref
(
)
.
to_owned
(
)
;
asyncify
(
move
|
|
std
:
:
fs
:
:
rename
(
from
to
)
)
.
await
} | 29 |
{
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... | 30 |
{
wr.write_u8(marker.to_u8()).map_err(From::from)
} | 31 |
{
try!(write_marker(wr, Marker::F64));
write_data_f64(wr, val)
} | 32 |
{
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
)
}
}
} | 33 |
{
match
self
.
compare_exchange
(
current
new
)
{
Ok
(
v
)
=
>
v
Err
(
v
)
=
>
v
}
} | 34 |
{
} | 35 |
{
matches
!
(
err
Error
:
:
InvalidColumnType
(
.
.
)
)
} | 36 |
{
try!(write_marker(wr, Marker::I32));
write_data_i32(wr, val)
} | 37 |
{
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 wor... | 38 |
{
atomic
!
{
T
a
{
a
=
&
*
(
dst
as
*
const
_
as
*
const
_
)
;
let
mut
current_raw
=
mem
:
:
transmute_copy
(
&
current
)
;
let
new_raw
=
mem
:
:
transmute_copy
(
&
new
)
;
loop
{
match
a
.
compare_exchange_weak
(
current_raw
new_raw
Ordering
:
:
AcqRel
Ordering
:
:
Acquire
)
{
Ok
(
_
)
=
>
break
Ok
(
current
)
Err
(
p... | 39 |
{
wr.write_u8(marker.to_u8()).map_err(|err| FixedValueWriteError(From::from(err)))
} | 40 |
{
try!(write_bin_len(wr, data.len() as u32));
wr.write_all(data).map_err(|err| ValueWriteError::InvalidDataWrite(WriteError(err)))
} | 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 |
{
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()
... | 43 |
{
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
(
(
)
)
} | 44 |
{
connect_async_with_config(request, None).await
} | 45 |
{
try!(write_str_len(wr, data.len() as u32));
wr.write_all(data.as_bytes()).map_err(|err| ValueWriteError::InvalidDataWrite(WriteError(err)))
} | 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 |
{
self
.
execute
(
fut
)
} | 48 |
{
accept_hdr_async_with_config(stream, callback, None).await
} | 49 |
{
let compressed = comp(expected_dec);
assert_eq!(compressed, expected_comp);
} | 50 |
{
#
[
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
{... | 51 |
{
let
a
=
unsafe
{
&
*
(
self
.
as_ptr
(
)
as
*
const
AtomicBool
)
}
;
a
.
fetch_nand
(
val
Ordering
:
:
AcqRel
)
} | 52 |
{
assert!(val < 128);
write_fixval(wr, Marker::FixPos(val))
} | 53 |
{
try!(write_marker(wr, Marker::I16));
write_data_i16(wr, val)
} | 54 |
{
Ok
(
(
)
)
} | 55 |
{
let mut buf = String::with_capacity(100);
stdin().read_line(&mut buf).unwrap();
return buf.split_whitespace().map(|s| s.parse().unwrap()).collect();
} | 56 |
{
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;
}
... | 57 |
{
match File::create(&path) {
Err(_) => {
println!("cannot create file: {:?}", path.as_ref());
exit(1)
}
Ok(file) => file,
}
} | 58 |
{
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
)
;
}
}
} | 59 |
{
unsafe
{
atomic_compare_exchange_weak
(
self
.
as_ptr
(
)
current
new
)
}
} | 60 |
{
let aff_size = std::mem::size_of::<E::G1Affine>() + std::mem::size_of::<E::G2Affine>();
let exp_size = exp_size::<E>();
let proj_size = std::mem::size_of::<E::G1>() + std::mem::size_of::<E::G2>();
((((mem as f64) * (1f64 - MEMORY_PADDING)) as usize)
- (2 * core_count * ((1 << MAX_WINDOW_SIZE) ... | 61 |
{
if
mem
:
:
needs_drop
:
:
<
T
>
(
)
{
unsafe
{
self
.
as_ptr
(
)
.
drop_in_place
(
)
;
}
}
} | 62 |
{
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... | 63 |
{
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... | 64 |
{
fn inner<E, CS>(mut cs: CS, left: &Scalar<E>, right: &Scalar<E>) -> Result<Scalar<E>, Error>
where
E: IEngine,
CS: ConstraintSystem<E>,
{
let scalar_type = zinc_types::ScalarType::expect_same(left.get_type(), right.get_type())?;
scalar_type.assert_signed(false)?;
l... | 65 |
{
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;
},
... | 66 |
{
client_async_tls_with_connector_and_config(request, stream, None, config).await
} | 67 |
{
client_async_tls_with_connector_and_config(request, stream, None, None).await
} | 68 |
{
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... | 69 |
{
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
(
(
)
)
} | 70 |
{
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
... | 71 |
{
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... | 72 |
{
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... | 73 |
{
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... | 74 |
{
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... | 75 |
{
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... | 76 |
{
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)) => {
... | 77 |
{
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)... | 78 |
{
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
(
(
)
)
} | 79 |
{
let in_data = dot_vox::load(ifpath).unwrap();
let file = File::create(ofpath)?;
let mut file = LineWriter::new(file);
let len_str: String = in_data.palette.len().to_string() + "\n";
file.write_all(b"JASC\n")?;
file.write_all(b"0100\n")?;
file.write_all(len_str.as_bytes())?;
for elemen... | 80 |
{
// 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))
... | 81 |
{
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);
} | 82 |
{
let mut body_children = layout.children();
let body_background = Primitive::Quad {
bounds: layout.bounds(),
background: style.body_background,
border_radius: 0.0,
border_width: 0.0,
border_color: Color::TRANSPARENT,
};
let (body, mouse_interaction) = body.draw(... | 83 |
{
try!(write_marker(wr, Marker::U8));
write_data_u8(wr, val)
} | 84 |
{
MessagePackSink(w)
} | 85 |
{
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.... | 86 |
{
f
.
debug_struct
(
"
AtomicCell
"
)
.
field
(
"
value
"
&
self
.
load
(
)
)
.
finish
(
)
} | 87 |
{
try!(write_marker(wr, Marker::I8));
write_data_i8(wr, val)
} | 88 |
{
try!(write_marker(wr, Marker::U64));
write_data_u64(wr, val)
} | 89 |
{
let
is_lock_free
=
can_transmute
:
:
<
T
AtomicUnit
>
(
)
|
can_transmute
:
:
<
T
atomic
:
:
AtomicU8
>
(
)
|
can_transmute
:
:
<
T
atomic
:
:
AtomicU16
>
(
)
|
can_transmute
:
:
<
T
atomic
:
:
AtomicU32
>
(
)
;
#
[
cfg
(
not
(
crossbeam_no_atomic_64
)
)
]
let
is_lock_free
=
is_lock_free
|
can_transmute
:
:
<
T
atomi... | 90 |
{
client_async_tls_with_connector_and_config(request, stream, connector, None).await
} | 91 |
{
move |ratio| {
if ratio_checker(ratio) {
format!("{ratio:.3}")
} else {
format!("* {ratio:.3} *")
}
}
} | 92 |
{
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... | 93 |
{
use x86_64::instructions::segmentation::set_cs;
use x86_64::instructions::tables::load_tss;
GDT.0.load();
unsafe
{
set_cs(GDT.1.codesel);
load_tss(GDT.1.tsssel);
}
} | 94 |
{
try!(write_marker(wr, Marker::F32));
write_data_f32(wr, val)
} | 95 |
{
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()
} | 96 |
{
accept_hdr_async_with_config(stream, NoCallback, config).await
} | 97 |
{
try!(write_marker(wr, Marker::I64));
write_data_i64(wr, val)
} | 98 |
{
device_manager::register_driver(&s_pci_legacy_driver);
device_manager::register_driver(&s_pci_native_driver);
} | 99 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.