file_name
large_stringlengths 4
69
| prefix
large_stringlengths 0
26.7k
| suffix
large_stringlengths 0
24.8k
| middle
large_stringlengths 0
2.12k
| fim_type
large_stringclasses 4
values |
|---|---|---|---|---|
adv3.rs | #![allow(warnings)]
// Goal #1: Eliminate the borrow check error in the `remove` method.
pub struct Map<K: Eq, V> {
elements: Vec<(K, V)>,
}
impl<K: Eq, V> Map<K, V> { | pub fn new() -> Self {
Map { elements: vec![] }
}
pub fn insert(&mut self, key: K, value: V) {
self.elements.push((key, value));
}
pub fn get(&self, key: &K) -> Option<&V> {
self.elements.iter().rev().find(|pair| pair.0 == *key).map(|pair| &pair.1)
}
pub fn remove(&mut self, key: &K) {
let mut i : Option<usize> = None;
for (index, pair) in self.elements.iter().enumerate() {
if pair.0 == *key {
i = Some(index);
break;
}
}
match i {
Some(index) => {self.elements.remove(index);},
None => {},
}
}
} | random_line_split |
|
fault.rs | use std::panic::catch_unwind;
use std::error::Error;
use std::fmt;
use std::io::{Write, stderr, Error as IoError, ErrorKind};
pub fn catch_fault() {
let result = catch_unwind(|| {
panic!("holy crap!");
});
println!("\n{:?}\n", result);
}
pub fn get_something() -> Result<(), String> {
Err("holy crap".to_string())
}
| let _ = writeln!(stderr(), "error: {}", err);
while let Some(cause) = err.cause() {
let _ = writeln!(stderr(), "caused by: {}", cause);
err = cause;
}
}
pub fn demo_print_std_err() {
#[derive(Debug)]
struct SuperErrorSideKick;
impl fmt::Display for SuperErrorSideKick {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "SuperErrorSideKick is here!")
}
}
impl Error for SuperErrorSideKick {
fn description(&self) -> &str {
"I'm SuperError side kick"
}
}
#[derive(Debug)]
struct SuperError;
impl fmt::Display for SuperError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "SuperError is here!")
}
}
impl Error for SuperError {
fn description(&self) -> &str {
"I'm the superhero of errors"
}
fn cause(&self) -> Option<&Error> {
Some(&SuperErrorSideKick{})
}
}
let mut err = SuperError{};
println!("{:?}", err.cause());
print_error(&err);
}
pub fn err_propagation() -> Result<(), IoError> {
Err(IoError::new(ErrorKind::Other, "oh no!"))
}
pub fn demo_err_propagation() -> Result<(), IoError> {
let result = err_propagation()?;
println!("propagation in middle.");
Ok(())
} | pub fn print_error(mut err: &Error) { | random_line_split |
fault.rs | use std::panic::catch_unwind;
use std::error::Error;
use std::fmt;
use std::io::{Write, stderr, Error as IoError, ErrorKind};
pub fn catch_fault() {
let result = catch_unwind(|| {
panic!("holy crap!");
});
println!("\n{:?}\n", result);
}
pub fn get_something() -> Result<(), String> {
Err("holy crap".to_string())
}
pub fn print_error(mut err: &Error) {
let _ = writeln!(stderr(), "error: {}", err);
while let Some(cause) = err.cause() {
let _ = writeln!(stderr(), "caused by: {}", cause);
err = cause;
}
}
pub fn demo_print_std_err() {
#[derive(Debug)]
struct SuperErrorSideKick;
impl fmt::Display for SuperErrorSideKick {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "SuperErrorSideKick is here!")
}
}
impl Error for SuperErrorSideKick {
fn description(&self) -> &str |
}
#[derive(Debug)]
struct SuperError;
impl fmt::Display for SuperError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "SuperError is here!")
}
}
impl Error for SuperError {
fn description(&self) -> &str {
"I'm the superhero of errors"
}
fn cause(&self) -> Option<&Error> {
Some(&SuperErrorSideKick{})
}
}
let mut err = SuperError{};
println!("{:?}", err.cause());
print_error(&err);
}
pub fn err_propagation() -> Result<(), IoError> {
Err(IoError::new(ErrorKind::Other, "oh no!"))
}
pub fn demo_err_propagation() -> Result<(), IoError> {
let result = err_propagation()?;
println!("propagation in middle.");
Ok(())
} | {
"I'm SuperError side kick"
} | identifier_body |
fault.rs | use std::panic::catch_unwind;
use std::error::Error;
use std::fmt;
use std::io::{Write, stderr, Error as IoError, ErrorKind};
pub fn catch_fault() {
let result = catch_unwind(|| {
panic!("holy crap!");
});
println!("\n{:?}\n", result);
}
pub fn get_something() -> Result<(), String> {
Err("holy crap".to_string())
}
pub fn print_error(mut err: &Error) {
let _ = writeln!(stderr(), "error: {}", err);
while let Some(cause) = err.cause() {
let _ = writeln!(stderr(), "caused by: {}", cause);
err = cause;
}
}
pub fn demo_print_std_err() {
#[derive(Debug)]
struct SuperErrorSideKick;
impl fmt::Display for SuperErrorSideKick {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "SuperErrorSideKick is here!")
}
}
impl Error for SuperErrorSideKick {
fn description(&self) -> &str {
"I'm SuperError side kick"
}
}
#[derive(Debug)]
struct SuperError;
impl fmt::Display for SuperError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "SuperError is here!")
}
}
impl Error for SuperError {
fn | (&self) -> &str {
"I'm the superhero of errors"
}
fn cause(&self) -> Option<&Error> {
Some(&SuperErrorSideKick{})
}
}
let mut err = SuperError{};
println!("{:?}", err.cause());
print_error(&err);
}
pub fn err_propagation() -> Result<(), IoError> {
Err(IoError::new(ErrorKind::Other, "oh no!"))
}
pub fn demo_err_propagation() -> Result<(), IoError> {
let result = err_propagation()?;
println!("propagation in middle.");
Ok(())
} | description | identifier_name |
extcolorbufferhalffloat.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
use canvas_traits::webgl::WebGLVersion;
use crate::dom::bindings::codegen::Bindings::EXTColorBufferHalfFloatBinding;
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
use crate::dom::bindings::root::DomRoot;
use crate::dom::webgl_extensions::ext::oestexturehalffloat::OESTextureHalfFloat;
use crate::dom::webglrenderingcontext::WebGLRenderingContext;
use dom_struct::dom_struct;
#[dom_struct]
pub struct EXTColorBufferHalfFloat {
reflector_: Reflector, |
impl EXTColorBufferHalfFloat {
fn new_inherited() -> EXTColorBufferHalfFloat {
Self {
reflector_: Reflector::new(),
}
}
}
impl WebGLExtension for EXTColorBufferHalfFloat {
type Extension = EXTColorBufferHalfFloat;
fn new(ctx: &WebGLRenderingContext) -> DomRoot<EXTColorBufferHalfFloat> {
reflect_dom_object(
Box::new(EXTColorBufferHalfFloat::new_inherited()),
&*ctx.global(),
EXTColorBufferHalfFloatBinding::Wrap,
)
}
fn spec() -> WebGLExtensionSpec {
WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
}
fn is_supported(ext: &WebGLExtensions) -> bool {
OESTextureHalfFloat::is_supported(ext)
}
fn enable(_ext: &WebGLExtensions) {}
fn name() -> &'static str {
"EXT_color_buffer_half_float"
}
} | } | random_line_split |
extcolorbufferhalffloat.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
use canvas_traits::webgl::WebGLVersion;
use crate::dom::bindings::codegen::Bindings::EXTColorBufferHalfFloatBinding;
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
use crate::dom::bindings::root::DomRoot;
use crate::dom::webgl_extensions::ext::oestexturehalffloat::OESTextureHalfFloat;
use crate::dom::webglrenderingcontext::WebGLRenderingContext;
use dom_struct::dom_struct;
#[dom_struct]
pub struct | {
reflector_: Reflector,
}
impl EXTColorBufferHalfFloat {
fn new_inherited() -> EXTColorBufferHalfFloat {
Self {
reflector_: Reflector::new(),
}
}
}
impl WebGLExtension for EXTColorBufferHalfFloat {
type Extension = EXTColorBufferHalfFloat;
fn new(ctx: &WebGLRenderingContext) -> DomRoot<EXTColorBufferHalfFloat> {
reflect_dom_object(
Box::new(EXTColorBufferHalfFloat::new_inherited()),
&*ctx.global(),
EXTColorBufferHalfFloatBinding::Wrap,
)
}
fn spec() -> WebGLExtensionSpec {
WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
}
fn is_supported(ext: &WebGLExtensions) -> bool {
OESTextureHalfFloat::is_supported(ext)
}
fn enable(_ext: &WebGLExtensions) {}
fn name() -> &'static str {
"EXT_color_buffer_half_float"
}
}
| EXTColorBufferHalfFloat | identifier_name |
common.rs | use std::ffi::CString;
use std::os::raw::c_char;
#[macro_export]
macro_rules! take_until_and_consume (
( $i:expr, $needle:expr ) => (
{
let input: &[u8] = $i;
let (rem, res) = ::nom::take_until!(input, $needle)?;
let (rem, _) = ::nom::take!(rem, $needle.len())?;
Ok((rem, res))
}
);
);
#[cfg(not(feature = "debug-validate"))]
#[macro_export]
macro_rules! debug_validate_bug_on (
($item:expr) => {};
);
#[cfg(feature = "debug-validate")]
#[macro_export]
macro_rules! debug_validate_bug_on (
($item:expr) => {
if $item {
panic!("Condition check failed");
}
};
);
#[cfg(not(feature = "debug-validate"))]
#[macro_export]
macro_rules! debug_validate_fail (
($msg:expr) => {};
);
#[cfg(feature = "debug-validate")]
#[macro_export]
macro_rules! debug_validate_fail (
($msg:expr) => {
// Wrap in a conditional to prevent unreachable code warning in caller.
if true {
panic!($msg);
}
};
);
/// Convert a String to C-compatible string
///
/// This function will consume the provided data and use the underlying bytes to construct a new
/// string, ensuring that there is a trailing 0 byte. This trailing 0 byte will be appended by this
/// function; the provided data should *not* contain any 0 bytes in it.
///
/// Returns a valid pointer, or NULL
pub fn rust_string_to_c(s: String) -> *mut c_char {
CString::new(s)
.map(|c_str| c_str.into_raw())
.unwrap_or(std::ptr::null_mut())
}
/// Free a CString allocated by Rust (for ex. using `rust_string_to_c`)
///
/// # Safety
///
/// s must be allocated by rust, using `CString::new`
#[no_mangle]
pub unsafe extern "C" fn rs_cstring_free(s: *mut c_char) {
if s.is_null() |
drop(CString::from_raw(s));
}
| {
return;
} | conditional_block |
common.rs | use std::ffi::CString;
use std::os::raw::c_char;
#[macro_export]
macro_rules! take_until_and_consume (
( $i:expr, $needle:expr ) => (
{
let input: &[u8] = $i;
let (rem, res) = ::nom::take_until!(input, $needle)?;
let (rem, _) = ::nom::take!(rem, $needle.len())?;
Ok((rem, res))
}
);
);
#[cfg(not(feature = "debug-validate"))]
#[macro_export]
macro_rules! debug_validate_bug_on (
($item:expr) => {};
);
#[cfg(feature = "debug-validate")]
#[macro_export]
macro_rules! debug_validate_bug_on (
($item:expr) => {
if $item {
panic!("Condition check failed");
}
};
);
#[cfg(not(feature = "debug-validate"))]
#[macro_export]
macro_rules! debug_validate_fail (
($msg:expr) => {};
);
#[cfg(feature = "debug-validate")]
#[macro_export]
macro_rules! debug_validate_fail (
($msg:expr) => {
// Wrap in a conditional to prevent unreachable code warning in caller.
if true {
panic!($msg);
}
};
);
/// Convert a String to C-compatible string
///
/// This function will consume the provided data and use the underlying bytes to construct a new
/// string, ensuring that there is a trailing 0 byte. This trailing 0 byte will be appended by this
/// function; the provided data should *not* contain any 0 bytes in it.
///
/// Returns a valid pointer, or NULL
pub fn | (s: String) -> *mut c_char {
CString::new(s)
.map(|c_str| c_str.into_raw())
.unwrap_or(std::ptr::null_mut())
}
/// Free a CString allocated by Rust (for ex. using `rust_string_to_c`)
///
/// # Safety
///
/// s must be allocated by rust, using `CString::new`
#[no_mangle]
pub unsafe extern "C" fn rs_cstring_free(s: *mut c_char) {
if s.is_null() {
return;
}
drop(CString::from_raw(s));
}
| rust_string_to_c | identifier_name |
common.rs | use std::ffi::CString;
use std::os::raw::c_char;
#[macro_export]
macro_rules! take_until_and_consume (
( $i:expr, $needle:expr ) => (
{
let input: &[u8] = $i;
let (rem, res) = ::nom::take_until!(input, $needle)?;
let (rem, _) = ::nom::take!(rem, $needle.len())?;
Ok((rem, res))
}
);
);
#[cfg(not(feature = "debug-validate"))]
#[macro_export]
macro_rules! debug_validate_bug_on (
($item:expr) => {};
);
#[cfg(feature = "debug-validate")]
#[macro_export]
macro_rules! debug_validate_bug_on (
($item:expr) => {
if $item {
panic!("Condition check failed");
}
};
);
#[cfg(not(feature = "debug-validate"))]
#[macro_export]
macro_rules! debug_validate_fail (
($msg:expr) => {};
);
#[cfg(feature = "debug-validate")]
#[macro_export]
macro_rules! debug_validate_fail (
($msg:expr) => {
// Wrap in a conditional to prevent unreachable code warning in caller.
if true {
panic!($msg);
}
};
); | ///
/// This function will consume the provided data and use the underlying bytes to construct a new
/// string, ensuring that there is a trailing 0 byte. This trailing 0 byte will be appended by this
/// function; the provided data should *not* contain any 0 bytes in it.
///
/// Returns a valid pointer, or NULL
pub fn rust_string_to_c(s: String) -> *mut c_char {
CString::new(s)
.map(|c_str| c_str.into_raw())
.unwrap_or(std::ptr::null_mut())
}
/// Free a CString allocated by Rust (for ex. using `rust_string_to_c`)
///
/// # Safety
///
/// s must be allocated by rust, using `CString::new`
#[no_mangle]
pub unsafe extern "C" fn rs_cstring_free(s: *mut c_char) {
if s.is_null() {
return;
}
drop(CString::from_raw(s));
} |
/// Convert a String to C-compatible string | random_line_split |
common.rs | use std::ffi::CString;
use std::os::raw::c_char;
#[macro_export]
macro_rules! take_until_and_consume (
( $i:expr, $needle:expr ) => (
{
let input: &[u8] = $i;
let (rem, res) = ::nom::take_until!(input, $needle)?;
let (rem, _) = ::nom::take!(rem, $needle.len())?;
Ok((rem, res))
}
);
);
#[cfg(not(feature = "debug-validate"))]
#[macro_export]
macro_rules! debug_validate_bug_on (
($item:expr) => {};
);
#[cfg(feature = "debug-validate")]
#[macro_export]
macro_rules! debug_validate_bug_on (
($item:expr) => {
if $item {
panic!("Condition check failed");
}
};
);
#[cfg(not(feature = "debug-validate"))]
#[macro_export]
macro_rules! debug_validate_fail (
($msg:expr) => {};
);
#[cfg(feature = "debug-validate")]
#[macro_export]
macro_rules! debug_validate_fail (
($msg:expr) => {
// Wrap in a conditional to prevent unreachable code warning in caller.
if true {
panic!($msg);
}
};
);
/// Convert a String to C-compatible string
///
/// This function will consume the provided data and use the underlying bytes to construct a new
/// string, ensuring that there is a trailing 0 byte. This trailing 0 byte will be appended by this
/// function; the provided data should *not* contain any 0 bytes in it.
///
/// Returns a valid pointer, or NULL
pub fn rust_string_to_c(s: String) -> *mut c_char |
/// Free a CString allocated by Rust (for ex. using `rust_string_to_c`)
///
/// # Safety
///
/// s must be allocated by rust, using `CString::new`
#[no_mangle]
pub unsafe extern "C" fn rs_cstring_free(s: *mut c_char) {
if s.is_null() {
return;
}
drop(CString::from_raw(s));
}
| {
CString::new(s)
.map(|c_str| c_str.into_raw())
.unwrap_or(std::ptr::null_mut())
} | identifier_body |
https.rs | extern crate rustls;
extern crate webpki_roots;
use std::net::SocketAddr;
use crate::name_server::RuntimeProvider;
use crate::tls::CLIENT_CONFIG;
use proto::xfer::{DnsExchange, DnsExchangeConnect};
use proto::TokioTime;
use trust_dns_https::{
HttpsClientConnect, HttpsClientResponse, HttpsClientStream, HttpsClientStreamBuilder,
};
use crate::config::TlsClientConfig;
#[allow(clippy::type_complexity)]
pub(crate) fn new_https_stream<R>(
socket_addr: SocketAddr,
dns_name: String,
client_config: Option<TlsClientConfig>,
) -> DnsExchangeConnect<HttpsClientConnect<R::Tcp>, HttpsClientStream, HttpsClientResponse, TokioTime>
where
R: RuntimeProvider,
{
let client_config = client_config.map_or_else(
|| CLIENT_CONFIG.clone(),
|TlsClientConfig(client_config)| client_config,
);
let https_builder = HttpsClientStreamBuilder::with_client_config(client_config);
DnsExchange::connect(https_builder.build::<R::Tcp>(socket_addr, dns_name))
}
#[cfg(test)]
mod tests {
extern crate env_logger;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use tokio::runtime::Runtime;
use crate::config::{ResolverConfig, ResolverOpts};
use crate::TokioAsyncResolver;
fn https_test(config: ResolverConfig) {
//env_logger::try_init().ok();
let mut io_loop = Runtime::new().unwrap();
let resolver =
TokioAsyncResolver::new(config, ResolverOpts::default(), io_loop.handle().clone())
.expect("failed to create resolver");
let response = io_loop
.block_on(resolver.lookup_ip("www.example.com."))
.expect("failed to run lookup");
assert_eq!(response.iter().count(), 1);
for address in response.iter() {
if address.is_ipv4() {
assert_eq!(address, IpAddr::V4(Ipv4Addr::new(93, 184, 216, 34)));
} else {
assert_eq!(
address,
IpAddr::V6(Ipv6Addr::new(
0x2606, 0x2800, 0x220, 0x1, 0x248, 0x1893, 0x25c8, 0x1946,
))
);
}
}
// check if there is another connection created
let response = io_loop
.block_on(resolver.lookup_ip("www.example.com."))
.expect("failed to run lookup");
assert_eq!(response.iter().count(), 1);
for address in response.iter() {
if address.is_ipv4() {
assert_eq!(address, IpAddr::V4(Ipv4Addr::new(93, 184, 216, 34)));
} else {
assert_eq!(
address,
IpAddr::V6(Ipv6Addr::new(
0x2606, 0x2800, 0x220, 0x1, 0x248, 0x1893, 0x25c8, 0x1946,
))
);
}
}
}
#[test]
fn test_cloudflare_https() |
}
| {
https_test(ResolverConfig::cloudflare_https())
} | identifier_body |
https.rs | extern crate rustls;
extern crate webpki_roots;
use std::net::SocketAddr;
use crate::name_server::RuntimeProvider;
use crate::tls::CLIENT_CONFIG;
use proto::xfer::{DnsExchange, DnsExchangeConnect};
use proto::TokioTime;
use trust_dns_https::{
HttpsClientConnect, HttpsClientResponse, HttpsClientStream, HttpsClientStreamBuilder,
};
use crate::config::TlsClientConfig;
#[allow(clippy::type_complexity)]
pub(crate) fn new_https_stream<R>(
socket_addr: SocketAddr,
dns_name: String,
client_config: Option<TlsClientConfig>,
) -> DnsExchangeConnect<HttpsClientConnect<R::Tcp>, HttpsClientStream, HttpsClientResponse, TokioTime>
where
R: RuntimeProvider,
{
let client_config = client_config.map_or_else(
|| CLIENT_CONFIG.clone(),
|TlsClientConfig(client_config)| client_config,
);
let https_builder = HttpsClientStreamBuilder::with_client_config(client_config);
DnsExchange::connect(https_builder.build::<R::Tcp>(socket_addr, dns_name))
}
#[cfg(test)]
mod tests {
extern crate env_logger;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use tokio::runtime::Runtime;
use crate::config::{ResolverConfig, ResolverOpts};
use crate::TokioAsyncResolver;
fn https_test(config: ResolverConfig) {
//env_logger::try_init().ok();
let mut io_loop = Runtime::new().unwrap();
let resolver =
TokioAsyncResolver::new(config, ResolverOpts::default(), io_loop.handle().clone())
.expect("failed to create resolver");
let response = io_loop
.block_on(resolver.lookup_ip("www.example.com."))
.expect("failed to run lookup");
assert_eq!(response.iter().count(), 1);
for address in response.iter() {
if address.is_ipv4() {
assert_eq!(address, IpAddr::V4(Ipv4Addr::new(93, 184, 216, 34)));
} else {
assert_eq!(
address,
IpAddr::V6(Ipv6Addr::new(
0x2606, 0x2800, 0x220, 0x1, 0x248, 0x1893, 0x25c8, 0x1946,
))
);
}
}
// check if there is another connection created
let response = io_loop
.block_on(resolver.lookup_ip("www.example.com."))
.expect("failed to run lookup");
assert_eq!(response.iter().count(), 1);
for address in response.iter() {
if address.is_ipv4() {
assert_eq!(address, IpAddr::V4(Ipv4Addr::new(93, 184, 216, 34)));
} else {
assert_eq!(
address,
IpAddr::V6(Ipv6Addr::new(
0x2606, 0x2800, 0x220, 0x1, 0x248, 0x1893, 0x25c8, 0x1946,
))
);
}
}
}
#[test]
fn | () {
https_test(ResolverConfig::cloudflare_https())
}
}
| test_cloudflare_https | identifier_name |
https.rs | extern crate rustls;
extern crate webpki_roots;
use std::net::SocketAddr;
use crate::name_server::RuntimeProvider;
use crate::tls::CLIENT_CONFIG;
use proto::xfer::{DnsExchange, DnsExchangeConnect};
use proto::TokioTime;
use trust_dns_https::{
HttpsClientConnect, HttpsClientResponse, HttpsClientStream, HttpsClientStreamBuilder,
};
use crate::config::TlsClientConfig;
#[allow(clippy::type_complexity)]
pub(crate) fn new_https_stream<R>(
socket_addr: SocketAddr,
dns_name: String,
client_config: Option<TlsClientConfig>,
) -> DnsExchangeConnect<HttpsClientConnect<R::Tcp>, HttpsClientStream, HttpsClientResponse, TokioTime>
where
R: RuntimeProvider,
{
let client_config = client_config.map_or_else(
|| CLIENT_CONFIG.clone(),
|TlsClientConfig(client_config)| client_config,
);
let https_builder = HttpsClientStreamBuilder::with_client_config(client_config);
DnsExchange::connect(https_builder.build::<R::Tcp>(socket_addr, dns_name))
}
#[cfg(test)]
mod tests {
extern crate env_logger;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use tokio::runtime::Runtime;
use crate::config::{ResolverConfig, ResolverOpts};
use crate::TokioAsyncResolver;
fn https_test(config: ResolverConfig) {
//env_logger::try_init().ok();
let mut io_loop = Runtime::new().unwrap();
| let resolver =
TokioAsyncResolver::new(config, ResolverOpts::default(), io_loop.handle().clone())
.expect("failed to create resolver");
let response = io_loop
.block_on(resolver.lookup_ip("www.example.com."))
.expect("failed to run lookup");
assert_eq!(response.iter().count(), 1);
for address in response.iter() {
if address.is_ipv4() {
assert_eq!(address, IpAddr::V4(Ipv4Addr::new(93, 184, 216, 34)));
} else {
assert_eq!(
address,
IpAddr::V6(Ipv6Addr::new(
0x2606, 0x2800, 0x220, 0x1, 0x248, 0x1893, 0x25c8, 0x1946,
))
);
}
}
// check if there is another connection created
let response = io_loop
.block_on(resolver.lookup_ip("www.example.com."))
.expect("failed to run lookup");
assert_eq!(response.iter().count(), 1);
for address in response.iter() {
if address.is_ipv4() {
assert_eq!(address, IpAddr::V4(Ipv4Addr::new(93, 184, 216, 34)));
} else {
assert_eq!(
address,
IpAddr::V6(Ipv6Addr::new(
0x2606, 0x2800, 0x220, 0x1, 0x248, 0x1893, 0x25c8, 0x1946,
))
);
}
}
}
#[test]
fn test_cloudflare_https() {
https_test(ResolverConfig::cloudflare_https())
}
} | random_line_split |
|
https.rs | extern crate rustls;
extern crate webpki_roots;
use std::net::SocketAddr;
use crate::name_server::RuntimeProvider;
use crate::tls::CLIENT_CONFIG;
use proto::xfer::{DnsExchange, DnsExchangeConnect};
use proto::TokioTime;
use trust_dns_https::{
HttpsClientConnect, HttpsClientResponse, HttpsClientStream, HttpsClientStreamBuilder,
};
use crate::config::TlsClientConfig;
#[allow(clippy::type_complexity)]
pub(crate) fn new_https_stream<R>(
socket_addr: SocketAddr,
dns_name: String,
client_config: Option<TlsClientConfig>,
) -> DnsExchangeConnect<HttpsClientConnect<R::Tcp>, HttpsClientStream, HttpsClientResponse, TokioTime>
where
R: RuntimeProvider,
{
let client_config = client_config.map_or_else(
|| CLIENT_CONFIG.clone(),
|TlsClientConfig(client_config)| client_config,
);
let https_builder = HttpsClientStreamBuilder::with_client_config(client_config);
DnsExchange::connect(https_builder.build::<R::Tcp>(socket_addr, dns_name))
}
#[cfg(test)]
mod tests {
extern crate env_logger;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use tokio::runtime::Runtime;
use crate::config::{ResolverConfig, ResolverOpts};
use crate::TokioAsyncResolver;
fn https_test(config: ResolverConfig) {
//env_logger::try_init().ok();
let mut io_loop = Runtime::new().unwrap();
let resolver =
TokioAsyncResolver::new(config, ResolverOpts::default(), io_loop.handle().clone())
.expect("failed to create resolver");
let response = io_loop
.block_on(resolver.lookup_ip("www.example.com."))
.expect("failed to run lookup");
assert_eq!(response.iter().count(), 1);
for address in response.iter() {
if address.is_ipv4() {
assert_eq!(address, IpAddr::V4(Ipv4Addr::new(93, 184, 216, 34)));
} else |
}
// check if there is another connection created
let response = io_loop
.block_on(resolver.lookup_ip("www.example.com."))
.expect("failed to run lookup");
assert_eq!(response.iter().count(), 1);
for address in response.iter() {
if address.is_ipv4() {
assert_eq!(address, IpAddr::V4(Ipv4Addr::new(93, 184, 216, 34)));
} else {
assert_eq!(
address,
IpAddr::V6(Ipv6Addr::new(
0x2606, 0x2800, 0x220, 0x1, 0x248, 0x1893, 0x25c8, 0x1946,
))
);
}
}
}
#[test]
fn test_cloudflare_https() {
https_test(ResolverConfig::cloudflare_https())
}
}
| {
assert_eq!(
address,
IpAddr::V6(Ipv6Addr::new(
0x2606, 0x2800, 0x220, 0x1, 0x248, 0x1893, 0x25c8, 0x1946,
))
);
} | conditional_block |
htmldatalistelement.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::codegen::Bindings::HTMLDataListElementBinding;
use dom::bindings::codegen::Bindings::HTMLDataListElementBinding::HTMLDataListElementMethods;
use dom::bindings::codegen::InheritTypes::{HTMLDataListElementDerived, HTMLOptionElementDerived};
use dom::bindings::codegen::InheritTypes::NodeCast;
use dom::bindings::js::{JSRef, Rootable, Temporary};
use dom::document::Document;
use dom::element::Element;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlcollection::{HTMLCollection, CollectionFilter};
use dom::element::ElementTypeId;
use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
use dom::node::{Node, NodeTypeId, window_from_node};
use util::str::DOMString;
#[dom_struct]
pub struct HTMLDataListElement {
htmlelement: HTMLElement
}
impl HTMLDataListElementDerived for EventTarget {
fn is_htmldatalistelement(&self) -> bool {
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDataListElement)))
}
}
impl HTMLDataListElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDataListElement {
HTMLDataListElement {
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLDataListElement, localName, prefix, document)
}
}
#[allow(unrooted_must_root)]
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLDataListElement> {
let element = HTMLDataListElement::new_inherited(localName, prefix, document);
Node::reflect_node(box element, document, HTMLDataListElementBinding::Wrap)
}
}
impl<'a> HTMLDataListElementMethods for JSRef<'a, HTMLDataListElement> {
fn Options(self) -> Temporary<HTMLCollection> { | }
}
let node: JSRef<Node> = NodeCast::from_ref(self);
let filter = box HTMLDataListOptionsFilter;
let window = window_from_node(node).root();
HTMLCollection::create(window.r(), node, filter)
}
} | #[jstraceable]
struct HTMLDataListOptionsFilter;
impl CollectionFilter for HTMLDataListOptionsFilter {
fn filter(&self, elem: JSRef<Element>, _root: JSRef<Node>) -> bool {
elem.is_htmloptionelement() | random_line_split |
htmldatalistelement.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::codegen::Bindings::HTMLDataListElementBinding;
use dom::bindings::codegen::Bindings::HTMLDataListElementBinding::HTMLDataListElementMethods;
use dom::bindings::codegen::InheritTypes::{HTMLDataListElementDerived, HTMLOptionElementDerived};
use dom::bindings::codegen::InheritTypes::NodeCast;
use dom::bindings::js::{JSRef, Rootable, Temporary};
use dom::document::Document;
use dom::element::Element;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlcollection::{HTMLCollection, CollectionFilter};
use dom::element::ElementTypeId;
use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
use dom::node::{Node, NodeTypeId, window_from_node};
use util::str::DOMString;
#[dom_struct]
pub struct HTMLDataListElement {
htmlelement: HTMLElement
}
impl HTMLDataListElementDerived for EventTarget {
fn | (&self) -> bool {
*self.type_id() == EventTargetTypeId::Node(NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLDataListElement)))
}
}
impl HTMLDataListElement {
fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLDataListElement {
HTMLDataListElement {
htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLDataListElement, localName, prefix, document)
}
}
#[allow(unrooted_must_root)]
pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLDataListElement> {
let element = HTMLDataListElement::new_inherited(localName, prefix, document);
Node::reflect_node(box element, document, HTMLDataListElementBinding::Wrap)
}
}
impl<'a> HTMLDataListElementMethods for JSRef<'a, HTMLDataListElement> {
fn Options(self) -> Temporary<HTMLCollection> {
#[jstraceable]
struct HTMLDataListOptionsFilter;
impl CollectionFilter for HTMLDataListOptionsFilter {
fn filter(&self, elem: JSRef<Element>, _root: JSRef<Node>) -> bool {
elem.is_htmloptionelement()
}
}
let node: JSRef<Node> = NodeCast::from_ref(self);
let filter = box HTMLDataListOptionsFilter;
let window = window_from_node(node).root();
HTMLCollection::create(window.r(), node, filter)
}
}
| is_htmldatalistelement | identifier_name |
lib.rs | #![warn(missing_docs)]
// #![feature(external_doc)]
// #![doc(include = "../README.md")]
//! For an introduction and context view, read...
//!
//! [README.md pending](https://github.com/jleahred/...)
//!
//! A very basic example...
//! ```rust
//!```
//!
//!
//!
//! Please, read [README.md pending](https://github.com/jleahred/...) for
//! more context information
//!
#[macro_use]
pub mod expr; |
#[cfg(test)]
mod test;
use result::*;
use rules::*;
use status::Status;
fn from_status_error_2_result_error(e: status::Error) -> Error {
Error {
pos: e.status.pos.clone(),
expected: e.expected,
line: e
.status
.text2parse
.lines()
.into_iter()
.skip(e.status.pos.row)
.take(1)
.collect(),
}
}
// --------------------------------------------------------------------------------
/// Parse a string with for a given set of rules
pub fn parse<'a, CustI>(text: &'a str, rules: &SetOfRules<CustI>) -> Result<'a> {
let status = Status::init(text);
expr::non_term::parse_ref_rule(rules, status, &RuleName("main".to_string()))
.map_err(from_status_error_2_result_error)?
.check_finalization()
}
// --------------------------------------------------------------------------------
// todo:
impl<'a> Status<'a> {
fn check_finalization(&self) -> Result<'a> {
if self.pos.n == self.text2parse.len() {
Ok(())
} else {
match &self.deeper_error {
None => Err(Error {
pos: self.pos.clone(),
expected: im::vector!["not consumed full input...".to_owned()],
line: self
.text2parse
.lines()
.into_iter()
.skip(self.pos.row)
.take(1)
.collect(),
}),
Some(e) => Err(from_status_error_2_result_error(*e.clone())),
}
}
}
} | pub mod result;
#[macro_use]
pub mod rules;
pub(crate) mod status; | random_line_split |
lib.rs | #![warn(missing_docs)]
// #![feature(external_doc)]
// #![doc(include = "../README.md")]
//! For an introduction and context view, read...
//!
//! [README.md pending](https://github.com/jleahred/...)
//!
//! A very basic example...
//! ```rust
//!```
//!
//!
//!
//! Please, read [README.md pending](https://github.com/jleahred/...) for
//! more context information
//!
#[macro_use]
pub mod expr;
pub mod result;
#[macro_use]
pub mod rules;
pub(crate) mod status;
#[cfg(test)]
mod test;
use result::*;
use rules::*;
use status::Status;
fn from_status_error_2_result_error(e: status::Error) -> Error {
Error {
pos: e.status.pos.clone(),
expected: e.expected,
line: e
.status
.text2parse
.lines()
.into_iter()
.skip(e.status.pos.row)
.take(1)
.collect(),
}
}
// --------------------------------------------------------------------------------
/// Parse a string with for a given set of rules
pub fn | <'a, CustI>(text: &'a str, rules: &SetOfRules<CustI>) -> Result<'a> {
let status = Status::init(text);
expr::non_term::parse_ref_rule(rules, status, &RuleName("main".to_string()))
.map_err(from_status_error_2_result_error)?
.check_finalization()
}
// --------------------------------------------------------------------------------
// todo:
impl<'a> Status<'a> {
fn check_finalization(&self) -> Result<'a> {
if self.pos.n == self.text2parse.len() {
Ok(())
} else {
match &self.deeper_error {
None => Err(Error {
pos: self.pos.clone(),
expected: im::vector!["not consumed full input...".to_owned()],
line: self
.text2parse
.lines()
.into_iter()
.skip(self.pos.row)
.take(1)
.collect(),
}),
Some(e) => Err(from_status_error_2_result_error(*e.clone())),
}
}
}
}
| parse | identifier_name |
lib.rs | #![warn(missing_docs)]
// #![feature(external_doc)]
// #![doc(include = "../README.md")]
//! For an introduction and context view, read...
//!
//! [README.md pending](https://github.com/jleahred/...)
//!
//! A very basic example...
//! ```rust
//!```
//!
//!
//!
//! Please, read [README.md pending](https://github.com/jleahred/...) for
//! more context information
//!
#[macro_use]
pub mod expr;
pub mod result;
#[macro_use]
pub mod rules;
pub(crate) mod status;
#[cfg(test)]
mod test;
use result::*;
use rules::*;
use status::Status;
fn from_status_error_2_result_error(e: status::Error) -> Error {
Error {
pos: e.status.pos.clone(),
expected: e.expected,
line: e
.status
.text2parse
.lines()
.into_iter()
.skip(e.status.pos.row)
.take(1)
.collect(),
}
}
// --------------------------------------------------------------------------------
/// Parse a string with for a given set of rules
pub fn parse<'a, CustI>(text: &'a str, rules: &SetOfRules<CustI>) -> Result<'a> |
// --------------------------------------------------------------------------------
// todo:
impl<'a> Status<'a> {
fn check_finalization(&self) -> Result<'a> {
if self.pos.n == self.text2parse.len() {
Ok(())
} else {
match &self.deeper_error {
None => Err(Error {
pos: self.pos.clone(),
expected: im::vector!["not consumed full input...".to_owned()],
line: self
.text2parse
.lines()
.into_iter()
.skip(self.pos.row)
.take(1)
.collect(),
}),
Some(e) => Err(from_status_error_2_result_error(*e.clone())),
}
}
}
}
| {
let status = Status::init(text);
expr::non_term::parse_ref_rule(rules, status, &RuleName("main".to_string()))
.map_err(from_status_error_2_result_error)?
.check_finalization()
} | identifier_body |
lib.rs | #![warn(missing_docs)]
// #![feature(external_doc)]
// #![doc(include = "../README.md")]
//! For an introduction and context view, read...
//!
//! [README.md pending](https://github.com/jleahred/...)
//!
//! A very basic example...
//! ```rust
//!```
//!
//!
//!
//! Please, read [README.md pending](https://github.com/jleahred/...) for
//! more context information
//!
#[macro_use]
pub mod expr;
pub mod result;
#[macro_use]
pub mod rules;
pub(crate) mod status;
#[cfg(test)]
mod test;
use result::*;
use rules::*;
use status::Status;
fn from_status_error_2_result_error(e: status::Error) -> Error {
Error {
pos: e.status.pos.clone(),
expected: e.expected,
line: e
.status
.text2parse
.lines()
.into_iter()
.skip(e.status.pos.row)
.take(1)
.collect(),
}
}
// --------------------------------------------------------------------------------
/// Parse a string with for a given set of rules
pub fn parse<'a, CustI>(text: &'a str, rules: &SetOfRules<CustI>) -> Result<'a> {
let status = Status::init(text);
expr::non_term::parse_ref_rule(rules, status, &RuleName("main".to_string()))
.map_err(from_status_error_2_result_error)?
.check_finalization()
}
// --------------------------------------------------------------------------------
// todo:
impl<'a> Status<'a> {
fn check_finalization(&self) -> Result<'a> {
if self.pos.n == self.text2parse.len() | else {
match &self.deeper_error {
None => Err(Error {
pos: self.pos.clone(),
expected: im::vector!["not consumed full input...".to_owned()],
line: self
.text2parse
.lines()
.into_iter()
.skip(self.pos.row)
.take(1)
.collect(),
}),
Some(e) => Err(from_status_error_2_result_error(*e.clone())),
}
}
}
}
| {
Ok(())
} | conditional_block |
fragments.rs | tcx>, tcx: &ty::ctxt<'tcx>) -> String {
let repr = |mpi| move_data.path_loan_path(mpi).repr(tcx);
match *self {
Just(mpi) => repr(mpi),
AllButOneFrom(mpi) => format!("$(allbutone {})", repr(mpi)),
}
}
fn loan_path_user_string<'tcx>(&self,
move_data: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>) -> String {
let user_string = |mpi| move_data.path_loan_path(mpi).user_string(tcx);
match *self {
Just(mpi) => user_string(mpi),
AllButOneFrom(mpi) => format!("$(allbutone {})", user_string(mpi)),
}
}
}
pub struct FragmentSets {
/// During move_data construction, `moved_leaf_paths` tracks paths
/// that have been used directly by being moved out of. When
/// move_data construction has been completed, `moved_leaf_paths`
/// tracks such paths that are *leaf fragments* (e.g. `a.j` if we
/// never move out any child like `a.j.x`); any parent paths
/// (e.g. `a` for the `a.j` example) are moved over to
/// `parents_of_fragments`.
moved_leaf_paths: Vec<MovePathIndex>,
/// `assigned_leaf_paths` tracks paths that have been used
/// directly by being overwritten, but is otherwise much like
/// `moved_leaf_paths`.
assigned_leaf_paths: Vec<MovePathIndex>,
/// `parents_of_fragments` tracks paths that are definitely
/// parents of paths that have been moved.
///
/// FIXME(pnkfelix) probably do not want/need
/// `parents_of_fragments` at all, if we can avoid it.
///
/// Update: I do not see a way to to avoid it. Maybe just remove
/// above fixme, or at least document why doing this may be hard.
parents_of_fragments: Vec<MovePathIndex>,
/// During move_data construction (specifically the
/// fixup_fragment_sets call), `unmoved_fragments` tracks paths
/// that have been "left behind" after a sibling has been moved or
/// assigned. When move_data construction has been completed,
/// `unmoved_fragments` tracks paths that were *only* results of
/// being left-behind, and never directly moved themselves.
unmoved_fragments: Vec<Fragment>,
}
impl FragmentSets {
pub fn new() -> FragmentSets {
FragmentSets {
unmoved_fragments: Vec::new(),
moved_leaf_paths: Vec::new(),
assigned_leaf_paths: Vec::new(),
parents_of_fragments: Vec::new(),
}
}
pub fn add_move(&mut self, path_index: MovePathIndex) {
self.moved_leaf_paths.push(path_index);
}
pub fn add_assignment(&mut self, path_index: MovePathIndex) {
self.assigned_leaf_paths.push(path_index);
}
}
pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
sp: Span,
id: ast::NodeId) {
let span_err = tcx.map.attrs(id).iter()
.any(|a| a.check_name("rustc_move_fragments"));
let print = tcx.sess.opts.debugging_opts.print_move_fragments;
if!span_err &&!print { return; }
let instrument_all_paths = |kind, vec_rc: &Vec<MovePathIndex>| {
for (i, mpi) in vec_rc.iter().enumerate() {
let render = || this.path_loan_path(*mpi).user_string(tcx);
if span_err {
tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render()));
}
if print {
println!("id:{} {}[{}] `{}`", id, kind, i, render());
}
}
};
let instrument_all_fragments = |kind, vec_rc: &Vec<Fragment>| {
for (i, f) in vec_rc.iter().enumerate() {
let render = || f.loan_path_user_string(this, tcx);
if span_err {
tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render()));
}
if print {
println!("id:{} {}[{}] `{}`", id, kind, i, render());
}
}
};
let fragments = this.fragments.borrow();
instrument_all_paths("moved_leaf_path", &fragments.moved_leaf_paths);
instrument_all_fragments("unmoved_fragment", &fragments.unmoved_fragments);
instrument_all_paths("parent_of_fragments", &fragments.parents_of_fragments);
instrument_all_paths("assigned_leaf_path", &fragments.assigned_leaf_paths);
}
/// Normalizes the fragment sets in `this`; i.e., removes duplicate entries, constructs the set of
/// parents, and constructs the left-over fragments.
///
/// Note: "left-over fragments" means paths that were not directly referenced in moves nor
/// assignments, but must nonetheless be tracked as potential drop obligations.
pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) {
let mut fragments = this.fragments.borrow_mut();
// Swap out contents of fragments so that we can modify the fields
// without borrowing the common fragments.
let mut unmoved = mem::replace(&mut fragments.unmoved_fragments, vec![]);
let mut parents = mem::replace(&mut fragments.parents_of_fragments, vec![]);
let mut moved = mem::replace(&mut fragments.moved_leaf_paths, vec![]);
let mut assigned = mem::replace(&mut fragments.assigned_leaf_paths, vec![]);
let path_lps = |mpis: &[MovePathIndex]| -> Vec<String> {
mpis.iter().map(|mpi| this.path_loan_path(*mpi).repr(tcx)).collect()
};
let frag_lps = |fs: &[Fragment]| -> Vec<String> {
fs.iter().map(|f| f.loan_path_repr(this, tcx)).collect()
};
// First, filter out duplicates
moved.sort();
moved.dedup();
debug!("fragments 1 moved: {:?}", path_lps(&moved[..]));
assigned.sort();
assigned.dedup();
debug!("fragments 1 assigned: {:?}", path_lps(&assigned[..]));
// Second, build parents from the moved and assigned.
for m in &moved {
let mut p = this.path_parent(*m);
while p!= InvalidMovePathIndex {
parents.push(p);
p = this.path_parent(p);
}
}
for a in &assigned {
let mut p = this.path_parent(*a);
while p!= InvalidMovePathIndex {
parents.push(p);
p = this.path_parent(p);
}
}
parents.sort();
parents.dedup();
debug!("fragments 2 parents: {:?}", path_lps(&parents[..]));
// Third, filter the moved and assigned fragments down to just the non-parents
moved.retain(|f| non_member(*f, &parents[..]));
debug!("fragments 3 moved: {:?}", path_lps(&moved[..]));
assigned.retain(|f| non_member(*f, &parents[..]));
debug!("fragments 3 assigned: {:?}", path_lps(&assigned[..]));
// Fourth, build the leftover from the moved, assigned, and parents.
for m in &moved {
let lp = this.path_loan_path(*m);
add_fragment_siblings(this, tcx, &mut unmoved, lp, None);
}
for a in &assigned {
let lp = this.path_loan_path(*a);
add_fragment_siblings(this, tcx, &mut unmoved, lp, None);
}
for p in &parents {
let lp = this.path_loan_path(*p);
add_fragment_siblings(this, tcx, &mut unmoved, lp, None);
}
unmoved.sort();
unmoved.dedup();
debug!("fragments 4 unmoved: {:?}", frag_lps(&unmoved[..]));
// Fifth, filter the leftover fragments down to its core.
unmoved.retain(|f| match *f {
AllButOneFrom(_) => true,
Just(mpi) => non_member(mpi, &parents[..]) &&
non_member(mpi, &moved[..]) &&
non_member(mpi, &assigned[..])
});
debug!("fragments 5 unmoved: {:?}", frag_lps(&unmoved[..]));
// Swap contents back in.
fragments.unmoved_fragments = unmoved;
fragments.parents_of_fragments = parents;
fragments.moved_leaf_paths = moved;
fragments.assigned_leaf_paths = assigned;
return;
fn non_member(elem: MovePathIndex, set: &[MovePathIndex]) -> bool {
match set.binary_search(&elem) {
Ok(_) => false,
Err(_) => true,
}
}
}
/// Adds all of the precisely-tracked siblings of `lp` as potential move paths of interest. For
/// example, if `lp` represents `s.x.j`, then adds moves paths for `s.x.i` and `s.x.k`, the
/// siblings of `s.x.j`.
fn add_fragment_siblings<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
gathered_fragments: &mut Vec<Fragment>,
lp: Rc<LoanPath<'tcx>>,
origin_id: Option<ast::NodeId>) {
match lp.kind {
LpVar(_) | LpUpvar(..) => {} // Local variables have no siblings.
// Consuming a downcast is like consuming the original value, so propage inward.
LpDowncast(ref loan_parent, _) => {
add_fragment_siblings(this, tcx, gathered_fragments, loan_parent.clone(), origin_id);
}
// *LV for Unique consumes the contents of the box (at
// least when it is non-copy...), so propagate inward.
LpExtend(ref loan_parent, _, LpDeref(mc::Unique)) => {
add_fragment_siblings(this, tcx, gathered_fragments, loan_parent.clone(), origin_id);
}
// *LV for unsafe and borrowed pointers do not consume their loan path, so stop here.
LpExtend(_, _, LpDeref(mc::UnsafePtr(..))) |
LpExtend(_, _, LpDeref(mc::Implicit(..))) |
LpExtend(_, _, LpDeref(mc::BorrowedPtr(..))) => {}
// FIXME (pnkfelix): LV[j] should be tracked, at least in the
// sense of we will track the remaining drop obligation of the
// rest of the array.
//
// Well, either that or LV[j] should be made illegal.
// But even then, we will need to deal with destructuring
// bind.
//
// Anyway, for now: LV[j] is not tracked precisely
LpExtend(_, _, LpInterior(InteriorElement(..))) => {
let mp = this.move_path(tcx, lp.clone());
gathered_fragments.push(AllButOneFrom(mp));
}
// field access LV.x and tuple access LV#k are the cases
// we are interested in
LpExtend(ref loan_parent, mc,
LpInterior(InteriorField(ref field_name))) => {
let enum_variant_info = match loan_parent.kind {
LpDowncast(ref loan_parent_2, variant_def_id) =>
Some((variant_def_id, loan_parent_2.clone())),
LpExtend(..) | LpVar(..) | LpUpvar(..) =>
None,
};
add_fragment_siblings_for_extension(
this,
tcx,
gathered_fragments,
loan_parent, mc, field_name, &lp, origin_id, enum_variant_info);
}
}
}
/// We have determined that `origin_lp` destructures to LpExtend(parent, original_field_name).
/// Based on this, add move paths for all of the siblings of `origin_lp`.
fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
gathered_fragments: &mut Vec<Fragment>,
parent_lp: &Rc<LoanPath<'tcx>>,
mc: mc::MutabilityCategory,
origin_field_name: &mc::FieldName,
origin_lp: &Rc<LoanPath<'tcx>>,
origin_id: Option<ast::NodeId>,
enum_variant_info: Option<(ast::DefId,
Rc<LoanPath<'tcx>>)>) {
let parent_ty = parent_lp.to_type();
let mut add_fragment_sibling_local = |field_name, variant_did| {
add_fragment_sibling_core(
this, tcx, gathered_fragments, parent_lp.clone(), mc, field_name, origin_lp,
variant_did);
};
match (&parent_ty.sty, enum_variant_info) {
(&ty::ty_tup(ref v), None) => {
let tuple_idx = match *origin_field_name {
mc::PositionalField(tuple_idx) => tuple_idx,
mc::NamedField(_) =>
panic!("tuple type {} should not have named fields.",
parent_ty.repr(tcx)),
};
let tuple_len = v.len();
for i in 0..tuple_len {
if i == tuple_idx { continue }
let field_name = mc::PositionalField(i);
add_fragment_sibling_local(field_name, None);
}
}
(&ty::ty_struct(def_id, ref _substs), None) => {
let fields = ty::lookup_struct_fields(tcx, def_id);
match *origin_field_name {
mc::NamedField(ast_name) => {
for f in &fields {
if f.name == ast_name {
continue;
}
let field_name = mc::NamedField(f.name);
add_fragment_sibling_local(field_name, None);
}
}
mc::PositionalField(tuple_idx) => {
for (i, _f) in fields.iter().enumerate() {
if i == tuple_idx {
continue
}
let field_name = mc::PositionalField(i);
add_fragment_sibling_local(field_name, None);
}
}
}
}
(&ty::ty_enum(enum_def_id, substs), ref enum_variant_info) => {
let variant_info = {
let mut variants = ty::substd_enum_variants(tcx, enum_def_id, substs);
match *enum_variant_info {
Some((variant_def_id, ref _lp2)) =>
variants.iter()
.find(|variant| variant.id == variant_def_id)
.expect("enum_variant_with_id(): no variant exists with that ID")
.clone(),
None => {
assert_eq!(variants.len(), 1);
variants.pop().unwrap()
}
}
};
match *origin_field_name {
mc::NamedField(ast_name) => {
let variant_arg_names = variant_info.arg_names.as_ref().unwrap();
for variant_arg_ident in variant_arg_names {
if variant_arg_ident.name == ast_name {
continue;
}
let field_name = mc::NamedField(variant_arg_ident.name);
add_fragment_sibling_local(field_name, Some(variant_info.id));
}
}
mc::PositionalField(tuple_idx) => {
let variant_arg_types = &variant_info.args;
for (i, _variant_arg_ty) in variant_arg_types.iter().enumerate() {
if tuple_idx == i {
continue;
}
let field_name = mc::PositionalField(i);
add_fragment_sibling_local(field_name, None);
}
}
}
}
ref sty_and_variant_info => {
let msg = format!("type {} ({:?}) is not fragmentable",
parent_ty.repr(tcx), sty_and_variant_info);
let opt_span = origin_id.and_then(|id|tcx.map.opt_span(id));
tcx.sess.opt_span_bug(opt_span, &msg[..])
}
}
}
/// Adds the single sibling `LpExtend(parent, new_field_name)` of `origin_lp` (the original
/// loan-path).
fn add_fragment_sibling_core<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
gathered_fragments: &mut Vec<Fragment>,
parent: Rc<LoanPath<'tcx>>,
mc: mc::MutabilityCategory,
new_field_name: mc::FieldName,
origin_lp: &Rc<LoanPath<'tcx>>,
enum_variant_did: Option<ast::DefId>) -> MovePathIndex | {
let opt_variant_did = match parent.kind {
LpDowncast(_, variant_did) => Some(variant_did),
LpVar(..) | LpUpvar(..) | LpExtend(..) => enum_variant_did,
};
let loan_path_elem = LpInterior(InteriorField(new_field_name));
let new_lp_type = match new_field_name {
mc::NamedField(ast_name) =>
ty::named_element_ty(tcx, parent.to_type(), ast_name, opt_variant_did),
mc::PositionalField(idx) =>
ty::positional_element_ty(tcx, parent.to_type(), idx, opt_variant_did),
};
let new_lp_variant = LpExtend(parent, mc, loan_path_elem);
let new_lp = LoanPath::new(new_lp_variant, new_lp_type.unwrap());
debug!("add_fragment_sibling_core(new_lp={}, origin_lp={})",
new_lp.repr(tcx), origin_lp.repr(tcx));
let mp = this.move_path(tcx, Rc::new(new_lp));
// Do not worry about checking for duplicates here; we will sort | identifier_body |
|
fragments.rs | Eq, PartialOrd, Ord)]
enum Fragment {
// This represents the path described by the move path index
Just(MovePathIndex),
// This represents the collection of all but one of the elements
// from an array at the path described by the move path index.
// Note that attached MovePathIndex should have mem_categorization
// of InteriorElement (i.e. array dereference `&foo[..]`).
AllButOneFrom(MovePathIndex),
}
impl Fragment {
fn loan_path_repr<'tcx>(&self, move_data: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) -> String {
let repr = |mpi| move_data.path_loan_path(mpi).repr(tcx);
match *self {
Just(mpi) => repr(mpi),
AllButOneFrom(mpi) => format!("$(allbutone {})", repr(mpi)),
}
}
fn loan_path_user_string<'tcx>(&self,
move_data: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>) -> String {
let user_string = |mpi| move_data.path_loan_path(mpi).user_string(tcx);
match *self {
Just(mpi) => user_string(mpi),
AllButOneFrom(mpi) => format!("$(allbutone {})", user_string(mpi)),
}
}
}
pub struct FragmentSets {
/// During move_data construction, `moved_leaf_paths` tracks paths
/// that have been used directly by being moved out of. When
/// move_data construction has been completed, `moved_leaf_paths`
/// tracks such paths that are *leaf fragments* (e.g. `a.j` if we
/// never move out any child like `a.j.x`); any parent paths
/// (e.g. `a` for the `a.j` example) are moved over to
/// `parents_of_fragments`.
moved_leaf_paths: Vec<MovePathIndex>,
/// `assigned_leaf_paths` tracks paths that have been used
/// directly by being overwritten, but is otherwise much like
/// `moved_leaf_paths`.
assigned_leaf_paths: Vec<MovePathIndex>,
/// `parents_of_fragments` tracks paths that are definitely
/// parents of paths that have been moved.
///
/// FIXME(pnkfelix) probably do not want/need
/// `parents_of_fragments` at all, if we can avoid it.
///
/// Update: I do not see a way to to avoid it. Maybe just remove
/// above fixme, or at least document why doing this may be hard.
parents_of_fragments: Vec<MovePathIndex>,
/// During move_data construction (specifically the
/// fixup_fragment_sets call), `unmoved_fragments` tracks paths
/// that have been "left behind" after a sibling has been moved or
/// assigned. When move_data construction has been completed,
/// `unmoved_fragments` tracks paths that were *only* results of
/// being left-behind, and never directly moved themselves.
unmoved_fragments: Vec<Fragment>,
}
impl FragmentSets {
pub fn new() -> FragmentSets {
FragmentSets {
unmoved_fragments: Vec::new(),
moved_leaf_paths: Vec::new(),
assigned_leaf_paths: Vec::new(),
parents_of_fragments: Vec::new(),
}
}
pub fn add_move(&mut self, path_index: MovePathIndex) {
self.moved_leaf_paths.push(path_index);
}
pub fn add_assignment(&mut self, path_index: MovePathIndex) {
self.assigned_leaf_paths.push(path_index);
}
}
pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
sp: Span,
id: ast::NodeId) {
let span_err = tcx.map.attrs(id).iter()
.any(|a| a.check_name("rustc_move_fragments"));
let print = tcx.sess.opts.debugging_opts.print_move_fragments;
if!span_err &&!print { return; }
let instrument_all_paths = |kind, vec_rc: &Vec<MovePathIndex>| {
for (i, mpi) in vec_rc.iter().enumerate() {
let render = || this.path_loan_path(*mpi).user_string(tcx);
if span_err {
tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render()));
}
if print {
println!("id:{} {}[{}] `{}`", id, kind, i, render());
}
}
};
let instrument_all_fragments = |kind, vec_rc: &Vec<Fragment>| {
for (i, f) in vec_rc.iter().enumerate() {
let render = || f.loan_path_user_string(this, tcx);
if span_err {
tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render()));
}
if print {
println!("id:{} {}[{}] `{}`", id, kind, i, render());
}
}
};
let fragments = this.fragments.borrow();
instrument_all_paths("moved_leaf_path", &fragments.moved_leaf_paths);
instrument_all_fragments("unmoved_fragment", &fragments.unmoved_fragments);
instrument_all_paths("parent_of_fragments", &fragments.parents_of_fragments);
instrument_all_paths("assigned_leaf_path", &fragments.assigned_leaf_paths);
}
/// Normalizes the fragment sets in `this`; i.e., removes duplicate entries, constructs the set of
/// parents, and constructs the left-over fragments.
///
/// Note: "left-over fragments" means paths that were not directly referenced in moves nor
/// assignments, but must nonetheless be tracked as potential drop obligations.
pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) {
let mut fragments = this.fragments.borrow_mut();
// Swap out contents of fragments so that we can modify the fields
// without borrowing the common fragments.
let mut unmoved = mem::replace(&mut fragments.unmoved_fragments, vec![]);
let mut parents = mem::replace(&mut fragments.parents_of_fragments, vec![]);
let mut moved = mem::replace(&mut fragments.moved_leaf_paths, vec![]);
let mut assigned = mem::replace(&mut fragments.assigned_leaf_paths, vec![]);
let path_lps = |mpis: &[MovePathIndex]| -> Vec<String> {
mpis.iter().map(|mpi| this.path_loan_path(*mpi).repr(tcx)).collect()
};
let frag_lps = |fs: &[Fragment]| -> Vec<String> {
fs.iter().map(|f| f.loan_path_repr(this, tcx)).collect()
};
// First, filter out duplicates
moved.sort();
moved.dedup();
debug!("fragments 1 moved: {:?}", path_lps(&moved[..]));
assigned.sort();
assigned.dedup();
debug!("fragments 1 assigned: {:?}", path_lps(&assigned[..]));
// Second, build parents from the moved and assigned.
for m in &moved {
let mut p = this.path_parent(*m);
while p!= InvalidMovePathIndex {
parents.push(p);
p = this.path_parent(p);
}
}
for a in &assigned {
let mut p = this.path_parent(*a);
while p!= InvalidMovePathIndex {
parents.push(p);
p = this.path_parent(p);
}
}
parents.sort();
parents.dedup();
debug!("fragments 2 parents: {:?}", path_lps(&parents[..]));
// Third, filter the moved and assigned fragments down to just the non-parents
moved.retain(|f| non_member(*f, &parents[..]));
debug!("fragments 3 moved: {:?}", path_lps(&moved[..]));
assigned.retain(|f| non_member(*f, &parents[..]));
debug!("fragments 3 assigned: {:?}", path_lps(&assigned[..]));
// Fourth, build the leftover from the moved, assigned, and parents.
for m in &moved {
let lp = this.path_loan_path(*m);
add_fragment_siblings(this, tcx, &mut unmoved, lp, None);
}
for a in &assigned {
let lp = this.path_loan_path(*a);
add_fragment_siblings(this, tcx, &mut unmoved, lp, None);
}
for p in &parents {
let lp = this.path_loan_path(*p);
add_fragment_siblings(this, tcx, &mut unmoved, lp, None);
}
unmoved.sort();
unmoved.dedup();
debug!("fragments 4 unmoved: {:?}", frag_lps(&unmoved[..]));
// Fifth, filter the leftover fragments down to its core.
unmoved.retain(|f| match *f {
AllButOneFrom(_) => true,
Just(mpi) => non_member(mpi, &parents[..]) &&
non_member(mpi, &moved[..]) &&
non_member(mpi, &assigned[..])
});
debug!("fragments 5 unmoved: {:?}", frag_lps(&unmoved[..]));
// Swap contents back in.
fragments.unmoved_fragments = unmoved;
fragments.parents_of_fragments = parents;
fragments.moved_leaf_paths = moved;
fragments.assigned_leaf_paths = assigned;
return;
fn non_member(elem: MovePathIndex, set: &[MovePathIndex]) -> bool {
match set.binary_search(&elem) {
Ok(_) => false,
Err(_) => true,
}
}
}
/// Adds all of the precisely-tracked siblings of `lp` as potential move paths of interest. For
/// example, if `lp` represents `s.x.j`, then adds moves paths for `s.x.i` and `s.x.k`, the
/// siblings of `s.x.j`.
fn add_fragment_siblings<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
gathered_fragments: &mut Vec<Fragment>,
lp: Rc<LoanPath<'tcx>>,
origin_id: Option<ast::NodeId>) {
match lp.kind {
LpVar(_) | LpUpvar(..) => {} // Local variables have no siblings.
// Consuming a downcast is like consuming the original value, so propage inward.
LpDowncast(ref loan_parent, _) => {
add_fragment_siblings(this, tcx, gathered_fragments, loan_parent.clone(), origin_id);
}
// *LV for Unique consumes the contents of the box (at
// least when it is non-copy...), so propagate inward.
LpExtend(ref loan_parent, _, LpDeref(mc::Unique)) => {
add_fragment_siblings(this, tcx, gathered_fragments, loan_parent.clone(), origin_id);
}
// *LV for unsafe and borrowed pointers do not consume their loan path, so stop here.
LpExtend(_, _, LpDeref(mc::UnsafePtr(..))) |
LpExtend(_, _, LpDeref(mc::Implicit(..))) |
LpExtend(_, _, LpDeref(mc::BorrowedPtr(..))) => {}
// FIXME (pnkfelix): LV[j] should be tracked, at least in the
// sense of we will track the remaining drop obligation of the
// rest of the array.
//
// Well, either that or LV[j] should be made illegal.
// But even then, we will need to deal with destructuring
// bind.
//
// Anyway, for now: LV[j] is not tracked precisely
LpExtend(_, _, LpInterior(InteriorElement(..))) => {
let mp = this.move_path(tcx, lp.clone());
gathered_fragments.push(AllButOneFrom(mp));
}
// field access LV.x and tuple access LV#k are the cases
// we are interested in
LpExtend(ref loan_parent, mc,
LpInterior(InteriorField(ref field_name))) => {
let enum_variant_info = match loan_parent.kind {
LpDowncast(ref loan_parent_2, variant_def_id) =>
Some((variant_def_id, loan_parent_2.clone())),
LpExtend(..) | LpVar(..) | LpUpvar(..) =>
None,
};
add_fragment_siblings_for_extension(
this,
tcx,
gathered_fragments,
loan_parent, mc, field_name, &lp, origin_id, enum_variant_info);
}
}
}
/// We have determined that `origin_lp` destructures to LpExtend(parent, original_field_name).
/// Based on this, add move paths for all of the siblings of `origin_lp`.
fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
gathered_fragments: &mut Vec<Fragment>,
parent_lp: &Rc<LoanPath<'tcx>>,
mc: mc::MutabilityCategory,
origin_field_name: &mc::FieldName,
origin_lp: &Rc<LoanPath<'tcx>>,
origin_id: Option<ast::NodeId>,
enum_variant_info: Option<(ast::DefId,
Rc<LoanPath<'tcx>>)>) {
let parent_ty = parent_lp.to_type();
let mut add_fragment_sibling_local = |field_name, variant_did| {
add_fragment_sibling_core(
this, tcx, gathered_fragments, parent_lp.clone(), mc, field_name, origin_lp,
variant_did);
};
match (&parent_ty.sty, enum_variant_info) {
(&ty::ty_tup(ref v), None) => {
let tuple_idx = match *origin_field_name {
mc::PositionalField(tuple_idx) => tuple_idx,
mc::NamedField(_) =>
panic!("tuple type {} should not have named fields.",
parent_ty.repr(tcx)),
};
let tuple_len = v.len();
for i in 0..tuple_len {
if i == tuple_idx { continue }
let field_name = mc::PositionalField(i);
add_fragment_sibling_local(field_name, None);
}
}
(&ty::ty_struct(def_id, ref _substs), None) => {
let fields = ty::lookup_struct_fields(tcx, def_id);
match *origin_field_name {
mc::NamedField(ast_name) => {
for f in &fields {
if f.name == ast_name {
continue;
}
let field_name = mc::NamedField(f.name);
add_fragment_sibling_local(field_name, None);
}
}
mc::PositionalField(tuple_idx) => {
for (i, _f) in fields.iter().enumerate() {
if i == tuple_idx {
continue
}
let field_name = mc::PositionalField(i);
add_fragment_sibling_local(field_name, None);
}
}
}
}
(&ty::ty_enum(enum_def_id, substs), ref enum_variant_info) => {
let variant_info = {
let mut variants = ty::substd_enum_variants(tcx, enum_def_id, substs);
match *enum_variant_info {
Some((variant_def_id, ref _lp2)) =>
variants.iter()
.find(|variant| variant.id == variant_def_id)
.expect("enum_variant_with_id(): no variant exists with that ID")
.clone(),
None => {
assert_eq!(variants.len(), 1);
variants.pop().unwrap()
}
}
};
match *origin_field_name {
mc::NamedField(ast_name) => {
let variant_arg_names = variant_info.arg_names.as_ref().unwrap();
for variant_arg_ident in variant_arg_names {
if variant_arg_ident.name == ast_name {
continue;
}
let field_name = mc::NamedField(variant_arg_ident.name);
add_fragment_sibling_local(field_name, Some(variant_info.id));
}
}
mc::PositionalField(tuple_idx) => {
let variant_arg_types = &variant_info.args;
for (i, _variant_arg_ty) in variant_arg_types.iter().enumerate() {
if tuple_idx == i {
continue;
}
let field_name = mc::PositionalField(i);
add_fragment_sibling_local(field_name, None);
}
}
}
}
ref sty_and_variant_info => {
let msg = format!("type {} ({:?}) is not fragmentable",
parent_ty.repr(tcx), sty_and_variant_info);
let opt_span = origin_id.and_then(|id|tcx.map.opt_span(id));
tcx.sess.opt_span_bug(opt_span, &msg[..])
}
}
}
/// Adds the single sibling `LpExtend(parent, new_field_name)` of `origin_lp` (the original
/// loan-path).
fn add_fragment_sibling_core<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
gathered_fragments: &mut Vec<Fragment>,
parent: Rc<LoanPath<'tcx>>,
mc: mc::MutabilityCategory,
new_field_name: mc::FieldName,
origin_lp: &Rc<LoanPath<'tcx>>,
enum_variant_did: Option<ast::DefId>) -> MovePathIndex {
let opt_variant_did = match parent.kind {
LpDowncast(_, variant_did) => Some(variant_did),
LpVar(..) | LpUpvar(..) | LpExtend(..) => enum_variant_did,
};
let loan_path_elem = LpInterior(InteriorField(new_field_name));
let new_lp_type = match new_field_name { | mc::NamedField(ast_name) =>
ty::named_element_ty(tcx, parent.to_type(), ast_name, opt_variant_did),
mc::PositionalField(idx) =>
ty::positional_element_ty(tcx, parent.to_type(), idx, opt_variant_did), | random_line_split |
|
fragments.rs | .md`.
use self::Fragment::*;
use borrowck::InteriorKind::{InteriorField, InteriorElement};
use borrowck::LoanPath;
use borrowck::LoanPathKind::{LpVar, LpUpvar, LpDowncast, LpExtend};
use borrowck::LoanPathElem::{LpDeref, LpInterior};
use borrowck::move_data::InvalidMovePathIndex;
use borrowck::move_data::{MoveData, MovePathIndex};
use rustc::middle::ty;
use rustc::middle::mem_categorization as mc;
use rustc::util::ppaux::{Repr, UserString};
use std::mem;
use std::rc::Rc;
use syntax::ast;
use syntax::attr::AttrMetaMethods;
use syntax::codemap::Span;
#[derive(PartialEq, Eq, PartialOrd, Ord)]
enum Fragment {
// This represents the path described by the move path index
Just(MovePathIndex),
// This represents the collection of all but one of the elements
// from an array at the path described by the move path index.
// Note that attached MovePathIndex should have mem_categorization
// of InteriorElement (i.e. array dereference `&foo[..]`).
AllButOneFrom(MovePathIndex),
}
impl Fragment {
fn loan_path_repr<'tcx>(&self, move_data: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) -> String {
let repr = |mpi| move_data.path_loan_path(mpi).repr(tcx);
match *self {
Just(mpi) => repr(mpi),
AllButOneFrom(mpi) => format!("$(allbutone {})", repr(mpi)),
}
}
fn loan_path_user_string<'tcx>(&self,
move_data: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>) -> String {
let user_string = |mpi| move_data.path_loan_path(mpi).user_string(tcx);
match *self {
Just(mpi) => user_string(mpi),
AllButOneFrom(mpi) => format!("$(allbutone {})", user_string(mpi)),
}
}
}
pub struct FragmentSets {
/// During move_data construction, `moved_leaf_paths` tracks paths
/// that have been used directly by being moved out of. When
/// move_data construction has been completed, `moved_leaf_paths`
/// tracks such paths that are *leaf fragments* (e.g. `a.j` if we
/// never move out any child like `a.j.x`); any parent paths
/// (e.g. `a` for the `a.j` example) are moved over to
/// `parents_of_fragments`.
moved_leaf_paths: Vec<MovePathIndex>,
/// `assigned_leaf_paths` tracks paths that have been used
/// directly by being overwritten, but is otherwise much like
/// `moved_leaf_paths`.
assigned_leaf_paths: Vec<MovePathIndex>,
/// `parents_of_fragments` tracks paths that are definitely
/// parents of paths that have been moved.
///
/// FIXME(pnkfelix) probably do not want/need
/// `parents_of_fragments` at all, if we can avoid it.
///
/// Update: I do not see a way to to avoid it. Maybe just remove
/// above fixme, or at least document why doing this may be hard.
parents_of_fragments: Vec<MovePathIndex>,
/// During move_data construction (specifically the
/// fixup_fragment_sets call), `unmoved_fragments` tracks paths
/// that have been "left behind" after a sibling has been moved or
/// assigned. When move_data construction has been completed,
/// `unmoved_fragments` tracks paths that were *only* results of
/// being left-behind, and never directly moved themselves.
unmoved_fragments: Vec<Fragment>,
}
impl FragmentSets {
pub fn new() -> FragmentSets {
FragmentSets {
unmoved_fragments: Vec::new(),
moved_leaf_paths: Vec::new(),
assigned_leaf_paths: Vec::new(),
parents_of_fragments: Vec::new(),
}
}
pub fn add_move(&mut self, path_index: MovePathIndex) {
self.moved_leaf_paths.push(path_index);
}
pub fn add_assignment(&mut self, path_index: MovePathIndex) {
self.assigned_leaf_paths.push(path_index);
}
}
pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
sp: Span,
id: ast::NodeId) {
let span_err = tcx.map.attrs(id).iter()
.any(|a| a.check_name("rustc_move_fragments"));
let print = tcx.sess.opts.debugging_opts.print_move_fragments;
if!span_err &&!print { return; }
let instrument_all_paths = |kind, vec_rc: &Vec<MovePathIndex>| {
for (i, mpi) in vec_rc.iter().enumerate() {
let render = || this.path_loan_path(*mpi).user_string(tcx);
if span_err {
tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render()));
}
if print {
println!("id:{} {}[{}] `{}`", id, kind, i, render());
}
}
};
let instrument_all_fragments = |kind, vec_rc: &Vec<Fragment>| {
for (i, f) in vec_rc.iter().enumerate() {
let render = || f.loan_path_user_string(this, tcx);
if span_err {
tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render()));
}
if print {
println!("id:{} {}[{}] `{}`", id, kind, i, render());
}
}
};
let fragments = this.fragments.borrow();
instrument_all_paths("moved_leaf_path", &fragments.moved_leaf_paths);
instrument_all_fragments("unmoved_fragment", &fragments.unmoved_fragments);
instrument_all_paths("parent_of_fragments", &fragments.parents_of_fragments);
instrument_all_paths("assigned_leaf_path", &fragments.assigned_leaf_paths);
}
/// Normalizes the fragment sets in `this`; i.e., removes duplicate entries, constructs the set of
/// parents, and constructs the left-over fragments.
///
/// Note: "left-over fragments" means paths that were not directly referenced in moves nor
/// assignments, but must nonetheless be tracked as potential drop obligations.
pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) {
let mut fragments = this.fragments.borrow_mut();
// Swap out contents of fragments so that we can modify the fields
// without borrowing the common fragments.
let mut unmoved = mem::replace(&mut fragments.unmoved_fragments, vec![]);
let mut parents = mem::replace(&mut fragments.parents_of_fragments, vec![]);
let mut moved = mem::replace(&mut fragments.moved_leaf_paths, vec![]);
let mut assigned = mem::replace(&mut fragments.assigned_leaf_paths, vec![]);
let path_lps = |mpis: &[MovePathIndex]| -> Vec<String> {
mpis.iter().map(|mpi| this.path_loan_path(*mpi).repr(tcx)).collect()
};
let frag_lps = |fs: &[Fragment]| -> Vec<String> {
fs.iter().map(|f| f.loan_path_repr(this, tcx)).collect()
};
// First, filter out duplicates
moved.sort();
moved.dedup();
debug!("fragments 1 moved: {:?}", path_lps(&moved[..]));
assigned.sort();
assigned.dedup();
debug!("fragments 1 assigned: {:?}", path_lps(&assigned[..]));
// Second, build parents from the moved and assigned.
for m in &moved {
let mut p = this.path_parent(*m);
while p!= InvalidMovePathIndex {
parents.push(p);
p = this.path_parent(p);
}
}
for a in &assigned {
let mut p = this.path_parent(*a);
while p!= InvalidMovePathIndex {
parents.push(p);
p = this.path_parent(p);
}
}
parents.sort();
parents.dedup();
debug!("fragments 2 parents: {:?}", path_lps(&parents[..]));
// Third, filter the moved and assigned fragments down to just the non-parents
moved.retain(|f| non_member(*f, &parents[..]));
debug!("fragments 3 moved: {:?}", path_lps(&moved[..]));
assigned.retain(|f| non_member(*f, &parents[..]));
debug!("fragments 3 assigned: {:?}", path_lps(&assigned[..]));
// Fourth, build the leftover from the moved, assigned, and parents.
for m in &moved {
let lp = this.path_loan_path(*m);
add_fragment_siblings(this, tcx, &mut unmoved, lp, None);
}
for a in &assigned {
let lp = this.path_loan_path(*a);
add_fragment_siblings(this, tcx, &mut unmoved, lp, None);
}
for p in &parents {
let lp = this.path_loan_path(*p);
add_fragment_siblings(this, tcx, &mut unmoved, lp, None);
}
unmoved.sort();
unmoved.dedup();
debug!("fragments 4 unmoved: {:?}", frag_lps(&unmoved[..]));
// Fifth, filter the leftover fragments down to its core.
unmoved.retain(|f| match *f {
AllButOneFrom(_) => true,
Just(mpi) => non_member(mpi, &parents[..]) &&
non_member(mpi, &moved[..]) &&
non_member(mpi, &assigned[..])
});
debug!("fragments 5 unmoved: {:?}", frag_lps(&unmoved[..]));
// Swap contents back in.
fragments.unmoved_fragments = unmoved;
fragments.parents_of_fragments = parents;
fragments.moved_leaf_paths = moved;
fragments.assigned_leaf_paths = assigned;
return;
fn non_member(elem: MovePathIndex, set: &[MovePathIndex]) -> bool {
match set.binary_search(&elem) {
Ok(_) => false,
Err(_) => true,
}
}
}
/// Adds all of the precisely-tracked siblings of `lp` as potential move paths of interest. For
/// example, if `lp` represents `s.x.j`, then adds moves paths for `s.x.i` and `s.x.k`, the
/// siblings of `s.x.j`.
fn | <'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
gathered_fragments: &mut Vec<Fragment>,
lp: Rc<LoanPath<'tcx>>,
origin_id: Option<ast::NodeId>) {
match lp.kind {
LpVar(_) | LpUpvar(..) => {} // Local variables have no siblings.
// Consuming a downcast is like consuming the original value, so propage inward.
LpDowncast(ref loan_parent, _) => {
add_fragment_siblings(this, tcx, gathered_fragments, loan_parent.clone(), origin_id);
}
// *LV for Unique consumes the contents of the box (at
// least when it is non-copy...), so propagate inward.
LpExtend(ref loan_parent, _, LpDeref(mc::Unique)) => {
add_fragment_siblings(this, tcx, gathered_fragments, loan_parent.clone(), origin_id);
}
// *LV for unsafe and borrowed pointers do not consume their loan path, so stop here.
LpExtend(_, _, LpDeref(mc::UnsafePtr(..))) |
LpExtend(_, _, LpDeref(mc::Implicit(..))) |
LpExtend(_, _, LpDeref(mc::BorrowedPtr(..))) => {}
// FIXME (pnkfelix): LV[j] should be tracked, at least in the
// sense of we will track the remaining drop obligation of the
// rest of the array.
//
// Well, either that or LV[j] should be made illegal.
// But even then, we will need to deal with destructuring
// bind.
//
// Anyway, for now: LV[j] is not tracked precisely
LpExtend(_, _, LpInterior(InteriorElement(..))) => {
let mp = this.move_path(tcx, lp.clone());
gathered_fragments.push(AllButOneFrom(mp));
}
// field access LV.x and tuple access LV#k are the cases
// we are interested in
LpExtend(ref loan_parent, mc,
LpInterior(InteriorField(ref field_name))) => {
let enum_variant_info = match loan_parent.kind {
LpDowncast(ref loan_parent_2, variant_def_id) =>
Some((variant_def_id, loan_parent_2.clone())),
LpExtend(..) | LpVar(..) | LpUpvar(..) =>
None,
};
add_fragment_siblings_for_extension(
this,
tcx,
gathered_fragments,
loan_parent, mc, field_name, &lp, origin_id, enum_variant_info);
}
}
}
/// We have determined that `origin_lp` destructures to LpExtend(parent, original_field_name).
/// Based on this, add move paths for all of the siblings of `origin_lp`.
fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
gathered_fragments: &mut Vec<Fragment>,
parent_lp: &Rc<LoanPath<'tcx>>,
mc: mc::MutabilityCategory,
origin_field_name: &mc::FieldName,
origin_lp: &Rc<LoanPath<'tcx>>,
origin_id: Option<ast::NodeId>,
enum_variant_info: Option<(ast::DefId,
Rc<LoanPath<'tcx>>)>) {
let parent_ty = parent_lp.to_type();
let mut add_fragment_sibling_local = |field_name, variant_did| {
add_fragment_sibling_core(
this, tcx, gathered_fragments, parent_lp.clone(), mc, field_name, origin_lp,
variant_did);
};
match (&parent_ty.sty, enum_variant_info) {
(&ty::ty_tup(ref v), None) => {
let tuple_idx = match *origin_field_name {
mc::PositionalField(tuple_idx) => tuple_idx,
mc::NamedField(_) =>
panic!("tuple type {} should not have named fields.",
parent_ty.repr(tcx)),
};
let tuple_len = v.len();
for i in 0..tuple_len {
if i == tuple_idx { continue }
let field_name = mc::PositionalField(i);
add_fragment_sibling_local(field_name, None);
}
}
(&ty::ty_struct(def_id, ref _substs), None) => {
let fields = ty::lookup_struct_fields(tcx, def_id);
match *origin_field_name {
mc::NamedField(ast_name) => {
for f in &fields {
if f.name == ast_name {
continue;
}
let field_name = mc::NamedField(f.name);
add_fragment_sibling_local(field_name, None);
}
}
mc::PositionalField(tuple_idx) => {
for (i, _f) in fields.iter().enumerate() {
if i == tuple_idx {
continue
}
let field_name = mc::PositionalField(i);
add_fragment_sibling_local(field_name, None);
}
}
}
}
(&ty::ty_enum(enum_def_id, substs), ref enum_variant_info) => {
let variant_info = {
let mut variants = ty::substd_enum_variants(tcx, enum_def_id, substs);
match *enum_variant_info {
Some((variant_def_id, ref _lp2)) =>
variants.iter()
.find(|variant| variant.id == variant_def_id)
.expect("enum_variant_with_id(): no variant exists with that ID")
.clone(),
None => {
assert_eq!(variants.len(), 1);
variants.pop().unwrap()
}
}
};
match *origin_field_name {
mc::NamedField(ast_name) => {
let variant_arg_names = variant_info.arg_names.as_ref().unwrap();
for variant_arg_ident in variant_arg_names {
if variant_arg_ident.name == ast_name {
continue;
}
let field_name = mc::NamedField(variant_arg_ident.name);
add_fragment_sibling_local(field_name, Some(variant_info.id));
}
}
mc::PositionalField(tuple_idx) => {
let variant_arg_types = &variant_info.args;
for (i, _variant_arg_ty) in variant_arg_types.iter().enumerate() {
if tuple_idx == i {
continue;
}
let field_name = mc::PositionalField(i);
add_fragment_sibling_local(field_name, None);
}
}
}
}
ref sty_and_variant_info => {
let msg = format!("type {} ({:?}) is not fragmentable",
parent_ty.repr(tcx), sty_and_variant_info);
let opt_span = origin_id.and_then(|id|tcx.map.opt_span(id));
tcx.sess.opt_span_bug(opt_span, &msg[..])
}
}
}
/// Adds the single sibling `LpExtend(parent, new_field_name)` of `origin_lp` (the original
/// loan-path).
fn add_fragment_sibling_core<'tcx>(this: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>,
gathered_fragments: &mut Vec<Fragment>,
parent: Rc<LoanPath<'tcx>>,
mc: mc::MutabilityCategory,
new_field_name: mc::FieldName,
origin_lp: &Rc<LoanPath<'tcx>>,
enum_variant_did: Option<ast::DefId>) -> MovePathIndex {
let opt_variant_did = match parent.kind {
LpDowncast(_, variant_did) => Some(variant | add_fragment_siblings | identifier_name |
rtnl.rs | impl_var!(
/// Internet address families
Af, libc::c_uchar,
Inet => libc::AF_INET as libc::c_uchar,
Inet6 => libc::AF_INET6 as libc::c_uchar
);
impl_var!(
/// General address families for sockets
RtAddrFamily, u8,
Unspecified => libc::AF_UNSPEC as u8,
UnixOrLocal => libc::AF_UNIX as u8,
Inet => libc::AF_INET as u8,
Inet6 => libc::AF_INET6 as u8,
Ipx => libc::AF_IPX as u8,
Netlink => libc::AF_NETLINK as u8,
X25 => libc::AF_X25 as u8,
Ax25 => libc::AF_AX25 as u8,
Atmpvc => libc::AF_ATMPVC as u8,
Appletalk => libc::AF_APPLETALK as u8,
Packet => libc::AF_PACKET as u8,
Alg => libc::AF_ALG as u8
);
impl_var!(
/// Interface address flags
IfaF, u32,
Secondary => libc::IFA_F_SECONDARY,
Temporary => libc::IFA_F_TEMPORARY,
Nodad => libc::IFA_F_NODAD,
Optimistic => libc::IFA_F_OPTIMISTIC,
Dadfailed => libc::IFA_F_DADFAILED,
Homeaddress => libc::IFA_F_HOMEADDRESS,
Deprecated => libc::IFA_F_DEPRECATED,
Tentative => libc::IFA_F_TENTATIVE,
Permanent => libc::IFA_F_PERMANENT,
#[cfg(target_env="gnu")]
Managetempaddr => libc::IFA_F_MANAGETEMPADDR,
#[cfg(target_env="gnu")]
Noprefixroute => libc::IFA_F_NOPREFIXROUTE,
#[cfg(target_env="gnu")]
Mcautojoin => libc::IFA_F_MCAUTOJOIN,
#[cfg(target_env="gnu")]
StablePrivacy => libc::IFA_F_STABLE_PRIVACY
);
impl_var!(
/// `rtm_type`
/// The results of a lookup from a route table
Rtn, libc::c_uchar,
Unspec => libc::RTN_UNSPEC,
Unicast => libc::RTN_UNICAST,
Local => libc::RTN_LOCAL,
Broadcast => libc::RTN_BROADCAST,
Anycast => libc::RTN_ANYCAST,
Multicast => libc::RTN_MULTICAST,
Blackhole => libc::RTN_BLACKHOLE,
Unreachable => libc::RTN_UNREACHABLE,
Prohibit => libc::RTN_PROHIBIT,
Throw => libc::RTN_THROW,
Nat => libc::RTN_NAT,
Xresolve => libc::RTN_XRESOLVE
);
impl_var!(
/// `rtm_protocol`
/// The origins of routes that are defined in the kernel
Rtprot, libc::c_uchar,
Unspec => libc::RTPROT_UNSPEC,
Redirect => libc::RTPROT_REDIRECT,
Kernel => libc::RTPROT_KERNEL,
Boot => libc::RTPROT_BOOT,
Static => libc::RTPROT_STATIC
);
impl_var!(
/// `rtm_scope`
/// The distance between destinations
RtScope, libc::c_uchar,
Universe => libc::RT_SCOPE_UNIVERSE,
Site => libc::RT_SCOPE_SITE,
Link => libc::RT_SCOPE_LINK,
Host => libc::RT_SCOPE_HOST,
Nowhere => libc::RT_SCOPE_NOWHERE
);
impl_var!(
/// `rt_class_t`
/// Reserved route table identifiers
RtTable, libc::c_uchar,
Unspec => libc::RT_TABLE_UNSPEC,
Compat => libc::RT_TABLE_COMPAT,
Default => libc::RT_TABLE_DEFAULT,
Main => libc::RT_TABLE_MAIN,
Local => libc::RT_TABLE_LOCAL
);
impl_var!(
/// `rtm_flags`
/// Flags for rtnetlink messages
RtmF, libc::c_uint,
Notify => libc::RTM_F_NOTIFY,
Cloned => libc::RTM_F_CLONED,
Equalize => libc::RTM_F_EQUALIZE,
Prefix => libc::RTM_F_PREFIX,
#[cfg(target_env="gnu")]
LookupTable => libc::RTM_F_LOOKUP_TABLE,
#[cfg(target_env="gnu")]
FibMatch => libc::RTM_F_FIB_MATCH
);
impl_var!(
/// Arp neighbor cache entry states
Nud, u16,
None => libc::NUD_NONE,
Incomplete => libc::NUD_INCOMPLETE,
Reachable => libc::NUD_REACHABLE,
Stale => libc::NUD_STALE,
Delay => libc::NUD_DELAY,
Probe => libc::NUD_PROBE,
Failed => libc::NUD_FAILED,
Noarp => libc::NUD_NOARP,
Permanent => libc::NUD_PERMANENT
);
impl_var!(
/// Arp neighbor cache entry flags
Ntf, u8,
Use => libc::NTF_USE,
Self_ => libc::NTF_SELF,
Master => libc::NTF_MASTER,
Proxy => libc::NTF_PROXY,
#[cfg(target_env="gnu")]
ExtLearned => libc::NTF_EXT_LEARNED,
#[cfg(target_env="gnu")]
Offloaded => libc::NTF_OFFLOADED,
Router => libc::NTF_ROUTER
);
impl_trait!(
/// Marker trait for `Rtattr.rta_type` field
RtaType,
libc::c_ushort
);
impl_var_trait!(
/// Enum for use with `Rtattr.rta_type`.
/// Values are interface information message attributes. Used with `Ifinfomsg`.
Ifla, libc::c_ushort, RtaType,
Unspec => libc::IFLA_UNSPEC,
Address => libc::IFLA_ADDRESS,
Broadcast => libc::IFLA_BROADCAST,
Ifname => libc::IFLA_IFNAME,
Mtu => libc::IFLA_MTU, | Priority => libc::IFLA_PRIORITY,
Master => libc::IFLA_MASTER,
Wireless => libc::IFLA_WIRELESS,
Protinfo => libc::IFLA_PROTINFO,
Txqlen => libc::IFLA_TXQLEN,
Map => libc::IFLA_MAP,
Weight => libc::IFLA_WEIGHT,
Operstate => libc::IFLA_OPERSTATE,
Linkmode => libc::IFLA_LINKMODE,
Linkinfo => libc::IFLA_LINKINFO,
NetNsPid => libc::IFLA_NET_NS_PID,
Ifalias => libc::IFLA_IFALIAS,
NumVf => libc::IFLA_NUM_VF,
VfinfoList => libc::IFLA_VFINFO_LIST,
Stats64 => libc::IFLA_STATS64,
VfPorts => libc::IFLA_VF_PORTS,
PortSelf => libc::IFLA_PORT_SELF,
AfSpec => libc::IFLA_AF_SPEC,
Group => libc::IFLA_GROUP,
NetNsFd => libc::IFLA_NET_NS_FD,
ExtMask => libc::IFLA_EXT_MASK,
Promiscuity => libc::IFLA_PROMISCUITY,
NumTxQueues => libc::IFLA_NUM_TX_QUEUES,
NumRxQueues => libc::IFLA_NUM_RX_QUEUES,
Carrier => libc::IFLA_CARRIER,
PhysPortId => libc::IFLA_PHYS_PORT_ID,
CarrierChanges => libc::IFLA_CARRIER_CHANGES,
PhysSwitchId => libc::IFLA_PHYS_SWITCH_ID,
LinkNetnsid => libc::IFLA_LINK_NETNSID,
PhysPortName => libc::IFLA_PHYS_PORT_NAME,
ProtoDown => libc::IFLA_PROTO_DOWN
);
impl_trait!(
/// Marker trait for `Rtattr.rta_type` field
IflaInfoType,
libc::c_ushort
);
impl_var_trait!(
/// Enum for use with `Rtattr.rta_type`.
/// Values are nested attributes to IFLA_LINKMODE.
IflaInfo, libc::c_ushort, IflaInfoType,
Unspec => libc::IFLA_INFO_UNSPEC,
Kind => libc::IFLA_INFO_KIND,
Data => libc::IFLA_INFO_DATA,
Xstats => libc::IFLA_INFO_XSTATS,
SlaveKind => libc::IFLA_INFO_SLAVE_KIND,
SlaveData => libc::IFLA_INFO_SLAVE_DATA
);
impl_var_trait!(
/// Enum for use with `Rtattr.rta_type`.
/// Values are interface address message attributes. Used with `Ifaddrmsg`.
Ifa, libc::c_ushort, RtaType,
Unspec => libc::IFA_UNSPEC,
Address => libc::IFA_ADDRESS,
Local => libc::IFA_LOCAL,
Label => libc::IFA_LABEL,
Broadcast => libc::IFA_BROADCAST,
Anycast => libc::IFA_ANYCAST,
Cacheinfo => libc::IFA_CACHEINFO,
Multicast => libc::IFA_MULTICAST,
#[cfg(target_env="gnu")]
Flags => libc::IFA_FLAGS
);
impl_var_trait!(
/// Enum for use with `Rtattr.rta_type`.
/// Values are routing message attributes. Used with `Rtmsg`.
Rta, libc::c_ushort, RtaType,
Unspec => libc::RTA_UNSPEC,
Dst => libc::RTA_DST,
Src => libc::RTA_SRC,
Iif => libc::RTA_IIF,
Oif => libc::RTA_OIF,
Gateway => libc::RTA_GATEWAY,
Priority => libc::RTA_PRIORITY,
Prefsrc => libc::RTA_PREFSRC,
Metrics => libc::RTA_METRICS,
Multipath => libc::RTA_MULTIPATH,
Protoinfo => libc::RTA_PROTOINFO, // no longer used in Linux
Flow => libc::RTA_FLOW,
Cacheinfo => libc::RTA_CACHEINFO,
Session => libc::RTA_SESSION, // no longer used in Linux
MpAlgo => libc::RTA_MP_ALGO, // no longer used in Linux
Table => libc::RTA_TABLE,
Mark => libc::RTA_MARK,
MfcStats => libc::RTA_MFC_STATS,
#[cfg(target_env="gnu")]
Via => libc::RTA_VIA,
#[cfg(target_env="gnu")]
Newdst => libc::RTA_NEWDST,
#[cfg(target_env="gnu")]
Pref => libc::RTA_PREF,
#[cfg(target_env="gnu")]
EncapType => libc::RTA_ENCAP_TYPE,
#[cfg(target_env="gnu")]
Encap => libc::RTA_ENCAP,
#[cfg(target_env="gnu")]
Expires => libc::RTA_EXPIRES,
#[cfg(target_env="gnu")]
Pad => libc::RTA_PAD,
#[cfg(target_env="gnu")]
Uid => libc::RTA_UID,
#[cfg(target_env="gnu")]
TtlPropagate => libc::RTA_TTL_PROPAGATE
);
impl_var_trait!(
/// Enum for use with `Rtattr.rta_type` -
/// Values specify queuing discipline attributes. Used with `Tcmsg`.
Tca, libc::c_ushort, RtaType,
Unspec => libc::TCA_UNSPEC,
Kind => libc::TCA_KIND,
Options => libc::TCA_OPTIONS,
Stats => libc::TCA_STATS,
Xstats => libc::TCA_XSTATS,
Rate => libc::TCA_RATE,
Fcnt => libc::TCA_FCNT,
Stats2 => libc::TCA_STATS2,
Stab => libc::TCA_STAB
);
impl_var_trait!(
/// Enum for use with `Rtattr.rta_type` -
/// Values specify neighbor table attributes
Nda, libc::c_ushort, RtaType,
Unspec => libc::NDA_UNSPEC,
Dst => libc::NDA_DST,
Lladdr => libc::NDA_LLADDR,
Cacheinfo => libc::NDA_CACHEINFO,
Probes => libc::NDA_PROBES,
Vlan => libc::NDA_VLAN,
Port => libc::NDA_PORT,
Vni => libc::NDA_VNI,
Ifindex => libc::NDA_IFINDEX,
#[cfg(target_env="gnu")]
Master => libc::NDA_MASTER,
#[cfg(target_env="gnu")]
LinkNetnsid => libc::NDA_LINK_NETNSID,
#[cfg(target_env="gnu")]
SrcVni => libc::NDA_SRC_VNI
);
impl_var!(
/// Interface types
Arphrd, libc::c_ushort,
Netrom => libc::ARPHRD_NETROM,
Ether => libc::ARPHRD_ETHER,
Eether => libc::ARPHRD_EETHER,
AX25 => libc::ARPHRD_AX25,
Pronet => libc::ARPHRD_PRONET,
Chaos => libc::ARPHRD_CHAOS,
Ieee802 => libc::ARPHRD_IEEE802,
Arcnet => libc::ARPHRD_ARCNET,
Appletlk => libc::ARPHRD_APPLETLK,
Dlci => libc::ARPHRD_DLCI,
Atm => libc::ARPHRD_APPLETLK,
Metricom => libc::ARPHRD_METRICOM,
Ieee1394 => libc::ARPHRD_IEEE1394,
Eui64 => libc::ARPHRD_EUI64,
Infiniband => libc::ARPHRD_INFINIBAND,
// Possibly more types here - need to look into ARP more
Void => libc::ARPHRD_VOID,
None => libc::ARPHRD_NONE
);
impl_var!(
/// Values for `ifi_flags` in `Ifinfomsg`
Iff, libc::c_uint,
Up => libc::IFF_UP as libc::c_uint,
Broadcast => libc::IFF_BROADCAST as libc::c_uint,
Debug => libc::IFF_DEBUG as libc::c_uint,
Loopback => libc::IFF_LOOPBACK as libc::c_uint,
Pointopoint => libc::IFF_POINTOPOINT as libc::c_uint,
Running => libc::IFF_RUNNING as libc::c_uint,
Noarp => libc::IFF_NOARP as libc::c_uint,
Promisc => libc::IFF_PROMISC as libc::c_uint,
Notrailers => libc::IFF_NOTRAILERS as libc::c_uint,
Allmulti => libc::IFF_ALLMULTI as libc::c_uint,
Master => libc::IFF_MASTER as libc::c_uint,
Slave => libc::IFF_SLAVE as libc::c_uint,
Multicast => libc::IFF_MULTICAST as libc::c_uint,
Portsel => libc::IFF_PORTSEL as libc::c_uint,
Automedia => libc::IFF_AUTOMEDIA as libc::c_uint,
Dynamic => libc::IFF_DYNAMIC as libc::c_uint,
LowerUp => libc::IFF_LOWER_UP as libc::c_uint,
Dormant => libc::IFF_DORMANT as libc::c_uint,
Echo => libc::IFF_ECHO as libc::c_uint
// Possibly more types here - need to look into private flags for interfaces
); | Link => libc::IFLA_LINK,
Qdisc => libc::IFLA_QDISC,
Stats => libc::IFLA_STATS,
Cost => libc::IFLA_COST, | random_line_split |
process_builder.rs | use std::fmt::{mod, Show, Formatter};
use std::os;
use std::c_str::CString;
use std::io::process::{Command, ProcessOutput, InheritFd};
use std::collections::HashMap;
use util::{ProcessError, process_error};
#[deriving(Clone,PartialEq)]
pub struct ProcessBuilder {
program: CString,
args: Vec<CString>,
env: HashMap<String, Option<CString>>,
cwd: Path,
}
impl Show for ProcessBuilder {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
try!(write!(f, "`{}", String::from_utf8_lossy(self.program.as_bytes_no_nul())));
for arg in self.args.iter() {
try!(write!(f, " {}", String::from_utf8_lossy(arg.as_bytes_no_nul())));
}
write!(f, "`")
}
}
impl ProcessBuilder {
pub fn arg<T: ToCStr>(mut self, arg: T) -> ProcessBuilder {
self.args.push(arg.to_c_str());
self
}
pub fn args<T: ToCStr>(mut self, arguments: &[T]) -> ProcessBuilder {
self.args.extend(arguments.iter().map(|t| t.to_c_str()));
self
}
pub fn get_args(&self) -> &[CString] {
self.args.as_slice()
}
pub fn cwd(mut self, path: Path) -> ProcessBuilder {
self.cwd = path;
self
}
pub fn env<T: ToCStr>(mut self, key: &str, val: Option<T>) -> ProcessBuilder |
// TODO: should InheritFd be hardcoded?
pub fn exec(&self) -> Result<(), ProcessError> {
let mut command = self.build_command();
command.stdout(InheritFd(1))
.stderr(InheritFd(2))
.stdin(InheritFd(0));
let exit = try!(command.status().map_err(|e| {
process_error(format!("Could not execute process `{}`",
self.debug_string()),
Some(e), None, None)
}));
if exit.success() {
Ok(())
} else {
Err(process_error(format!("Process didn't exit successfully: `{}`",
self.debug_string()),
None, Some(&exit), None))
}
}
pub fn exec_with_output(&self) -> Result<ProcessOutput, ProcessError> {
let command = self.build_command();
let output = try!(command.output().map_err(|e| {
process_error(format!("Could not execute process `{}`",
self.debug_string()),
Some(e), None, None)
}));
if output.status.success() {
Ok(output)
} else {
Err(process_error(format!("Process didn't exit successfully: `{}`",
self.debug_string()),
None, Some(&output.status), Some(&output)))
}
}
pub fn build_command(&self) -> Command {
let mut command = Command::new(self.program.as_bytes_no_nul());
command.cwd(&self.cwd);
for arg in self.args.iter() {
command.arg(arg.as_bytes_no_nul());
}
for (k, v) in self.env.iter() {
let k = k.as_slice();
match *v {
Some(ref v) => { command.env(k, v.as_bytes_no_nul()); }
None => { command.env_remove(k); }
}
}
command
}
fn debug_string(&self) -> String {
let program = String::from_utf8_lossy(self.program.as_bytes_no_nul());
let mut program = program.into_string();
for arg in self.args.iter() {
program.push_char(' ');
let s = String::from_utf8_lossy(arg.as_bytes_no_nul());
program.push_str(s.as_slice());
}
program
}
}
pub fn process<T: ToCStr>(cmd: T) -> ProcessBuilder {
ProcessBuilder {
program: cmd.to_c_str(),
args: Vec::new(),
cwd: os::getcwd(),
env: HashMap::new(),
}
}
| {
self.env.insert(key.to_string(), val.map(|t| t.to_c_str()));
self
} | identifier_body |
process_builder.rs | use std::fmt::{mod, Show, Formatter};
use std::os;
use std::c_str::CString;
use std::io::process::{Command, ProcessOutput, InheritFd};
use std::collections::HashMap;
use util::{ProcessError, process_error};
#[deriving(Clone,PartialEq)]
pub struct ProcessBuilder {
program: CString,
args: Vec<CString>,
env: HashMap<String, Option<CString>>,
cwd: Path,
}
impl Show for ProcessBuilder {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
try!(write!(f, "`{}", String::from_utf8_lossy(self.program.as_bytes_no_nul())));
for arg in self.args.iter() {
try!(write!(f, " {}", String::from_utf8_lossy(arg.as_bytes_no_nul())));
}
write!(f, "`")
}
}
impl ProcessBuilder {
pub fn arg<T: ToCStr>(mut self, arg: T) -> ProcessBuilder {
self.args.push(arg.to_c_str());
self
}
pub fn args<T: ToCStr>(mut self, arguments: &[T]) -> ProcessBuilder {
self.args.extend(arguments.iter().map(|t| t.to_c_str()));
self
}
pub fn get_args(&self) -> &[CString] {
self.args.as_slice()
}
pub fn cwd(mut self, path: Path) -> ProcessBuilder {
self.cwd = path;
self
}
pub fn env<T: ToCStr>(mut self, key: &str, val: Option<T>) -> ProcessBuilder {
self.env.insert(key.to_string(), val.map(|t| t.to_c_str()));
self
}
// TODO: should InheritFd be hardcoded?
pub fn exec(&self) -> Result<(), ProcessError> {
let mut command = self.build_command();
command.stdout(InheritFd(1))
.stderr(InheritFd(2))
.stdin(InheritFd(0));
let exit = try!(command.status().map_err(|e| {
process_error(format!("Could not execute process `{}`",
self.debug_string()),
Some(e), None, None)
}));
if exit.success() {
Ok(())
} else {
Err(process_error(format!("Process didn't exit successfully: `{}`",
self.debug_string()),
None, Some(&exit), None))
}
}
pub fn exec_with_output(&self) -> Result<ProcessOutput, ProcessError> {
let command = self.build_command();
let output = try!(command.output().map_err(|e| {
process_error(format!("Could not execute process `{}`",
self.debug_string()),
Some(e), None, None)
}));
if output.status.success() {
Ok(output)
} else {
Err(process_error(format!("Process didn't exit successfully: `{}`",
self.debug_string()),
None, Some(&output.status), Some(&output)))
}
}
pub fn build_command(&self) -> Command {
let mut command = Command::new(self.program.as_bytes_no_nul());
command.cwd(&self.cwd);
for arg in self.args.iter() {
command.arg(arg.as_bytes_no_nul());
}
for (k, v) in self.env.iter() {
let k = k.as_slice();
match *v {
Some(ref v) => { command.env(k, v.as_bytes_no_nul()); }
None => { command.env_remove(k); }
}
}
command
} | fn debug_string(&self) -> String {
let program = String::from_utf8_lossy(self.program.as_bytes_no_nul());
let mut program = program.into_string();
for arg in self.args.iter() {
program.push_char(' ');
let s = String::from_utf8_lossy(arg.as_bytes_no_nul());
program.push_str(s.as_slice());
}
program
}
}
pub fn process<T: ToCStr>(cmd: T) -> ProcessBuilder {
ProcessBuilder {
program: cmd.to_c_str(),
args: Vec::new(),
cwd: os::getcwd(),
env: HashMap::new(),
}
} | random_line_split |
|
process_builder.rs | use std::fmt::{mod, Show, Formatter};
use std::os;
use std::c_str::CString;
use std::io::process::{Command, ProcessOutput, InheritFd};
use std::collections::HashMap;
use util::{ProcessError, process_error};
#[deriving(Clone,PartialEq)]
pub struct ProcessBuilder {
program: CString,
args: Vec<CString>,
env: HashMap<String, Option<CString>>,
cwd: Path,
}
impl Show for ProcessBuilder {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
try!(write!(f, "`{}", String::from_utf8_lossy(self.program.as_bytes_no_nul())));
for arg in self.args.iter() {
try!(write!(f, " {}", String::from_utf8_lossy(arg.as_bytes_no_nul())));
}
write!(f, "`")
}
}
impl ProcessBuilder {
pub fn arg<T: ToCStr>(mut self, arg: T) -> ProcessBuilder {
self.args.push(arg.to_c_str());
self
}
pub fn args<T: ToCStr>(mut self, arguments: &[T]) -> ProcessBuilder {
self.args.extend(arguments.iter().map(|t| t.to_c_str()));
self
}
pub fn get_args(&self) -> &[CString] {
self.args.as_slice()
}
pub fn cwd(mut self, path: Path) -> ProcessBuilder {
self.cwd = path;
self
}
pub fn env<T: ToCStr>(mut self, key: &str, val: Option<T>) -> ProcessBuilder {
self.env.insert(key.to_string(), val.map(|t| t.to_c_str()));
self
}
// TODO: should InheritFd be hardcoded?
pub fn | (&self) -> Result<(), ProcessError> {
let mut command = self.build_command();
command.stdout(InheritFd(1))
.stderr(InheritFd(2))
.stdin(InheritFd(0));
let exit = try!(command.status().map_err(|e| {
process_error(format!("Could not execute process `{}`",
self.debug_string()),
Some(e), None, None)
}));
if exit.success() {
Ok(())
} else {
Err(process_error(format!("Process didn't exit successfully: `{}`",
self.debug_string()),
None, Some(&exit), None))
}
}
pub fn exec_with_output(&self) -> Result<ProcessOutput, ProcessError> {
let command = self.build_command();
let output = try!(command.output().map_err(|e| {
process_error(format!("Could not execute process `{}`",
self.debug_string()),
Some(e), None, None)
}));
if output.status.success() {
Ok(output)
} else {
Err(process_error(format!("Process didn't exit successfully: `{}`",
self.debug_string()),
None, Some(&output.status), Some(&output)))
}
}
pub fn build_command(&self) -> Command {
let mut command = Command::new(self.program.as_bytes_no_nul());
command.cwd(&self.cwd);
for arg in self.args.iter() {
command.arg(arg.as_bytes_no_nul());
}
for (k, v) in self.env.iter() {
let k = k.as_slice();
match *v {
Some(ref v) => { command.env(k, v.as_bytes_no_nul()); }
None => { command.env_remove(k); }
}
}
command
}
fn debug_string(&self) -> String {
let program = String::from_utf8_lossy(self.program.as_bytes_no_nul());
let mut program = program.into_string();
for arg in self.args.iter() {
program.push_char(' ');
let s = String::from_utf8_lossy(arg.as_bytes_no_nul());
program.push_str(s.as_slice());
}
program
}
}
pub fn process<T: ToCStr>(cmd: T) -> ProcessBuilder {
ProcessBuilder {
program: cmd.to_c_str(),
args: Vec::new(),
cwd: os::getcwd(),
env: HashMap::new(),
}
}
| exec | identifier_name |
process_builder.rs | use std::fmt::{mod, Show, Formatter};
use std::os;
use std::c_str::CString;
use std::io::process::{Command, ProcessOutput, InheritFd};
use std::collections::HashMap;
use util::{ProcessError, process_error};
#[deriving(Clone,PartialEq)]
pub struct ProcessBuilder {
program: CString,
args: Vec<CString>,
env: HashMap<String, Option<CString>>,
cwd: Path,
}
impl Show for ProcessBuilder {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
try!(write!(f, "`{}", String::from_utf8_lossy(self.program.as_bytes_no_nul())));
for arg in self.args.iter() {
try!(write!(f, " {}", String::from_utf8_lossy(arg.as_bytes_no_nul())));
}
write!(f, "`")
}
}
impl ProcessBuilder {
pub fn arg<T: ToCStr>(mut self, arg: T) -> ProcessBuilder {
self.args.push(arg.to_c_str());
self
}
pub fn args<T: ToCStr>(mut self, arguments: &[T]) -> ProcessBuilder {
self.args.extend(arguments.iter().map(|t| t.to_c_str()));
self
}
pub fn get_args(&self) -> &[CString] {
self.args.as_slice()
}
pub fn cwd(mut self, path: Path) -> ProcessBuilder {
self.cwd = path;
self
}
pub fn env<T: ToCStr>(mut self, key: &str, val: Option<T>) -> ProcessBuilder {
self.env.insert(key.to_string(), val.map(|t| t.to_c_str()));
self
}
// TODO: should InheritFd be hardcoded?
pub fn exec(&self) -> Result<(), ProcessError> {
let mut command = self.build_command();
command.stdout(InheritFd(1))
.stderr(InheritFd(2))
.stdin(InheritFd(0));
let exit = try!(command.status().map_err(|e| {
process_error(format!("Could not execute process `{}`",
self.debug_string()),
Some(e), None, None)
}));
if exit.success() {
Ok(())
} else {
Err(process_error(format!("Process didn't exit successfully: `{}`",
self.debug_string()),
None, Some(&exit), None))
}
}
pub fn exec_with_output(&self) -> Result<ProcessOutput, ProcessError> {
let command = self.build_command();
let output = try!(command.output().map_err(|e| {
process_error(format!("Could not execute process `{}`",
self.debug_string()),
Some(e), None, None)
}));
if output.status.success() {
Ok(output)
} else |
}
pub fn build_command(&self) -> Command {
let mut command = Command::new(self.program.as_bytes_no_nul());
command.cwd(&self.cwd);
for arg in self.args.iter() {
command.arg(arg.as_bytes_no_nul());
}
for (k, v) in self.env.iter() {
let k = k.as_slice();
match *v {
Some(ref v) => { command.env(k, v.as_bytes_no_nul()); }
None => { command.env_remove(k); }
}
}
command
}
fn debug_string(&self) -> String {
let program = String::from_utf8_lossy(self.program.as_bytes_no_nul());
let mut program = program.into_string();
for arg in self.args.iter() {
program.push_char(' ');
let s = String::from_utf8_lossy(arg.as_bytes_no_nul());
program.push_str(s.as_slice());
}
program
}
}
pub fn process<T: ToCStr>(cmd: T) -> ProcessBuilder {
ProcessBuilder {
program: cmd.to_c_str(),
args: Vec::new(),
cwd: os::getcwd(),
env: HashMap::new(),
}
}
| {
Err(process_error(format!("Process didn't exit successfully: `{}`",
self.debug_string()),
None, Some(&output.status), Some(&output)))
} | conditional_block |
variance-trait-matching.rs | // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Issue #5781. Tests that subtyping is handled properly in trait matching.
trait Make<'a> {
fn make(x: &'a mut isize) -> Self;
}
impl<'a> Make<'a> for &'a mut isize {
fn make(x: &'a mut isize) -> &'a mut isize {
x
}
}
fn f() -> &'static mut isize {
let mut x = 1;
let y: &'static mut isize = Make::make(&mut x); //~ ERROR `x` does not live long enough
y | }
fn main() {} | random_line_split |
|
variance-trait-matching.rs | // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Issue #5781. Tests that subtyping is handled properly in trait matching.
trait Make<'a> {
fn make(x: &'a mut isize) -> Self;
}
impl<'a> Make<'a> for &'a mut isize {
fn make(x: &'a mut isize) -> &'a mut isize {
x
}
}
fn f() -> &'static mut isize |
fn main() {}
| {
let mut x = 1;
let y: &'static mut isize = Make::make(&mut x); //~ ERROR `x` does not live long enough
y
} | identifier_body |
variance-trait-matching.rs | // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Issue #5781. Tests that subtyping is handled properly in trait matching.
trait Make<'a> {
fn make(x: &'a mut isize) -> Self;
}
impl<'a> Make<'a> for &'a mut isize {
fn make(x: &'a mut isize) -> &'a mut isize {
x
}
}
fn | () -> &'static mut isize {
let mut x = 1;
let y: &'static mut isize = Make::make(&mut x); //~ ERROR `x` does not live long enough
y
}
fn main() {}
| f | identifier_name |
mod.rs | /*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
use common::SourceLocationKey;
use fixture_tests::Fixture;
use graphql_ir::build;
use graphql_syntax::parse_executable;
use graphql_text_printer::print_ir;
use relay_test_schema::TEST_SCHEMA;
pub fn transform_fixture(fixture: &Fixture<'_>) -> Result<String, String> | {
let source_location = SourceLocationKey::standalone(fixture.file_name);
let ast = parse_executable(fixture.content, source_location).unwrap();
build(&TEST_SCHEMA, &ast.definitions)
.map(|definitions| print_ir(&TEST_SCHEMA, &definitions).join("\n\n"))
.map_err(|errors| {
errors
.into_iter()
.map(|error| format!("{:?}", error))
.collect::<Vec<_>>()
.join("\n\n")
})
} | identifier_body |
|
mod.rs | /*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
use common::SourceLocationKey;
use fixture_tests::Fixture;
use graphql_ir::build;
use graphql_syntax::parse_executable;
use graphql_text_printer::print_ir;
use relay_test_schema::TEST_SCHEMA;
pub fn transform_fixture(fixture: &Fixture<'_>) -> Result<String, String> {
let source_location = SourceLocationKey::standalone(fixture.file_name);
let ast = parse_executable(fixture.content, source_location).unwrap();
build(&TEST_SCHEMA, &ast.definitions)
.map(|definitions| print_ir(&TEST_SCHEMA, &definitions).join("\n\n"))
.map_err(|errors| {
errors
.into_iter()
.map(|error| format!("{:?}", error))
.collect::<Vec<_>>()
.join("\n\n") | } | }) | random_line_split |
mod.rs | /*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
use common::SourceLocationKey;
use fixture_tests::Fixture;
use graphql_ir::build;
use graphql_syntax::parse_executable;
use graphql_text_printer::print_ir;
use relay_test_schema::TEST_SCHEMA;
pub fn | (fixture: &Fixture<'_>) -> Result<String, String> {
let source_location = SourceLocationKey::standalone(fixture.file_name);
let ast = parse_executable(fixture.content, source_location).unwrap();
build(&TEST_SCHEMA, &ast.definitions)
.map(|definitions| print_ir(&TEST_SCHEMA, &definitions).join("\n\n"))
.map_err(|errors| {
errors
.into_iter()
.map(|error| format!("{:?}", error))
.collect::<Vec<_>>()
.join("\n\n")
})
}
| transform_fixture | identifier_name |
bunch.rs |
#![feature(test)]
extern crate misc;
extern crate lsm;
extern crate test;
fn tid() -> String {
// TODO use the rand crate
fn bytes() -> std::io::Result<[u8;16]> {
use std::fs::OpenOptions;
let mut f = try!(OpenOptions::new()
.read(true)
.open("/dev/urandom"));
let mut ba = [0;16];
try!(misc::io::read_fully(&mut f, &mut ba));
Ok(ba)
}
fn to_hex_string(ba: &[u8]) -> String {
let strs: Vec<String> = ba.iter()
.map(|b| format!("{:02X}", b))
.collect();
strs.connect("")
}
let ba = bytes().unwrap();
to_hex_string(&ba)
}
fn tempfile(base: &str) -> String {
std::fs::create_dir("tmp");
let file = "tmp/".to_string() + base + "_" + &tid();
file
}
#[bench]
fn | (b: &mut test::Bencher) {
fn f() -> lsm::Result<bool> {
//println!("running");
let db = try!(lsm::db::new(tempfile("bunch"), lsm::DEFAULT_SETTINGS));
const NUM : usize = 10000;
let mut a = Vec::new();
for i in 0.. 10 {
let g = try!(db.WriteSegmentFromSortedSequence(lsm::GenerateNumbers {cur: i * NUM, end: (i+1) * NUM, step: i+1}));
a.push(g);
}
{
let lck = try!(db.GetWriteLock());
try!(lck.commitSegments(a.clone()));
}
let g3 = try!(db.merge(0, 2, None));
assert!(g3.is_some());
let g3 = g3.unwrap();
{
let lck = try!(db.GetWriteLock());
try!(lck.commitMerge(g3));
}
let res : lsm::Result<bool> = Ok(true);
res
}
b.iter(|| assert!(f().is_ok()) );
}
| bunch | identifier_name |
bunch.rs | #![feature(test)]
extern crate misc;
extern crate lsm;
extern crate test;
fn tid() -> String {
// TODO use the rand crate
fn bytes() -> std::io::Result<[u8;16]> {
use std::fs::OpenOptions;
let mut f = try!(OpenOptions::new()
.read(true)
.open("/dev/urandom"));
let mut ba = [0;16];
try!(misc::io::read_fully(&mut f, &mut ba));
Ok(ba)
}
fn to_hex_string(ba: &[u8]) -> String {
let strs: Vec<String> = ba.iter()
.map(|b| format!("{:02X}", b))
.collect();
strs.connect("")
}
let ba = bytes().unwrap();
to_hex_string(&ba)
}
fn tempfile(base: &str) -> String {
std::fs::create_dir("tmp");
let file = "tmp/".to_string() + base + "_" + &tid();
file
}
#[bench]
fn bunch(b: &mut test::Bencher) {
fn f() -> lsm::Result<bool> {
//println!("running");
let db = try!(lsm::db::new(tempfile("bunch"), lsm::DEFAULT_SETTINGS));
const NUM : usize = 10000;
let mut a = Vec::new();
for i in 0.. 10 {
let g = try!(db.WriteSegmentFromSortedSequence(lsm::GenerateNumbers {cur: i * NUM, end: (i+1) * NUM, step: i+1}));
a.push(g); | {
let lck = try!(db.GetWriteLock());
try!(lck.commitSegments(a.clone()));
}
let g3 = try!(db.merge(0, 2, None));
assert!(g3.is_some());
let g3 = g3.unwrap();
{
let lck = try!(db.GetWriteLock());
try!(lck.commitMerge(g3));
}
let res : lsm::Result<bool> = Ok(true);
res
}
b.iter(|| assert!(f().is_ok()) );
} | } | random_line_split |
bunch.rs |
#![feature(test)]
extern crate misc;
extern crate lsm;
extern crate test;
fn tid() -> String {
// TODO use the rand crate
fn bytes() -> std::io::Result<[u8;16]> {
use std::fs::OpenOptions;
let mut f = try!(OpenOptions::new()
.read(true)
.open("/dev/urandom"));
let mut ba = [0;16];
try!(misc::io::read_fully(&mut f, &mut ba));
Ok(ba)
}
fn to_hex_string(ba: &[u8]) -> String |
let ba = bytes().unwrap();
to_hex_string(&ba)
}
fn tempfile(base: &str) -> String {
std::fs::create_dir("tmp");
let file = "tmp/".to_string() + base + "_" + &tid();
file
}
#[bench]
fn bunch(b: &mut test::Bencher) {
fn f() -> lsm::Result<bool> {
//println!("running");
let db = try!(lsm::db::new(tempfile("bunch"), lsm::DEFAULT_SETTINGS));
const NUM : usize = 10000;
let mut a = Vec::new();
for i in 0.. 10 {
let g = try!(db.WriteSegmentFromSortedSequence(lsm::GenerateNumbers {cur: i * NUM, end: (i+1) * NUM, step: i+1}));
a.push(g);
}
{
let lck = try!(db.GetWriteLock());
try!(lck.commitSegments(a.clone()));
}
let g3 = try!(db.merge(0, 2, None));
assert!(g3.is_some());
let g3 = g3.unwrap();
{
let lck = try!(db.GetWriteLock());
try!(lck.commitMerge(g3));
}
let res : lsm::Result<bool> = Ok(true);
res
}
b.iter(|| assert!(f().is_ok()) );
}
| {
let strs: Vec<String> = ba.iter()
.map(|b| format!("{:02X}", b))
.collect();
strs.connect("")
} | identifier_body |
mod.rs | #[doc = r" Value read from the register"]
pub struct R {
bits: u32,
}
#[doc = r" Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::OR {
#[doc = r" Modifies the contents of the register"]
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
let r = R { bits: bits };
let mut w = W { bits: bits };
f(&r, &mut w);
self.register.set(w.bits);
}
#[doc = r" Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r" Writes to the register"]
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
let mut w = W::reset_value();
f(&mut w);
self.register.set(w.bits);
}
#[doc = r" Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.write(|w| w)
}
}
#[doc = r" Value of the field"]
pub struct RMPR {
bits: u8,
}
impl RMPR {
#[doc = r" Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
self.bits
}
}
#[doc = r" Proxy"]
pub struct _RMPW<'a> {
w: &'a mut W,
}
impl<'a> _RMPW<'a> {
#[doc = r" Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
const MASK: u8 = 3;
const OFFSET: u8 = 0;
self.w.bits &=!((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
impl R {
#[doc = r" Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bits 0:1 - Timer input 1 remap"]
#[inline(always)]
pub fn rmp(&self) -> RMPR {
let bits = {
const MASK: u8 = 3;
const OFFSET: u8 = 0;
((self.bits >> OFFSET) & MASK as u32) as u8
};
RMPR { bits }
}
} | #[inline(always)]
pub fn reset_value() -> W {
W { bits: 0 }
}
#[doc = r" Writes raw bits to the register"]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bits 0:1 - Timer input 1 remap"]
#[inline(always)]
pub fn rmp(&mut self) -> _RMPW {
_RMPW { w: self }
}
} | impl W {
#[doc = r" Reset value of the register"] | random_line_split |
mod.rs | #[doc = r" Value read from the register"]
pub struct R {
bits: u32,
}
#[doc = r" Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::OR {
#[doc = r" Modifies the contents of the register"]
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
let r = R { bits: bits };
let mut w = W { bits: bits };
f(&r, &mut w);
self.register.set(w.bits);
}
#[doc = r" Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r" Writes to the register"]
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
let mut w = W::reset_value();
f(&mut w);
self.register.set(w.bits);
}
#[doc = r" Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.write(|w| w)
}
}
#[doc = r" Value of the field"]
pub struct | {
bits: u8,
}
impl RMPR {
#[doc = r" Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
self.bits
}
}
#[doc = r" Proxy"]
pub struct _RMPW<'a> {
w: &'a mut W,
}
impl<'a> _RMPW<'a> {
#[doc = r" Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
const MASK: u8 = 3;
const OFFSET: u8 = 0;
self.w.bits &=!((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
impl R {
#[doc = r" Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bits 0:1 - Timer input 1 remap"]
#[inline(always)]
pub fn rmp(&self) -> RMPR {
let bits = {
const MASK: u8 = 3;
const OFFSET: u8 = 0;
((self.bits >> OFFSET) & MASK as u32) as u8
};
RMPR { bits }
}
}
impl W {
#[doc = r" Reset value of the register"]
#[inline(always)]
pub fn reset_value() -> W {
W { bits: 0 }
}
#[doc = r" Writes raw bits to the register"]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bits 0:1 - Timer input 1 remap"]
#[inline(always)]
pub fn rmp(&mut self) -> _RMPW {
_RMPW { w: self }
}
}
| RMPR | identifier_name |
mod.rs | #[doc = r" Value read from the register"]
pub struct R {
bits: u32,
}
#[doc = r" Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::OR {
#[doc = r" Modifies the contents of the register"]
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
let r = R { bits: bits };
let mut w = W { bits: bits };
f(&r, &mut w);
self.register.set(w.bits);
}
#[doc = r" Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r" Writes to the register"]
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
|
#[doc = r" Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.write(|w| w)
}
}
#[doc = r" Value of the field"]
pub struct RMPR {
bits: u8,
}
impl RMPR {
#[doc = r" Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
self.bits
}
}
#[doc = r" Proxy"]
pub struct _RMPW<'a> {
w: &'a mut W,
}
impl<'a> _RMPW<'a> {
#[doc = r" Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
const MASK: u8 = 3;
const OFFSET: u8 = 0;
self.w.bits &=!((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
impl R {
#[doc = r" Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bits 0:1 - Timer input 1 remap"]
#[inline(always)]
pub fn rmp(&self) -> RMPR {
let bits = {
const MASK: u8 = 3;
const OFFSET: u8 = 0;
((self.bits >> OFFSET) & MASK as u32) as u8
};
RMPR { bits }
}
}
impl W {
#[doc = r" Reset value of the register"]
#[inline(always)]
pub fn reset_value() -> W {
W { bits: 0 }
}
#[doc = r" Writes raw bits to the register"]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bits 0:1 - Timer input 1 remap"]
#[inline(always)]
pub fn rmp(&mut self) -> _RMPW {
_RMPW { w: self }
}
}
| {
let mut w = W::reset_value();
f(&mut w);
self.register.set(w.bits);
} | identifier_body |
lib.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#![deny(unsafe_code)]
extern crate gfx;
extern crate ipc_channel;
extern crate metrics;
extern crate msg;
extern crate net_traits;
extern crate profile_traits;
extern crate script_traits;
extern crate servo_url;
extern crate webrender_api;
| // This module contains traits in layout used generically
// in the rest of Servo.
// The traits are here instead of in layout so
// that these modules won't have to depend on layout.
use gfx::font_cache_thread::FontCacheThread;
use ipc_channel::ipc::{IpcReceiver, IpcSender};
use metrics::PaintTimeMetrics;
use msg::constellation_msg::PipelineId;
use msg::constellation_msg::TopLevelBrowsingContextId;
use net_traits::image_cache::ImageCache;
use profile_traits::{mem, time};
use script_traits::{ConstellationControlMsg, LayoutControlMsg};
use script_traits::LayoutMsg as ConstellationMsg;
use servo_url::ServoUrl;
use std::sync::Arc;
use std::sync::mpsc::{Receiver, Sender};
// A static method creating a layout thread
// Here to remove the compositor -> layout dependency
pub trait LayoutThreadFactory {
type Message;
fn create(id: PipelineId,
top_level_browsing_context_id: TopLevelBrowsingContextId,
url: ServoUrl,
is_iframe: bool,
chan: (Sender<Self::Message>, Receiver<Self::Message>),
pipeline_port: IpcReceiver<LayoutControlMsg>,
constellation_chan: IpcSender<ConstellationMsg>,
script_chan: IpcSender<ConstellationControlMsg>,
image_cache: Arc<ImageCache>,
font_cache_thread: FontCacheThread,
time_profiler_chan: time::ProfilerChan,
mem_profiler_chan: mem::ProfilerChan,
content_process_shutdown_chan: Option<IpcSender<()>>,
webrender_api_sender: webrender_api::RenderApiSender,
layout_threads: usize,
paint_time_metrics: PaintTimeMetrics);
} | random_line_split |
|
css_section.rs | // This file was generated by gir (5c017c9) from gir-files (71d73f0)
// DO NOT EDIT
use CssSectionType;
use ffi;
use glib::translate::*;
glib_wrapper! {
pub struct CssSection(Shared<ffi::GtkCssSection>);
match fn {
ref => |ptr| ffi::gtk_css_section_ref(ptr),
unref => |ptr| ffi::gtk_css_section_unref(ptr),
}
}
impl CssSection {
pub fn get_end_line(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_end_line(self.to_glib_none().0)
}
}
pub fn get_end_position(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_end_position(self.to_glib_none().0)
}
}
//pub fn get_file(&self) -> /*Ignored*/Option<gio::File> {
// unsafe { TODO: call ffi::gtk_css_section_get_file() }
//}
pub fn get_parent(&self) -> Option<CssSection> {
unsafe {
from_glib_none(ffi::gtk_css_section_get_parent(self.to_glib_none().0))
}
}
pub fn | (&self) -> CssSectionType {
unsafe {
from_glib(ffi::gtk_css_section_get_section_type(self.to_glib_none().0))
}
}
pub fn get_start_line(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_start_line(self.to_glib_none().0)
}
}
pub fn get_start_position(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_start_position(self.to_glib_none().0)
}
}
}
| get_section_type | identifier_name |
css_section.rs | // This file was generated by gir (5c017c9) from gir-files (71d73f0)
// DO NOT EDIT
use CssSectionType;
use ffi;
use glib::translate::*;
glib_wrapper! {
pub struct CssSection(Shared<ffi::GtkCssSection>);
match fn {
ref => |ptr| ffi::gtk_css_section_ref(ptr),
unref => |ptr| ffi::gtk_css_section_unref(ptr),
}
}
impl CssSection {
pub fn get_end_line(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_end_line(self.to_glib_none().0)
}
}
pub fn get_end_position(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_end_position(self.to_glib_none().0)
}
}
//pub fn get_file(&self) -> /*Ignored*/Option<gio::File> {
// unsafe { TODO: call ffi::gtk_css_section_get_file() }
//}
pub fn get_parent(&self) -> Option<CssSection> {
unsafe {
from_glib_none(ffi::gtk_css_section_get_parent(self.to_glib_none().0))
}
}
pub fn get_section_type(&self) -> CssSectionType {
unsafe {
from_glib(ffi::gtk_css_section_get_section_type(self.to_glib_none().0))
}
}
pub fn get_start_line(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_start_line(self.to_glib_none().0)
}
} | }
} |
pub fn get_start_position(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_start_position(self.to_glib_none().0)
} | random_line_split |
css_section.rs | // This file was generated by gir (5c017c9) from gir-files (71d73f0)
// DO NOT EDIT
use CssSectionType;
use ffi;
use glib::translate::*;
glib_wrapper! {
pub struct CssSection(Shared<ffi::GtkCssSection>);
match fn {
ref => |ptr| ffi::gtk_css_section_ref(ptr),
unref => |ptr| ffi::gtk_css_section_unref(ptr),
}
}
impl CssSection {
pub fn get_end_line(&self) -> u32 |
pub fn get_end_position(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_end_position(self.to_glib_none().0)
}
}
//pub fn get_file(&self) -> /*Ignored*/Option<gio::File> {
// unsafe { TODO: call ffi::gtk_css_section_get_file() }
//}
pub fn get_parent(&self) -> Option<CssSection> {
unsafe {
from_glib_none(ffi::gtk_css_section_get_parent(self.to_glib_none().0))
}
}
pub fn get_section_type(&self) -> CssSectionType {
unsafe {
from_glib(ffi::gtk_css_section_get_section_type(self.to_glib_none().0))
}
}
pub fn get_start_line(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_start_line(self.to_glib_none().0)
}
}
pub fn get_start_position(&self) -> u32 {
unsafe {
ffi::gtk_css_section_get_start_position(self.to_glib_none().0)
}
}
}
| {
unsafe {
ffi::gtk_css_section_get_end_line(self.to_glib_none().0)
}
} | identifier_body |
validators.rs | // src/common/validation/validators.rs
/// Validators
// Import Modules
// External
use ::regex::Regex;
/// Check that a field is not supplied, or None
///
/// # Arguments
/// `val` - Option<T> the Option field
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn empty<T>(val: &Option<T>) -> bool{
match val{
&Some(_) => false,
&None => true
}
}
/// Check that a field is not empty
///
/// # Arguments
/// `val` - Option<T> the Option field
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn not_empty<T>(val: Option<T>) -> bool{
match val{
Some(_) => true,
None => false
}
}
/// Check that a String field is not empty
///
/// # Arguments
/// `val` - Option<String> the Option field
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn not_empty_string(val: Option<String>) -> bool |
/// Check that two values are identical
///
/// # Arguments
/// `val1` - Generic type T
/// `val2` - Generic type T
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn equals<T: PartialEq>(val1: T, val2: T) -> bool{
val1 == val2
}
/// Check if a string matches a regular expression
///
/// # Arguments
/// `value`
/// `regex`
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn matches(value: &str, regex: &str) -> bool{
let re = Regex::new(regex).unwrap();
re.is_match(value)
}
| {
match val{
Some(v) => !v.is_empty(),
None => false
}
} | identifier_body |
validators.rs | // src/common/validation/validators.rs
/// Validators
// Import Modules
// External
use ::regex::Regex;
/// Check that a field is not supplied, or None
///
/// # Arguments
/// `val` - Option<T> the Option field
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn empty<T>(val: &Option<T>) -> bool{
match val{
&Some(_) => false,
&None => true
}
}
/// Check that a field is not empty
///
/// # Arguments
/// `val` - Option<T> the Option field
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn not_empty<T>(val: Option<T>) -> bool{
match val{
Some(_) => true,
None => false
}
}
/// Check that a String field is not empty
///
/// # Arguments
/// `val` - Option<String> the Option field
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn not_empty_string(val: Option<String>) -> bool{
match val{
Some(v) =>!v.is_empty(),
None => false
}
}
/// Check that two values are identical
///
/// # Arguments
/// `val1` - Generic type T
/// `val2` - Generic type T
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn equals<T: PartialEq>(val1: T, val2: T) -> bool{
val1 == val2
}
/// Check if a string matches a regular expression
///
/// # Arguments
/// `value`
/// `regex`
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn | (value: &str, regex: &str) -> bool{
let re = Regex::new(regex).unwrap();
re.is_match(value)
}
| matches | identifier_name |
validators.rs | // src/common/validation/validators.rs
/// Validators
// Import Modules
// External
use ::regex::Regex;
/// Check that a field is not supplied, or None
///
/// # Arguments
/// `val` - Option<T> the Option field
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn empty<T>(val: &Option<T>) -> bool{
match val{
&Some(_) => false,
&None => true | /// Check that a field is not empty
///
/// # Arguments
/// `val` - Option<T> the Option field
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn not_empty<T>(val: Option<T>) -> bool{
match val{
Some(_) => true,
None => false
}
}
/// Check that a String field is not empty
///
/// # Arguments
/// `val` - Option<String> the Option field
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn not_empty_string(val: Option<String>) -> bool{
match val{
Some(v) =>!v.is_empty(),
None => false
}
}
/// Check that two values are identical
///
/// # Arguments
/// `val1` - Generic type T
/// `val2` - Generic type T
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn equals<T: PartialEq>(val1: T, val2: T) -> bool{
val1 == val2
}
/// Check if a string matches a regular expression
///
/// # Arguments
/// `value`
/// `regex`
///
/// # Returns
/// `bool` - True if valid, false otherwise (None)
pub fn matches(value: &str, regex: &str) -> bool{
let re = Regex::new(regex).unwrap();
re.is_match(value)
} | }
}
| random_line_split |
voxel_tree.rs | #![cfg_attr(test, feature(test))]
use cgmath::Ray3;
use std::mem;
use std::ops::{Deref, DerefMut};
use raycast;
use voxel;
use voxel::Voxel;
#[derive(Debug)]
pub struct VoxelTree {
/// The log_2 of the tree's size.
lg_size: u8,
/// Force the top level to always be branches;
/// it saves a branch in the grow logic.
contents: Branches,
}
#[derive(Debug, PartialEq, Eq)]
#[repr(C)]
pub struct Branches {
// xyz ordering
// This isn't an array because we can't move out of an array.
lll: TreeBody,
llh: TreeBody,
lhl: TreeBody,
lhh: TreeBody,
hll: TreeBody,
hlh: TreeBody,
hhl: TreeBody,
hhh: TreeBody,
}
/// The main, recursive, tree-y part of the `VoxelTree`.
#[derive(Debug, PartialEq, Eq)]
pub enum TreeBody {
Empty,
Leaf(Voxel),
Branch(Box<Branches>),
}
impl Branches {
pub fn empty() -> Branches {
Branches {
lll: TreeBody::Empty,
llh: TreeBody::Empty,
lhl: TreeBody::Empty,
lhh: TreeBody::Empty,
hll: TreeBody::Empty,
hlh: TreeBody::Empty,
hhl: TreeBody::Empty,
hhh: TreeBody::Empty,
}
}
pub fn get<'a>(&'a self, x: usize, y: usize, z: usize) -> &'a TreeBody {
let this: &'a [[[TreeBody; 2]; 2]; 2] = unsafe {
mem::transmute(self)
};
&this[x][y][z]
}
pub fn get_mut<'a>(&'a mut self, x: usize, y: usize, z: usize) -> &'a mut TreeBody {
let this: &'a mut [[[TreeBody; 2]; 2]; 2] = unsafe {
mem::transmute(self)
};
&mut this[x][y][z]
}
}
impl VoxelTree {
pub fn new() -> VoxelTree {
VoxelTree {
lg_size: 0,
contents: Branches::empty(),
}
}
/// Is this voxel (non-strictly) within an origin-centered voxel with
/// size `2^lg_size`?
pub fn contains_bounds(&self, voxel: &voxel::Bounds) -> bool {
let high;
if voxel.lg_size >= 0 {
high = (1 << self.lg_size) >> voxel.lg_size;
} else {
high = (1 << self.lg_size) << (-voxel.lg_size);
}
voxel.x < high &&
voxel.y < high &&
voxel.z < high &&
{
let low = -high;
voxel.x >= low &&
voxel.y >= low &&
voxel.z >= low &&
true
}
}
/// Ensure that this tree can hold the provided voxel.
pub fn grow_to_hold(&mut self, voxel: &voxel::Bounds) {
while!self.contains_bounds(voxel) {
// Double the bounds in every direction.
self.lg_size += 1;
// Pull out `self.contents` so we can move out of it.
let contents = mem::replace(&mut self.contents, Branches::empty());
// We re-construct the tree with bounds twice the size (but still centered
// around the origin) by deconstructing the top level of branches,
// creating a new doubly-sized top level, and moving the old branches back
// in as the new top level's children. e.g. in 2D:
//
// ---------------------------
// | | |0| | |
// | | |0| | |
// --------------- ------------|0|------------
// | 1 |0| 2 | | | 1 |0| 2 | |
// | |0| | | | |0| | |
// |------0------| |------------0------------|
// 000000000000000 ==> |0000000000000000000000000|
// |------0------| |------------0------------|
// | |0| | | | |0| | |
// | 3 |0| 4 | | | 3 |0| 4 | |
// --------------- |------------0------------|
// | | |0| | |
// | | |0| | |
// ---------------------------
macro_rules! at(
($c_idx:ident, $b_idx:ident) => {{
let mut branches = Branches::empty();
branches.$b_idx = contents.$c_idx;
TreeBody::Branch(Box::new(branches))
}}
);
self.contents =
Branches {
lll: at!(lll, hhh),
llh: at!(llh, hhl),
lhl: at!(lhl, hlh),
lhh: at!(lhh, hll),
hll: at!(hll, lhh),
hlh: at!(hlh, lhl),
hhl: at!(hhl, llh),
hhh: at!(hhh, lll),
};
}
}
fn find_mask(&self, voxel: &voxel::Bounds) -> i32 {
// When we compare the voxel position to octree bounds to choose subtrees
// for insertion, we'll be comparing voxel position to values of 2^n and
// -2^n, so we can just use the position bits to branch directly.
// This actually works for negative values too, without much wrestling:
// we need to branch on the sign bit up front, but after that, two's
// complement magic means the branching on bits works regardless of sign.
let mut mask = (1 << self.lg_size) >> 1;
// Shift everything by the voxel's lg_size, so we can compare the mask to 0
// to know whether we're done.
if voxel.lg_size >= 0 {
mask = mask >> voxel.lg_size;
} else {
// TODO: Check for overflow.
mask = mask << -voxel.lg_size;
}
mask
}
fn find_mut<'a, Step, E>(
&'a mut self,
voxel: &voxel::Bounds,
mut step: Step,
) -> Result<&'a mut TreeBody, E> where
Step: FnMut(&'a mut TreeBody) -> Result<&'a mut Branches, E>,
{
let mut mask = self.find_mask(voxel);
let mut branches = &mut self.contents;
macro_rules! iter(
($select:expr, $step:block) => {{
let branches_temp = branches;
let x = $select(voxel.x);
let y = $select(voxel.y);
let z = $select(voxel.z);
let branch = branches_temp.get_mut(x, y, z);
$step;
// We've reached the voxel.
if mask == 0 {
return Ok(branch)
}
branches = try!(step(branch));
}}
);
iter!(|x| (x >= 0) as usize, {});
loop {
iter!(
|x| ((x & mask)!= 0) as usize,
// Branch through half this size next time.
{ mask = mask >> 1; }
);
}
}
fn find<'a, Step, E>(
&'a self,
voxel: &voxel::Bounds,
mut step: Step,
) -> Result<&'a TreeBody, E> where
Step: FnMut(&'a TreeBody) -> Result<&'a Branches, E>,
{
let mut mask = self.find_mask(voxel);
let mut branches = &self.contents;
macro_rules! iter(
($select:expr, $step:block) => {{
let branches_temp = branches;
let x = $select(voxel.x);
let y = $select(voxel.y);
let z = $select(voxel.z);
let branch = branches_temp.get(x, y, z);
$step;
// We've reached the voxel.
if mask == 0 {
return Ok(branch)
}
branches = try!(step(branch));
}}
);
iter!(|x| (x >= 0) as usize, {});
loop {
iter!(
|x| { ((x & mask)!= 0) as usize },
// Branch through half this size next time.
{ mask = mask >> 1; }
);
}
}
/// Find a voxel inside this tree.
/// If it doesn't exist, it will be created as empty.
pub fn get_mut_or_create<'a>(&'a mut self, voxel: &voxel::Bounds) -> &'a mut TreeBody {
self.grow_to_hold(voxel);
let branch: Result<_, ()> =
self.find_mut(voxel, |branch| { Ok(VoxelTree::get_mut_or_create_step(branch)) });
branch.unwrap()
}
fn get_mut_or_create_step<'a>(
branch: &'a mut TreeBody,
) -> &'a mut Branches {
// "Step down" the tree.
match *branch {
// Branches; we can go straight to the branching logic.
TreeBody::Branch(ref mut b) => b,
// Otherwise, keep going, but we need to insert a voxel inside the
// space occupied by the current branch.
TreeBody::Empty => {
// Replace this branch with 8 empty sub-branches - who's gonna notice?
*branch = TreeBody::Branch(Box::new(Branches::empty()));
match *branch {
TreeBody::Branch(ref mut b) => b,
_ => unreachable!(),
}
},
TreeBody::Leaf(_) => {
// Erase this leaf and replace it with 8 empty sub-branches.
// This behavior is pretty debatable, but we need to do something,
// and it's easier to debug accidentally replacing a big chunk
// with a smaller one than to debug a nop.
*branch = TreeBody::Branch(Box::new(Branches::empty()));
match *branch {
TreeBody::Branch(ref mut b) => b,
_ => unreachable!(),
}
},
}
}
/// Find a voxel inside this tree.
pub fn get<'a>(&'a self, voxel: &voxel::Bounds) -> Option<&'a Voxel> {
if!self.contains_bounds(voxel) {
return None
}
let get_step = |branch| {
match branch {
&TreeBody::Branch(ref branches) => Ok(branches.deref()),
_ => Err(()),
}
};
match self.find(voxel, get_step) {
Ok(&TreeBody::Leaf(ref t)) => Some(t),
_ => None,
}
}
/// Find a voxel inside this tree.
pub fn get_mut<'a>(&'a mut self, voxel: &voxel::Bounds) -> Option<&'a mut Voxel> {
if!self.contains_bounds(voxel) {
return None
}
let get_step = |branch| {
match branch {
&mut TreeBody::Branch(ref mut branches) => Ok(branches.deref_mut()),
_ => Err(()),
}
};
match self.find_mut(voxel, get_step) {
Ok(&mut TreeBody::Leaf(ref mut t)) => Some(t),
_ => None,
}
}
pub fn cast_ray<'a, Act, R>(
&'a self,
ray: &Ray3<f32>,
act: &mut Act,
) -> Option<R>
where
// TODO: Does this *have* to be callback-based?
Act: FnMut(voxel::Bounds, &'a Voxel) -> Option<R>
{
let coords = [
if ray.origin.x >= 0.0 {1} else {0},
if ray.origin.y >= 0.0 {1} else {0},
if ray.origin.z >= 0.0 {1} else {0},
];
// NB: The children are half the size of the tree itself,
// but tree.lg_size=0 means it extends tree.lg_size=0 in *each direction*,
// so the "actual" size of the tree as a voxel would be tree.lg_size+1.
let child_lg_size = self.lg_size as i16;
let mut make_bounds = |coords: [usize; 3]| {
voxel::Bounds {
x: coords[0] as i32 - 1,
y: coords[1] as i32 - 1,
z: coords[2] as i32 - 1,
lg_size: child_lg_size,
}
};
match raycast::cast_ray_branches(
&self.contents,
ray,
None,
coords,
&mut make_bounds,
act,
) {
Ok(r) => Some(r),
Err(_) => None,
}
}
}
#[cfg(test)]
mod tests {
extern crate test;
use voxel;
use super::{VoxelTree, TreeBody};
#[test]
fn insert_and_lookup() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(8, -8, 4, 0)) = TreeBody::Leaf(2);
*tree.get_mut_or_create(voxel::Bounds::new(2, 0, 4, 4)) = TreeBody::Leaf(3);
*tree.get_mut_or_create(voxel::Bounds::new(9, 0, 16, 2)) = TreeBody::Leaf(4);
*tree.get_mut_or_create(voxel::Bounds::new(9, 0, 16, 2)) = TreeBody::Leaf(5);
assert_eq!(tree.get(voxel::Bounds::new(1, 1, 1, 0)), Some(&1));
assert_eq!(tree.get(voxel::Bounds::new(8, -8, 4, 0)), Some(&2));
assert_eq!(tree.get(voxel::Bounds::new(9, 0, 16, 2)), Some(&5));
assert_eq!(tree.get(voxel::Bounds::new(2, 0, 4, 4)), None);
}
#[test]
fn wrong_voxel_size_is_not_found() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, -4, 1)) = TreeBody::Leaf(1);
assert_eq!(tree.get(voxel::Bounds::new(4, 4, -4, 0)), None);
assert_eq!(tree.get(voxel::Bounds::new(4, 4, -4, 2)), None);
}
#[test]
fn | () {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 1));
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 2));
tree.grow_to_hold(voxel::Bounds::new(-32, 32, -128, 3));
assert_eq!(tree.get(voxel::Bounds::new(1, 1, 1, 0)), Some(&1));
}
#[test]
fn simple_cast_ray() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, 4, 0)) = TreeBody::Leaf(2);
let actual = tree.cast_ray(
[4.5, 3.0, 4.5],
[0.1, 0.8, 0.1],
// Return the first voxel we hit.
&mut |bounds, v| Some((bounds, v)),
);
assert_eq!(actual, Some((voxel::Bounds::new(4, 4, 4, 0), &2)));
}
#[bench]
fn simple_inserts(bencher: &mut test::Bencher) {
let mut tree: VoxelTree<i32> = VoxelTree::new();
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 30));
bencher.iter(|| {
*tree.get_mut_or_create(voxel::Bounds::new(0, 0, 0, 0)) = TreeBody::Leaf(0);
});
test::black_box(tree);
}
#[bench]
fn bench_cast_ray(bencher: &mut test::Bencher) {
let mut tree: VoxelTree<i32> = VoxelTree::new();
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 30));
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, 4, 0)) = TreeBody::Leaf(2);
bencher.iter(|| {
let r = tree.cast_ray(
[4.5, 3.0, 4.5],
[0.1, 0.8, 0.1],
// Return the first voxel we hit.
&mut |bounds, v| Some((bounds, v)),
);
test::black_box(r);
});
}
}
| grow_is_transparent | identifier_name |
voxel_tree.rs | #![cfg_attr(test, feature(test))]
use cgmath::Ray3;
use std::mem;
use std::ops::{Deref, DerefMut};
use raycast;
use voxel;
use voxel::Voxel;
#[derive(Debug)]
pub struct VoxelTree {
/// The log_2 of the tree's size.
lg_size: u8,
/// Force the top level to always be branches;
/// it saves a branch in the grow logic.
contents: Branches,
}
#[derive(Debug, PartialEq, Eq)]
#[repr(C)]
pub struct Branches {
// xyz ordering
// This isn't an array because we can't move out of an array.
lll: TreeBody,
llh: TreeBody,
lhl: TreeBody,
lhh: TreeBody,
hll: TreeBody,
hlh: TreeBody,
hhl: TreeBody,
hhh: TreeBody,
}
/// The main, recursive, tree-y part of the `VoxelTree`.
#[derive(Debug, PartialEq, Eq)]
pub enum TreeBody {
Empty,
Leaf(Voxel),
Branch(Box<Branches>),
}
impl Branches {
pub fn empty() -> Branches {
Branches {
lll: TreeBody::Empty,
llh: TreeBody::Empty,
lhl: TreeBody::Empty,
lhh: TreeBody::Empty,
hll: TreeBody::Empty,
hlh: TreeBody::Empty,
hhl: TreeBody::Empty,
hhh: TreeBody::Empty,
}
}
pub fn get<'a>(&'a self, x: usize, y: usize, z: usize) -> &'a TreeBody {
let this: &'a [[[TreeBody; 2]; 2]; 2] = unsafe {
mem::transmute(self)
};
&this[x][y][z]
}
pub fn get_mut<'a>(&'a mut self, x: usize, y: usize, z: usize) -> &'a mut TreeBody {
let this: &'a mut [[[TreeBody; 2]; 2]; 2] = unsafe {
mem::transmute(self)
};
&mut this[x][y][z]
}
}
impl VoxelTree {
pub fn new() -> VoxelTree {
VoxelTree {
lg_size: 0,
contents: Branches::empty(),
}
}
/// Is this voxel (non-strictly) within an origin-centered voxel with
/// size `2^lg_size`?
pub fn contains_bounds(&self, voxel: &voxel::Bounds) -> bool {
let high;
if voxel.lg_size >= 0 {
high = (1 << self.lg_size) >> voxel.lg_size;
} else {
high = (1 << self.lg_size) << (-voxel.lg_size);
}
voxel.x < high &&
voxel.y < high &&
voxel.z < high &&
{
let low = -high;
voxel.x >= low &&
voxel.y >= low &&
voxel.z >= low &&
true
}
}
/// Ensure that this tree can hold the provided voxel.
pub fn grow_to_hold(&mut self, voxel: &voxel::Bounds) {
while!self.contains_bounds(voxel) {
// Double the bounds in every direction.
self.lg_size += 1;
// Pull out `self.contents` so we can move out of it.
let contents = mem::replace(&mut self.contents, Branches::empty());
// We re-construct the tree with bounds twice the size (but still centered
// around the origin) by deconstructing the top level of branches,
// creating a new doubly-sized top level, and moving the old branches back
// in as the new top level's children. e.g. in 2D:
//
// ---------------------------
// | | |0| | |
// | | |0| | |
// --------------- ------------|0|------------
// | 1 |0| 2 | | | 1 |0| 2 | |
// | |0| | | | |0| | |
// |------0------| |------------0------------|
// 000000000000000 ==> |0000000000000000000000000|
// |------0------| |------------0------------|
// | |0| | | | |0| | |
// | 3 |0| 4 | | | 3 |0| 4 | |
// --------------- |------------0------------|
// | | |0| | |
// | | |0| | |
// ---------------------------
macro_rules! at(
($c_idx:ident, $b_idx:ident) => {{
let mut branches = Branches::empty();
branches.$b_idx = contents.$c_idx;
TreeBody::Branch(Box::new(branches))
}}
);
self.contents =
Branches {
lll: at!(lll, hhh),
llh: at!(llh, hhl),
lhl: at!(lhl, hlh),
lhh: at!(lhh, hll),
hll: at!(hll, lhh),
hlh: at!(hlh, lhl),
hhl: at!(hhl, llh),
hhh: at!(hhh, lll),
};
}
}
fn find_mask(&self, voxel: &voxel::Bounds) -> i32 {
// When we compare the voxel position to octree bounds to choose subtrees
// for insertion, we'll be comparing voxel position to values of 2^n and
// -2^n, so we can just use the position bits to branch directly.
// This actually works for negative values too, without much wrestling:
// we need to branch on the sign bit up front, but after that, two's
// complement magic means the branching on bits works regardless of sign.
let mut mask = (1 << self.lg_size) >> 1;
// Shift everything by the voxel's lg_size, so we can compare the mask to 0
// to know whether we're done.
if voxel.lg_size >= 0 {
mask = mask >> voxel.lg_size;
} else {
// TODO: Check for overflow.
mask = mask << -voxel.lg_size;
}
mask
}
fn find_mut<'a, Step, E>(
&'a mut self,
voxel: &voxel::Bounds,
mut step: Step,
) -> Result<&'a mut TreeBody, E> where
Step: FnMut(&'a mut TreeBody) -> Result<&'a mut Branches, E>,
{
let mut mask = self.find_mask(voxel);
let mut branches = &mut self.contents;
macro_rules! iter(
($select:expr, $step:block) => {{
let branches_temp = branches;
let x = $select(voxel.x);
let y = $select(voxel.y);
let z = $select(voxel.z);
let branch = branches_temp.get_mut(x, y, z);
$step;
// We've reached the voxel.
if mask == 0 {
return Ok(branch)
}
branches = try!(step(branch));
}}
);
iter!(|x| (x >= 0) as usize, {});
loop {
iter!(
|x| ((x & mask)!= 0) as usize,
// Branch through half this size next time.
{ mask = mask >> 1; }
);
}
}
fn find<'a, Step, E>(
&'a self,
voxel: &voxel::Bounds,
mut step: Step,
) -> Result<&'a TreeBody, E> where
Step: FnMut(&'a TreeBody) -> Result<&'a Branches, E>,
{
let mut mask = self.find_mask(voxel);
let mut branches = &self.contents;
macro_rules! iter(
($select:expr, $step:block) => {{
let branches_temp = branches;
let x = $select(voxel.x);
let y = $select(voxel.y);
let z = $select(voxel.z);
let branch = branches_temp.get(x, y, z);
$step;
// We've reached the voxel.
if mask == 0 {
return Ok(branch)
}
branches = try!(step(branch));
}}
);
iter!(|x| (x >= 0) as usize, {});
loop {
iter!(
|x| { ((x & mask)!= 0) as usize },
// Branch through half this size next time.
{ mask = mask >> 1; }
);
}
}
/// Find a voxel inside this tree.
/// If it doesn't exist, it will be created as empty.
pub fn get_mut_or_create<'a>(&'a mut self, voxel: &voxel::Bounds) -> &'a mut TreeBody {
self.grow_to_hold(voxel);
let branch: Result<_, ()> =
self.find_mut(voxel, |branch| { Ok(VoxelTree::get_mut_or_create_step(branch)) });
branch.unwrap()
}
fn get_mut_or_create_step<'a>(
branch: &'a mut TreeBody,
) -> &'a mut Branches {
// "Step down" the tree.
match *branch {
// Branches; we can go straight to the branching logic.
TreeBody::Branch(ref mut b) => b,
// Otherwise, keep going, but we need to insert a voxel inside the
// space occupied by the current branch.
TreeBody::Empty => {
// Replace this branch with 8 empty sub-branches - who's gonna notice?
*branch = TreeBody::Branch(Box::new(Branches::empty()));
match *branch {
TreeBody::Branch(ref mut b) => b,
_ => unreachable!(),
}
},
TreeBody::Leaf(_) => {
// Erase this leaf and replace it with 8 empty sub-branches.
// This behavior is pretty debatable, but we need to do something,
// and it's easier to debug accidentally replacing a big chunk
// with a smaller one than to debug a nop.
*branch = TreeBody::Branch(Box::new(Branches::empty()));
match *branch {
TreeBody::Branch(ref mut b) => b,
_ => unreachable!(),
}
},
}
}
/// Find a voxel inside this tree.
pub fn get<'a>(&'a self, voxel: &voxel::Bounds) -> Option<&'a Voxel> {
if!self.contains_bounds(voxel) {
return None
}
let get_step = |branch| {
match branch {
&TreeBody::Branch(ref branches) => Ok(branches.deref()),
_ => Err(()),
}
};
match self.find(voxel, get_step) {
Ok(&TreeBody::Leaf(ref t)) => Some(t),
_ => None,
}
}
/// Find a voxel inside this tree.
pub fn get_mut<'a>(&'a mut self, voxel: &voxel::Bounds) -> Option<&'a mut Voxel> {
if!self.contains_bounds(voxel) {
return None
}
let get_step = |branch| {
match branch {
&mut TreeBody::Branch(ref mut branches) => Ok(branches.deref_mut()),
_ => Err(()),
}
};
match self.find_mut(voxel, get_step) {
Ok(&mut TreeBody::Leaf(ref mut t)) => Some(t),
_ => None,
}
}
pub fn cast_ray<'a, Act, R>(
&'a self,
ray: &Ray3<f32>,
act: &mut Act,
) -> Option<R>
where
// TODO: Does this *have* to be callback-based?
Act: FnMut(voxel::Bounds, &'a Voxel) -> Option<R>
{
let coords = [
if ray.origin.x >= 0.0 {1} else {0},
if ray.origin.y >= 0.0 {1} else {0},
if ray.origin.z >= 0.0 {1} else | ,
];
// NB: The children are half the size of the tree itself,
// but tree.lg_size=0 means it extends tree.lg_size=0 in *each direction*,
// so the "actual" size of the tree as a voxel would be tree.lg_size+1.
let child_lg_size = self.lg_size as i16;
let mut make_bounds = |coords: [usize; 3]| {
voxel::Bounds {
x: coords[0] as i32 - 1,
y: coords[1] as i32 - 1,
z: coords[2] as i32 - 1,
lg_size: child_lg_size,
}
};
match raycast::cast_ray_branches(
&self.contents,
ray,
None,
coords,
&mut make_bounds,
act,
) {
Ok(r) => Some(r),
Err(_) => None,
}
}
}
#[cfg(test)]
mod tests {
extern crate test;
use voxel;
use super::{VoxelTree, TreeBody};
#[test]
fn insert_and_lookup() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(8, -8, 4, 0)) = TreeBody::Leaf(2);
*tree.get_mut_or_create(voxel::Bounds::new(2, 0, 4, 4)) = TreeBody::Leaf(3);
*tree.get_mut_or_create(voxel::Bounds::new(9, 0, 16, 2)) = TreeBody::Leaf(4);
*tree.get_mut_or_create(voxel::Bounds::new(9, 0, 16, 2)) = TreeBody::Leaf(5);
assert_eq!(tree.get(voxel::Bounds::new(1, 1, 1, 0)), Some(&1));
assert_eq!(tree.get(voxel::Bounds::new(8, -8, 4, 0)), Some(&2));
assert_eq!(tree.get(voxel::Bounds::new(9, 0, 16, 2)), Some(&5));
assert_eq!(tree.get(voxel::Bounds::new(2, 0, 4, 4)), None);
}
#[test]
fn wrong_voxel_size_is_not_found() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, -4, 1)) = TreeBody::Leaf(1);
assert_eq!(tree.get(voxel::Bounds::new(4, 4, -4, 0)), None);
assert_eq!(tree.get(voxel::Bounds::new(4, 4, -4, 2)), None);
}
#[test]
fn grow_is_transparent() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 1));
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 2));
tree.grow_to_hold(voxel::Bounds::new(-32, 32, -128, 3));
assert_eq!(tree.get(voxel::Bounds::new(1, 1, 1, 0)), Some(&1));
}
#[test]
fn simple_cast_ray() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, 4, 0)) = TreeBody::Leaf(2);
let actual = tree.cast_ray(
[4.5, 3.0, 4.5],
[0.1, 0.8, 0.1],
// Return the first voxel we hit.
&mut |bounds, v| Some((bounds, v)),
);
assert_eq!(actual, Some((voxel::Bounds::new(4, 4, 4, 0), &2)));
}
#[bench]
fn simple_inserts(bencher: &mut test::Bencher) {
let mut tree: VoxelTree<i32> = VoxelTree::new();
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 30));
bencher.iter(|| {
*tree.get_mut_or_create(voxel::Bounds::new(0, 0, 0, 0)) = TreeBody::Leaf(0);
});
test::black_box(tree);
}
#[bench]
fn bench_cast_ray(bencher: &mut test::Bencher) {
let mut tree: VoxelTree<i32> = VoxelTree::new();
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 30));
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, 4, 0)) = TreeBody::Leaf(2);
bencher.iter(|| {
let r = tree.cast_ray(
[4.5, 3.0, 4.5],
[0.1, 0.8, 0.1],
// Return the first voxel we hit.
&mut |bounds, v| Some((bounds, v)),
);
test::black_box(r);
});
}
}
| {0} | conditional_block |
voxel_tree.rs | #![cfg_attr(test, feature(test))]
use cgmath::Ray3;
use std::mem;
use std::ops::{Deref, DerefMut};
use raycast;
use voxel;
use voxel::Voxel;
#[derive(Debug)]
pub struct VoxelTree {
/// The log_2 of the tree's size.
lg_size: u8,
/// Force the top level to always be branches;
/// it saves a branch in the grow logic.
contents: Branches,
}
#[derive(Debug, PartialEq, Eq)]
#[repr(C)]
pub struct Branches {
// xyz ordering
// This isn't an array because we can't move out of an array.
lll: TreeBody,
llh: TreeBody,
lhl: TreeBody,
lhh: TreeBody,
hll: TreeBody,
hlh: TreeBody,
hhl: TreeBody,
hhh: TreeBody,
}
/// The main, recursive, tree-y part of the `VoxelTree`.
#[derive(Debug, PartialEq, Eq)]
pub enum TreeBody {
Empty,
Leaf(Voxel),
Branch(Box<Branches>),
}
impl Branches {
pub fn empty() -> Branches {
Branches {
lll: TreeBody::Empty,
llh: TreeBody::Empty,
lhl: TreeBody::Empty,
lhh: TreeBody::Empty,
hll: TreeBody::Empty,
hlh: TreeBody::Empty,
hhl: TreeBody::Empty,
hhh: TreeBody::Empty,
}
}
pub fn get<'a>(&'a self, x: usize, y: usize, z: usize) -> &'a TreeBody {
let this: &'a [[[TreeBody; 2]; 2]; 2] = unsafe {
mem::transmute(self)
};
&this[x][y][z]
}
pub fn get_mut<'a>(&'a mut self, x: usize, y: usize, z: usize) -> &'a mut TreeBody {
let this: &'a mut [[[TreeBody; 2]; 2]; 2] = unsafe {
mem::transmute(self)
};
&mut this[x][y][z]
}
}
impl VoxelTree {
pub fn new() -> VoxelTree {
VoxelTree {
lg_size: 0,
contents: Branches::empty(),
}
}
/// Is this voxel (non-strictly) within an origin-centered voxel with
/// size `2^lg_size`?
pub fn contains_bounds(&self, voxel: &voxel::Bounds) -> bool {
let high;
if voxel.lg_size >= 0 {
high = (1 << self.lg_size) >> voxel.lg_size;
} else {
high = (1 << self.lg_size) << (-voxel.lg_size);
}
voxel.x < high &&
voxel.y < high &&
voxel.z < high &&
{
let low = -high;
voxel.x >= low &&
voxel.y >= low &&
voxel.z >= low &&
true
}
}
/// Ensure that this tree can hold the provided voxel.
pub fn grow_to_hold(&mut self, voxel: &voxel::Bounds) {
while!self.contains_bounds(voxel) {
// Double the bounds in every direction.
self.lg_size += 1;
// Pull out `self.contents` so we can move out of it.
let contents = mem::replace(&mut self.contents, Branches::empty());
// We re-construct the tree with bounds twice the size (but still centered
// around the origin) by deconstructing the top level of branches,
// creating a new doubly-sized top level, and moving the old branches back
// in as the new top level's children. e.g. in 2D:
//
// ---------------------------
// | | |0| | |
// | | |0| | |
// --------------- ------------|0|------------
// | 1 |0| 2 | | | 1 |0| 2 | |
// | |0| | | | |0| | |
// |------0------| |------------0------------|
// 000000000000000 ==> |0000000000000000000000000|
// |------0------| |------------0------------|
// | |0| | | | |0| | |
// | 3 |0| 4 | | | 3 |0| 4 | |
// --------------- |------------0------------|
// | | |0| | |
// | | |0| | |
// ---------------------------
macro_rules! at(
($c_idx:ident, $b_idx:ident) => {{
let mut branches = Branches::empty();
branches.$b_idx = contents.$c_idx;
TreeBody::Branch(Box::new(branches))
}}
);
self.contents =
Branches {
lll: at!(lll, hhh),
llh: at!(llh, hhl),
lhl: at!(lhl, hlh),
lhh: at!(lhh, hll),
hll: at!(hll, lhh),
hlh: at!(hlh, lhl),
hhl: at!(hhl, llh),
hhh: at!(hhh, lll),
};
}
}
fn find_mask(&self, voxel: &voxel::Bounds) -> i32 {
// When we compare the voxel position to octree bounds to choose subtrees
// for insertion, we'll be comparing voxel position to values of 2^n and
// -2^n, so we can just use the position bits to branch directly.
// This actually works for negative values too, without much wrestling:
// we need to branch on the sign bit up front, but after that, two's
// complement magic means the branching on bits works regardless of sign.
let mut mask = (1 << self.lg_size) >> 1;
// Shift everything by the voxel's lg_size, so we can compare the mask to 0
// to know whether we're done.
if voxel.lg_size >= 0 {
mask = mask >> voxel.lg_size;
} else {
// TODO: Check for overflow.
mask = mask << -voxel.lg_size;
}
mask
}
fn find_mut<'a, Step, E>(
&'a mut self,
voxel: &voxel::Bounds,
mut step: Step,
) -> Result<&'a mut TreeBody, E> where
Step: FnMut(&'a mut TreeBody) -> Result<&'a mut Branches, E>,
{
let mut mask = self.find_mask(voxel);
let mut branches = &mut self.contents;
macro_rules! iter(
($select:expr, $step:block) => {{
let branches_temp = branches;
let x = $select(voxel.x);
let y = $select(voxel.y);
let z = $select(voxel.z);
let branch = branches_temp.get_mut(x, y, z);
$step;
// We've reached the voxel.
if mask == 0 {
return Ok(branch)
}
branches = try!(step(branch));
}}
);
iter!(|x| (x >= 0) as usize, {});
loop {
iter!(
|x| ((x & mask)!= 0) as usize,
// Branch through half this size next time.
{ mask = mask >> 1; }
);
}
}
fn find<'a, Step, E>(
&'a self,
voxel: &voxel::Bounds,
mut step: Step,
) -> Result<&'a TreeBody, E> where
Step: FnMut(&'a TreeBody) -> Result<&'a Branches, E>,
{
let mut mask = self.find_mask(voxel);
let mut branches = &self.contents;
macro_rules! iter(
($select:expr, $step:block) => {{
let branches_temp = branches;
let x = $select(voxel.x);
let y = $select(voxel.y);
let z = $select(voxel.z);
let branch = branches_temp.get(x, y, z);
$step;
// We've reached the voxel.
if mask == 0 {
return Ok(branch)
}
branches = try!(step(branch));
}}
);
iter!(|x| (x >= 0) as usize, {});
loop {
iter!(
|x| { ((x & mask)!= 0) as usize },
// Branch through half this size next time.
{ mask = mask >> 1; }
);
}
}
/// Find a voxel inside this tree.
/// If it doesn't exist, it will be created as empty.
pub fn get_mut_or_create<'a>(&'a mut self, voxel: &voxel::Bounds) -> &'a mut TreeBody {
self.grow_to_hold(voxel);
let branch: Result<_, ()> =
self.find_mut(voxel, |branch| { Ok(VoxelTree::get_mut_or_create_step(branch)) });
branch.unwrap()
}
fn get_mut_or_create_step<'a>(
branch: &'a mut TreeBody,
) -> &'a mut Branches {
// "Step down" the tree.
match *branch {
// Branches; we can go straight to the branching logic.
TreeBody::Branch(ref mut b) => b,
// Otherwise, keep going, but we need to insert a voxel inside the
// space occupied by the current branch.
TreeBody::Empty => {
// Replace this branch with 8 empty sub-branches - who's gonna notice?
*branch = TreeBody::Branch(Box::new(Branches::empty()));
match *branch {
TreeBody::Branch(ref mut b) => b,
_ => unreachable!(),
}
},
TreeBody::Leaf(_) => {
// Erase this leaf and replace it with 8 empty sub-branches.
// This behavior is pretty debatable, but we need to do something,
// and it's easier to debug accidentally replacing a big chunk
// with a smaller one than to debug a nop.
*branch = TreeBody::Branch(Box::new(Branches::empty()));
match *branch {
TreeBody::Branch(ref mut b) => b,
_ => unreachable!(),
}
},
}
}
/// Find a voxel inside this tree.
pub fn get<'a>(&'a self, voxel: &voxel::Bounds) -> Option<&'a Voxel> {
if!self.contains_bounds(voxel) {
return None
}
let get_step = |branch| {
match branch {
&TreeBody::Branch(ref branches) => Ok(branches.deref()),
_ => Err(()),
}
};
match self.find(voxel, get_step) {
Ok(&TreeBody::Leaf(ref t)) => Some(t),
_ => None,
}
}
/// Find a voxel inside this tree.
pub fn get_mut<'a>(&'a mut self, voxel: &voxel::Bounds) -> Option<&'a mut Voxel> |
pub fn cast_ray<'a, Act, R>(
&'a self,
ray: &Ray3<f32>,
act: &mut Act,
) -> Option<R>
where
// TODO: Does this *have* to be callback-based?
Act: FnMut(voxel::Bounds, &'a Voxel) -> Option<R>
{
let coords = [
if ray.origin.x >= 0.0 {1} else {0},
if ray.origin.y >= 0.0 {1} else {0},
if ray.origin.z >= 0.0 {1} else {0},
];
// NB: The children are half the size of the tree itself,
// but tree.lg_size=0 means it extends tree.lg_size=0 in *each direction*,
// so the "actual" size of the tree as a voxel would be tree.lg_size+1.
let child_lg_size = self.lg_size as i16;
let mut make_bounds = |coords: [usize; 3]| {
voxel::Bounds {
x: coords[0] as i32 - 1,
y: coords[1] as i32 - 1,
z: coords[2] as i32 - 1,
lg_size: child_lg_size,
}
};
match raycast::cast_ray_branches(
&self.contents,
ray,
None,
coords,
&mut make_bounds,
act,
) {
Ok(r) => Some(r),
Err(_) => None,
}
}
}
#[cfg(test)]
mod tests {
extern crate test;
use voxel;
use super::{VoxelTree, TreeBody};
#[test]
fn insert_and_lookup() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(8, -8, 4, 0)) = TreeBody::Leaf(2);
*tree.get_mut_or_create(voxel::Bounds::new(2, 0, 4, 4)) = TreeBody::Leaf(3);
*tree.get_mut_or_create(voxel::Bounds::new(9, 0, 16, 2)) = TreeBody::Leaf(4);
*tree.get_mut_or_create(voxel::Bounds::new(9, 0, 16, 2)) = TreeBody::Leaf(5);
assert_eq!(tree.get(voxel::Bounds::new(1, 1, 1, 0)), Some(&1));
assert_eq!(tree.get(voxel::Bounds::new(8, -8, 4, 0)), Some(&2));
assert_eq!(tree.get(voxel::Bounds::new(9, 0, 16, 2)), Some(&5));
assert_eq!(tree.get(voxel::Bounds::new(2, 0, 4, 4)), None);
}
#[test]
fn wrong_voxel_size_is_not_found() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, -4, 1)) = TreeBody::Leaf(1);
assert_eq!(tree.get(voxel::Bounds::new(4, 4, -4, 0)), None);
assert_eq!(tree.get(voxel::Bounds::new(4, 4, -4, 2)), None);
}
#[test]
fn grow_is_transparent() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 1));
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 2));
tree.grow_to_hold(voxel::Bounds::new(-32, 32, -128, 3));
assert_eq!(tree.get(voxel::Bounds::new(1, 1, 1, 0)), Some(&1));
}
#[test]
fn simple_cast_ray() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, 4, 0)) = TreeBody::Leaf(2);
let actual = tree.cast_ray(
[4.5, 3.0, 4.5],
[0.1, 0.8, 0.1],
// Return the first voxel we hit.
&mut |bounds, v| Some((bounds, v)),
);
assert_eq!(actual, Some((voxel::Bounds::new(4, 4, 4, 0), &2)));
}
#[bench]
fn simple_inserts(bencher: &mut test::Bencher) {
let mut tree: VoxelTree<i32> = VoxelTree::new();
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 30));
bencher.iter(|| {
*tree.get_mut_or_create(voxel::Bounds::new(0, 0, 0, 0)) = TreeBody::Leaf(0);
});
test::black_box(tree);
}
#[bench]
fn bench_cast_ray(bencher: &mut test::Bencher) {
let mut tree: VoxelTree<i32> = VoxelTree::new();
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 30));
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, 4, 0)) = TreeBody::Leaf(2);
bencher.iter(|| {
let r = tree.cast_ray(
[4.5, 3.0, 4.5],
[0.1, 0.8, 0.1],
// Return the first voxel we hit.
&mut |bounds, v| Some((bounds, v)),
);
test::black_box(r);
});
}
}
| {
if !self.contains_bounds(voxel) {
return None
}
let get_step = |branch| {
match branch {
&mut TreeBody::Branch(ref mut branches) => Ok(branches.deref_mut()),
_ => Err(()),
}
};
match self.find_mut(voxel, get_step) {
Ok(&mut TreeBody::Leaf(ref mut t)) => Some(t),
_ => None,
}
} | identifier_body |
voxel_tree.rs | #![cfg_attr(test, feature(test))]
use cgmath::Ray3;
use std::mem;
use std::ops::{Deref, DerefMut};
use raycast;
use voxel;
use voxel::Voxel;
#[derive(Debug)]
pub struct VoxelTree {
/// The log_2 of the tree's size.
lg_size: u8,
/// Force the top level to always be branches;
/// it saves a branch in the grow logic.
contents: Branches,
}
#[derive(Debug, PartialEq, Eq)]
#[repr(C)]
pub struct Branches {
// xyz ordering
// This isn't an array because we can't move out of an array.
lll: TreeBody,
llh: TreeBody, | lhh: TreeBody,
hll: TreeBody,
hlh: TreeBody,
hhl: TreeBody,
hhh: TreeBody,
}
/// The main, recursive, tree-y part of the `VoxelTree`.
#[derive(Debug, PartialEq, Eq)]
pub enum TreeBody {
Empty,
Leaf(Voxel),
Branch(Box<Branches>),
}
impl Branches {
pub fn empty() -> Branches {
Branches {
lll: TreeBody::Empty,
llh: TreeBody::Empty,
lhl: TreeBody::Empty,
lhh: TreeBody::Empty,
hll: TreeBody::Empty,
hlh: TreeBody::Empty,
hhl: TreeBody::Empty,
hhh: TreeBody::Empty,
}
}
pub fn get<'a>(&'a self, x: usize, y: usize, z: usize) -> &'a TreeBody {
let this: &'a [[[TreeBody; 2]; 2]; 2] = unsafe {
mem::transmute(self)
};
&this[x][y][z]
}
pub fn get_mut<'a>(&'a mut self, x: usize, y: usize, z: usize) -> &'a mut TreeBody {
let this: &'a mut [[[TreeBody; 2]; 2]; 2] = unsafe {
mem::transmute(self)
};
&mut this[x][y][z]
}
}
impl VoxelTree {
pub fn new() -> VoxelTree {
VoxelTree {
lg_size: 0,
contents: Branches::empty(),
}
}
/// Is this voxel (non-strictly) within an origin-centered voxel with
/// size `2^lg_size`?
pub fn contains_bounds(&self, voxel: &voxel::Bounds) -> bool {
let high;
if voxel.lg_size >= 0 {
high = (1 << self.lg_size) >> voxel.lg_size;
} else {
high = (1 << self.lg_size) << (-voxel.lg_size);
}
voxel.x < high &&
voxel.y < high &&
voxel.z < high &&
{
let low = -high;
voxel.x >= low &&
voxel.y >= low &&
voxel.z >= low &&
true
}
}
/// Ensure that this tree can hold the provided voxel.
pub fn grow_to_hold(&mut self, voxel: &voxel::Bounds) {
while!self.contains_bounds(voxel) {
// Double the bounds in every direction.
self.lg_size += 1;
// Pull out `self.contents` so we can move out of it.
let contents = mem::replace(&mut self.contents, Branches::empty());
// We re-construct the tree with bounds twice the size (but still centered
// around the origin) by deconstructing the top level of branches,
// creating a new doubly-sized top level, and moving the old branches back
// in as the new top level's children. e.g. in 2D:
//
// ---------------------------
// | | |0| | |
// | | |0| | |
// --------------- ------------|0|------------
// | 1 |0| 2 | | | 1 |0| 2 | |
// | |0| | | | |0| | |
// |------0------| |------------0------------|
// 000000000000000 ==> |0000000000000000000000000|
// |------0------| |------------0------------|
// | |0| | | | |0| | |
// | 3 |0| 4 | | | 3 |0| 4 | |
// --------------- |------------0------------|
// | | |0| | |
// | | |0| | |
// ---------------------------
macro_rules! at(
($c_idx:ident, $b_idx:ident) => {{
let mut branches = Branches::empty();
branches.$b_idx = contents.$c_idx;
TreeBody::Branch(Box::new(branches))
}}
);
self.contents =
Branches {
lll: at!(lll, hhh),
llh: at!(llh, hhl),
lhl: at!(lhl, hlh),
lhh: at!(lhh, hll),
hll: at!(hll, lhh),
hlh: at!(hlh, lhl),
hhl: at!(hhl, llh),
hhh: at!(hhh, lll),
};
}
}
fn find_mask(&self, voxel: &voxel::Bounds) -> i32 {
// When we compare the voxel position to octree bounds to choose subtrees
// for insertion, we'll be comparing voxel position to values of 2^n and
// -2^n, so we can just use the position bits to branch directly.
// This actually works for negative values too, without much wrestling:
// we need to branch on the sign bit up front, but after that, two's
// complement magic means the branching on bits works regardless of sign.
let mut mask = (1 << self.lg_size) >> 1;
// Shift everything by the voxel's lg_size, so we can compare the mask to 0
// to know whether we're done.
if voxel.lg_size >= 0 {
mask = mask >> voxel.lg_size;
} else {
// TODO: Check for overflow.
mask = mask << -voxel.lg_size;
}
mask
}
fn find_mut<'a, Step, E>(
&'a mut self,
voxel: &voxel::Bounds,
mut step: Step,
) -> Result<&'a mut TreeBody, E> where
Step: FnMut(&'a mut TreeBody) -> Result<&'a mut Branches, E>,
{
let mut mask = self.find_mask(voxel);
let mut branches = &mut self.contents;
macro_rules! iter(
($select:expr, $step:block) => {{
let branches_temp = branches;
let x = $select(voxel.x);
let y = $select(voxel.y);
let z = $select(voxel.z);
let branch = branches_temp.get_mut(x, y, z);
$step;
// We've reached the voxel.
if mask == 0 {
return Ok(branch)
}
branches = try!(step(branch));
}}
);
iter!(|x| (x >= 0) as usize, {});
loop {
iter!(
|x| ((x & mask)!= 0) as usize,
// Branch through half this size next time.
{ mask = mask >> 1; }
);
}
}
fn find<'a, Step, E>(
&'a self,
voxel: &voxel::Bounds,
mut step: Step,
) -> Result<&'a TreeBody, E> where
Step: FnMut(&'a TreeBody) -> Result<&'a Branches, E>,
{
let mut mask = self.find_mask(voxel);
let mut branches = &self.contents;
macro_rules! iter(
($select:expr, $step:block) => {{
let branches_temp = branches;
let x = $select(voxel.x);
let y = $select(voxel.y);
let z = $select(voxel.z);
let branch = branches_temp.get(x, y, z);
$step;
// We've reached the voxel.
if mask == 0 {
return Ok(branch)
}
branches = try!(step(branch));
}}
);
iter!(|x| (x >= 0) as usize, {});
loop {
iter!(
|x| { ((x & mask)!= 0) as usize },
// Branch through half this size next time.
{ mask = mask >> 1; }
);
}
}
/// Find a voxel inside this tree.
/// If it doesn't exist, it will be created as empty.
pub fn get_mut_or_create<'a>(&'a mut self, voxel: &voxel::Bounds) -> &'a mut TreeBody {
self.grow_to_hold(voxel);
let branch: Result<_, ()> =
self.find_mut(voxel, |branch| { Ok(VoxelTree::get_mut_or_create_step(branch)) });
branch.unwrap()
}
fn get_mut_or_create_step<'a>(
branch: &'a mut TreeBody,
) -> &'a mut Branches {
// "Step down" the tree.
match *branch {
// Branches; we can go straight to the branching logic.
TreeBody::Branch(ref mut b) => b,
// Otherwise, keep going, but we need to insert a voxel inside the
// space occupied by the current branch.
TreeBody::Empty => {
// Replace this branch with 8 empty sub-branches - who's gonna notice?
*branch = TreeBody::Branch(Box::new(Branches::empty()));
match *branch {
TreeBody::Branch(ref mut b) => b,
_ => unreachable!(),
}
},
TreeBody::Leaf(_) => {
// Erase this leaf and replace it with 8 empty sub-branches.
// This behavior is pretty debatable, but we need to do something,
// and it's easier to debug accidentally replacing a big chunk
// with a smaller one than to debug a nop.
*branch = TreeBody::Branch(Box::new(Branches::empty()));
match *branch {
TreeBody::Branch(ref mut b) => b,
_ => unreachable!(),
}
},
}
}
/// Find a voxel inside this tree.
pub fn get<'a>(&'a self, voxel: &voxel::Bounds) -> Option<&'a Voxel> {
if!self.contains_bounds(voxel) {
return None
}
let get_step = |branch| {
match branch {
&TreeBody::Branch(ref branches) => Ok(branches.deref()),
_ => Err(()),
}
};
match self.find(voxel, get_step) {
Ok(&TreeBody::Leaf(ref t)) => Some(t),
_ => None,
}
}
/// Find a voxel inside this tree.
pub fn get_mut<'a>(&'a mut self, voxel: &voxel::Bounds) -> Option<&'a mut Voxel> {
if!self.contains_bounds(voxel) {
return None
}
let get_step = |branch| {
match branch {
&mut TreeBody::Branch(ref mut branches) => Ok(branches.deref_mut()),
_ => Err(()),
}
};
match self.find_mut(voxel, get_step) {
Ok(&mut TreeBody::Leaf(ref mut t)) => Some(t),
_ => None,
}
}
pub fn cast_ray<'a, Act, R>(
&'a self,
ray: &Ray3<f32>,
act: &mut Act,
) -> Option<R>
where
// TODO: Does this *have* to be callback-based?
Act: FnMut(voxel::Bounds, &'a Voxel) -> Option<R>
{
let coords = [
if ray.origin.x >= 0.0 {1} else {0},
if ray.origin.y >= 0.0 {1} else {0},
if ray.origin.z >= 0.0 {1} else {0},
];
// NB: The children are half the size of the tree itself,
// but tree.lg_size=0 means it extends tree.lg_size=0 in *each direction*,
// so the "actual" size of the tree as a voxel would be tree.lg_size+1.
let child_lg_size = self.lg_size as i16;
let mut make_bounds = |coords: [usize; 3]| {
voxel::Bounds {
x: coords[0] as i32 - 1,
y: coords[1] as i32 - 1,
z: coords[2] as i32 - 1,
lg_size: child_lg_size,
}
};
match raycast::cast_ray_branches(
&self.contents,
ray,
None,
coords,
&mut make_bounds,
act,
) {
Ok(r) => Some(r),
Err(_) => None,
}
}
}
#[cfg(test)]
mod tests {
extern crate test;
use voxel;
use super::{VoxelTree, TreeBody};
#[test]
fn insert_and_lookup() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(8, -8, 4, 0)) = TreeBody::Leaf(2);
*tree.get_mut_or_create(voxel::Bounds::new(2, 0, 4, 4)) = TreeBody::Leaf(3);
*tree.get_mut_or_create(voxel::Bounds::new(9, 0, 16, 2)) = TreeBody::Leaf(4);
*tree.get_mut_or_create(voxel::Bounds::new(9, 0, 16, 2)) = TreeBody::Leaf(5);
assert_eq!(tree.get(voxel::Bounds::new(1, 1, 1, 0)), Some(&1));
assert_eq!(tree.get(voxel::Bounds::new(8, -8, 4, 0)), Some(&2));
assert_eq!(tree.get(voxel::Bounds::new(9, 0, 16, 2)), Some(&5));
assert_eq!(tree.get(voxel::Bounds::new(2, 0, 4, 4)), None);
}
#[test]
fn wrong_voxel_size_is_not_found() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, -4, 1)) = TreeBody::Leaf(1);
assert_eq!(tree.get(voxel::Bounds::new(4, 4, -4, 0)), None);
assert_eq!(tree.get(voxel::Bounds::new(4, 4, -4, 2)), None);
}
#[test]
fn grow_is_transparent() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 1));
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 2));
tree.grow_to_hold(voxel::Bounds::new(-32, 32, -128, 3));
assert_eq!(tree.get(voxel::Bounds::new(1, 1, 1, 0)), Some(&1));
}
#[test]
fn simple_cast_ray() {
let mut tree: VoxelTree<i32> = VoxelTree::new();
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, 4, 0)) = TreeBody::Leaf(2);
let actual = tree.cast_ray(
[4.5, 3.0, 4.5],
[0.1, 0.8, 0.1],
// Return the first voxel we hit.
&mut |bounds, v| Some((bounds, v)),
);
assert_eq!(actual, Some((voxel::Bounds::new(4, 4, 4, 0), &2)));
}
#[bench]
fn simple_inserts(bencher: &mut test::Bencher) {
let mut tree: VoxelTree<i32> = VoxelTree::new();
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 30));
bencher.iter(|| {
*tree.get_mut_or_create(voxel::Bounds::new(0, 0, 0, 0)) = TreeBody::Leaf(0);
});
test::black_box(tree);
}
#[bench]
fn bench_cast_ray(bencher: &mut test::Bencher) {
let mut tree: VoxelTree<i32> = VoxelTree::new();
tree.grow_to_hold(voxel::Bounds::new(0, 0, 0, 30));
*tree.get_mut_or_create(voxel::Bounds::new(1, 1, 1, 0)) = TreeBody::Leaf(1);
*tree.get_mut_or_create(voxel::Bounds::new(4, 4, 4, 0)) = TreeBody::Leaf(2);
bencher.iter(|| {
let r = tree.cast_ray(
[4.5, 3.0, 4.5],
[0.1, 0.8, 0.1],
// Return the first voxel we hit.
&mut |bounds, v| Some((bounds, v)),
);
test::black_box(r);
});
}
} | lhl: TreeBody, | random_line_split |
read.rs | /*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
use std::io;
use std::result;
use anyhow::{bail, Context as _};
use byteorder::{ByteOrder, NativeEndian};
#[cfg(feature = "debug_bytes")]
use std::fmt;
#[cfg(feature = "debug_bytes")]
macro_rules! debug_bytes {
($($arg:tt)*) => {
eprint!($($arg)*);
}
}
#[cfg(not(feature = "debug_bytes"))]
macro_rules! debug_bytes {
($($arg:tt)*) => {};
}
#[cfg(feature = "debug_bytes")]
struct ByteBuf<'a>(&'a [u8]);
#[cfg(feature = "debug_bytes")]
impl<'a> fmt::LowerHex for ByteBuf<'a> {
fn fmt(&self, fmtr: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
for byte in self.0 {
let val = byte.clone();
if (val >= b'-' && val <= b'9')
|| (val >= b'A' && val <= b'Z')
|| (val >= b'a' && val <= b'z')
|| val == b'_'
{
fmtr.write_fmt(format_args!("{}", val as char))?;
} else {
fmtr.write_fmt(format_args!(r"\x{:02x}", byte))?;
}
}
Ok(())
}
}
pub trait DeRead<'de> {
/// read next byte (if peeked byte not discarded return it)
fn next(&mut self) -> anyhow::Result<u8>;
/// peek next byte (peeked byte should come in next and next_bytes unless discarded)
fn peek(&mut self) -> anyhow::Result<u8>;
/// how many bytes have been read so far.
/// this doesn't include the peeked byte
fn read_count(&self) -> usize;
/// discard peeked byte
fn discard(&mut self);
/// read next byte (if peeked byte not discarded include it)
fn next_bytes<'s>(
&'s mut self,
len: usize,
scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'de,'s, [u8]>>;
/// read u32 as native endian
fn next_u32(&mut self, scratch: &mut Vec<u8>) -> anyhow::Result<u32> {
let bytes = self
.next_bytes(4, scratch)
.context("error while parsing u32")?
.get_ref();
Ok(NativeEndian::read_u32(bytes))
}
}
pub struct SliceRead<'a> {
slice: &'a [u8],
index: usize,
}
impl<'a> SliceRead<'a> {
pub fn new(slice: &'a [u8]) -> Self {
SliceRead { slice, index: 0 }
}
}
pub struct IoRead<R>
where
R: io::Read,
{
reader: R,
read_count: usize,
/// Temporary storage of peeked byte.
peeked: Option<u8>,
}
impl<R> IoRead<R>
where
R: io::Read,
{
pub fn new(reader: R) -> Self {
debug_bytes!("Read bytes:\n");
IoRead {
reader,
read_count: 0,
peeked: None,
}
}
}
impl<R> Drop for IoRead<R>
where
R: io::Read,
{
fn drop(&mut self) {
debug_bytes!("\n");
}
}
impl<'a> DeRead<'a> for SliceRead<'a> {
fn next(&mut self) -> anyhow::Result<u8> {
if self.index >= self.slice.len() {
bail!("eof while reading next byte");
} | self.index += 1;
Ok(ch)
}
fn peek(&mut self) -> anyhow::Result<u8> {
if self.index >= self.slice.len() {
bail!("eof while peeking next byte");
}
Ok(self.slice[self.index])
}
#[inline]
fn read_count(&self) -> usize {
self.index
}
#[inline]
fn discard(&mut self) {
self.index += 1;
}
fn next_bytes<'s>(
&'s mut self,
len: usize,
_scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'a,'s, [u8]>> {
// BSER has no escaping or anything similar, so just go ahead and return
// a reference to the bytes.
if self.index + len > self.slice.len() {
bail!("eof while parsing bytes/string");
}
let borrowed = &self.slice[self.index..(self.index + len)];
self.index += len;
Ok(Reference::Borrowed(borrowed))
}
}
impl<'de, R> DeRead<'de> for IoRead<R>
where
R: io::Read,
{
fn next(&mut self) -> anyhow::Result<u8> {
match self.peeked.take() {
Some(peeked) => Ok(peeked),
None => {
let mut buffer = [0; 1];
self.reader.read_exact(&mut buffer)?;
debug_bytes!("{:x}", ByteBuf(&buffer));
self.read_count += 1;
Ok(buffer[0])
}
}
}
fn peek(&mut self) -> anyhow::Result<u8> {
match self.peeked {
Some(peeked) => Ok(peeked),
None => {
let mut buffer = [0; 1];
self.reader.read_exact(&mut buffer)?;
debug_bytes!("{:x}", ByteBuf(&buffer));
self.peeked = Some(buffer[0]);
self.read_count += 1;
Ok(buffer[0])
}
}
}
#[inline]
fn read_count(&self) -> usize {
match self.peeked {
Some(_) => self.read_count - 1,
None => self.read_count,
}
}
#[inline]
fn discard(&mut self) {
self.peeked = None
}
fn next_bytes<'s>(
&'s mut self,
len: usize,
scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'de,'s, [u8]>> {
scratch.resize(len, 0);
let mut idx = 0;
if self.peeked.is_some() {
idx += 1;
}
if idx < len {
self.reader.read_exact(&mut scratch[idx..len])?;
debug_bytes!("{:x}", ByteBuf(&scratch[idx..len]));
self.read_count += len - idx;
}
if let Some(peeked) = self.peeked.take() {
scratch[0] = peeked;
}
Ok(Reference::Copied(&scratch[0..len]))
}
}
#[derive(Debug)]
pub enum Reference<'b, 'c, T:?Sized> {
Borrowed(&'b T),
Copied(&'c T),
}
impl<'b, 'c, T> Reference<'b, 'c, T>
where
T:?Sized,
{
pub fn map_result<F, U, E>(self, f: F) -> anyhow::Result<Reference<'b, 'c, U>>
where
F: FnOnce(&T) -> result::Result<&U, E>,
E: std::error::Error + Send + Sync +'static,
U:?Sized + 'b + 'c,
{
match self {
Reference::Borrowed(borrowed) => Ok(Reference::Borrowed(f(borrowed)?)),
Reference::Copied(copied) => Ok(Reference::Copied(f(copied)?)),
}
}
pub fn get_ref<'a>(&self) -> &'a T
where
'b: 'a,
'c: 'a,
{
match *self {
Reference::Borrowed(borrowed) => borrowed,
Reference::Copied(copied) => copied,
}
}
} | let ch = self.slice[self.index]; | random_line_split |
read.rs | /*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
use std::io;
use std::result;
use anyhow::{bail, Context as _};
use byteorder::{ByteOrder, NativeEndian};
#[cfg(feature = "debug_bytes")]
use std::fmt;
#[cfg(feature = "debug_bytes")]
macro_rules! debug_bytes {
($($arg:tt)*) => {
eprint!($($arg)*);
}
}
#[cfg(not(feature = "debug_bytes"))]
macro_rules! debug_bytes {
($($arg:tt)*) => {};
}
#[cfg(feature = "debug_bytes")]
struct ByteBuf<'a>(&'a [u8]);
#[cfg(feature = "debug_bytes")]
impl<'a> fmt::LowerHex for ByteBuf<'a> {
fn fmt(&self, fmtr: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
for byte in self.0 {
let val = byte.clone();
if (val >= b'-' && val <= b'9')
|| (val >= b'A' && val <= b'Z')
|| (val >= b'a' && val <= b'z')
|| val == b'_'
{
fmtr.write_fmt(format_args!("{}", val as char))?;
} else {
fmtr.write_fmt(format_args!(r"\x{:02x}", byte))?;
}
}
Ok(())
}
}
pub trait DeRead<'de> {
/// read next byte (if peeked byte not discarded return it)
fn next(&mut self) -> anyhow::Result<u8>;
/// peek next byte (peeked byte should come in next and next_bytes unless discarded)
fn peek(&mut self) -> anyhow::Result<u8>;
/// how many bytes have been read so far.
/// this doesn't include the peeked byte
fn read_count(&self) -> usize;
/// discard peeked byte
fn discard(&mut self);
/// read next byte (if peeked byte not discarded include it)
fn next_bytes<'s>(
&'s mut self,
len: usize,
scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'de,'s, [u8]>>;
/// read u32 as native endian
fn next_u32(&mut self, scratch: &mut Vec<u8>) -> anyhow::Result<u32> {
let bytes = self
.next_bytes(4, scratch)
.context("error while parsing u32")?
.get_ref();
Ok(NativeEndian::read_u32(bytes))
}
}
pub struct SliceRead<'a> {
slice: &'a [u8],
index: usize,
}
impl<'a> SliceRead<'a> {
pub fn new(slice: &'a [u8]) -> Self {
SliceRead { slice, index: 0 }
}
}
pub struct IoRead<R>
where
R: io::Read,
{
reader: R,
read_count: usize,
/// Temporary storage of peeked byte.
peeked: Option<u8>,
}
impl<R> IoRead<R>
where
R: io::Read,
{
pub fn new(reader: R) -> Self {
debug_bytes!("Read bytes:\n");
IoRead {
reader,
read_count: 0,
peeked: None,
}
}
}
impl<R> Drop for IoRead<R>
where
R: io::Read,
{
fn drop(&mut self) {
debug_bytes!("\n");
}
}
impl<'a> DeRead<'a> for SliceRead<'a> {
fn next(&mut self) -> anyhow::Result<u8> {
if self.index >= self.slice.len() {
bail!("eof while reading next byte");
}
let ch = self.slice[self.index];
self.index += 1;
Ok(ch)
}
fn peek(&mut self) -> anyhow::Result<u8> {
if self.index >= self.slice.len() {
bail!("eof while peeking next byte");
}
Ok(self.slice[self.index])
}
#[inline]
fn read_count(&self) -> usize {
self.index
}
#[inline]
fn discard(&mut self) {
self.index += 1;
}
fn next_bytes<'s>(
&'s mut self,
len: usize,
_scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'a,'s, [u8]>> {
// BSER has no escaping or anything similar, so just go ahead and return
// a reference to the bytes.
if self.index + len > self.slice.len() |
let borrowed = &self.slice[self.index..(self.index + len)];
self.index += len;
Ok(Reference::Borrowed(borrowed))
}
}
impl<'de, R> DeRead<'de> for IoRead<R>
where
R: io::Read,
{
fn next(&mut self) -> anyhow::Result<u8> {
match self.peeked.take() {
Some(peeked) => Ok(peeked),
None => {
let mut buffer = [0; 1];
self.reader.read_exact(&mut buffer)?;
debug_bytes!("{:x}", ByteBuf(&buffer));
self.read_count += 1;
Ok(buffer[0])
}
}
}
fn peek(&mut self) -> anyhow::Result<u8> {
match self.peeked {
Some(peeked) => Ok(peeked),
None => {
let mut buffer = [0; 1];
self.reader.read_exact(&mut buffer)?;
debug_bytes!("{:x}", ByteBuf(&buffer));
self.peeked = Some(buffer[0]);
self.read_count += 1;
Ok(buffer[0])
}
}
}
#[inline]
fn read_count(&self) -> usize {
match self.peeked {
Some(_) => self.read_count - 1,
None => self.read_count,
}
}
#[inline]
fn discard(&mut self) {
self.peeked = None
}
fn next_bytes<'s>(
&'s mut self,
len: usize,
scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'de,'s, [u8]>> {
scratch.resize(len, 0);
let mut idx = 0;
if self.peeked.is_some() {
idx += 1;
}
if idx < len {
self.reader.read_exact(&mut scratch[idx..len])?;
debug_bytes!("{:x}", ByteBuf(&scratch[idx..len]));
self.read_count += len - idx;
}
if let Some(peeked) = self.peeked.take() {
scratch[0] = peeked;
}
Ok(Reference::Copied(&scratch[0..len]))
}
}
#[derive(Debug)]
pub enum Reference<'b, 'c, T:?Sized> {
Borrowed(&'b T),
Copied(&'c T),
}
impl<'b, 'c, T> Reference<'b, 'c, T>
where
T:?Sized,
{
pub fn map_result<F, U, E>(self, f: F) -> anyhow::Result<Reference<'b, 'c, U>>
where
F: FnOnce(&T) -> result::Result<&U, E>,
E: std::error::Error + Send + Sync +'static,
U:?Sized + 'b + 'c,
{
match self {
Reference::Borrowed(borrowed) => Ok(Reference::Borrowed(f(borrowed)?)),
Reference::Copied(copied) => Ok(Reference::Copied(f(copied)?)),
}
}
pub fn get_ref<'a>(&self) -> &'a T
where
'b: 'a,
'c: 'a,
{
match *self {
Reference::Borrowed(borrowed) => borrowed,
Reference::Copied(copied) => copied,
}
}
}
| {
bail!("eof while parsing bytes/string");
} | conditional_block |
read.rs | /*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
use std::io;
use std::result;
use anyhow::{bail, Context as _};
use byteorder::{ByteOrder, NativeEndian};
#[cfg(feature = "debug_bytes")]
use std::fmt;
#[cfg(feature = "debug_bytes")]
macro_rules! debug_bytes {
($($arg:tt)*) => {
eprint!($($arg)*);
}
}
#[cfg(not(feature = "debug_bytes"))]
macro_rules! debug_bytes {
($($arg:tt)*) => {};
}
#[cfg(feature = "debug_bytes")]
struct | <'a>(&'a [u8]);
#[cfg(feature = "debug_bytes")]
impl<'a> fmt::LowerHex for ByteBuf<'a> {
fn fmt(&self, fmtr: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
for byte in self.0 {
let val = byte.clone();
if (val >= b'-' && val <= b'9')
|| (val >= b'A' && val <= b'Z')
|| (val >= b'a' && val <= b'z')
|| val == b'_'
{
fmtr.write_fmt(format_args!("{}", val as char))?;
} else {
fmtr.write_fmt(format_args!(r"\x{:02x}", byte))?;
}
}
Ok(())
}
}
pub trait DeRead<'de> {
/// read next byte (if peeked byte not discarded return it)
fn next(&mut self) -> anyhow::Result<u8>;
/// peek next byte (peeked byte should come in next and next_bytes unless discarded)
fn peek(&mut self) -> anyhow::Result<u8>;
/// how many bytes have been read so far.
/// this doesn't include the peeked byte
fn read_count(&self) -> usize;
/// discard peeked byte
fn discard(&mut self);
/// read next byte (if peeked byte not discarded include it)
fn next_bytes<'s>(
&'s mut self,
len: usize,
scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'de,'s, [u8]>>;
/// read u32 as native endian
fn next_u32(&mut self, scratch: &mut Vec<u8>) -> anyhow::Result<u32> {
let bytes = self
.next_bytes(4, scratch)
.context("error while parsing u32")?
.get_ref();
Ok(NativeEndian::read_u32(bytes))
}
}
pub struct SliceRead<'a> {
slice: &'a [u8],
index: usize,
}
impl<'a> SliceRead<'a> {
pub fn new(slice: &'a [u8]) -> Self {
SliceRead { slice, index: 0 }
}
}
pub struct IoRead<R>
where
R: io::Read,
{
reader: R,
read_count: usize,
/// Temporary storage of peeked byte.
peeked: Option<u8>,
}
impl<R> IoRead<R>
where
R: io::Read,
{
pub fn new(reader: R) -> Self {
debug_bytes!("Read bytes:\n");
IoRead {
reader,
read_count: 0,
peeked: None,
}
}
}
impl<R> Drop for IoRead<R>
where
R: io::Read,
{
fn drop(&mut self) {
debug_bytes!("\n");
}
}
impl<'a> DeRead<'a> for SliceRead<'a> {
fn next(&mut self) -> anyhow::Result<u8> {
if self.index >= self.slice.len() {
bail!("eof while reading next byte");
}
let ch = self.slice[self.index];
self.index += 1;
Ok(ch)
}
fn peek(&mut self) -> anyhow::Result<u8> {
if self.index >= self.slice.len() {
bail!("eof while peeking next byte");
}
Ok(self.slice[self.index])
}
#[inline]
fn read_count(&self) -> usize {
self.index
}
#[inline]
fn discard(&mut self) {
self.index += 1;
}
fn next_bytes<'s>(
&'s mut self,
len: usize,
_scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'a,'s, [u8]>> {
// BSER has no escaping or anything similar, so just go ahead and return
// a reference to the bytes.
if self.index + len > self.slice.len() {
bail!("eof while parsing bytes/string");
}
let borrowed = &self.slice[self.index..(self.index + len)];
self.index += len;
Ok(Reference::Borrowed(borrowed))
}
}
impl<'de, R> DeRead<'de> for IoRead<R>
where
R: io::Read,
{
fn next(&mut self) -> anyhow::Result<u8> {
match self.peeked.take() {
Some(peeked) => Ok(peeked),
None => {
let mut buffer = [0; 1];
self.reader.read_exact(&mut buffer)?;
debug_bytes!("{:x}", ByteBuf(&buffer));
self.read_count += 1;
Ok(buffer[0])
}
}
}
fn peek(&mut self) -> anyhow::Result<u8> {
match self.peeked {
Some(peeked) => Ok(peeked),
None => {
let mut buffer = [0; 1];
self.reader.read_exact(&mut buffer)?;
debug_bytes!("{:x}", ByteBuf(&buffer));
self.peeked = Some(buffer[0]);
self.read_count += 1;
Ok(buffer[0])
}
}
}
#[inline]
fn read_count(&self) -> usize {
match self.peeked {
Some(_) => self.read_count - 1,
None => self.read_count,
}
}
#[inline]
fn discard(&mut self) {
self.peeked = None
}
fn next_bytes<'s>(
&'s mut self,
len: usize,
scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'de,'s, [u8]>> {
scratch.resize(len, 0);
let mut idx = 0;
if self.peeked.is_some() {
idx += 1;
}
if idx < len {
self.reader.read_exact(&mut scratch[idx..len])?;
debug_bytes!("{:x}", ByteBuf(&scratch[idx..len]));
self.read_count += len - idx;
}
if let Some(peeked) = self.peeked.take() {
scratch[0] = peeked;
}
Ok(Reference::Copied(&scratch[0..len]))
}
}
#[derive(Debug)]
pub enum Reference<'b, 'c, T:?Sized> {
Borrowed(&'b T),
Copied(&'c T),
}
impl<'b, 'c, T> Reference<'b, 'c, T>
where
T:?Sized,
{
pub fn map_result<F, U, E>(self, f: F) -> anyhow::Result<Reference<'b, 'c, U>>
where
F: FnOnce(&T) -> result::Result<&U, E>,
E: std::error::Error + Send + Sync +'static,
U:?Sized + 'b + 'c,
{
match self {
Reference::Borrowed(borrowed) => Ok(Reference::Borrowed(f(borrowed)?)),
Reference::Copied(copied) => Ok(Reference::Copied(f(copied)?)),
}
}
pub fn get_ref<'a>(&self) -> &'a T
where
'b: 'a,
'c: 'a,
{
match *self {
Reference::Borrowed(borrowed) => borrowed,
Reference::Copied(copied) => copied,
}
}
}
| ByteBuf | identifier_name |
read.rs | /*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
use std::io;
use std::result;
use anyhow::{bail, Context as _};
use byteorder::{ByteOrder, NativeEndian};
#[cfg(feature = "debug_bytes")]
use std::fmt;
#[cfg(feature = "debug_bytes")]
macro_rules! debug_bytes {
($($arg:tt)*) => {
eprint!($($arg)*);
}
}
#[cfg(not(feature = "debug_bytes"))]
macro_rules! debug_bytes {
($($arg:tt)*) => {};
}
#[cfg(feature = "debug_bytes")]
struct ByteBuf<'a>(&'a [u8]);
#[cfg(feature = "debug_bytes")]
impl<'a> fmt::LowerHex for ByteBuf<'a> {
fn fmt(&self, fmtr: &mut fmt::Formatter) -> result::Result<(), fmt::Error> |
}
pub trait DeRead<'de> {
/// read next byte (if peeked byte not discarded return it)
fn next(&mut self) -> anyhow::Result<u8>;
/// peek next byte (peeked byte should come in next and next_bytes unless discarded)
fn peek(&mut self) -> anyhow::Result<u8>;
/// how many bytes have been read so far.
/// this doesn't include the peeked byte
fn read_count(&self) -> usize;
/// discard peeked byte
fn discard(&mut self);
/// read next byte (if peeked byte not discarded include it)
fn next_bytes<'s>(
&'s mut self,
len: usize,
scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'de,'s, [u8]>>;
/// read u32 as native endian
fn next_u32(&mut self, scratch: &mut Vec<u8>) -> anyhow::Result<u32> {
let bytes = self
.next_bytes(4, scratch)
.context("error while parsing u32")?
.get_ref();
Ok(NativeEndian::read_u32(bytes))
}
}
pub struct SliceRead<'a> {
slice: &'a [u8],
index: usize,
}
impl<'a> SliceRead<'a> {
pub fn new(slice: &'a [u8]) -> Self {
SliceRead { slice, index: 0 }
}
}
pub struct IoRead<R>
where
R: io::Read,
{
reader: R,
read_count: usize,
/// Temporary storage of peeked byte.
peeked: Option<u8>,
}
impl<R> IoRead<R>
where
R: io::Read,
{
pub fn new(reader: R) -> Self {
debug_bytes!("Read bytes:\n");
IoRead {
reader,
read_count: 0,
peeked: None,
}
}
}
impl<R> Drop for IoRead<R>
where
R: io::Read,
{
fn drop(&mut self) {
debug_bytes!("\n");
}
}
impl<'a> DeRead<'a> for SliceRead<'a> {
fn next(&mut self) -> anyhow::Result<u8> {
if self.index >= self.slice.len() {
bail!("eof while reading next byte");
}
let ch = self.slice[self.index];
self.index += 1;
Ok(ch)
}
fn peek(&mut self) -> anyhow::Result<u8> {
if self.index >= self.slice.len() {
bail!("eof while peeking next byte");
}
Ok(self.slice[self.index])
}
#[inline]
fn read_count(&self) -> usize {
self.index
}
#[inline]
fn discard(&mut self) {
self.index += 1;
}
fn next_bytes<'s>(
&'s mut self,
len: usize,
_scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'a,'s, [u8]>> {
// BSER has no escaping or anything similar, so just go ahead and return
// a reference to the bytes.
if self.index + len > self.slice.len() {
bail!("eof while parsing bytes/string");
}
let borrowed = &self.slice[self.index..(self.index + len)];
self.index += len;
Ok(Reference::Borrowed(borrowed))
}
}
impl<'de, R> DeRead<'de> for IoRead<R>
where
R: io::Read,
{
fn next(&mut self) -> anyhow::Result<u8> {
match self.peeked.take() {
Some(peeked) => Ok(peeked),
None => {
let mut buffer = [0; 1];
self.reader.read_exact(&mut buffer)?;
debug_bytes!("{:x}", ByteBuf(&buffer));
self.read_count += 1;
Ok(buffer[0])
}
}
}
fn peek(&mut self) -> anyhow::Result<u8> {
match self.peeked {
Some(peeked) => Ok(peeked),
None => {
let mut buffer = [0; 1];
self.reader.read_exact(&mut buffer)?;
debug_bytes!("{:x}", ByteBuf(&buffer));
self.peeked = Some(buffer[0]);
self.read_count += 1;
Ok(buffer[0])
}
}
}
#[inline]
fn read_count(&self) -> usize {
match self.peeked {
Some(_) => self.read_count - 1,
None => self.read_count,
}
}
#[inline]
fn discard(&mut self) {
self.peeked = None
}
fn next_bytes<'s>(
&'s mut self,
len: usize,
scratch: &'s mut Vec<u8>,
) -> anyhow::Result<Reference<'de,'s, [u8]>> {
scratch.resize(len, 0);
let mut idx = 0;
if self.peeked.is_some() {
idx += 1;
}
if idx < len {
self.reader.read_exact(&mut scratch[idx..len])?;
debug_bytes!("{:x}", ByteBuf(&scratch[idx..len]));
self.read_count += len - idx;
}
if let Some(peeked) = self.peeked.take() {
scratch[0] = peeked;
}
Ok(Reference::Copied(&scratch[0..len]))
}
}
#[derive(Debug)]
pub enum Reference<'b, 'c, T:?Sized> {
Borrowed(&'b T),
Copied(&'c T),
}
impl<'b, 'c, T> Reference<'b, 'c, T>
where
T:?Sized,
{
pub fn map_result<F, U, E>(self, f: F) -> anyhow::Result<Reference<'b, 'c, U>>
where
F: FnOnce(&T) -> result::Result<&U, E>,
E: std::error::Error + Send + Sync +'static,
U:?Sized + 'b + 'c,
{
match self {
Reference::Borrowed(borrowed) => Ok(Reference::Borrowed(f(borrowed)?)),
Reference::Copied(copied) => Ok(Reference::Copied(f(copied)?)),
}
}
pub fn get_ref<'a>(&self) -> &'a T
where
'b: 'a,
'c: 'a,
{
match *self {
Reference::Borrowed(borrowed) => borrowed,
Reference::Copied(copied) => copied,
}
}
}
| {
for byte in self.0 {
let val = byte.clone();
if (val >= b'-' && val <= b'9')
|| (val >= b'A' && val <= b'Z')
|| (val >= b'a' && val <= b'z')
|| val == b'_'
{
fmtr.write_fmt(format_args!("{}", val as char))?;
} else {
fmtr.write_fmt(format_args!(r"\x{:02x}", byte))?;
}
}
Ok(())
} | identifier_body |
htmlbuttonelement.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::activation::Activatable;
use dom::attr::Attr;
use dom::bindings::codegen::Bindings::HTMLButtonElementBinding;
use dom::bindings::codegen::Bindings::HTMLButtonElementBinding::HTMLButtonElementMethods;
use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLButtonElementCast, NodeCast};
use dom::bindings::codegen::InheritTypes::{HTMLButtonElementDerived, HTMLFieldSetElementDerived};
use dom::bindings::js::Root;
use dom::document::Document;
use dom::element::{Element, ElementTypeId};
use dom::event::Event;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
use dom::htmlformelement::{FormSubmitter, FormControl};
use dom::htmlformelement::{SubmittedFrom};
use dom::node::{Node, NodeTypeId, document_from_node, window_from_node};
use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods;
use std::ascii::AsciiExt;
use std::borrow::ToOwned;
use std::cell::Cell;
use util::str::DOMString;
#[derive(JSTraceable, PartialEq, Copy, Clone)]
#[allow(dead_code)]
#[derive(HeapSizeOf)]
enum ButtonType {
ButtonSubmit,
ButtonReset,
ButtonButton,
ButtonMenu
}
#[dom_struct]
pub struct HTMLButtonElement {
htmlelement: HTMLElement,
button_type: Cell<ButtonType>
}
impl HTMLButtonElementDerived for EventTarget {
fn is_htmlbuttonelement(&self) -> bool {
*self.type_id() ==
EventTargetTypeId::Node(
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)))
}
}
impl HTMLButtonElement {
fn new_inherited(localName: DOMString,
prefix: Option<DOMString>,
document: &Document) -> HTMLButtonElement {
HTMLButtonElement {
htmlelement:
HTMLElement::new_inherited(HTMLElementTypeId::HTMLButtonElement, localName, prefix, document),
//TODO: implement button_type in after_set_attr
button_type: Cell::new(ButtonType::ButtonSubmit)
}
}
#[allow(unrooted_must_root)]
pub fn new(localName: DOMString,
prefix: Option<DOMString>,
document: &Document) -> Root<HTMLButtonElement> {
let element = HTMLButtonElement::new_inherited(localName, prefix, document);
Node::reflect_node(box element, document, HTMLButtonElementBinding::Wrap)
}
}
impl HTMLButtonElementMethods for HTMLButtonElement {
// https://html.spec.whatwg.org/multipage/#dom-cva-validity
fn Validity(&self) -> Root<ValidityState> {
let window = window_from_node(self);
ValidityState::new(window.r())
}
// https://www.whatwg.org/html/#dom-fe-disabled
make_bool_getter!(Disabled);
// https://www.whatwg.org/html/#dom-fe-disabled
make_bool_setter!(SetDisabled, "disabled");
// https://html.spec.whatwg.org/multipage/#dom-button-type
fn Type(&self) -> DOMString {
let elem = ElementCast::from_ref(self);
let mut ty = elem.get_string_attribute(&atom!("type"));
ty.make_ascii_lowercase();
// https://html.spec.whatwg.org/multipage/#attr-button-type
match &*ty {
"reset" | "button" | "menu" => ty,
_ => "submit".to_owned()
}
}
// https://html.spec.whatwg.org/multipage/#dom-button-type
make_setter!(SetType, "type");
// https://html.spec.whatwg.org/multipage/#htmlbuttonelement
make_url_or_base_getter!(FormAction);
make_setter!(SetFormAction, "formaction");
make_enumerated_getter!(
FormEnctype, "application/x-www-form-urlencoded", ("text/plain") | ("multipart/form-data"));
make_setter!(SetFormEnctype, "formenctype");
make_enumerated_getter!(FormMethod, "get", ("post") | ("dialog"));
make_setter!(SetFormMethod, "formmethod");
make_getter!(FormTarget);
make_setter!(SetFormTarget, "formtarget");
// https://html.spec.whatwg.org/multipage/#dom-fe-name
make_getter!(Name);
// https://html.spec.whatwg.org/multipage/#dom-fe-name
make_setter!(SetName, "name");
// https://html.spec.whatwg.org/multipage/#dom-button-value
make_getter!(Value);
// https://html.spec.whatwg.org/multipage/#dom-button-value
make_setter!(SetValue, "value");
}
impl VirtualMethods for HTMLButtonElement {
fn super_type<'b>(&'b self) -> Option<&'b VirtualMethods> {
let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
Some(htmlelement as &VirtualMethods)
}
fn after_set_attr(&self, attr: &Attr) {
if let Some(ref s) = self.super_type() {
s.after_set_attr(attr);
}
match attr.local_name() {
&atom!("disabled") => {
let node = NodeCast::from_ref(self);
node.set_disabled_state(true);
node.set_enabled_state(false);
},
_ => ()
}
}
fn before_remove_attr(&self, attr: &Attr) {
if let Some(ref s) = self.super_type() {
s.before_remove_attr(attr);
}
match attr.local_name() {
&atom!("disabled") => {
let node = NodeCast::from_ref(self);
node.set_disabled_state(false);
node.set_enabled_state(true);
node.check_ancestors_disabled_state_for_form_control();
},
_ => ()
}
}
fn bind_to_tree(&self, tree_in_doc: bool) {
if let Some(ref s) = self.super_type() {
s.bind_to_tree(tree_in_doc);
}
let node = NodeCast::from_ref(self);
node.check_ancestors_disabled_state_for_form_control();
}
fn unbind_from_tree(&self, tree_in_doc: bool) {
if let Some(ref s) = self.super_type() {
s.unbind_from_tree(tree_in_doc);
}
let node = NodeCast::from_ref(self);
if node.ancestors().any(|ancestor| ancestor.r().is_htmlfieldsetelement()) {
node.check_ancestors_disabled_state_for_form_control();
} else {
node.check_disabled_attribute();
}
}
}
impl<'a> FormControl<'a> for &'a HTMLButtonElement {
fn to_element(self) -> &'a Element {
ElementCast::from_ref(self)
}
}
impl<'a> Activatable for &'a HTMLButtonElement {
fn as_element<'b>(&'b self) -> &'b Element {
ElementCast::from_ref(*self)
}
fn is_instance_activatable(&self) -> bool {
//https://html.spec.whatwg.org/multipage/#the-button-element
let node = NodeCast::from_ref(*self);
!(node.get_disabled_state())
}
// https://html.spec.whatwg.org/multipage/#run-pre-click-activation-steps
// https://html.spec.whatwg.org/multipage/#the-button-element:activation-behavior
fn pre_click_activation(&self) |
// https://html.spec.whatwg.org/multipage/#run-canceled-activation-steps
fn canceled_activation(&self) {
}
// https://html.spec.whatwg.org/multipage/#run-post-click-activation-steps
fn activation_behavior(&self, _event: &Event, _target: &EventTarget) {
let ty = self.button_type.get();
match ty {
//https://html.spec.whatwg.org/multipage/#attr-button-type-submit-state
ButtonType::ButtonSubmit => {
self.form_owner().map(|o| {
o.r().submit(SubmittedFrom::NotFromFormSubmitMethod,
FormSubmitter::ButtonElement(self.clone()))
});
},
_ => ()
}
}
// https://html.spec.whatwg.org/multipage/#implicit-submission
#[allow(unsafe_code)]
fn implicit_submission(&self, ctrlKey: bool, shiftKey: bool, altKey: bool, metaKey: bool) {
let doc = document_from_node(*self);
let node = NodeCast::from_ref(doc.r());
let owner = self.form_owner();
let elem = ElementCast::from_ref(*self);
if owner.is_none() || elem.click_in_progress() {
return;
}
// This is safe because we are stopping after finding the first element
// and only then performing actions which may modify the DOM tree
unsafe {
node.query_selector_iter("button[type=submit]".to_owned()).unwrap()
.filter_map(HTMLButtonElementCast::to_root)
.find(|r| r.r().form_owner() == owner)
.map(|s| s.r().synthetic_click_activation(ctrlKey, shiftKey, altKey, metaKey));
}
}
}
| {
} | identifier_body |
htmlbuttonelement.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::activation::Activatable;
use dom::attr::Attr;
use dom::bindings::codegen::Bindings::HTMLButtonElementBinding;
use dom::bindings::codegen::Bindings::HTMLButtonElementBinding::HTMLButtonElementMethods;
use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLButtonElementCast, NodeCast};
use dom::bindings::codegen::InheritTypes::{HTMLButtonElementDerived, HTMLFieldSetElementDerived};
use dom::bindings::js::Root;
use dom::document::Document;
use dom::element::{Element, ElementTypeId};
use dom::event::Event;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
use dom::htmlformelement::{FormSubmitter, FormControl};
use dom::htmlformelement::{SubmittedFrom};
use dom::node::{Node, NodeTypeId, document_from_node, window_from_node};
use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods;
use std::ascii::AsciiExt;
use std::borrow::ToOwned;
use std::cell::Cell;
use util::str::DOMString;
#[derive(JSTraceable, PartialEq, Copy, Clone)]
#[allow(dead_code)]
#[derive(HeapSizeOf)]
enum ButtonType {
ButtonSubmit,
ButtonReset,
ButtonButton,
ButtonMenu
}
#[dom_struct]
pub struct HTMLButtonElement {
htmlelement: HTMLElement,
button_type: Cell<ButtonType>
}
impl HTMLButtonElementDerived for EventTarget {
fn is_htmlbuttonelement(&self) -> bool {
*self.type_id() ==
EventTargetTypeId::Node(
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)))
}
}
impl HTMLButtonElement {
fn new_inherited(localName: DOMString,
prefix: Option<DOMString>,
document: &Document) -> HTMLButtonElement {
HTMLButtonElement {
htmlelement:
HTMLElement::new_inherited(HTMLElementTypeId::HTMLButtonElement, localName, prefix, document),
//TODO: implement button_type in after_set_attr
button_type: Cell::new(ButtonType::ButtonSubmit)
}
}
#[allow(unrooted_must_root)]
pub fn new(localName: DOMString,
prefix: Option<DOMString>,
document: &Document) -> Root<HTMLButtonElement> {
let element = HTMLButtonElement::new_inherited(localName, prefix, document);
Node::reflect_node(box element, document, HTMLButtonElementBinding::Wrap)
}
}
impl HTMLButtonElementMethods for HTMLButtonElement {
// https://html.spec.whatwg.org/multipage/#dom-cva-validity
fn Validity(&self) -> Root<ValidityState> {
let window = window_from_node(self);
ValidityState::new(window.r())
}
// https://www.whatwg.org/html/#dom-fe-disabled
make_bool_getter!(Disabled);
// https://www.whatwg.org/html/#dom-fe-disabled
make_bool_setter!(SetDisabled, "disabled");
// https://html.spec.whatwg.org/multipage/#dom-button-type
fn Type(&self) -> DOMString {
let elem = ElementCast::from_ref(self);
let mut ty = elem.get_string_attribute(&atom!("type"));
ty.make_ascii_lowercase();
// https://html.spec.whatwg.org/multipage/#attr-button-type
match &*ty {
"reset" | "button" | "menu" => ty,
_ => "submit".to_owned()
}
}
// https://html.spec.whatwg.org/multipage/#dom-button-type
make_setter!(SetType, "type");
// https://html.spec.whatwg.org/multipage/#htmlbuttonelement
make_url_or_base_getter!(FormAction);
make_setter!(SetFormAction, "formaction");
make_enumerated_getter!(
FormEnctype, "application/x-www-form-urlencoded", ("text/plain") | ("multipart/form-data"));
make_setter!(SetFormEnctype, "formenctype");
make_enumerated_getter!(FormMethod, "get", ("post") | ("dialog"));
make_setter!(SetFormMethod, "formmethod");
make_getter!(FormTarget);
make_setter!(SetFormTarget, "formtarget");
// https://html.spec.whatwg.org/multipage/#dom-fe-name
make_getter!(Name);
// https://html.spec.whatwg.org/multipage/#dom-fe-name
make_setter!(SetName, "name");
// https://html.spec.whatwg.org/multipage/#dom-button-value
make_getter!(Value);
// https://html.spec.whatwg.org/multipage/#dom-button-value
make_setter!(SetValue, "value");
}
impl VirtualMethods for HTMLButtonElement {
fn super_type<'b>(&'b self) -> Option<&'b VirtualMethods> {
let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
Some(htmlelement as &VirtualMethods)
}
fn after_set_attr(&self, attr: &Attr) {
if let Some(ref s) = self.super_type() {
s.after_set_attr(attr);
}
match attr.local_name() {
&atom!("disabled") => {
let node = NodeCast::from_ref(self);
node.set_disabled_state(true);
node.set_enabled_state(false);
},
_ => ()
}
}
fn before_remove_attr(&self, attr: &Attr) {
if let Some(ref s) = self.super_type() {
s.before_remove_attr(attr);
}
match attr.local_name() {
&atom!("disabled") => {
let node = NodeCast::from_ref(self);
node.set_disabled_state(false);
node.set_enabled_state(true);
node.check_ancestors_disabled_state_for_form_control();
},
_ => ()
}
}
fn bind_to_tree(&self, tree_in_doc: bool) {
if let Some(ref s) = self.super_type() {
s.bind_to_tree(tree_in_doc);
}
let node = NodeCast::from_ref(self);
node.check_ancestors_disabled_state_for_form_control();
}
fn unbind_from_tree(&self, tree_in_doc: bool) {
if let Some(ref s) = self.super_type() {
s.unbind_from_tree(tree_in_doc);
}
let node = NodeCast::from_ref(self);
if node.ancestors().any(|ancestor| ancestor.r().is_htmlfieldsetelement()) {
node.check_ancestors_disabled_state_for_form_control();
} else {
node.check_disabled_attribute();
}
}
}
impl<'a> FormControl<'a> for &'a HTMLButtonElement {
fn to_element(self) -> &'a Element {
ElementCast::from_ref(self)
}
}
impl<'a> Activatable for &'a HTMLButtonElement {
fn as_element<'b>(&'b self) -> &'b Element {
ElementCast::from_ref(*self)
}
fn is_instance_activatable(&self) -> bool {
//https://html.spec.whatwg.org/multipage/#the-button-element
let node = NodeCast::from_ref(*self);
!(node.get_disabled_state())
}
// https://html.spec.whatwg.org/multipage/#run-pre-click-activation-steps
// https://html.spec.whatwg.org/multipage/#the-button-element:activation-behavior
fn | (&self) {
}
// https://html.spec.whatwg.org/multipage/#run-canceled-activation-steps
fn canceled_activation(&self) {
}
// https://html.spec.whatwg.org/multipage/#run-post-click-activation-steps
fn activation_behavior(&self, _event: &Event, _target: &EventTarget) {
let ty = self.button_type.get();
match ty {
//https://html.spec.whatwg.org/multipage/#attr-button-type-submit-state
ButtonType::ButtonSubmit => {
self.form_owner().map(|o| {
o.r().submit(SubmittedFrom::NotFromFormSubmitMethod,
FormSubmitter::ButtonElement(self.clone()))
});
},
_ => ()
}
}
// https://html.spec.whatwg.org/multipage/#implicit-submission
#[allow(unsafe_code)]
fn implicit_submission(&self, ctrlKey: bool, shiftKey: bool, altKey: bool, metaKey: bool) {
let doc = document_from_node(*self);
let node = NodeCast::from_ref(doc.r());
let owner = self.form_owner();
let elem = ElementCast::from_ref(*self);
if owner.is_none() || elem.click_in_progress() {
return;
}
// This is safe because we are stopping after finding the first element
// and only then performing actions which may modify the DOM tree
unsafe {
node.query_selector_iter("button[type=submit]".to_owned()).unwrap()
.filter_map(HTMLButtonElementCast::to_root)
.find(|r| r.r().form_owner() == owner)
.map(|s| s.r().synthetic_click_activation(ctrlKey, shiftKey, altKey, metaKey));
}
}
}
| pre_click_activation | identifier_name |
htmlbuttonelement.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::activation::Activatable;
use dom::attr::Attr;
use dom::bindings::codegen::Bindings::HTMLButtonElementBinding;
use dom::bindings::codegen::Bindings::HTMLButtonElementBinding::HTMLButtonElementMethods;
use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLButtonElementCast, NodeCast};
use dom::bindings::codegen::InheritTypes::{HTMLButtonElementDerived, HTMLFieldSetElementDerived};
use dom::bindings::js::Root;
use dom::document::Document;
use dom::element::{Element, ElementTypeId};
use dom::event::Event;
use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
use dom::htmlformelement::{FormSubmitter, FormControl};
use dom::htmlformelement::{SubmittedFrom};
use dom::node::{Node, NodeTypeId, document_from_node, window_from_node};
use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods;
use std::ascii::AsciiExt;
use std::borrow::ToOwned;
use std::cell::Cell;
use util::str::DOMString;
#[derive(JSTraceable, PartialEq, Copy, Clone)]
#[allow(dead_code)]
#[derive(HeapSizeOf)]
enum ButtonType {
ButtonSubmit,
ButtonReset,
ButtonButton,
ButtonMenu
}
#[dom_struct]
pub struct HTMLButtonElement {
htmlelement: HTMLElement,
button_type: Cell<ButtonType>
}
impl HTMLButtonElementDerived for EventTarget {
fn is_htmlbuttonelement(&self) -> bool {
*self.type_id() ==
EventTargetTypeId::Node(
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLButtonElement)))
}
}
impl HTMLButtonElement {
fn new_inherited(localName: DOMString,
prefix: Option<DOMString>,
document: &Document) -> HTMLButtonElement {
HTMLButtonElement {
htmlelement:
HTMLElement::new_inherited(HTMLElementTypeId::HTMLButtonElement, localName, prefix, document),
//TODO: implement button_type in after_set_attr
button_type: Cell::new(ButtonType::ButtonSubmit)
}
}
#[allow(unrooted_must_root)]
pub fn new(localName: DOMString,
prefix: Option<DOMString>,
document: &Document) -> Root<HTMLButtonElement> {
let element = HTMLButtonElement::new_inherited(localName, prefix, document);
Node::reflect_node(box element, document, HTMLButtonElementBinding::Wrap)
}
}
impl HTMLButtonElementMethods for HTMLButtonElement {
// https://html.spec.whatwg.org/multipage/#dom-cva-validity
fn Validity(&self) -> Root<ValidityState> {
let window = window_from_node(self);
ValidityState::new(window.r())
}
// https://www.whatwg.org/html/#dom-fe-disabled
make_bool_getter!(Disabled);
// https://www.whatwg.org/html/#dom-fe-disabled
make_bool_setter!(SetDisabled, "disabled");
// https://html.spec.whatwg.org/multipage/#dom-button-type
fn Type(&self) -> DOMString {
let elem = ElementCast::from_ref(self);
let mut ty = elem.get_string_attribute(&atom!("type"));
ty.make_ascii_lowercase();
// https://html.spec.whatwg.org/multipage/#attr-button-type
match &*ty {
"reset" | "button" | "menu" => ty,
_ => "submit".to_owned()
}
}
// https://html.spec.whatwg.org/multipage/#dom-button-type
make_setter!(SetType, "type");
// https://html.spec.whatwg.org/multipage/#htmlbuttonelement
make_url_or_base_getter!(FormAction);
make_setter!(SetFormAction, "formaction");
make_enumerated_getter!(
FormEnctype, "application/x-www-form-urlencoded", ("text/plain") | ("multipart/form-data"));
make_setter!(SetFormEnctype, "formenctype");
make_enumerated_getter!(FormMethod, "get", ("post") | ("dialog"));
make_setter!(SetFormMethod, "formmethod");
make_getter!(FormTarget);
make_setter!(SetFormTarget, "formtarget");
// https://html.spec.whatwg.org/multipage/#dom-fe-name
make_getter!(Name);
// https://html.spec.whatwg.org/multipage/#dom-fe-name
make_setter!(SetName, "name");
// https://html.spec.whatwg.org/multipage/#dom-button-value
make_getter!(Value);
// https://html.spec.whatwg.org/multipage/#dom-button-value
make_setter!(SetValue, "value");
}
impl VirtualMethods for HTMLButtonElement {
fn super_type<'b>(&'b self) -> Option<&'b VirtualMethods> {
let htmlelement: &HTMLElement = HTMLElementCast::from_ref(self);
Some(htmlelement as &VirtualMethods)
}
fn after_set_attr(&self, attr: &Attr) {
if let Some(ref s) = self.super_type() {
s.after_set_attr(attr);
}
match attr.local_name() {
&atom!("disabled") => {
let node = NodeCast::from_ref(self);
node.set_disabled_state(true);
node.set_enabled_state(false);
},
_ => ()
}
}
fn before_remove_attr(&self, attr: &Attr) {
if let Some(ref s) = self.super_type() {
s.before_remove_attr(attr);
}
match attr.local_name() {
&atom!("disabled") => {
let node = NodeCast::from_ref(self);
node.set_disabled_state(false);
node.set_enabled_state(true);
node.check_ancestors_disabled_state_for_form_control();
},
_ => ()
}
}
fn bind_to_tree(&self, tree_in_doc: bool) {
if let Some(ref s) = self.super_type() {
s.bind_to_tree(tree_in_doc);
}
let node = NodeCast::from_ref(self);
node.check_ancestors_disabled_state_for_form_control();
}
fn unbind_from_tree(&self, tree_in_doc: bool) {
if let Some(ref s) = self.super_type() {
s.unbind_from_tree(tree_in_doc);
}
let node = NodeCast::from_ref(self);
if node.ancestors().any(|ancestor| ancestor.r().is_htmlfieldsetelement()) {
node.check_ancestors_disabled_state_for_form_control();
} else {
node.check_disabled_attribute();
}
}
}
impl<'a> FormControl<'a> for &'a HTMLButtonElement {
fn to_element(self) -> &'a Element {
ElementCast::from_ref(self)
}
}
impl<'a> Activatable for &'a HTMLButtonElement {
fn as_element<'b>(&'b self) -> &'b Element {
ElementCast::from_ref(*self)
}
fn is_instance_activatable(&self) -> bool {
//https://html.spec.whatwg.org/multipage/#the-button-element
let node = NodeCast::from_ref(*self);
!(node.get_disabled_state())
}
// https://html.spec.whatwg.org/multipage/#run-pre-click-activation-steps
// https://html.spec.whatwg.org/multipage/#the-button-element:activation-behavior
fn pre_click_activation(&self) {
}
// https://html.spec.whatwg.org/multipage/#run-canceled-activation-steps
fn canceled_activation(&self) {
}
// https://html.spec.whatwg.org/multipage/#run-post-click-activation-steps
fn activation_behavior(&self, _event: &Event, _target: &EventTarget) {
let ty = self.button_type.get();
match ty {
//https://html.spec.whatwg.org/multipage/#attr-button-type-submit-state
ButtonType::ButtonSubmit => {
self.form_owner().map(|o| {
o.r().submit(SubmittedFrom::NotFromFormSubmitMethod,
FormSubmitter::ButtonElement(self.clone()))
});
},
_ => ()
} | }
// https://html.spec.whatwg.org/multipage/#implicit-submission
#[allow(unsafe_code)]
fn implicit_submission(&self, ctrlKey: bool, shiftKey: bool, altKey: bool, metaKey: bool) {
let doc = document_from_node(*self);
let node = NodeCast::from_ref(doc.r());
let owner = self.form_owner();
let elem = ElementCast::from_ref(*self);
if owner.is_none() || elem.click_in_progress() {
return;
}
// This is safe because we are stopping after finding the first element
// and only then performing actions which may modify the DOM tree
unsafe {
node.query_selector_iter("button[type=submit]".to_owned()).unwrap()
.filter_map(HTMLButtonElementCast::to_root)
.find(|r| r.r().form_owner() == owner)
.map(|s| s.r().synthetic_click_activation(ctrlKey, shiftKey, altKey, metaKey));
}
}
} | random_line_split |
|
cli.rs | //! Command argument types
//! The deserialized structures of the command args.
#![allow(non_camel_case_types,non_snake_case)]
use core::fmt;
use core::str::FromStr;
use docopt;
use opengl_graphics::OpenGL;
use rustc_serialize::{Decodable,Decoder};
use std::net;
docopt!(pub Args derive Debug,concat!("
Usage: ",PROGRAM_NAME!()," [options]
",PROGRAM_NAME!()," --help
A game with tetrominos falling.
Options:
-h, --help Show this message
-v, --version Show version
--credits Show credits/staff
--manual Show instruction manual/guide for the game
--online=CONNECTION Available modes: none, server, client [default: none]
--host=ADDR Network address used for the online connection [default: 0.0.0.0]
--port=N Network port used for the online connection [default: 7374]
--window-size=SIZE Window size [default: 800x600]
--window-mode=MODE Available modes: window, fullscreen [default: window]
--gl-backend=BACKEND Not implemented yet. Available backends: sdl2, glfw, glutin [default: glutin]
--gl-version=NN Available versions: 20, 21, 30, 31, 32, 33, 40, 41, 42, 43, 44, 45 [default: 32]
"),
flag_online : OnlineConnection,
flag_host : Host,
flag_port : Port,
flag_window_size: WindowSize,
flag_window_mode: WindowMode,
flag_gl_backend : GlBackend,
flag_gl_version : GlVersion,
);
///Workaround for the creation of Args because the docopt macro is not making everything public
#[inline(always)]
pub fn Args_docopt() -> docopt::Docopt{Args::docopt()}
#[derive(Debug)]
pub struct | (pub net::IpAddr);
impl Decodable for Host{
fn decode<D: Decoder>(d: &mut D) -> Result<Self,D::Error>{
let str = try!(d.read_str());
let str = &*str;
Ok(Host(match net::IpAddr::from_str(str){
Ok(addr) => addr,
Err(_) => try!(try!(try!(
net::lookup_host(str).map_err(|_| d.error("Error when lookup_host")))
.next().ok_or_else(|| d.error("No hosts when lookup_host")))
.map_err(|_| d.error("Error when converting to IpAddr with lookup_host")))
.ip()
}))
}
}
pub type Port = u16;
#[derive(Debug,RustcDecodable)]
pub enum OnlineConnection{none,server,client}
#[derive(Debug)]
pub struct WindowSize(pub u32,pub u32);
impl Decodable for WindowSize{
fn decode<D: Decoder>(d: &mut D) -> Result<Self,D::Error>{
let str = try!(d.read_str());
let str = &*str;
let (w,h) = str.split_at(try!(str.find('x').ok_or_else(|| d.error("Invalid format: Missing 'x' in \"<WIDTH>x<HEIGHT>\""))));
Ok(WindowSize(
try!(FromStr::from_str(w).map_err(|_| d.error("Invalid format: <WIDTH> in (<SIZE> = <WIDTH>x<HEIGHT>) is not a valid positive integer"))),
try!(FromStr::from_str(&h[1..]).map_err(|_| d.error("Invalid format: <HEIGHT> in (<SIZE> = <WIDTH>x<HEIGHT>) is not a valid positive integer")))
))
}
}
#[derive(Debug,RustcDecodable)]
pub enum WindowMode{window,fullscreen}
#[derive(Debug,RustcDecodable)]
pub enum GlBackend{sdl2,glfw,glutin}
pub struct GlVersion(pub OpenGL);
impl fmt::Debug for GlVersion{
fn fmt(&self,f: &mut fmt::Formatter) -> fmt::Result{
write!(f,"{}",match self.0{
OpenGL::V2_0 => "v2.0",
OpenGL::V2_1 => "v2.1",
OpenGL::V3_0 => "v3.0",
OpenGL::V3_1 => "v3.1",
OpenGL::V3_2 => "v3.2",
OpenGL::V3_3 => "v3.3",
OpenGL::V4_0 => "v4.0",
OpenGL::V4_1 => "v4.1",
OpenGL::V4_2 => "v4.2",
OpenGL::V4_3 => "v4.3",
OpenGL::V4_4 => "v4.4",
OpenGL::V4_5 => "v4.5",
})
}
}
impl Decodable for GlVersion{
fn decode<D: Decoder>(d: &mut D) -> Result<Self,D::Error>{
let str = try!(d.read_str());
let str = &*str;
Ok(GlVersion(
match try!(u8::from_str(str).map_err(|_| d.error("Invalid format: <NN> in (--gl-version=NN) is not a valid positive integer"))){
20 => OpenGL::V2_0,
21 => OpenGL::V2_1,
30 => OpenGL::V3_0,
31 => OpenGL::V3_1,
32 => OpenGL::V3_2,
33 => OpenGL::V3_3,
40 => OpenGL::V4_0,
41 => OpenGL::V4_1,
42 => OpenGL::V4_2,
43 => OpenGL::V4_3,
44 => OpenGL::V4_4,
45 => OpenGL::V4_5,
_ => return Err(d.error("Invalid version number was given"))
}
))
}
}
| Host | identifier_name |
cli.rs | //! Command argument types
//! The deserialized structures of the command args.
#![allow(non_camel_case_types,non_snake_case)]
use core::fmt;
use core::str::FromStr;
use docopt;
use opengl_graphics::OpenGL;
use rustc_serialize::{Decodable,Decoder};
use std::net;
docopt!(pub Args derive Debug,concat!("
Usage: ",PROGRAM_NAME!()," [options]
",PROGRAM_NAME!()," --help
A game with tetrominos falling.
Options:
-h, --help Show this message
-v, --version Show version
--credits Show credits/staff
--manual Show instruction manual/guide for the game
--online=CONNECTION Available modes: none, server, client [default: none]
--host=ADDR Network address used for the online connection [default: 0.0.0.0]
--port=N Network port used for the online connection [default: 7374]
--window-size=SIZE Window size [default: 800x600]
--window-mode=MODE Available modes: window, fullscreen [default: window]
--gl-backend=BACKEND Not implemented yet. Available backends: sdl2, glfw, glutin [default: glutin]
--gl-version=NN Available versions: 20, 21, 30, 31, 32, 33, 40, 41, 42, 43, 44, 45 [default: 32]
"),
flag_online : OnlineConnection,
flag_host : Host,
flag_port : Port,
flag_window_size: WindowSize,
flag_window_mode: WindowMode,
flag_gl_backend : GlBackend,
flag_gl_version : GlVersion,
);
///Workaround for the creation of Args because the docopt macro is not making everything public
#[inline(always)]
pub fn Args_docopt() -> docopt::Docopt{Args::docopt()}
#[derive(Debug)]
pub struct Host(pub net::IpAddr);
impl Decodable for Host{
fn decode<D: Decoder>(d: &mut D) -> Result<Self,D::Error>{
let str = try!(d.read_str());
let str = &*str;
Ok(Host(match net::IpAddr::from_str(str){
Ok(addr) => addr,
Err(_) => try!(try!(try!(
net::lookup_host(str).map_err(|_| d.error("Error when lookup_host")))
.next().ok_or_else(|| d.error("No hosts when lookup_host")))
.map_err(|_| d.error("Error when converting to IpAddr with lookup_host")))
.ip()
}))
}
}
pub type Port = u16;
#[derive(Debug,RustcDecodable)]
pub enum OnlineConnection{none,server,client}
#[derive(Debug)]
pub struct WindowSize(pub u32,pub u32);
impl Decodable for WindowSize{
fn decode<D: Decoder>(d: &mut D) -> Result<Self,D::Error>{
let str = try!(d.read_str());
let str = &*str;
let (w,h) = str.split_at(try!(str.find('x').ok_or_else(|| d.error("Invalid format: Missing 'x' in \"<WIDTH>x<HEIGHT>\""))));
Ok(WindowSize(
try!(FromStr::from_str(w).map_err(|_| d.error("Invalid format: <WIDTH> in (<SIZE> = <WIDTH>x<HEIGHT>) is not a valid positive integer"))),
try!(FromStr::from_str(&h[1..]).map_err(|_| d.error("Invalid format: <HEIGHT> in (<SIZE> = <WIDTH>x<HEIGHT>) is not a valid positive integer")))
))
}
}
#[derive(Debug,RustcDecodable)]
pub enum WindowMode{window,fullscreen}
#[derive(Debug,RustcDecodable)]
pub enum GlBackend{sdl2,glfw,glutin}
pub struct GlVersion(pub OpenGL); | impl fmt::Debug for GlVersion{
fn fmt(&self,f: &mut fmt::Formatter) -> fmt::Result{
write!(f,"{}",match self.0{
OpenGL::V2_0 => "v2.0",
OpenGL::V2_1 => "v2.1",
OpenGL::V3_0 => "v3.0",
OpenGL::V3_1 => "v3.1",
OpenGL::V3_2 => "v3.2",
OpenGL::V3_3 => "v3.3",
OpenGL::V4_0 => "v4.0",
OpenGL::V4_1 => "v4.1",
OpenGL::V4_2 => "v4.2",
OpenGL::V4_3 => "v4.3",
OpenGL::V4_4 => "v4.4",
OpenGL::V4_5 => "v4.5",
})
}
}
impl Decodable for GlVersion{
fn decode<D: Decoder>(d: &mut D) -> Result<Self,D::Error>{
let str = try!(d.read_str());
let str = &*str;
Ok(GlVersion(
match try!(u8::from_str(str).map_err(|_| d.error("Invalid format: <NN> in (--gl-version=NN) is not a valid positive integer"))){
20 => OpenGL::V2_0,
21 => OpenGL::V2_1,
30 => OpenGL::V3_0,
31 => OpenGL::V3_1,
32 => OpenGL::V3_2,
33 => OpenGL::V3_3,
40 => OpenGL::V4_0,
41 => OpenGL::V4_1,
42 => OpenGL::V4_2,
43 => OpenGL::V4_3,
44 => OpenGL::V4_4,
45 => OpenGL::V4_5,
_ => return Err(d.error("Invalid version number was given"))
}
))
}
} | random_line_split |
|
test_cargo_publish.rs | use std::io::prelude::*;
use std::fs::{self, File};
use std::io::{Cursor, SeekFrom};
use std::path::PathBuf;
use flate2::read::GzDecoder;
use tar::Archive;
use url::Url;
use support::{project, execs};
use support::{UPDATING, PACKAGING, UPLOADING};
use support::paths;
use support::git::repo;
use hamcrest::assert_that;
fn registry_path() -> PathBuf { paths::root().join("registry") }
fn registry() -> Url { Url::from_file_path(&*registry_path()).ok().unwrap() }
fn upload_path() -> PathBuf |
fn upload() -> Url { Url::from_file_path(&*upload_path()).ok().unwrap() }
fn setup() {
let config = paths::root().join(".cargo/config");
fs::create_dir_all(config.parent().unwrap()).unwrap();
File::create(&config).unwrap().write_all(&format!(r#"
[registry]
index = "{reg}"
token = "api-token"
"#, reg = registry()).as_bytes()).unwrap();
fs::create_dir_all(&upload_path().join("api/v1/crates")).unwrap();
repo(®istry_path())
.file("config.json", &format!(r#"{{
"dl": "{0}",
"api": "{0}"
}}"#, upload()))
.build();
}
test!(simple {
let p = project("foo")
.file("Cargo.toml", r#"
[project]
name = "foo"
version = "0.0.1"
authors = []
license = "MIT"
description = "foo"
"#)
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("publish").arg("--no-verify"),
execs().with_status(0).with_stdout(&format!("\
{updating} registry `{reg}`
{packaging} foo v0.0.1 ({dir})
{uploading} foo v0.0.1 ({dir})
",
updating = UPDATING,
uploading = UPLOADING,
packaging = PACKAGING,
dir = p.url(),
reg = registry())));
let mut f = File::open(&upload_path().join("api/v1/crates/new")).unwrap();
// Skip the metadata payload and the size of the tarball
let mut sz = [0; 4];
assert_eq!(f.read(&mut sz).unwrap(), 4);
let sz = ((sz[0] as u32) << 0) |
((sz[1] as u32) << 8) |
((sz[2] as u32) << 16) |
((sz[3] as u32) << 24);
f.seek(SeekFrom::Current(sz as i64 + 4)).unwrap();
// Verify the tarball
let mut rdr = GzDecoder::new(f).unwrap();
assert_eq!(rdr.header().filename().unwrap(), "foo-0.0.1.crate".as_bytes());
let mut contents = Vec::new();
rdr.read_to_end(&mut contents).unwrap();
let inner = Cursor::new(contents);
let ar = Archive::new(inner);
for file in ar.files().unwrap() {
let file = file.unwrap();
let fname = file.header().path_bytes();
let fname = &*fname;
assert!(fname == b"foo-0.0.1/Cargo.toml" ||
fname == b"foo-0.0.1/src/main.rs",
"unexpected filename: {:?}", file.header().path());
}
});
test!(git_deps {
let p = project("foo")
.file("Cargo.toml", r#"
[project]
name = "foo"
version = "0.0.1"
authors = []
license = "MIT"
description = "foo"
[dependencies.foo]
git = "git://path/to/nowhere"
"#)
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("publish").arg("-v").arg("--no-verify"),
execs().with_status(101).with_stderr("\
all dependencies must come from the same source.
dependency `foo` comes from git://path/to/nowhere instead
"));
});
test!(path_dependency_no_version {
let p = project("foo")
.file("Cargo.toml", r#"
[project]
name = "foo"
version = "0.0.1"
authors = []
license = "MIT"
description = "foo"
[dependencies.bar]
path = "bar"
"#)
.file("src/main.rs", "fn main() {}")
.file("bar/Cargo.toml", r#"
[package]
name = "bar"
version = "0.0.1"
authors = []
"#)
.file("bar/src/lib.rs", "");
assert_that(p.cargo_process("publish"),
execs().with_status(101).with_stderr("\
all path dependencies must have a version specified when publishing.
dependency `bar` does not specify a version
"));
});
| { paths::root().join("upload") } | identifier_body |
test_cargo_publish.rs | use std::io::prelude::*;
use std::fs::{self, File};
use std::io::{Cursor, SeekFrom};
use std::path::PathBuf;
use flate2::read::GzDecoder;
use tar::Archive;
use url::Url; | use support::git::repo;
use hamcrest::assert_that;
fn registry_path() -> PathBuf { paths::root().join("registry") }
fn registry() -> Url { Url::from_file_path(&*registry_path()).ok().unwrap() }
fn upload_path() -> PathBuf { paths::root().join("upload") }
fn upload() -> Url { Url::from_file_path(&*upload_path()).ok().unwrap() }
fn setup() {
let config = paths::root().join(".cargo/config");
fs::create_dir_all(config.parent().unwrap()).unwrap();
File::create(&config).unwrap().write_all(&format!(r#"
[registry]
index = "{reg}"
token = "api-token"
"#, reg = registry()).as_bytes()).unwrap();
fs::create_dir_all(&upload_path().join("api/v1/crates")).unwrap();
repo(®istry_path())
.file("config.json", &format!(r#"{{
"dl": "{0}",
"api": "{0}"
}}"#, upload()))
.build();
}
test!(simple {
let p = project("foo")
.file("Cargo.toml", r#"
[project]
name = "foo"
version = "0.0.1"
authors = []
license = "MIT"
description = "foo"
"#)
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("publish").arg("--no-verify"),
execs().with_status(0).with_stdout(&format!("\
{updating} registry `{reg}`
{packaging} foo v0.0.1 ({dir})
{uploading} foo v0.0.1 ({dir})
",
updating = UPDATING,
uploading = UPLOADING,
packaging = PACKAGING,
dir = p.url(),
reg = registry())));
let mut f = File::open(&upload_path().join("api/v1/crates/new")).unwrap();
// Skip the metadata payload and the size of the tarball
let mut sz = [0; 4];
assert_eq!(f.read(&mut sz).unwrap(), 4);
let sz = ((sz[0] as u32) << 0) |
((sz[1] as u32) << 8) |
((sz[2] as u32) << 16) |
((sz[3] as u32) << 24);
f.seek(SeekFrom::Current(sz as i64 + 4)).unwrap();
// Verify the tarball
let mut rdr = GzDecoder::new(f).unwrap();
assert_eq!(rdr.header().filename().unwrap(), "foo-0.0.1.crate".as_bytes());
let mut contents = Vec::new();
rdr.read_to_end(&mut contents).unwrap();
let inner = Cursor::new(contents);
let ar = Archive::new(inner);
for file in ar.files().unwrap() {
let file = file.unwrap();
let fname = file.header().path_bytes();
let fname = &*fname;
assert!(fname == b"foo-0.0.1/Cargo.toml" ||
fname == b"foo-0.0.1/src/main.rs",
"unexpected filename: {:?}", file.header().path());
}
});
test!(git_deps {
let p = project("foo")
.file("Cargo.toml", r#"
[project]
name = "foo"
version = "0.0.1"
authors = []
license = "MIT"
description = "foo"
[dependencies.foo]
git = "git://path/to/nowhere"
"#)
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("publish").arg("-v").arg("--no-verify"),
execs().with_status(101).with_stderr("\
all dependencies must come from the same source.
dependency `foo` comes from git://path/to/nowhere instead
"));
});
test!(path_dependency_no_version {
let p = project("foo")
.file("Cargo.toml", r#"
[project]
name = "foo"
version = "0.0.1"
authors = []
license = "MIT"
description = "foo"
[dependencies.bar]
path = "bar"
"#)
.file("src/main.rs", "fn main() {}")
.file("bar/Cargo.toml", r#"
[package]
name = "bar"
version = "0.0.1"
authors = []
"#)
.file("bar/src/lib.rs", "");
assert_that(p.cargo_process("publish"),
execs().with_status(101).with_stderr("\
all path dependencies must have a version specified when publishing.
dependency `bar` does not specify a version
"));
}); |
use support::{project, execs};
use support::{UPDATING, PACKAGING, UPLOADING};
use support::paths; | random_line_split |
test_cargo_publish.rs | use std::io::prelude::*;
use std::fs::{self, File};
use std::io::{Cursor, SeekFrom};
use std::path::PathBuf;
use flate2::read::GzDecoder;
use tar::Archive;
use url::Url;
use support::{project, execs};
use support::{UPDATING, PACKAGING, UPLOADING};
use support::paths;
use support::git::repo;
use hamcrest::assert_that;
fn registry_path() -> PathBuf { paths::root().join("registry") }
fn registry() -> Url { Url::from_file_path(&*registry_path()).ok().unwrap() }
fn upload_path() -> PathBuf { paths::root().join("upload") }
fn | () -> Url { Url::from_file_path(&*upload_path()).ok().unwrap() }
fn setup() {
let config = paths::root().join(".cargo/config");
fs::create_dir_all(config.parent().unwrap()).unwrap();
File::create(&config).unwrap().write_all(&format!(r#"
[registry]
index = "{reg}"
token = "api-token"
"#, reg = registry()).as_bytes()).unwrap();
fs::create_dir_all(&upload_path().join("api/v1/crates")).unwrap();
repo(®istry_path())
.file("config.json", &format!(r#"{{
"dl": "{0}",
"api": "{0}"
}}"#, upload()))
.build();
}
test!(simple {
let p = project("foo")
.file("Cargo.toml", r#"
[project]
name = "foo"
version = "0.0.1"
authors = []
license = "MIT"
description = "foo"
"#)
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("publish").arg("--no-verify"),
execs().with_status(0).with_stdout(&format!("\
{updating} registry `{reg}`
{packaging} foo v0.0.1 ({dir})
{uploading} foo v0.0.1 ({dir})
",
updating = UPDATING,
uploading = UPLOADING,
packaging = PACKAGING,
dir = p.url(),
reg = registry())));
let mut f = File::open(&upload_path().join("api/v1/crates/new")).unwrap();
// Skip the metadata payload and the size of the tarball
let mut sz = [0; 4];
assert_eq!(f.read(&mut sz).unwrap(), 4);
let sz = ((sz[0] as u32) << 0) |
((sz[1] as u32) << 8) |
((sz[2] as u32) << 16) |
((sz[3] as u32) << 24);
f.seek(SeekFrom::Current(sz as i64 + 4)).unwrap();
// Verify the tarball
let mut rdr = GzDecoder::new(f).unwrap();
assert_eq!(rdr.header().filename().unwrap(), "foo-0.0.1.crate".as_bytes());
let mut contents = Vec::new();
rdr.read_to_end(&mut contents).unwrap();
let inner = Cursor::new(contents);
let ar = Archive::new(inner);
for file in ar.files().unwrap() {
let file = file.unwrap();
let fname = file.header().path_bytes();
let fname = &*fname;
assert!(fname == b"foo-0.0.1/Cargo.toml" ||
fname == b"foo-0.0.1/src/main.rs",
"unexpected filename: {:?}", file.header().path());
}
});
test!(git_deps {
let p = project("foo")
.file("Cargo.toml", r#"
[project]
name = "foo"
version = "0.0.1"
authors = []
license = "MIT"
description = "foo"
[dependencies.foo]
git = "git://path/to/nowhere"
"#)
.file("src/main.rs", "fn main() {}");
assert_that(p.cargo_process("publish").arg("-v").arg("--no-verify"),
execs().with_status(101).with_stderr("\
all dependencies must come from the same source.
dependency `foo` comes from git://path/to/nowhere instead
"));
});
test!(path_dependency_no_version {
let p = project("foo")
.file("Cargo.toml", r#"
[project]
name = "foo"
version = "0.0.1"
authors = []
license = "MIT"
description = "foo"
[dependencies.bar]
path = "bar"
"#)
.file("src/main.rs", "fn main() {}")
.file("bar/Cargo.toml", r#"
[package]
name = "bar"
version = "0.0.1"
authors = []
"#)
.file("bar/src/lib.rs", "");
assert_that(p.cargo_process("publish"),
execs().with_status(101).with_stderr("\
all path dependencies must have a version specified when publishing.
dependency `bar` does not specify a version
"));
});
| upload | identifier_name |
suback.rs | use std::io::{self, Read, Write};
use std::error::Error;
use std::fmt;
use std::convert::From;
use byteorder::{self, WriteBytesExt, ReadBytesExt};
use control::{FixedHeader, PacketType, ControlType};
use control::variable_header::PacketIdentifier;
use packet::{Packet, PacketError};
use {Encodable, Decodable};
#[repr(u8)]
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
pub enum SubscribeReturnCode {
MaximumQoSLevel0 = 0x00,
MaximumQoSLevel1 = 0x01,
MaximumQoSLevel2 = 0x02,
Failure = 0x80,
}
#[derive(Debug, Eq, PartialEq)]
pub struct SubackPacket {
fixed_header: FixedHeader,
packet_identifier: PacketIdentifier,
payload: SubackPacketPayload,
}
impl SubackPacket {
pub fn new(pkid: u16, subscribes: Vec<SubscribeReturnCode>) -> SubackPacket {
let mut pk = SubackPacket {
fixed_header: FixedHeader::new(PacketType::with_default(ControlType::SubscribeAcknowledgement), 0),
packet_identifier: PacketIdentifier(pkid),
payload: SubackPacketPayload::new(subscribes),
};
pk.fixed_header.remaining_length =
pk.encoded_variable_headers_length() + pk.payload.encoded_length();
pk
}
pub fn packet_identifier(&self) -> u16 {
self.packet_identifier.0
}
pub fn set_packet_identifier(&mut self, pkid: u16) {
self.packet_identifier.0 = pkid;
}
}
impl<'a> Packet<'a> for SubackPacket {
type Payload = SubackPacketPayload;
fn fixed_header(&self) -> &FixedHeader {
&self.fixed_header
}
fn payload(&self) -> &Self::Payload {
&self.payload
}
fn encode_variable_headers<W: Write>(&self, writer: &mut W) -> Result<(), PacketError<'a, Self>> {
try!(self.packet_identifier.encode(writer));
Ok(())
}
fn encoded_variable_headers_length(&self) -> u32 {
self.packet_identifier.encoded_length()
}
fn decode_packet<R: Read>(reader: &mut R, fixed_header: FixedHeader) -> Result<Self, PacketError<'a, Self>> {
let packet_identifier: PacketIdentifier = try!(PacketIdentifier::decode(reader));
let payload: SubackPacketPayload =
try!(SubackPacketPayload::decode_with(reader, Some(fixed_header.remaining_length
- packet_identifier.encoded_length()))
.map_err(PacketError::PayloadError));
Ok(SubackPacket {
fixed_header: fixed_header,
packet_identifier: packet_identifier,
payload: payload,
})
}
}
#[derive(Debug, Eq, PartialEq)]
pub struct SubackPacketPayload {
subscribes: Vec<SubscribeReturnCode>,
}
impl SubackPacketPayload {
pub fn new(subs: Vec<SubscribeReturnCode>) -> SubackPacketPayload {
SubackPacketPayload {
subscribes: subs,
}
}
pub fn | (&self) -> &[SubscribeReturnCode] {
&self.subscribes[..]
}
}
impl<'a> Encodable<'a> for SubackPacketPayload {
type Err = SubackPacketPayloadError;
fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Self::Err> {
for code in self.subscribes.iter() {
try!(writer.write_u8(*code as u8));
}
Ok(())
}
fn encoded_length(&self) -> u32 {
self.subscribes.len() as u32
}
}
impl<'a> Decodable<'a> for SubackPacketPayload {
type Err = SubackPacketPayloadError;
type Cond = u32;
fn decode_with<R: Read>(reader: &mut R, payload_len: Option<u32>)
-> Result<SubackPacketPayload, SubackPacketPayloadError> {
let payload_len = payload_len.expect("Must provide payload length");
let mut subs = Vec::new();
for _ in 0..payload_len {
let retcode = match try!(reader.read_u8()) {
0x00 => SubscribeReturnCode::MaximumQoSLevel0,
0x01 => SubscribeReturnCode::MaximumQoSLevel1,
0x02 => SubscribeReturnCode::MaximumQoSLevel2,
0x80 => SubscribeReturnCode::Failure,
code => return Err(SubackPacketPayloadError::InvalidSubscribeReturnCode(code)),
};
subs.push(retcode);
}
Ok(SubackPacketPayload::new(subs))
}
}
#[derive(Debug)]
pub enum SubackPacketPayloadError {
IoError(io::Error),
InvalidSubscribeReturnCode(u8),
}
impl fmt::Display for SubackPacketPayloadError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
&SubackPacketPayloadError::IoError(ref err) => err.fmt(f),
&SubackPacketPayloadError::InvalidSubscribeReturnCode(code) =>
write!(f, "Invalid subscribe return code {}", code),
}
}
}
impl Error for SubackPacketPayloadError {
fn description(&self) -> &str {
match self {
&SubackPacketPayloadError::IoError(ref err) => err.description(),
&SubackPacketPayloadError::InvalidSubscribeReturnCode(..) => "Invalid subscribe return code",
}
}
fn cause(&self) -> Option<&Error> {
match self {
&SubackPacketPayloadError::IoError(ref err) => Some(err),
&SubackPacketPayloadError::InvalidSubscribeReturnCode(..) => None,
}
}
}
impl From<byteorder::Error> for SubackPacketPayloadError {
fn from(err: byteorder::Error) -> SubackPacketPayloadError {
SubackPacketPayloadError::IoError(From::from(err))
}
}
| subscribes | identifier_name |
suback.rs | use std::io::{self, Read, Write};
use std::error::Error;
use std::fmt;
use std::convert::From;
use byteorder::{self, WriteBytesExt, ReadBytesExt};
use control::{FixedHeader, PacketType, ControlType};
use control::variable_header::PacketIdentifier;
use packet::{Packet, PacketError};
use {Encodable, Decodable};
#[repr(u8)]
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
pub enum SubscribeReturnCode {
MaximumQoSLevel0 = 0x00,
MaximumQoSLevel1 = 0x01,
MaximumQoSLevel2 = 0x02,
Failure = 0x80,
}
#[derive(Debug, Eq, PartialEq)]
pub struct SubackPacket {
fixed_header: FixedHeader,
packet_identifier: PacketIdentifier,
payload: SubackPacketPayload,
}
impl SubackPacket {
pub fn new(pkid: u16, subscribes: Vec<SubscribeReturnCode>) -> SubackPacket {
let mut pk = SubackPacket {
fixed_header: FixedHeader::new(PacketType::with_default(ControlType::SubscribeAcknowledgement), 0),
packet_identifier: PacketIdentifier(pkid),
payload: SubackPacketPayload::new(subscribes),
};
pk.fixed_header.remaining_length =
pk.encoded_variable_headers_length() + pk.payload.encoded_length();
pk
}
pub fn packet_identifier(&self) -> u16 {
self.packet_identifier.0
}
pub fn set_packet_identifier(&mut self, pkid: u16) {
self.packet_identifier.0 = pkid;
}
}
impl<'a> Packet<'a> for SubackPacket {
type Payload = SubackPacketPayload;
fn fixed_header(&self) -> &FixedHeader {
&self.fixed_header
}
fn payload(&self) -> &Self::Payload {
&self.payload
}
fn encode_variable_headers<W: Write>(&self, writer: &mut W) -> Result<(), PacketError<'a, Self>> |
fn encoded_variable_headers_length(&self) -> u32 {
self.packet_identifier.encoded_length()
}
fn decode_packet<R: Read>(reader: &mut R, fixed_header: FixedHeader) -> Result<Self, PacketError<'a, Self>> {
let packet_identifier: PacketIdentifier = try!(PacketIdentifier::decode(reader));
let payload: SubackPacketPayload =
try!(SubackPacketPayload::decode_with(reader, Some(fixed_header.remaining_length
- packet_identifier.encoded_length()))
.map_err(PacketError::PayloadError));
Ok(SubackPacket {
fixed_header: fixed_header,
packet_identifier: packet_identifier,
payload: payload,
})
}
}
#[derive(Debug, Eq, PartialEq)]
pub struct SubackPacketPayload {
subscribes: Vec<SubscribeReturnCode>,
}
impl SubackPacketPayload {
pub fn new(subs: Vec<SubscribeReturnCode>) -> SubackPacketPayload {
SubackPacketPayload {
subscribes: subs,
}
}
pub fn subscribes(&self) -> &[SubscribeReturnCode] {
&self.subscribes[..]
}
}
impl<'a> Encodable<'a> for SubackPacketPayload {
type Err = SubackPacketPayloadError;
fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Self::Err> {
for code in self.subscribes.iter() {
try!(writer.write_u8(*code as u8));
}
Ok(())
}
fn encoded_length(&self) -> u32 {
self.subscribes.len() as u32
}
}
impl<'a> Decodable<'a> for SubackPacketPayload {
type Err = SubackPacketPayloadError;
type Cond = u32;
fn decode_with<R: Read>(reader: &mut R, payload_len: Option<u32>)
-> Result<SubackPacketPayload, SubackPacketPayloadError> {
let payload_len = payload_len.expect("Must provide payload length");
let mut subs = Vec::new();
for _ in 0..payload_len {
let retcode = match try!(reader.read_u8()) {
0x00 => SubscribeReturnCode::MaximumQoSLevel0,
0x01 => SubscribeReturnCode::MaximumQoSLevel1,
0x02 => SubscribeReturnCode::MaximumQoSLevel2,
0x80 => SubscribeReturnCode::Failure,
code => return Err(SubackPacketPayloadError::InvalidSubscribeReturnCode(code)),
};
subs.push(retcode);
}
Ok(SubackPacketPayload::new(subs))
}
}
#[derive(Debug)]
pub enum SubackPacketPayloadError {
IoError(io::Error),
InvalidSubscribeReturnCode(u8),
}
impl fmt::Display for SubackPacketPayloadError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
&SubackPacketPayloadError::IoError(ref err) => err.fmt(f),
&SubackPacketPayloadError::InvalidSubscribeReturnCode(code) =>
write!(f, "Invalid subscribe return code {}", code),
}
}
}
impl Error for SubackPacketPayloadError {
fn description(&self) -> &str {
match self {
&SubackPacketPayloadError::IoError(ref err) => err.description(),
&SubackPacketPayloadError::InvalidSubscribeReturnCode(..) => "Invalid subscribe return code",
}
}
fn cause(&self) -> Option<&Error> {
match self {
&SubackPacketPayloadError::IoError(ref err) => Some(err),
&SubackPacketPayloadError::InvalidSubscribeReturnCode(..) => None,
}
}
}
impl From<byteorder::Error> for SubackPacketPayloadError {
fn from(err: byteorder::Error) -> SubackPacketPayloadError {
SubackPacketPayloadError::IoError(From::from(err))
}
}
| {
try!(self.packet_identifier.encode(writer));
Ok(())
} | identifier_body |
suback.rs | use std::io::{self, Read, Write};
use std::error::Error;
use std::fmt;
use std::convert::From;
use byteorder::{self, WriteBytesExt, ReadBytesExt};
use control::{FixedHeader, PacketType, ControlType};
use control::variable_header::PacketIdentifier;
use packet::{Packet, PacketError};
use {Encodable, Decodable};
#[repr(u8)]
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
pub enum SubscribeReturnCode {
MaximumQoSLevel0 = 0x00,
MaximumQoSLevel1 = 0x01,
MaximumQoSLevel2 = 0x02,
Failure = 0x80,
}
#[derive(Debug, Eq, PartialEq)]
pub struct SubackPacket {
fixed_header: FixedHeader,
packet_identifier: PacketIdentifier,
payload: SubackPacketPayload,
}
impl SubackPacket {
pub fn new(pkid: u16, subscribes: Vec<SubscribeReturnCode>) -> SubackPacket {
let mut pk = SubackPacket {
fixed_header: FixedHeader::new(PacketType::with_default(ControlType::SubscribeAcknowledgement), 0),
packet_identifier: PacketIdentifier(pkid),
payload: SubackPacketPayload::new(subscribes),
};
pk.fixed_header.remaining_length =
pk.encoded_variable_headers_length() + pk.payload.encoded_length();
pk
}
pub fn packet_identifier(&self) -> u16 {
self.packet_identifier.0
}
pub fn set_packet_identifier(&mut self, pkid: u16) {
self.packet_identifier.0 = pkid;
}
}
impl<'a> Packet<'a> for SubackPacket {
type Payload = SubackPacketPayload;
fn fixed_header(&self) -> &FixedHeader {
&self.fixed_header
}
fn payload(&self) -> &Self::Payload {
&self.payload
}
fn encode_variable_headers<W: Write>(&self, writer: &mut W) -> Result<(), PacketError<'a, Self>> {
try!(self.packet_identifier.encode(writer));
Ok(())
}
fn encoded_variable_headers_length(&self) -> u32 {
self.packet_identifier.encoded_length()
}
fn decode_packet<R: Read>(reader: &mut R, fixed_header: FixedHeader) -> Result<Self, PacketError<'a, Self>> {
let packet_identifier: PacketIdentifier = try!(PacketIdentifier::decode(reader));
let payload: SubackPacketPayload =
try!(SubackPacketPayload::decode_with(reader, Some(fixed_header.remaining_length
- packet_identifier.encoded_length()))
.map_err(PacketError::PayloadError));
Ok(SubackPacket {
fixed_header: fixed_header,
packet_identifier: packet_identifier,
payload: payload,
})
}
}
#[derive(Debug, Eq, PartialEq)]
pub struct SubackPacketPayload {
subscribes: Vec<SubscribeReturnCode>,
}
impl SubackPacketPayload {
pub fn new(subs: Vec<SubscribeReturnCode>) -> SubackPacketPayload {
SubackPacketPayload {
subscribes: subs,
}
}
pub fn subscribes(&self) -> &[SubscribeReturnCode] {
&self.subscribes[..]
}
}
impl<'a> Encodable<'a> for SubackPacketPayload {
type Err = SubackPacketPayloadError;
fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Self::Err> {
for code in self.subscribes.iter() {
try!(writer.write_u8(*code as u8));
}
Ok(())
}
fn encoded_length(&self) -> u32 {
self.subscribes.len() as u32
}
}
impl<'a> Decodable<'a> for SubackPacketPayload {
type Err = SubackPacketPayloadError;
type Cond = u32;
fn decode_with<R: Read>(reader: &mut R, payload_len: Option<u32>)
-> Result<SubackPacketPayload, SubackPacketPayloadError> {
let payload_len = payload_len.expect("Must provide payload length");
let mut subs = Vec::new();
for _ in 0..payload_len {
let retcode = match try!(reader.read_u8()) {
0x00 => SubscribeReturnCode::MaximumQoSLevel0,
0x01 => SubscribeReturnCode::MaximumQoSLevel1,
0x02 => SubscribeReturnCode::MaximumQoSLevel2,
0x80 => SubscribeReturnCode::Failure,
code => return Err(SubackPacketPayloadError::InvalidSubscribeReturnCode(code)),
};
subs.push(retcode);
}
Ok(SubackPacketPayload::new(subs))
}
}
#[derive(Debug)]
pub enum SubackPacketPayloadError {
IoError(io::Error),
InvalidSubscribeReturnCode(u8),
}
impl fmt::Display for SubackPacketPayloadError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
&SubackPacketPayloadError::IoError(ref err) => err.fmt(f),
&SubackPacketPayloadError::InvalidSubscribeReturnCode(code) =>
write!(f, "Invalid subscribe return code {}", code),
}
}
}
impl Error for SubackPacketPayloadError { | match self {
&SubackPacketPayloadError::IoError(ref err) => err.description(),
&SubackPacketPayloadError::InvalidSubscribeReturnCode(..) => "Invalid subscribe return code",
}
}
fn cause(&self) -> Option<&Error> {
match self {
&SubackPacketPayloadError::IoError(ref err) => Some(err),
&SubackPacketPayloadError::InvalidSubscribeReturnCode(..) => None,
}
}
}
impl From<byteorder::Error> for SubackPacketPayloadError {
fn from(err: byteorder::Error) -> SubackPacketPayloadError {
SubackPacketPayloadError::IoError(From::from(err))
}
} | fn description(&self) -> &str { | random_line_split |
sqlite.rs | /*
* database/handle.rs
*
* markov-music - A music player that uses Markov chains to choose songs
* Copyright (c) 2017-2018 Ammon Smith
*
* markov-music is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* markov-music is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with markov-music. If not, see <http://www.gnu.org/licenses/>.
*/
use {diesel, Error, Result, StdResult};
use diesel::sqlite::SqliteConnection;
use super::Database;
use super::models::*;
use super::schema::*;
pub struct | {
conn: SqliteConnection,
}
impl SqliteDatabase {
pub fn new<S: AsRef<str>>(url: S) -> Result<Self> {
let conn = SqliteConnection::establish(url.as_ref())?;
Ok(SqliteDatabase { conn: conn })
}
}
impl Database for SqliteDatabase {
type Error = Error;
fn modify_weight(
&mut self,
song: &str,
next: &str,
diff: i32,
) -> Result<()> {
self.conn.transaction::<(), Error, _>(|| {
use self::associations::dsl;
let row = associations::table
.find((song, next))
.first::<Association>(&self.conn)
.optional()?;
let weight = row.map(|assoc| assoc.weight).unwrap_or(0) + diff;
let new_assoc = NewAssociation {
song: song,
next: next,
weight: weight,
};
diesel::replace_into(starters::table)
.values(&[new_assoc])
.execute(&self.conn)?;
Ok(())
})
}
fn clear(&mut self, song: &str) -> Result<()> {
self.conn.transaction::<(), Error, _>(|| {
use self::associations::dsl;
diesel::delete(associations::table.filter(dsl::song.eq(song)))
.execute(&self.conn)?;
Ok(())
})
}
}
| SqliteDatabase | identifier_name |
sqlite.rs | /*
* database/handle.rs
*
* markov-music - A music player that uses Markov chains to choose songs
* Copyright (c) 2017-2018 Ammon Smith
*
* markov-music is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* markov-music is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with markov-music. If not, see <http://www.gnu.org/licenses/>.
*/
use {diesel, Error, Result, StdResult};
use diesel::sqlite::SqliteConnection;
use super::Database;
use super::models::*;
use super::schema::*;
pub struct SqliteDatabase {
conn: SqliteConnection,
}
impl SqliteDatabase {
pub fn new<S: AsRef<str>>(url: S) -> Result<Self> {
let conn = SqliteConnection::establish(url.as_ref())?;
Ok(SqliteDatabase { conn: conn })
}
}
impl Database for SqliteDatabase {
type Error = Error;
fn modify_weight(
&mut self,
song: &str,
next: &str,
diff: i32,
) -> Result<()> {
self.conn.transaction::<(), Error, _>(|| {
use self::associations::dsl;
let row = associations::table
.find((song, next))
.first::<Association>(&self.conn)
.optional()?;
let weight = row.map(|assoc| assoc.weight).unwrap_or(0) + diff;
let new_assoc = NewAssociation {
song: song,
next: next,
weight: weight,
};
| Ok(())
})
}
fn clear(&mut self, song: &str) -> Result<()> {
self.conn.transaction::<(), Error, _>(|| {
use self::associations::dsl;
diesel::delete(associations::table.filter(dsl::song.eq(song)))
.execute(&self.conn)?;
Ok(())
})
}
} | diesel::replace_into(starters::table)
.values(&[new_assoc])
.execute(&self.conn)?;
| random_line_split |
sqlite.rs | /*
* database/handle.rs
*
* markov-music - A music player that uses Markov chains to choose songs
* Copyright (c) 2017-2018 Ammon Smith
*
* markov-music is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* markov-music is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with markov-music. If not, see <http://www.gnu.org/licenses/>.
*/
use {diesel, Error, Result, StdResult};
use diesel::sqlite::SqliteConnection;
use super::Database;
use super::models::*;
use super::schema::*;
pub struct SqliteDatabase {
conn: SqliteConnection,
}
impl SqliteDatabase {
pub fn new<S: AsRef<str>>(url: S) -> Result<Self> {
let conn = SqliteConnection::establish(url.as_ref())?;
Ok(SqliteDatabase { conn: conn })
}
}
impl Database for SqliteDatabase {
type Error = Error;
fn modify_weight(
&mut self,
song: &str,
next: &str,
diff: i32,
) -> Result<()> | Ok(())
})
}
fn clear(&mut self, song: &str) -> Result<()> {
self.conn.transaction::<(), Error, _>(|| {
use self::associations::dsl;
diesel::delete(associations::table.filter(dsl::song.eq(song)))
.execute(&self.conn)?;
Ok(())
})
}
}
| {
self.conn.transaction::<(), Error, _>(|| {
use self::associations::dsl;
let row = associations::table
.find((song, next))
.first::<Association>(&self.conn)
.optional()?;
let weight = row.map(|assoc| assoc.weight).unwrap_or(0) + diff;
let new_assoc = NewAssociation {
song: song,
next: next,
weight: weight,
};
diesel::replace_into(starters::table)
.values(&[new_assoc])
.execute(&self.conn)?;
| identifier_body |
local-inlining-but-not-all.rs | //
// We specify incremental here because we want to test the partitioning for
// incremental compilation
// incremental
// compile-flags:-Zprint-mono-items=lazy
// compile-flags:-Zinline-in-all-cgus=no
#![allow(dead_code)]
#![crate_type="lib"]
mod inline {
//~ MONO_ITEM fn inline::inlined_function @@ local_inlining_but_not_all-inline[External]
#[inline]
pub fn inlined_function()
|
}
pub mod user1 {
use super::inline;
//~ MONO_ITEM fn user1::foo @@ local_inlining_but_not_all-user1[External]
pub fn foo() {
inline::inlined_function();
}
}
pub mod user2 {
use super::inline;
//~ MONO_ITEM fn user2::bar @@ local_inlining_but_not_all-user2[External]
pub fn bar() {
inline::inlined_function();
}
}
pub mod non_user {
//~ MONO_ITEM fn non_user::baz @@ local_inlining_but_not_all-non_user[External]
pub fn baz() {
}
}
| {
} | identifier_body |
local-inlining-but-not-all.rs | //
// We specify incremental here because we want to test the partitioning for
// incremental compilation | #![allow(dead_code)]
#![crate_type="lib"]
mod inline {
//~ MONO_ITEM fn inline::inlined_function @@ local_inlining_but_not_all-inline[External]
#[inline]
pub fn inlined_function()
{
}
}
pub mod user1 {
use super::inline;
//~ MONO_ITEM fn user1::foo @@ local_inlining_but_not_all-user1[External]
pub fn foo() {
inline::inlined_function();
}
}
pub mod user2 {
use super::inline;
//~ MONO_ITEM fn user2::bar @@ local_inlining_but_not_all-user2[External]
pub fn bar() {
inline::inlined_function();
}
}
pub mod non_user {
//~ MONO_ITEM fn non_user::baz @@ local_inlining_but_not_all-non_user[External]
pub fn baz() {
}
} | // incremental
// compile-flags:-Zprint-mono-items=lazy
// compile-flags:-Zinline-in-all-cgus=no
| random_line_split |
local-inlining-but-not-all.rs | //
// We specify incremental here because we want to test the partitioning for
// incremental compilation
// incremental
// compile-flags:-Zprint-mono-items=lazy
// compile-flags:-Zinline-in-all-cgus=no
#![allow(dead_code)]
#![crate_type="lib"]
mod inline {
//~ MONO_ITEM fn inline::inlined_function @@ local_inlining_but_not_all-inline[External]
#[inline]
pub fn | ()
{
}
}
pub mod user1 {
use super::inline;
//~ MONO_ITEM fn user1::foo @@ local_inlining_but_not_all-user1[External]
pub fn foo() {
inline::inlined_function();
}
}
pub mod user2 {
use super::inline;
//~ MONO_ITEM fn user2::bar @@ local_inlining_but_not_all-user2[External]
pub fn bar() {
inline::inlined_function();
}
}
pub mod non_user {
//~ MONO_ITEM fn non_user::baz @@ local_inlining_but_not_all-non_user[External]
pub fn baz() {
}
}
| inlined_function | identifier_name |
mod.rs | mut [u64] = unsafe { cast::transmute(slice) };
for dest in as_u64.mut_iter() {
*dest = self.next_u64();
}
// the above will have filled up the vector as much as
// possible in multiples of 8 bytes.
let mut remaining = dest.len() % 8;
// space for a u32
if remaining >= 4 {
let mut slice: Slice<u32> = unsafe { cast::transmute_copy(&dest) };
slice.len /= size_of::<u32>();
let as_u32: &mut [u32] = unsafe { cast::transmute(slice) };
as_u32[as_u32.len() - 1] = self.next_u32();
remaining -= 4;
}
// exactly filled
if remaining == 0 { return }
// now we know we've either got 1, 2 or 3 spots to go,
// i.e. exactly one u32 is enough.
let rand = self.next_u32();
let remaining_index = dest.len() - remaining;
match dest.mut_slice_from(remaining_index) {
[ref mut a] => {
*a = rand as u8;
}
[ref mut a, ref mut b] => {
*a = rand as u8;
*b = (rand >> 8) as u8;
}
[ref mut a, ref mut b, ref mut c] => {
*a = rand as u8;
*b = (rand >> 8) as u8;
*c = (rand >> 16) as u8;
}
_ => fail2!("Rng.fill_bytes: the impossible occurred: remaining!= 1, 2 or 3")
}
}
/// Return a random value of a Rand type.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let x: uint = rng.gen();
/// println!("{}", x);
/// println!("{:?}", rng.gen::<(f64, bool)>());
/// }
/// ```
#[inline(always)]
fn gen<T: Rand>(&mut self) -> T {
Rand::rand(self)
}
/// Return a random vector of the specified length.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let x: ~[uint] = rng.gen_vec(10);
/// println!("{:?}", x);
/// println!("{:?}", rng.gen_vec::<(f64, bool)>(5));
/// }
/// ```
fn gen_vec<T: Rand>(&mut self, len: uint) -> ~[T] {
vec::from_fn(len, |_| self.gen())
}
/// Generate a random primitive integer in the range [`low`,
/// `high`). Fails if `low >= high`.
///
/// This gives a uniform distribution (assuming this RNG is itself
/// uniform), even for edge cases like `gen_integer_range(0u8,
/// 170)`, which a naive modulo operation would return numbers
/// less than 85 with double the probability to those greater than
/// 85.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let n: uint = rng.gen_integer_range(0u, 10);
/// println!("{}", n);
/// let m: int = rng.gen_integer_range(-40, 400);
/// println!("{}", m);
/// }
/// ```
fn gen_integer_range<T: Rand + Int>(&mut self, low: T, high: T) -> T {
assert!(low < high, "RNG.gen_integer_range called with low >= high");
let range = (high - low).to_u64().unwrap();
let accept_zone = u64::max_value - u64::max_value % range;
loop {
let rand = self.gen::<u64>();
if rand < accept_zone {
return low + NumCast::from(rand % range).unwrap();
}
}
}
/// Return a bool with a 1 in n chance of true
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// println!("{:b}", rng.gen_weighted_bool(3));
/// }
/// ```
fn | (&mut self, n: uint) -> bool {
n == 0 || self.gen_integer_range(0, n) == 0
}
/// Return a random string of the specified length composed of
/// A-Z,a-z,0-9.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// println(rand::task_rng().gen_ascii_str(10));
/// }
/// ```
fn gen_ascii_str(&mut self, len: uint) -> ~str {
static GEN_ASCII_STR_CHARSET: &'static [u8] = bytes!("ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz\
0123456789");
let mut s = str::with_capacity(len);
for _ in range(0, len) {
s.push_char(self.choose(GEN_ASCII_STR_CHARSET) as char)
}
s
}
/// Choose an item randomly, failing if `values` is empty.
fn choose<T: Clone>(&mut self, values: &[T]) -> T {
self.choose_option(values).expect("Rng.choose: `values` is empty").clone()
}
/// Choose `Some(&item)` randomly, returning `None` if values is
/// empty.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// println!("{:?}", rand::task_rng().choose_option([1,2,4,8,16,32]));
/// println!("{:?}", rand::task_rng().choose_option([]));
/// }
/// ```
fn choose_option<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
if values.is_empty() {
None
} else {
Some(&values[self.gen_integer_range(0u, values.len())])
}
}
/// Choose an item respecting the relative weights, failing if the sum of
/// the weights is 0
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// let x = [rand::Weighted {weight: 4, item: 'a'},
/// rand::Weighted {weight: 2, item: 'b'},
/// rand::Weighted {weight: 2, item: 'c'}];
/// println!("{}", rng.choose_weighted(x));
/// }
/// ```
fn choose_weighted<T:Clone>(&mut self, v: &[Weighted<T>]) -> T {
self.choose_weighted_option(v).expect("Rng.choose_weighted: total weight is 0")
}
/// Choose Some(item) respecting the relative weights, returning none if
/// the sum of the weights is 0
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// let x = [rand::Weighted {weight: 4, item: 'a'},
/// rand::Weighted {weight: 2, item: 'b'},
/// rand::Weighted {weight: 2, item: 'c'}];
/// println!("{:?}", rng.choose_weighted_option(x));
/// }
/// ```
fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
-> Option<T> {
let mut total = 0u;
for item in v.iter() {
total += item.weight;
}
if total == 0u {
return None;
}
let chosen = self.gen_integer_range(0u, total);
let mut so_far = 0u;
for item in v.iter() {
so_far += item.weight;
if so_far > chosen {
return Some(item.item.clone());
}
}
unreachable!();
}
/// Return a vec containing copies of the items, in order, where
/// the weight of the item determines how many copies there are
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// let x = [rand::Weighted {weight: 4, item: 'a'},
/// rand::Weighted {weight: 2, item: 'b'},
/// rand::Weighted {weight: 2, item: 'c'}];
/// println!("{}", rng.weighted_vec(x));
/// }
/// ```
fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T] {
let mut r = ~[];
for item in v.iter() {
for _ in range(0u, item.weight) {
r.push(item.item.clone());
}
}
r
}
/// Shuffle a vec
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// println!("{:?}", rand::task_rng().shuffle(~[1,2,3]));
/// }
/// ```
fn shuffle<T>(&mut self, values: ~[T]) -> ~[T] {
let mut v = values;
self.shuffle_mut(v);
v
}
/// Shuffle a mutable vector in place.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let mut y = [1,2,3];
/// rng.shuffle_mut(y);
/// println!("{:?}", y);
/// rng.shuffle_mut(y);
/// println!("{:?}", y);
/// }
/// ```
fn shuffle_mut<T>(&mut self, values: &mut [T]) {
let mut i = values.len();
while i >= 2u {
// invariant: elements with index >= i have been locked in place.
i -= 1u;
// lock element i in place.
values.swap(i, self.gen_integer_range(0u, i + 1u));
}
}
/// Randomly sample up to `n` elements from an iterator.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let sample = rng.sample(range(1, 100), 5);
/// println!("{:?}", sample);
/// }
/// ```
fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A] {
let mut reservoir : ~[A] = vec::with_capacity(n);
for (i, elem) in iter.enumerate() {
if i < n {
reservoir.push(elem);
continue
}
let k = self.gen_integer_range(0, i + 1);
if k < reservoir.len() {
reservoir[k] = elem
}
}
reservoir
}
}
/// A random number generator that can be explicitly seeded to produce
/// the same stream of randomness multiple times.
pub trait SeedableRng<Seed>: Rng {
/// Reseed an RNG with the given seed.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng: rand::StdRng = rand::SeedableRng::from_seed(&[1, 2, 3, 4]);
/// println!("{}", rng.gen::<f64>());
/// rng.reseed([5, 6, 7, 8]);
/// println!("{}", rng.gen::<f64>());
/// }
/// ```
fn reseed(&mut self, Seed);
/// Create a new RNG with the given seed.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng: rand::StdRng = rand::SeedableRng::from_seed(&[1, 2, 3, 4]);
/// println!("{}", rng.gen::<f64>());
/// }
/// ```
fn from_seed(seed: Seed) -> Self;
}
/// Create a random number generator with a default algorithm and seed.
///
/// It returns the cryptographically-safest `Rng` algorithm currently
/// available in Rust. If you require a specifically seeded `Rng` for
/// consistency over time you should pick one algorithm and create the
/// `Rng` yourself.
///
/// This is a very expensive operation as it has to read randomness
/// from the operating system and use this in an expensive seeding
/// operation. If one does not require high performance generation of
/// random numbers, `task_rng` and/or `random` may be more
/// appropriate.
pub fn rng() -> StdRng {
StdRng::new()
}
/// The standard RNG. This is designed to be efficient on the current
/// platform.
#[cfg(not(target_word_size="64"))]
pub struct StdRng { priv rng: IsaacRng }
/// The standard RNG. This is designed to be efficient on the current
/// platform.
#[cfg(target_word_size="64")]
pub struct StdRng { priv rng: Isaac64Rng }
impl StdRng {
/// Create a randomly seeded instance of `StdRng`. This reads
/// randomness from the OS to seed the PRNG.
#[cfg(not(target_word_size="64"))]
pub fn new() -> StdRng {
StdRng { rng: IsaacRng::new() }
}
/// Create a randomly seeded instance of `StdRng`. This reads
/// randomness from the OS to seed the PRNG.
#[cfg(target_word_size="64")]
pub fn new() -> StdRng {
StdRng { rng: Isaac64Rng::new() }
}
}
impl Rng for StdRng {
#[inline]
fn next_u32(&mut self) -> u32 {
self.rng.next_u32()
}
#[inline]
fn next_u64(&mut self) -> u64 {
self.rng.next_u64()
}
}
impl<'self> SeedableRng<&'self [uint]> for StdRng {
fn reseed(&mut self, seed: &'self [uint]) {
// the internal RNG can just be seeded from the above
// randomness.
self.rng.reseed(unsafe {cast::transmute(seed)})
}
fn from_seed(seed: &'self [uint]) -> StdRng {
StdRng { rng: SeedableRng::from_seed(unsafe {cast::transmute(seed)}) }
}
}
/// Create a weak random number generator with a default algorithm and seed.
///
/// It returns the fastest `Rng` algorithm currently available in Rust without
/// consideration for cryptography or security. If you require a specifically
/// seeded `Rng` for consistency over time you should pick one algorithm and
/// create the `Rng` yourself.
///
/// This will read randomness from the operating system to seed the
/// generator.
pub fn weak_rng() -> XorShiftRng {
XorShiftRng::new()
}
/// An [Xorshift random number
/// generator](http://en.wikipedia.org/wiki/Xorshift).
///
/// The Xorshift algorithm is not suitable for cryptographic purposes
/// but is very fast. If you do not know for sure that it fits your
/// requirements, use a more secure one such as `IsaacRng`.
pub struct XorShiftRng {
priv x: u32,
priv y: u32,
priv z: u32,
priv w: u32,
}
impl Rng for XorShiftRng {
#[inline]
fn next_u32(&mut self) -> u32 {
let x = self.x;
let t = x ^ (x << 11);
self.x = self.y;
self.y = self.z;
self.z = self.w;
let w = self.w;
self.w = w ^ (w >> 19) ^ (t ^ (t >> 8));
self.w
}
}
impl SeedableRng<[u32,.. 4]> for XorShiftRng {
/// Reseed an XorShiftRng. This will fail if `seed` is entirely 0.
fn reseed(&mut self, seed: [u32,.. 4]) {
assert!(!seed.iter().all(|&x| x == 0),
"XorShiftRng.reseed called with an all zero seed.");
self.x = seed[0];
self.y = seed[1];
self.z = seed[2];
self.w = seed[3];
}
/// Create a new XorShiftRng. This will fail if `seed` is entirely 0.
fn from_seed(seed: [u32,.. 4]) -> XorShiftRng {
assert!(!seed.iter().all(|&x| x == 0),
"XorShiftRng::from_seed called with an all zero seed.");
XorShiftRng {
x: seed[0],
y: seed[1],
z: seed[2],
w: seed[3]
}
}
}
impl XorShiftRng {
/// Create an xor shift random number generator with a random seed.
pub fn new() -> XorShiftRng {
let mut s = [0u8,..16];
loop {
let mut r = OSRng::new();
r.fill_bytes(s);
if!s.iter().all(|x| *x == 0) {
break;
}
}
let s: [u32,..4] = unsafe { cast::transmute(s) };
SeedableRng::from_seed(s)
}
}
/// Controls how the task-local RNG is reseeded.
struct TaskRngReseeder;
impl reseeding::Reseeder<StdRng> for TaskRngReseeder {
fn reseed(&mut self, rng: &mut StdRng) {
*rng = StdRng::new();
}
}
static TASK_RNG_RESEED_THRESHOLD: uint = 32_768;
/// The task-local RNG.
pub type TaskRng = reseeding::ReseedingRng<StdRng, TaskRngReseeder>;
// used to make space in TLS for a random number generator
local_data_key!(TASK_RNG_KEY: @mut TaskRng)
/// Retrieve the lazily-initialized task-local random number
/// generator, seeded by the system. Intended to be used in method
/// chaining style, e.g. `task_rng().gen::<int>()`.
///
/// The RNG provided will reseed itself from the operating system
/// after generating a certain amount of randomness.
///
/// The internal RNG used is platform and architecture dependent, even
/// if the operating system random number generator is rigged to give
/// the same sequence always. If absolute consistency is required,
/// explicitly select an RNG, e.g. `IsaacRng` or `Isaac64Rng`.
pub fn task_rng() -> @mut TaskRng {
let r = local_data::get(TASK_RNG_KEY, |k| k.map(|k| *k));
match r {
None => {
let rng = @mut reseeding::ReseedingRng::new(StdRng::new(),
TASK_RNG_RESEED_THRESHOLD,
TaskRngReseeder);
local_data::set(TASK_RNG_KEY, rng);
rng
}
Some(rng) => rng
}
}
// Allow direct chaining with `task_rng`
impl<R: Rng> Rng for @mut R {
#[inline]
fn next_u32(&mut self) -> u32 {
(**self).next_u32()
}
#[inline]
fn next_u64(&mut self) -> u64 {
(**self).next_u64()
}
#[inline]
fn fill_bytes(&mut self, bytes: &mut [u8]) {
(**self).fill_bytes(bytes);
}
}
/// Generate a random value using the task-local random number
/// generator.
///
/// # Example
///
/// ```rust
/// use std::rand::random;
///
/// fn main() {
/// if random() {
/// let x = random();
/// println!("{}", 2u * x);
/// } else {
/// println!("{}", random::<f64>());
/// }
/// }
/// ```
#[inline]
pub fn random<T: Rand>() -> T {
task_rng().gen()
}
#[cfg(test)]
mod test {
use iter::{Iterator, range};
use option::{Option, Some};
use super::*;
#[test]
fn test_fill_bytes_default() {
let mut r = weak_rng();
let mut v = [0u8,.. 100];
r.fill_bytes(v);
}
#[test]
fn test_gen_integer_range() {
let mut r = rng();
for _ in range(0, 1000) {
let a = r.gen_integer_range(-3i, 42);
assert!(a >= -3 && a < 42);
assert_eq!(r.gen_integer_range(0, 1), 0);
assert_eq!(r.gen_integer_range(-12, -11), -12);
}
for _ in range(0, 1000) {
let a = r.gen_integer_range(10, 42); | gen_weighted_bool | identifier_name |
mod.rs |
/// `high`). Fails if `low >= high`.
///
/// This gives a uniform distribution (assuming this RNG is itself
/// uniform), even for edge cases like `gen_integer_range(0u8,
/// 170)`, which a naive modulo operation would return numbers
/// less than 85 with double the probability to those greater than
/// 85.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let n: uint = rng.gen_integer_range(0u, 10);
/// println!("{}", n);
/// let m: int = rng.gen_integer_range(-40, 400);
/// println!("{}", m);
/// }
/// ```
fn gen_integer_range<T: Rand + Int>(&mut self, low: T, high: T) -> T {
assert!(low < high, "RNG.gen_integer_range called with low >= high");
let range = (high - low).to_u64().unwrap();
let accept_zone = u64::max_value - u64::max_value % range;
loop {
let rand = self.gen::<u64>();
if rand < accept_zone {
return low + NumCast::from(rand % range).unwrap();
}
}
}
/// Return a bool with a 1 in n chance of true
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// println!("{:b}", rng.gen_weighted_bool(3));
/// }
/// ```
fn gen_weighted_bool(&mut self, n: uint) -> bool {
n == 0 || self.gen_integer_range(0, n) == 0
}
/// Return a random string of the specified length composed of
/// A-Z,a-z,0-9.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// println(rand::task_rng().gen_ascii_str(10));
/// }
/// ```
fn gen_ascii_str(&mut self, len: uint) -> ~str {
static GEN_ASCII_STR_CHARSET: &'static [u8] = bytes!("ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz\
0123456789");
let mut s = str::with_capacity(len);
for _ in range(0, len) {
s.push_char(self.choose(GEN_ASCII_STR_CHARSET) as char)
}
s
}
/// Choose an item randomly, failing if `values` is empty.
fn choose<T: Clone>(&mut self, values: &[T]) -> T {
self.choose_option(values).expect("Rng.choose: `values` is empty").clone()
}
/// Choose `Some(&item)` randomly, returning `None` if values is
/// empty.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// println!("{:?}", rand::task_rng().choose_option([1,2,4,8,16,32]));
/// println!("{:?}", rand::task_rng().choose_option([]));
/// }
/// ```
fn choose_option<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
if values.is_empty() {
None
} else {
Some(&values[self.gen_integer_range(0u, values.len())])
}
}
/// Choose an item respecting the relative weights, failing if the sum of
/// the weights is 0
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// let x = [rand::Weighted {weight: 4, item: 'a'},
/// rand::Weighted {weight: 2, item: 'b'},
/// rand::Weighted {weight: 2, item: 'c'}];
/// println!("{}", rng.choose_weighted(x));
/// }
/// ```
fn choose_weighted<T:Clone>(&mut self, v: &[Weighted<T>]) -> T {
self.choose_weighted_option(v).expect("Rng.choose_weighted: total weight is 0")
}
/// Choose Some(item) respecting the relative weights, returning none if
/// the sum of the weights is 0
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// let x = [rand::Weighted {weight: 4, item: 'a'},
/// rand::Weighted {weight: 2, item: 'b'},
/// rand::Weighted {weight: 2, item: 'c'}];
/// println!("{:?}", rng.choose_weighted_option(x));
/// }
/// ```
fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
-> Option<T> {
let mut total = 0u;
for item in v.iter() {
total += item.weight;
}
if total == 0u {
return None;
}
let chosen = self.gen_integer_range(0u, total);
let mut so_far = 0u;
for item in v.iter() {
so_far += item.weight;
if so_far > chosen {
return Some(item.item.clone());
}
}
unreachable!();
}
/// Return a vec containing copies of the items, in order, where
/// the weight of the item determines how many copies there are
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// let x = [rand::Weighted {weight: 4, item: 'a'},
/// rand::Weighted {weight: 2, item: 'b'},
/// rand::Weighted {weight: 2, item: 'c'}];
/// println!("{}", rng.weighted_vec(x));
/// }
/// ```
fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T] {
let mut r = ~[];
for item in v.iter() {
for _ in range(0u, item.weight) {
r.push(item.item.clone());
}
}
r
}
/// Shuffle a vec
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// println!("{:?}", rand::task_rng().shuffle(~[1,2,3]));
/// }
/// ```
fn shuffle<T>(&mut self, values: ~[T]) -> ~[T] {
let mut v = values;
self.shuffle_mut(v);
v
}
/// Shuffle a mutable vector in place.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let mut y = [1,2,3];
/// rng.shuffle_mut(y);
/// println!("{:?}", y);
/// rng.shuffle_mut(y);
/// println!("{:?}", y);
/// }
/// ```
fn shuffle_mut<T>(&mut self, values: &mut [T]) {
let mut i = values.len();
while i >= 2u {
// invariant: elements with index >= i have been locked in place.
i -= 1u;
// lock element i in place.
values.swap(i, self.gen_integer_range(0u, i + 1u));
}
}
/// Randomly sample up to `n` elements from an iterator.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let sample = rng.sample(range(1, 100), 5);
/// println!("{:?}", sample);
/// }
/// ```
fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A] {
let mut reservoir : ~[A] = vec::with_capacity(n);
for (i, elem) in iter.enumerate() {
if i < n {
reservoir.push(elem);
continue
}
let k = self.gen_integer_range(0, i + 1);
if k < reservoir.len() {
reservoir[k] = elem
}
}
reservoir
}
}
/// A random number generator that can be explicitly seeded to produce
/// the same stream of randomness multiple times.
pub trait SeedableRng<Seed>: Rng {
/// Reseed an RNG with the given seed.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng: rand::StdRng = rand::SeedableRng::from_seed(&[1, 2, 3, 4]);
/// println!("{}", rng.gen::<f64>());
/// rng.reseed([5, 6, 7, 8]);
/// println!("{}", rng.gen::<f64>());
/// }
/// ```
fn reseed(&mut self, Seed);
/// Create a new RNG with the given seed.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng: rand::StdRng = rand::SeedableRng::from_seed(&[1, 2, 3, 4]);
/// println!("{}", rng.gen::<f64>());
/// }
/// ```
fn from_seed(seed: Seed) -> Self;
}
/// Create a random number generator with a default algorithm and seed.
///
/// It returns the cryptographically-safest `Rng` algorithm currently
/// available in Rust. If you require a specifically seeded `Rng` for
/// consistency over time you should pick one algorithm and create the
/// `Rng` yourself.
///
/// This is a very expensive operation as it has to read randomness
/// from the operating system and use this in an expensive seeding
/// operation. If one does not require high performance generation of
/// random numbers, `task_rng` and/or `random` may be more
/// appropriate.
pub fn rng() -> StdRng {
StdRng::new()
}
/// The standard RNG. This is designed to be efficient on the current
/// platform.
#[cfg(not(target_word_size="64"))]
pub struct StdRng { priv rng: IsaacRng }
/// The standard RNG. This is designed to be efficient on the current
/// platform.
#[cfg(target_word_size="64")]
pub struct StdRng { priv rng: Isaac64Rng }
impl StdRng {
/// Create a randomly seeded instance of `StdRng`. This reads
/// randomness from the OS to seed the PRNG.
#[cfg(not(target_word_size="64"))]
pub fn new() -> StdRng {
StdRng { rng: IsaacRng::new() }
}
/// Create a randomly seeded instance of `StdRng`. This reads
/// randomness from the OS to seed the PRNG.
#[cfg(target_word_size="64")]
pub fn new() -> StdRng {
StdRng { rng: Isaac64Rng::new() }
}
}
impl Rng for StdRng {
#[inline]
fn next_u32(&mut self) -> u32 {
self.rng.next_u32()
}
#[inline]
fn next_u64(&mut self) -> u64 {
self.rng.next_u64()
}
}
impl<'self> SeedableRng<&'self [uint]> for StdRng {
fn reseed(&mut self, seed: &'self [uint]) {
// the internal RNG can just be seeded from the above
// randomness.
self.rng.reseed(unsafe {cast::transmute(seed)})
}
fn from_seed(seed: &'self [uint]) -> StdRng {
StdRng { rng: SeedableRng::from_seed(unsafe {cast::transmute(seed)}) }
}
}
/// Create a weak random number generator with a default algorithm and seed.
///
/// It returns the fastest `Rng` algorithm currently available in Rust without
/// consideration for cryptography or security. If you require a specifically
/// seeded `Rng` for consistency over time you should pick one algorithm and
/// create the `Rng` yourself.
///
/// This will read randomness from the operating system to seed the
/// generator.
pub fn weak_rng() -> XorShiftRng {
XorShiftRng::new()
}
/// An [Xorshift random number
/// generator](http://en.wikipedia.org/wiki/Xorshift).
///
/// The Xorshift algorithm is not suitable for cryptographic purposes
/// but is very fast. If you do not know for sure that it fits your
/// requirements, use a more secure one such as `IsaacRng`.
pub struct XorShiftRng {
priv x: u32,
priv y: u32,
priv z: u32,
priv w: u32,
}
impl Rng for XorShiftRng {
#[inline]
fn next_u32(&mut self) -> u32 {
let x = self.x;
let t = x ^ (x << 11);
self.x = self.y;
self.y = self.z;
self.z = self.w;
let w = self.w;
self.w = w ^ (w >> 19) ^ (t ^ (t >> 8));
self.w
}
}
impl SeedableRng<[u32,.. 4]> for XorShiftRng {
/// Reseed an XorShiftRng. This will fail if `seed` is entirely 0.
fn reseed(&mut self, seed: [u32,.. 4]) {
assert!(!seed.iter().all(|&x| x == 0),
"XorShiftRng.reseed called with an all zero seed.");
self.x = seed[0];
self.y = seed[1];
self.z = seed[2];
self.w = seed[3];
}
/// Create a new XorShiftRng. This will fail if `seed` is entirely 0.
fn from_seed(seed: [u32,.. 4]) -> XorShiftRng {
assert!(!seed.iter().all(|&x| x == 0),
"XorShiftRng::from_seed called with an all zero seed.");
XorShiftRng {
x: seed[0],
y: seed[1],
z: seed[2],
w: seed[3]
}
}
}
impl XorShiftRng {
/// Create an xor shift random number generator with a random seed.
pub fn new() -> XorShiftRng {
let mut s = [0u8,..16];
loop {
let mut r = OSRng::new();
r.fill_bytes(s);
if!s.iter().all(|x| *x == 0) {
break;
}
}
let s: [u32,..4] = unsafe { cast::transmute(s) };
SeedableRng::from_seed(s)
}
}
/// Controls how the task-local RNG is reseeded.
struct TaskRngReseeder;
impl reseeding::Reseeder<StdRng> for TaskRngReseeder {
fn reseed(&mut self, rng: &mut StdRng) {
*rng = StdRng::new();
}
}
static TASK_RNG_RESEED_THRESHOLD: uint = 32_768;
/// The task-local RNG.
pub type TaskRng = reseeding::ReseedingRng<StdRng, TaskRngReseeder>;
// used to make space in TLS for a random number generator
local_data_key!(TASK_RNG_KEY: @mut TaskRng)
/// Retrieve the lazily-initialized task-local random number
/// generator, seeded by the system. Intended to be used in method
/// chaining style, e.g. `task_rng().gen::<int>()`.
///
/// The RNG provided will reseed itself from the operating system
/// after generating a certain amount of randomness.
///
/// The internal RNG used is platform and architecture dependent, even
/// if the operating system random number generator is rigged to give
/// the same sequence always. If absolute consistency is required,
/// explicitly select an RNG, e.g. `IsaacRng` or `Isaac64Rng`.
pub fn task_rng() -> @mut TaskRng {
let r = local_data::get(TASK_RNG_KEY, |k| k.map(|k| *k));
match r {
None => {
let rng = @mut reseeding::ReseedingRng::new(StdRng::new(),
TASK_RNG_RESEED_THRESHOLD,
TaskRngReseeder);
local_data::set(TASK_RNG_KEY, rng);
rng
}
Some(rng) => rng
}
}
// Allow direct chaining with `task_rng`
impl<R: Rng> Rng for @mut R {
#[inline]
fn next_u32(&mut self) -> u32 {
(**self).next_u32()
}
#[inline]
fn next_u64(&mut self) -> u64 {
(**self).next_u64()
}
#[inline]
fn fill_bytes(&mut self, bytes: &mut [u8]) {
(**self).fill_bytes(bytes);
}
}
/// Generate a random value using the task-local random number
/// generator.
///
/// # Example
///
/// ```rust
/// use std::rand::random;
///
/// fn main() {
/// if random() {
/// let x = random();
/// println!("{}", 2u * x);
/// } else {
/// println!("{}", random::<f64>());
/// }
/// }
/// ```
#[inline]
pub fn random<T: Rand>() -> T {
task_rng().gen()
}
#[cfg(test)]
mod test {
use iter::{Iterator, range};
use option::{Option, Some};
use super::*;
#[test]
fn test_fill_bytes_default() {
let mut r = weak_rng();
let mut v = [0u8,.. 100];
r.fill_bytes(v);
}
#[test]
fn test_gen_integer_range() {
let mut r = rng();
for _ in range(0, 1000) {
let a = r.gen_integer_range(-3i, 42);
assert!(a >= -3 && a < 42);
assert_eq!(r.gen_integer_range(0, 1), 0);
assert_eq!(r.gen_integer_range(-12, -11), -12);
}
for _ in range(0, 1000) {
let a = r.gen_integer_range(10, 42);
assert!(a >= 10 && a < 42);
assert_eq!(r.gen_integer_range(0, 1), 0);
assert_eq!(r.gen_integer_range(3_000_000u, 3_000_001), 3_000_000);
}
}
#[test]
#[should_fail]
fn test_gen_integer_range_fail_int() {
let mut r = rng();
r.gen_integer_range(5i, -2);
}
#[test]
#[should_fail]
fn test_gen_integer_range_fail_uint() {
let mut r = rng();
r.gen_integer_range(5u, 2u);
}
#[test]
fn test_gen_f64() {
let mut r = rng();
let a = r.gen::<f64>();
let b = r.gen::<f64>();
debug2!("{:?}", (a, b));
}
#[test]
fn test_gen_weighted_bool() {
let mut r = rng();
assert_eq!(r.gen_weighted_bool(0u), true);
assert_eq!(r.gen_weighted_bool(1u), true);
}
#[test]
fn test_gen_ascii_str() {
let mut r = rng();
debug2!("{}", r.gen_ascii_str(10u));
debug2!("{}", r.gen_ascii_str(10u));
debug2!("{}", r.gen_ascii_str(10u));
assert_eq!(r.gen_ascii_str(0u).len(), 0u);
assert_eq!(r.gen_ascii_str(10u).len(), 10u);
assert_eq!(r.gen_ascii_str(16u).len(), 16u);
}
#[test]
fn test_gen_vec() {
let mut r = rng();
assert_eq!(r.gen_vec::<u8>(0u).len(), 0u);
assert_eq!(r.gen_vec::<u8>(10u).len(), 10u);
assert_eq!(r.gen_vec::<f64>(16u).len(), 16u);
}
#[test]
fn test_choose() {
let mut r = rng();
assert_eq!(r.choose([1, 1, 1]), 1);
}
#[test]
fn test_choose_option() {
let mut r = rng();
let v: &[int] = &[];
assert!(r.choose_option(v).is_none());
let i = 1;
let v = [1,1,1];
assert_eq!(r.choose_option(v), Some(&i));
}
#[test]
fn test_choose_weighted() {
let mut r = rng();
assert!(r.choose_weighted([
Weighted { weight: 1u, item: 42 },
]) == 42);
assert!(r.choose_weighted([
Weighted { weight: 0u, item: 42 },
Weighted { weight: 1u, item: 43 },
]) == 43); | random_line_split |
||
mod.rs | mut [u64] = unsafe { cast::transmute(slice) };
for dest in as_u64.mut_iter() {
*dest = self.next_u64();
}
// the above will have filled up the vector as much as
// possible in multiples of 8 bytes.
let mut remaining = dest.len() % 8;
// space for a u32
if remaining >= 4 {
let mut slice: Slice<u32> = unsafe { cast::transmute_copy(&dest) };
slice.len /= size_of::<u32>();
let as_u32: &mut [u32] = unsafe { cast::transmute(slice) };
as_u32[as_u32.len() - 1] = self.next_u32();
remaining -= 4;
}
// exactly filled
if remaining == 0 { return }
// now we know we've either got 1, 2 or 3 spots to go,
// i.e. exactly one u32 is enough.
let rand = self.next_u32();
let remaining_index = dest.len() - remaining;
match dest.mut_slice_from(remaining_index) {
[ref mut a] => {
*a = rand as u8;
}
[ref mut a, ref mut b] => {
*a = rand as u8;
*b = (rand >> 8) as u8;
}
[ref mut a, ref mut b, ref mut c] => {
*a = rand as u8;
*b = (rand >> 8) as u8;
*c = (rand >> 16) as u8;
}
_ => fail2!("Rng.fill_bytes: the impossible occurred: remaining!= 1, 2 or 3")
}
}
/// Return a random value of a Rand type.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let x: uint = rng.gen();
/// println!("{}", x);
/// println!("{:?}", rng.gen::<(f64, bool)>());
/// }
/// ```
#[inline(always)]
fn gen<T: Rand>(&mut self) -> T {
Rand::rand(self)
}
/// Return a random vector of the specified length.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let x: ~[uint] = rng.gen_vec(10);
/// println!("{:?}", x);
/// println!("{:?}", rng.gen_vec::<(f64, bool)>(5));
/// }
/// ```
fn gen_vec<T: Rand>(&mut self, len: uint) -> ~[T] {
vec::from_fn(len, |_| self.gen())
}
/// Generate a random primitive integer in the range [`low`,
/// `high`). Fails if `low >= high`.
///
/// This gives a uniform distribution (assuming this RNG is itself
/// uniform), even for edge cases like `gen_integer_range(0u8,
/// 170)`, which a naive modulo operation would return numbers
/// less than 85 with double the probability to those greater than
/// 85.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let n: uint = rng.gen_integer_range(0u, 10);
/// println!("{}", n);
/// let m: int = rng.gen_integer_range(-40, 400);
/// println!("{}", m);
/// }
/// ```
fn gen_integer_range<T: Rand + Int>(&mut self, low: T, high: T) -> T {
assert!(low < high, "RNG.gen_integer_range called with low >= high");
let range = (high - low).to_u64().unwrap();
let accept_zone = u64::max_value - u64::max_value % range;
loop {
let rand = self.gen::<u64>();
if rand < accept_zone {
return low + NumCast::from(rand % range).unwrap();
}
}
}
/// Return a bool with a 1 in n chance of true
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// println!("{:b}", rng.gen_weighted_bool(3));
/// }
/// ```
fn gen_weighted_bool(&mut self, n: uint) -> bool {
n == 0 || self.gen_integer_range(0, n) == 0
}
/// Return a random string of the specified length composed of
/// A-Z,a-z,0-9.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// println(rand::task_rng().gen_ascii_str(10));
/// }
/// ```
fn gen_ascii_str(&mut self, len: uint) -> ~str {
static GEN_ASCII_STR_CHARSET: &'static [u8] = bytes!("ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz\
0123456789");
let mut s = str::with_capacity(len);
for _ in range(0, len) {
s.push_char(self.choose(GEN_ASCII_STR_CHARSET) as char)
}
s
}
/// Choose an item randomly, failing if `values` is empty.
fn choose<T: Clone>(&mut self, values: &[T]) -> T {
self.choose_option(values).expect("Rng.choose: `values` is empty").clone()
}
/// Choose `Some(&item)` randomly, returning `None` if values is
/// empty.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// println!("{:?}", rand::task_rng().choose_option([1,2,4,8,16,32]));
/// println!("{:?}", rand::task_rng().choose_option([]));
/// }
/// ```
fn choose_option<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
if values.is_empty() {
None
} else {
Some(&values[self.gen_integer_range(0u, values.len())])
}
}
/// Choose an item respecting the relative weights, failing if the sum of
/// the weights is 0
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// let x = [rand::Weighted {weight: 4, item: 'a'},
/// rand::Weighted {weight: 2, item: 'b'},
/// rand::Weighted {weight: 2, item: 'c'}];
/// println!("{}", rng.choose_weighted(x));
/// }
/// ```
fn choose_weighted<T:Clone>(&mut self, v: &[Weighted<T>]) -> T {
self.choose_weighted_option(v).expect("Rng.choose_weighted: total weight is 0")
}
/// Choose Some(item) respecting the relative weights, returning none if
/// the sum of the weights is 0
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// let x = [rand::Weighted {weight: 4, item: 'a'},
/// rand::Weighted {weight: 2, item: 'b'},
/// rand::Weighted {weight: 2, item: 'c'}];
/// println!("{:?}", rng.choose_weighted_option(x));
/// }
/// ```
fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
-> Option<T> {
let mut total = 0u;
for item in v.iter() {
total += item.weight;
}
if total == 0u {
return None;
}
let chosen = self.gen_integer_range(0u, total);
let mut so_far = 0u;
for item in v.iter() {
so_far += item.weight;
if so_far > chosen {
return Some(item.item.clone());
}
}
unreachable!();
}
/// Return a vec containing copies of the items, in order, where
/// the weight of the item determines how many copies there are
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::rng();
/// let x = [rand::Weighted {weight: 4, item: 'a'},
/// rand::Weighted {weight: 2, item: 'b'},
/// rand::Weighted {weight: 2, item: 'c'}];
/// println!("{}", rng.weighted_vec(x));
/// }
/// ```
fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T] {
let mut r = ~[];
for item in v.iter() {
for _ in range(0u, item.weight) {
r.push(item.item.clone());
}
}
r
}
/// Shuffle a vec
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// println!("{:?}", rand::task_rng().shuffle(~[1,2,3]));
/// }
/// ```
fn shuffle<T>(&mut self, values: ~[T]) -> ~[T] {
let mut v = values;
self.shuffle_mut(v);
v
}
/// Shuffle a mutable vector in place.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let mut y = [1,2,3];
/// rng.shuffle_mut(y);
/// println!("{:?}", y);
/// rng.shuffle_mut(y);
/// println!("{:?}", y);
/// }
/// ```
fn shuffle_mut<T>(&mut self, values: &mut [T]) {
let mut i = values.len();
while i >= 2u {
// invariant: elements with index >= i have been locked in place.
i -= 1u;
// lock element i in place.
values.swap(i, self.gen_integer_range(0u, i + 1u));
}
}
/// Randomly sample up to `n` elements from an iterator.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng = rand::task_rng();
/// let sample = rng.sample(range(1, 100), 5);
/// println!("{:?}", sample);
/// }
/// ```
fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A] {
let mut reservoir : ~[A] = vec::with_capacity(n);
for (i, elem) in iter.enumerate() {
if i < n {
reservoir.push(elem);
continue
}
let k = self.gen_integer_range(0, i + 1);
if k < reservoir.len() {
reservoir[k] = elem
}
}
reservoir
}
}
/// A random number generator that can be explicitly seeded to produce
/// the same stream of randomness multiple times.
pub trait SeedableRng<Seed>: Rng {
/// Reseed an RNG with the given seed.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng: rand::StdRng = rand::SeedableRng::from_seed(&[1, 2, 3, 4]);
/// println!("{}", rng.gen::<f64>());
/// rng.reseed([5, 6, 7, 8]);
/// println!("{}", rng.gen::<f64>());
/// }
/// ```
fn reseed(&mut self, Seed);
/// Create a new RNG with the given seed.
///
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::Rng;
///
/// fn main() {
/// let mut rng: rand::StdRng = rand::SeedableRng::from_seed(&[1, 2, 3, 4]);
/// println!("{}", rng.gen::<f64>());
/// }
/// ```
fn from_seed(seed: Seed) -> Self;
}
/// Create a random number generator with a default algorithm and seed.
///
/// It returns the cryptographically-safest `Rng` algorithm currently
/// available in Rust. If you require a specifically seeded `Rng` for
/// consistency over time you should pick one algorithm and create the
/// `Rng` yourself.
///
/// This is a very expensive operation as it has to read randomness
/// from the operating system and use this in an expensive seeding
/// operation. If one does not require high performance generation of
/// random numbers, `task_rng` and/or `random` may be more
/// appropriate.
pub fn rng() -> StdRng {
StdRng::new()
}
/// The standard RNG. This is designed to be efficient on the current
/// platform.
#[cfg(not(target_word_size="64"))]
pub struct StdRng { priv rng: IsaacRng }
/// The standard RNG. This is designed to be efficient on the current
/// platform.
#[cfg(target_word_size="64")]
pub struct StdRng { priv rng: Isaac64Rng }
impl StdRng {
/// Create a randomly seeded instance of `StdRng`. This reads
/// randomness from the OS to seed the PRNG.
#[cfg(not(target_word_size="64"))]
pub fn new() -> StdRng {
StdRng { rng: IsaacRng::new() }
}
/// Create a randomly seeded instance of `StdRng`. This reads
/// randomness from the OS to seed the PRNG.
#[cfg(target_word_size="64")]
pub fn new() -> StdRng {
StdRng { rng: Isaac64Rng::new() }
}
}
impl Rng for StdRng {
#[inline]
fn next_u32(&mut self) -> u32 {
self.rng.next_u32()
}
#[inline]
fn next_u64(&mut self) -> u64 {
self.rng.next_u64()
}
}
impl<'self> SeedableRng<&'self [uint]> for StdRng {
fn reseed(&mut self, seed: &'self [uint]) {
// the internal RNG can just be seeded from the above
// randomness.
self.rng.reseed(unsafe {cast::transmute(seed)})
}
fn from_seed(seed: &'self [uint]) -> StdRng {
StdRng { rng: SeedableRng::from_seed(unsafe {cast::transmute(seed)}) }
}
}
/// Create a weak random number generator with a default algorithm and seed.
///
/// It returns the fastest `Rng` algorithm currently available in Rust without
/// consideration for cryptography or security. If you require a specifically
/// seeded `Rng` for consistency over time you should pick one algorithm and
/// create the `Rng` yourself.
///
/// This will read randomness from the operating system to seed the
/// generator.
pub fn weak_rng() -> XorShiftRng |
/// An [Xorshift random number
/// generator](http://en.wikipedia.org/wiki/Xorshift).
///
/// The Xorshift algorithm is not suitable for cryptographic purposes
/// but is very fast. If you do not know for sure that it fits your
/// requirements, use a more secure one such as `IsaacRng`.
pub struct XorShiftRng {
priv x: u32,
priv y: u32,
priv z: u32,
priv w: u32,
}
impl Rng for XorShiftRng {
#[inline]
fn next_u32(&mut self) -> u32 {
let x = self.x;
let t = x ^ (x << 11);
self.x = self.y;
self.y = self.z;
self.z = self.w;
let w = self.w;
self.w = w ^ (w >> 19) ^ (t ^ (t >> 8));
self.w
}
}
impl SeedableRng<[u32,.. 4]> for XorShiftRng {
/// Reseed an XorShiftRng. This will fail if `seed` is entirely 0.
fn reseed(&mut self, seed: [u32,.. 4]) {
assert!(!seed.iter().all(|&x| x == 0),
"XorShiftRng.reseed called with an all zero seed.");
self.x = seed[0];
self.y = seed[1];
self.z = seed[2];
self.w = seed[3];
}
/// Create a new XorShiftRng. This will fail if `seed` is entirely 0.
fn from_seed(seed: [u32,.. 4]) -> XorShiftRng {
assert!(!seed.iter().all(|&x| x == 0),
"XorShiftRng::from_seed called with an all zero seed.");
XorShiftRng {
x: seed[0],
y: seed[1],
z: seed[2],
w: seed[3]
}
}
}
impl XorShiftRng {
/// Create an xor shift random number generator with a random seed.
pub fn new() -> XorShiftRng {
let mut s = [0u8,..16];
loop {
let mut r = OSRng::new();
r.fill_bytes(s);
if!s.iter().all(|x| *x == 0) {
break;
}
}
let s: [u32,..4] = unsafe { cast::transmute(s) };
SeedableRng::from_seed(s)
}
}
/// Controls how the task-local RNG is reseeded.
struct TaskRngReseeder;
impl reseeding::Reseeder<StdRng> for TaskRngReseeder {
fn reseed(&mut self, rng: &mut StdRng) {
*rng = StdRng::new();
}
}
static TASK_RNG_RESEED_THRESHOLD: uint = 32_768;
/// The task-local RNG.
pub type TaskRng = reseeding::ReseedingRng<StdRng, TaskRngReseeder>;
// used to make space in TLS for a random number generator
local_data_key!(TASK_RNG_KEY: @mut TaskRng)
/// Retrieve the lazily-initialized task-local random number
/// generator, seeded by the system. Intended to be used in method
/// chaining style, e.g. `task_rng().gen::<int>()`.
///
/// The RNG provided will reseed itself from the operating system
/// after generating a certain amount of randomness.
///
/// The internal RNG used is platform and architecture dependent, even
/// if the operating system random number generator is rigged to give
/// the same sequence always. If absolute consistency is required,
/// explicitly select an RNG, e.g. `IsaacRng` or `Isaac64Rng`.
pub fn task_rng() -> @mut TaskRng {
let r = local_data::get(TASK_RNG_KEY, |k| k.map(|k| *k));
match r {
None => {
let rng = @mut reseeding::ReseedingRng::new(StdRng::new(),
TASK_RNG_RESEED_THRESHOLD,
TaskRngReseeder);
local_data::set(TASK_RNG_KEY, rng);
rng
}
Some(rng) => rng
}
}
// Allow direct chaining with `task_rng`
impl<R: Rng> Rng for @mut R {
#[inline]
fn next_u32(&mut self) -> u32 {
(**self).next_u32()
}
#[inline]
fn next_u64(&mut self) -> u64 {
(**self).next_u64()
}
#[inline]
fn fill_bytes(&mut self, bytes: &mut [u8]) {
(**self).fill_bytes(bytes);
}
}
/// Generate a random value using the task-local random number
/// generator.
///
/// # Example
///
/// ```rust
/// use std::rand::random;
///
/// fn main() {
/// if random() {
/// let x = random();
/// println!("{}", 2u * x);
/// } else {
/// println!("{}", random::<f64>());
/// }
/// }
/// ```
#[inline]
pub fn random<T: Rand>() -> T {
task_rng().gen()
}
#[cfg(test)]
mod test {
use iter::{Iterator, range};
use option::{Option, Some};
use super::*;
#[test]
fn test_fill_bytes_default() {
let mut r = weak_rng();
let mut v = [0u8,.. 100];
r.fill_bytes(v);
}
#[test]
fn test_gen_integer_range() {
let mut r = rng();
for _ in range(0, 1000) {
let a = r.gen_integer_range(-3i, 42);
assert!(a >= -3 && a < 42);
assert_eq!(r.gen_integer_range(0, 1), 0);
assert_eq!(r.gen_integer_range(-12, -11), -12);
}
for _ in range(0, 1000) {
let a = r.gen_integer_range(10, 42); | {
XorShiftRng::new()
} | identifier_body |
example.rs | pub fn verse(n: i32) -> String {
match n {
0 => "No more bottles of beer on the wall, no more bottles of beer.\n\
Go to the store and buy some more, 99 bottles of beer on the wall.\n".to_string(),
1 => "1 bottle of beer on the wall, 1 bottle of beer.\n\
Take it down and pass it around, no more bottles of beer on the wall.\n".to_string(),
2 => "2 bottles of beer on the wall, 2 bottles of beer.\n\
Take one down and pass it around, 1 bottle of beer on the wall.\n".to_string(),
n if n > 2 && n <= 99 =>
format!(
"{n} bottles of beer on the wall, {n} bottles of beer.\n\
Take one down and pass it around, {n_minus_1} bottles of beer on the wall.\n",
n=n,
n_minus_1=n - 1),
_ =>
panic!(), | pub fn sing(start: i32, end: i32) -> String {
let mut song = Vec::new();
for n in (end.. start + 1).rev() {
song.push(verse(n))
}
song.connect("\n")
} | }
}
| random_line_split |
example.rs | pub fn verse(n: i32) -> String |
pub fn sing(start: i32, end: i32) -> String {
let mut song = Vec::new();
for n in (end.. start + 1).rev() {
song.push(verse(n))
}
song.connect("\n")
}
| {
match n {
0 => "No more bottles of beer on the wall, no more bottles of beer.\n\
Go to the store and buy some more, 99 bottles of beer on the wall.\n".to_string(),
1 => "1 bottle of beer on the wall, 1 bottle of beer.\n\
Take it down and pass it around, no more bottles of beer on the wall.\n".to_string(),
2 => "2 bottles of beer on the wall, 2 bottles of beer.\n\
Take one down and pass it around, 1 bottle of beer on the wall.\n".to_string(),
n if n > 2 && n <= 99 =>
format!(
"{n} bottles of beer on the wall, {n} bottles of beer.\n\
Take one down and pass it around, {n_minus_1} bottles of beer on the wall.\n",
n=n,
n_minus_1=n - 1),
_ =>
panic!(),
}
} | identifier_body |
example.rs | pub fn | (n: i32) -> String {
match n {
0 => "No more bottles of beer on the wall, no more bottles of beer.\n\
Go to the store and buy some more, 99 bottles of beer on the wall.\n".to_string(),
1 => "1 bottle of beer on the wall, 1 bottle of beer.\n\
Take it down and pass it around, no more bottles of beer on the wall.\n".to_string(),
2 => "2 bottles of beer on the wall, 2 bottles of beer.\n\
Take one down and pass it around, 1 bottle of beer on the wall.\n".to_string(),
n if n > 2 && n <= 99 =>
format!(
"{n} bottles of beer on the wall, {n} bottles of beer.\n\
Take one down and pass it around, {n_minus_1} bottles of beer on the wall.\n",
n=n,
n_minus_1=n - 1),
_ =>
panic!(),
}
}
pub fn sing(start: i32, end: i32) -> String {
let mut song = Vec::new();
for n in (end.. start + 1).rev() {
song.push(verse(n))
}
song.connect("\n")
}
| verse | identifier_name |
unboxed-closures-blanket-fn-mut.rs | // Copyright 2014 The Rust Project Developers. See the COPYRIGHT | // http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// run-pass
#![allow(unused_variables)]
// Test that you can supply `&F` where `F: FnMut()`.
#![feature(lang_items)]
fn a<F:FnMut() -> i32>(mut f: F) -> i32 {
f()
}
fn b(f: &mut FnMut() -> i32) -> i32 {
a(f)
}
fn c<F:FnMut() -> i32>(f: &mut F) -> i32 {
a(f)
}
fn main() {
let z: isize = 7;
let x = b(&mut || 22);
assert_eq!(x, 22);
let x = c(&mut || 22);
assert_eq!(x, 22);
} | // file at the top-level directory of this distribution and at | random_line_split |
unboxed-closures-blanket-fn-mut.rs | // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// run-pass
#![allow(unused_variables)]
// Test that you can supply `&F` where `F: FnMut()`.
#![feature(lang_items)]
fn a<F:FnMut() -> i32>(mut f: F) -> i32 |
fn b(f: &mut FnMut() -> i32) -> i32 {
a(f)
}
fn c<F:FnMut() -> i32>(f: &mut F) -> i32 {
a(f)
}
fn main() {
let z: isize = 7;
let x = b(&mut || 22);
assert_eq!(x, 22);
let x = c(&mut || 22);
assert_eq!(x, 22);
}
| {
f()
} | identifier_body |
unboxed-closures-blanket-fn-mut.rs | // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// run-pass
#![allow(unused_variables)]
// Test that you can supply `&F` where `F: FnMut()`.
#![feature(lang_items)]
fn a<F:FnMut() -> i32>(mut f: F) -> i32 {
f()
}
fn | (f: &mut FnMut() -> i32) -> i32 {
a(f)
}
fn c<F:FnMut() -> i32>(f: &mut F) -> i32 {
a(f)
}
fn main() {
let z: isize = 7;
let x = b(&mut || 22);
assert_eq!(x, 22);
let x = c(&mut || 22);
assert_eq!(x, 22);
}
| b | identifier_name |
simd.rs | // Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// ignore-android: FIXME(#10381)
// compile-flags:-g
// debugger:rbreak zzz
// debugger:run
// debugger:finish
// debugger:print/d i8x16
// check:$1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
// debugger:print/d i16x8
// check:$2 = {16, 17, 18, 19, 20, 21, 22, 23}
// debugger:print/d i32x4
// check:$3 = {24, 25, 26, 27}
// debugger:print/d i64x2
// check:$4 = {28, 29}
// debugger:print/d u8x16
// check:$5 = {30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45}
// debugger:print/d u16x8
// check:$6 = {46, 47, 48, 49, 50, 51, 52, 53}
// debugger:print/d u32x4
// check:$7 = {54, 55, 56, 57}
// debugger:print/d u64x2
// check:$8 = {58, 59}
// debugger:print f32x4
// check:$9 = {60.5, 61.5, 62.5, 63.5}
// debugger:print f64x2
// check:$10 = {64.5, 65.5}
// debugger:continue
#![allow(experimental)]
#![allow(unused_variable)]
use std::unstable::simd::{i8x16, i16x8,i32x4,i64x2,u8x16,u16x8,u32x4,u64x2,f32x4,f64x2};
fn main() {
let i8x16 = i8x16(0i8, 1i8, 2i8, 3i8, 4i8, 5i8, 6i8, 7i8,
8i8, 9i8, 10i8, 11i8, 12i8, 13i8, 14i8, 15i8);
let i16x8 = i16x8(16i16, 17i16, 18i16, 19i16, 20i16, 21i16, 22i16, 23i16);
let i32x4 = i32x4(24i32, 25i32, 26i32, 27i32);
let i64x2 = i64x2(28i64, 29i64);
let u8x16 = u8x16(30u8, 31u8, 32u8, 33u8, 34u8, 35u8, 36u8, 37u8,
38u8, 39u8, 40u8, 41u8, 42u8, 43u8, 44u8, 45u8);
let u16x8 = u16x8(46u16, 47u16, 48u16, 49u16, 50u16, 51u16, 52u16, 53u16);
let u32x4 = u32x4(54u32, 55u32, 56u32, 57u32);
let u64x2 = u64x2(58u64, 59u64);
let f32x4 = f32x4(60.5f32, 61.5f32, 62.5f32, 63.5f32);
let f64x2 = f64x2(64.5f64, 65.5f64); |
#[inline(never)]
fn zzz() { () } |
zzz();
} | random_line_split |
simd.rs | // Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// ignore-android: FIXME(#10381)
// compile-flags:-g
// debugger:rbreak zzz
// debugger:run
// debugger:finish
// debugger:print/d i8x16
// check:$1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
// debugger:print/d i16x8
// check:$2 = {16, 17, 18, 19, 20, 21, 22, 23}
// debugger:print/d i32x4
// check:$3 = {24, 25, 26, 27}
// debugger:print/d i64x2
// check:$4 = {28, 29}
// debugger:print/d u8x16
// check:$5 = {30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45}
// debugger:print/d u16x8
// check:$6 = {46, 47, 48, 49, 50, 51, 52, 53}
// debugger:print/d u32x4
// check:$7 = {54, 55, 56, 57}
// debugger:print/d u64x2
// check:$8 = {58, 59}
// debugger:print f32x4
// check:$9 = {60.5, 61.5, 62.5, 63.5}
// debugger:print f64x2
// check:$10 = {64.5, 65.5}
// debugger:continue
#![allow(experimental)]
#![allow(unused_variable)]
use std::unstable::simd::{i8x16, i16x8,i32x4,i64x2,u8x16,u16x8,u32x4,u64x2,f32x4,f64x2};
fn main() {
let i8x16 = i8x16(0i8, 1i8, 2i8, 3i8, 4i8, 5i8, 6i8, 7i8,
8i8, 9i8, 10i8, 11i8, 12i8, 13i8, 14i8, 15i8);
let i16x8 = i16x8(16i16, 17i16, 18i16, 19i16, 20i16, 21i16, 22i16, 23i16);
let i32x4 = i32x4(24i32, 25i32, 26i32, 27i32);
let i64x2 = i64x2(28i64, 29i64);
let u8x16 = u8x16(30u8, 31u8, 32u8, 33u8, 34u8, 35u8, 36u8, 37u8,
38u8, 39u8, 40u8, 41u8, 42u8, 43u8, 44u8, 45u8);
let u16x8 = u16x8(46u16, 47u16, 48u16, 49u16, 50u16, 51u16, 52u16, 53u16);
let u32x4 = u32x4(54u32, 55u32, 56u32, 57u32);
let u64x2 = u64x2(58u64, 59u64);
let f32x4 = f32x4(60.5f32, 61.5f32, 62.5f32, 63.5f32);
let f64x2 = f64x2(64.5f64, 65.5f64);
zzz();
}
#[inline(never)]
fn | () { () }
| zzz | identifier_name |
simd.rs | // Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// ignore-android: FIXME(#10381)
// compile-flags:-g
// debugger:rbreak zzz
// debugger:run
// debugger:finish
// debugger:print/d i8x16
// check:$1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
// debugger:print/d i16x8
// check:$2 = {16, 17, 18, 19, 20, 21, 22, 23}
// debugger:print/d i32x4
// check:$3 = {24, 25, 26, 27}
// debugger:print/d i64x2
// check:$4 = {28, 29}
// debugger:print/d u8x16
// check:$5 = {30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45}
// debugger:print/d u16x8
// check:$6 = {46, 47, 48, 49, 50, 51, 52, 53}
// debugger:print/d u32x4
// check:$7 = {54, 55, 56, 57}
// debugger:print/d u64x2
// check:$8 = {58, 59}
// debugger:print f32x4
// check:$9 = {60.5, 61.5, 62.5, 63.5}
// debugger:print f64x2
// check:$10 = {64.5, 65.5}
// debugger:continue
#![allow(experimental)]
#![allow(unused_variable)]
use std::unstable::simd::{i8x16, i16x8,i32x4,i64x2,u8x16,u16x8,u32x4,u64x2,f32x4,f64x2};
fn main() |
#[inline(never)]
fn zzz() { () }
| {
let i8x16 = i8x16(0i8, 1i8, 2i8, 3i8, 4i8, 5i8, 6i8, 7i8,
8i8, 9i8, 10i8, 11i8, 12i8, 13i8, 14i8, 15i8);
let i16x8 = i16x8(16i16, 17i16, 18i16, 19i16, 20i16, 21i16, 22i16, 23i16);
let i32x4 = i32x4(24i32, 25i32, 26i32, 27i32);
let i64x2 = i64x2(28i64, 29i64);
let u8x16 = u8x16(30u8, 31u8, 32u8, 33u8, 34u8, 35u8, 36u8, 37u8,
38u8, 39u8, 40u8, 41u8, 42u8, 43u8, 44u8, 45u8);
let u16x8 = u16x8(46u16, 47u16, 48u16, 49u16, 50u16, 51u16, 52u16, 53u16);
let u32x4 = u32x4(54u32, 55u32, 56u32, 57u32);
let u64x2 = u64x2(58u64, 59u64);
let f32x4 = f32x4(60.5f32, 61.5f32, 62.5f32, 63.5f32);
let f64x2 = f64x2(64.5f64, 65.5f64);
zzz();
} | identifier_body |
wal.rs | // CITA
// Copyright 2016-2017 Cryptape Technologies LLC.
// This program is free software: you can redistribute it
// and/or modify it under the terms of the GNU General Public
// License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any
// later version.
// This program is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
use std::ffi::OsString;
use std::fs::{File, read_dir, OpenOptions, DirBuilder};
use std::io;
use std::io::{Write, Read, Seek};
use std::mem::transmute; | use std::str;
pub struct Wal {
fs: File,
dir: String,
}
impl Wal {
pub fn new(dir: &str) -> Result<Wal, io::Error> {
let mut tmp = OsString::new();
let mut big_path = PathBuf::new();
let mut fss = read_dir(&dir);
if fss.is_err() {
DirBuilder::new().recursive(true).create(dir).unwrap();
fss = read_dir(&dir);
}
let mut fnum = 0;
for dir_entry in fss? {
let entry = dir_entry?;
let epath = entry.path();
if let Some(fname) = epath.clone().file_stem() {
if tmp.len() < fname.len() || (tmp.len() == fname.len() && tmp.as_os_str() < fname) {
tmp = fname.to_os_string();
big_path = epath;
fnum += 1;
}
}
}
if fnum == 0 {
tmp = OsString::from("1");
let fpath = dir.to_string() + "/1.log";
big_path = Path::new(&*fpath).to_path_buf();
}
let fs = OpenOptions::new().read(true).create(true).write(true).open(big_path)?;
let hstr = tmp.into_string().unwrap();
let hi = hstr.parse::<u32>();
match hi {
Err(_) => {
return Err(io::Error::new(io::ErrorKind::Other, "not number file name"));
}
Ok(_) => {}
}
Ok(Wal { fs: fs, dir: dir.to_string() })
}
pub fn set_height(&mut self, height: usize) -> Result<(), io::Error> {
let mut name = height.to_string();
name = name + ".log";
let pathname = self.dir.clone() + "/";
let filename = pathname.clone() + &*name;
self.fs = OpenOptions::new().create(true).read(true).write(true).open(filename)?;
if height > 2 {
let mut delname = (height - 2).to_string();
delname = delname + ".log";
let delfilename = pathname + &*delname;
let _ = ::std::fs::remove_file(delfilename);
}
Ok(())
}
pub fn save(&mut self, mtype: u8, msg: &Vec<u8>) -> io::Result<usize> {
let mlen = msg.len() as u32;
if mlen == 0 {
return Ok(0);
}
let len_bytes: [u8; 4] = unsafe { transmute(mlen.to_le()) };
let type_bytes: [u8; 1] = unsafe { transmute(mtype.to_le()) };
self.fs.seek(io::SeekFrom::End(0))?;
self.fs.write(&len_bytes[..])?;
self.fs.write(&type_bytes[..])?;
let hlen = self.fs.write(msg.as_slice())?;
self.fs.flush()?;
Ok(hlen)
}
pub fn load(&mut self) -> Vec<(u8, Vec<u8>)> {
let mut vec_buf: Vec<u8> = Vec::new();
let mut vec_out: Vec<(u8, Vec<u8>)> = Vec::new();
self.fs.seek(io::SeekFrom::Start(0)).unwrap();
let res_fsize = self.fs.read_to_end(&mut vec_buf);
if res_fsize.is_err() {
return vec_out;
}
let fsize = res_fsize.unwrap();
if fsize <= 5 {
return vec_out;
}
let mut index = 0;
loop {
if index + 5 > fsize {
break;
}
let hd: [u8; 4] = [vec_buf[index], vec_buf[index + 1], vec_buf[index + 2], vec_buf[index + 3]];
let tmp: u32 = unsafe { transmute::<[u8; 4], u32>(hd) };
let bodylen = tmp as usize;
let mtype = vec_buf[index + 4];
index += 5;
if index + bodylen > fsize {
break;
}
vec_out.push((mtype, vec_buf[index..index + bodylen].to_vec()));
index += bodylen;
}
vec_out
}
} | use std::path::{PathBuf, Path}; | random_line_split |
wal.rs | // CITA
// Copyright 2016-2017 Cryptape Technologies LLC.
// This program is free software: you can redistribute it
// and/or modify it under the terms of the GNU General Public
// License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any
// later version.
// This program is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
use std::ffi::OsString;
use std::fs::{File, read_dir, OpenOptions, DirBuilder};
use std::io;
use std::io::{Write, Read, Seek};
use std::mem::transmute;
use std::path::{PathBuf, Path};
use std::str;
pub struct Wal {
fs: File,
dir: String,
}
impl Wal {
pub fn new(dir: &str) -> Result<Wal, io::Error> {
let mut tmp = OsString::new();
let mut big_path = PathBuf::new();
let mut fss = read_dir(&dir);
if fss.is_err() {
DirBuilder::new().recursive(true).create(dir).unwrap();
fss = read_dir(&dir);
}
let mut fnum = 0;
for dir_entry in fss? {
let entry = dir_entry?;
let epath = entry.path();
if let Some(fname) = epath.clone().file_stem() {
if tmp.len() < fname.len() || (tmp.len() == fname.len() && tmp.as_os_str() < fname) {
tmp = fname.to_os_string();
big_path = epath;
fnum += 1;
}
}
}
if fnum == 0 {
tmp = OsString::from("1");
let fpath = dir.to_string() + "/1.log";
big_path = Path::new(&*fpath).to_path_buf();
}
let fs = OpenOptions::new().read(true).create(true).write(true).open(big_path)?;
let hstr = tmp.into_string().unwrap();
let hi = hstr.parse::<u32>();
match hi {
Err(_) => {
return Err(io::Error::new(io::ErrorKind::Other, "not number file name"));
}
Ok(_) => {}
}
Ok(Wal { fs: fs, dir: dir.to_string() })
}
pub fn set_height(&mut self, height: usize) -> Result<(), io::Error> {
let mut name = height.to_string();
name = name + ".log";
let pathname = self.dir.clone() + "/";
let filename = pathname.clone() + &*name;
self.fs = OpenOptions::new().create(true).read(true).write(true).open(filename)?;
if height > 2 |
Ok(())
}
pub fn save(&mut self, mtype: u8, msg: &Vec<u8>) -> io::Result<usize> {
let mlen = msg.len() as u32;
if mlen == 0 {
return Ok(0);
}
let len_bytes: [u8; 4] = unsafe { transmute(mlen.to_le()) };
let type_bytes: [u8; 1] = unsafe { transmute(mtype.to_le()) };
self.fs.seek(io::SeekFrom::End(0))?;
self.fs.write(&len_bytes[..])?;
self.fs.write(&type_bytes[..])?;
let hlen = self.fs.write(msg.as_slice())?;
self.fs.flush()?;
Ok(hlen)
}
pub fn load(&mut self) -> Vec<(u8, Vec<u8>)> {
let mut vec_buf: Vec<u8> = Vec::new();
let mut vec_out: Vec<(u8, Vec<u8>)> = Vec::new();
self.fs.seek(io::SeekFrom::Start(0)).unwrap();
let res_fsize = self.fs.read_to_end(&mut vec_buf);
if res_fsize.is_err() {
return vec_out;
}
let fsize = res_fsize.unwrap();
if fsize <= 5 {
return vec_out;
}
let mut index = 0;
loop {
if index + 5 > fsize {
break;
}
let hd: [u8; 4] = [vec_buf[index], vec_buf[index + 1], vec_buf[index + 2], vec_buf[index + 3]];
let tmp: u32 = unsafe { transmute::<[u8; 4], u32>(hd) };
let bodylen = tmp as usize;
let mtype = vec_buf[index + 4];
index += 5;
if index + bodylen > fsize {
break;
}
vec_out.push((mtype, vec_buf[index..index + bodylen].to_vec()));
index += bodylen;
}
vec_out
}
}
| {
let mut delname = (height - 2).to_string();
delname = delname + ".log";
let delfilename = pathname + &*delname;
let _ = ::std::fs::remove_file(delfilename);
} | conditional_block |
wal.rs | // CITA
// Copyright 2016-2017 Cryptape Technologies LLC.
// This program is free software: you can redistribute it
// and/or modify it under the terms of the GNU General Public
// License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any
// later version.
// This program is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
use std::ffi::OsString;
use std::fs::{File, read_dir, OpenOptions, DirBuilder};
use std::io;
use std::io::{Write, Read, Seek};
use std::mem::transmute;
use std::path::{PathBuf, Path};
use std::str;
pub struct Wal {
fs: File,
dir: String,
}
impl Wal {
pub fn new(dir: &str) -> Result<Wal, io::Error> | }
}
if fnum == 0 {
tmp = OsString::from("1");
let fpath = dir.to_string() + "/1.log";
big_path = Path::new(&*fpath).to_path_buf();
}
let fs = OpenOptions::new().read(true).create(true).write(true).open(big_path)?;
let hstr = tmp.into_string().unwrap();
let hi = hstr.parse::<u32>();
match hi {
Err(_) => {
return Err(io::Error::new(io::ErrorKind::Other, "not number file name"));
}
Ok(_) => {}
}
Ok(Wal { fs: fs, dir: dir.to_string() })
}
pub fn set_height(&mut self, height: usize) -> Result<(), io::Error> {
let mut name = height.to_string();
name = name + ".log";
let pathname = self.dir.clone() + "/";
let filename = pathname.clone() + &*name;
self.fs = OpenOptions::new().create(true).read(true).write(true).open(filename)?;
if height > 2 {
let mut delname = (height - 2).to_string();
delname = delname + ".log";
let delfilename = pathname + &*delname;
let _ = ::std::fs::remove_file(delfilename);
}
Ok(())
}
pub fn save(&mut self, mtype: u8, msg: &Vec<u8>) -> io::Result<usize> {
let mlen = msg.len() as u32;
if mlen == 0 {
return Ok(0);
}
let len_bytes: [u8; 4] = unsafe { transmute(mlen.to_le()) };
let type_bytes: [u8; 1] = unsafe { transmute(mtype.to_le()) };
self.fs.seek(io::SeekFrom::End(0))?;
self.fs.write(&len_bytes[..])?;
self.fs.write(&type_bytes[..])?;
let hlen = self.fs.write(msg.as_slice())?;
self.fs.flush()?;
Ok(hlen)
}
pub fn load(&mut self) -> Vec<(u8, Vec<u8>)> {
let mut vec_buf: Vec<u8> = Vec::new();
let mut vec_out: Vec<(u8, Vec<u8>)> = Vec::new();
self.fs.seek(io::SeekFrom::Start(0)).unwrap();
let res_fsize = self.fs.read_to_end(&mut vec_buf);
if res_fsize.is_err() {
return vec_out;
}
let fsize = res_fsize.unwrap();
if fsize <= 5 {
return vec_out;
}
let mut index = 0;
loop {
if index + 5 > fsize {
break;
}
let hd: [u8; 4] = [vec_buf[index], vec_buf[index + 1], vec_buf[index + 2], vec_buf[index + 3]];
let tmp: u32 = unsafe { transmute::<[u8; 4], u32>(hd) };
let bodylen = tmp as usize;
let mtype = vec_buf[index + 4];
index += 5;
if index + bodylen > fsize {
break;
}
vec_out.push((mtype, vec_buf[index..index + bodylen].to_vec()));
index += bodylen;
}
vec_out
}
}
| {
let mut tmp = OsString::new();
let mut big_path = PathBuf::new();
let mut fss = read_dir(&dir);
if fss.is_err() {
DirBuilder::new().recursive(true).create(dir).unwrap();
fss = read_dir(&dir);
}
let mut fnum = 0;
for dir_entry in fss? {
let entry = dir_entry?;
let epath = entry.path();
if let Some(fname) = epath.clone().file_stem() {
if tmp.len() < fname.len() || (tmp.len() == fname.len() && tmp.as_os_str() < fname) {
tmp = fname.to_os_string();
big_path = epath;
fnum += 1;
} | identifier_body |
wal.rs | // CITA
// Copyright 2016-2017 Cryptape Technologies LLC.
// This program is free software: you can redistribute it
// and/or modify it under the terms of the GNU General Public
// License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any
// later version.
// This program is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
use std::ffi::OsString;
use std::fs::{File, read_dir, OpenOptions, DirBuilder};
use std::io;
use std::io::{Write, Read, Seek};
use std::mem::transmute;
use std::path::{PathBuf, Path};
use std::str;
pub struct Wal {
fs: File,
dir: String,
}
impl Wal {
pub fn new(dir: &str) -> Result<Wal, io::Error> {
let mut tmp = OsString::new();
let mut big_path = PathBuf::new();
let mut fss = read_dir(&dir);
if fss.is_err() {
DirBuilder::new().recursive(true).create(dir).unwrap();
fss = read_dir(&dir);
}
let mut fnum = 0;
for dir_entry in fss? {
let entry = dir_entry?;
let epath = entry.path();
if let Some(fname) = epath.clone().file_stem() {
if tmp.len() < fname.len() || (tmp.len() == fname.len() && tmp.as_os_str() < fname) {
tmp = fname.to_os_string();
big_path = epath;
fnum += 1;
}
}
}
if fnum == 0 {
tmp = OsString::from("1");
let fpath = dir.to_string() + "/1.log";
big_path = Path::new(&*fpath).to_path_buf();
}
let fs = OpenOptions::new().read(true).create(true).write(true).open(big_path)?;
let hstr = tmp.into_string().unwrap();
let hi = hstr.parse::<u32>();
match hi {
Err(_) => {
return Err(io::Error::new(io::ErrorKind::Other, "not number file name"));
}
Ok(_) => {}
}
Ok(Wal { fs: fs, dir: dir.to_string() })
}
pub fn set_height(&mut self, height: usize) -> Result<(), io::Error> {
let mut name = height.to_string();
name = name + ".log";
let pathname = self.dir.clone() + "/";
let filename = pathname.clone() + &*name;
self.fs = OpenOptions::new().create(true).read(true).write(true).open(filename)?;
if height > 2 {
let mut delname = (height - 2).to_string();
delname = delname + ".log";
let delfilename = pathname + &*delname;
let _ = ::std::fs::remove_file(delfilename);
}
Ok(())
}
pub fn | (&mut self, mtype: u8, msg: &Vec<u8>) -> io::Result<usize> {
let mlen = msg.len() as u32;
if mlen == 0 {
return Ok(0);
}
let len_bytes: [u8; 4] = unsafe { transmute(mlen.to_le()) };
let type_bytes: [u8; 1] = unsafe { transmute(mtype.to_le()) };
self.fs.seek(io::SeekFrom::End(0))?;
self.fs.write(&len_bytes[..])?;
self.fs.write(&type_bytes[..])?;
let hlen = self.fs.write(msg.as_slice())?;
self.fs.flush()?;
Ok(hlen)
}
pub fn load(&mut self) -> Vec<(u8, Vec<u8>)> {
let mut vec_buf: Vec<u8> = Vec::new();
let mut vec_out: Vec<(u8, Vec<u8>)> = Vec::new();
self.fs.seek(io::SeekFrom::Start(0)).unwrap();
let res_fsize = self.fs.read_to_end(&mut vec_buf);
if res_fsize.is_err() {
return vec_out;
}
let fsize = res_fsize.unwrap();
if fsize <= 5 {
return vec_out;
}
let mut index = 0;
loop {
if index + 5 > fsize {
break;
}
let hd: [u8; 4] = [vec_buf[index], vec_buf[index + 1], vec_buf[index + 2], vec_buf[index + 3]];
let tmp: u32 = unsafe { transmute::<[u8; 4], u32>(hd) };
let bodylen = tmp as usize;
let mtype = vec_buf[index + 4];
index += 5;
if index + bodylen > fsize {
break;
}
vec_out.push((mtype, vec_buf[index..index + bodylen].to_vec()));
index += bodylen;
}
vec_out
}
}
| save | identifier_name |
forcetouchevent.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::codegen::Bindings::ForceTouchEventBinding;
use dom::bindings::codegen::Bindings::ForceTouchEventBinding::ForceTouchEventMethods;
use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
use dom::bindings::global::GlobalRef;
use dom::bindings::inheritance::Castable;
use dom::bindings::js::{Root};
use dom::bindings::num::Finite;
use dom::bindings::reflector::reflect_dom_object;
use dom::uievent::UIEvent;
use dom::window::Window;
use util::str::DOMString;
#[dom_struct]
pub struct ForceTouchEvent {
uievent: UIEvent,
force: f32,
}
impl ForceTouchEvent {
fn new_inherited(force: f32) -> ForceTouchEvent {
ForceTouchEvent {
uievent: UIEvent::new_inherited(),
force: force,
}
}
| type_: DOMString,
force: f32) -> Root<ForceTouchEvent> {
let event = box ForceTouchEvent::new_inherited(force);
let ev = reflect_dom_object(event, GlobalRef::Window(window), ForceTouchEventBinding::Wrap);
ev.upcast::<UIEvent>().InitUIEvent(type_, true, true, Some(window), 0);
ev
}
}
impl<'a> ForceTouchEventMethods for &'a ForceTouchEvent {
fn ServoForce(&self) -> Finite<f32> {
Finite::wrap(self.force)
}
fn SERVO_FORCE_AT_MOUSE_DOWN(&self) -> Finite<f32> {
Finite::wrap(1.0)
}
fn SERVO_FORCE_AT_FORCE_MOUSE_DOWN(&self) -> Finite<f32> {
Finite::wrap(2.0)
}
// https://dom.spec.whatwg.org/#dom-event-istrusted
fn IsTrusted(&self) -> bool {
self.uievent.IsTrusted()
}
} | pub fn new(window: &Window, | random_line_split |
forcetouchevent.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::codegen::Bindings::ForceTouchEventBinding;
use dom::bindings::codegen::Bindings::ForceTouchEventBinding::ForceTouchEventMethods;
use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
use dom::bindings::global::GlobalRef;
use dom::bindings::inheritance::Castable;
use dom::bindings::js::{Root};
use dom::bindings::num::Finite;
use dom::bindings::reflector::reflect_dom_object;
use dom::uievent::UIEvent;
use dom::window::Window;
use util::str::DOMString;
#[dom_struct]
pub struct ForceTouchEvent {
uievent: UIEvent,
force: f32,
}
impl ForceTouchEvent {
fn | (force: f32) -> ForceTouchEvent {
ForceTouchEvent {
uievent: UIEvent::new_inherited(),
force: force,
}
}
pub fn new(window: &Window,
type_: DOMString,
force: f32) -> Root<ForceTouchEvent> {
let event = box ForceTouchEvent::new_inherited(force);
let ev = reflect_dom_object(event, GlobalRef::Window(window), ForceTouchEventBinding::Wrap);
ev.upcast::<UIEvent>().InitUIEvent(type_, true, true, Some(window), 0);
ev
}
}
impl<'a> ForceTouchEventMethods for &'a ForceTouchEvent {
fn ServoForce(&self) -> Finite<f32> {
Finite::wrap(self.force)
}
fn SERVO_FORCE_AT_MOUSE_DOWN(&self) -> Finite<f32> {
Finite::wrap(1.0)
}
fn SERVO_FORCE_AT_FORCE_MOUSE_DOWN(&self) -> Finite<f32> {
Finite::wrap(2.0)
}
// https://dom.spec.whatwg.org/#dom-event-istrusted
fn IsTrusted(&self) -> bool {
self.uievent.IsTrusted()
}
}
| new_inherited | identifier_name |
forcetouchevent.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::codegen::Bindings::ForceTouchEventBinding;
use dom::bindings::codegen::Bindings::ForceTouchEventBinding::ForceTouchEventMethods;
use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
use dom::bindings::global::GlobalRef;
use dom::bindings::inheritance::Castable;
use dom::bindings::js::{Root};
use dom::bindings::num::Finite;
use dom::bindings::reflector::reflect_dom_object;
use dom::uievent::UIEvent;
use dom::window::Window;
use util::str::DOMString;
#[dom_struct]
pub struct ForceTouchEvent {
uievent: UIEvent,
force: f32,
}
impl ForceTouchEvent {
fn new_inherited(force: f32) -> ForceTouchEvent {
ForceTouchEvent {
uievent: UIEvent::new_inherited(),
force: force,
}
}
pub fn new(window: &Window,
type_: DOMString,
force: f32) -> Root<ForceTouchEvent> {
let event = box ForceTouchEvent::new_inherited(force);
let ev = reflect_dom_object(event, GlobalRef::Window(window), ForceTouchEventBinding::Wrap);
ev.upcast::<UIEvent>().InitUIEvent(type_, true, true, Some(window), 0);
ev
}
}
impl<'a> ForceTouchEventMethods for &'a ForceTouchEvent {
fn ServoForce(&self) -> Finite<f32> {
Finite::wrap(self.force)
}
fn SERVO_FORCE_AT_MOUSE_DOWN(&self) -> Finite<f32> {
Finite::wrap(1.0)
}
fn SERVO_FORCE_AT_FORCE_MOUSE_DOWN(&self) -> Finite<f32> |
// https://dom.spec.whatwg.org/#dom-event-istrusted
fn IsTrusted(&self) -> bool {
self.uievent.IsTrusted()
}
}
| {
Finite::wrap(2.0)
} | identifier_body |
webvr_traits.rs | /* This Source Code Form is subject to the terms of the Mozilla Public | use webvr::*;
pub type WebVRResult<T> = Result<T, String>;
// Messages from Script thread to WebVR thread.
#[derive(Deserialize, Serialize)]
pub enum WebVRMsg {
RegisterContext(PipelineId),
UnregisterContext(PipelineId),
PollEvents(IpcSender<bool>),
GetDisplays(IpcSender<WebVRResult<Vec<VRDisplayData>>>),
GetFrameData(PipelineId, u64, f64, f64, IpcSender<WebVRResult<VRFrameData>>),
ResetPose(PipelineId, u64, IpcSender<WebVRResult<VRDisplayData>>),
RequestPresent(PipelineId, u64, IpcSender<WebVRResult<()>>),
ExitPresent(PipelineId, u64, Option<IpcSender<WebVRResult<()>>>),
CreateCompositor(u64),
Exit,
} | * License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use ipc_channel::ipc::IpcSender;
use msg::constellation_msg::PipelineId; | random_line_split |
webvr_traits.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use ipc_channel::ipc::IpcSender;
use msg::constellation_msg::PipelineId;
use webvr::*;
pub type WebVRResult<T> = Result<T, String>;
// Messages from Script thread to WebVR thread.
#[derive(Deserialize, Serialize)]
pub enum | {
RegisterContext(PipelineId),
UnregisterContext(PipelineId),
PollEvents(IpcSender<bool>),
GetDisplays(IpcSender<WebVRResult<Vec<VRDisplayData>>>),
GetFrameData(PipelineId, u64, f64, f64, IpcSender<WebVRResult<VRFrameData>>),
ResetPose(PipelineId, u64, IpcSender<WebVRResult<VRDisplayData>>),
RequestPresent(PipelineId, u64, IpcSender<WebVRResult<()>>),
ExitPresent(PipelineId, u64, Option<IpcSender<WebVRResult<()>>>),
CreateCompositor(u64),
Exit,
}
| WebVRMsg | identifier_name |
run.rs | // Copyright 2015, 2016 Ethcore (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
use std::sync::{Arc, Mutex, Condvar};
use ctrlc::CtrlC;
use fdlimit::raise_fd_limit;
use ethcore_logger::{Config as LogConfig, setup_log};
use ethcore_rpc::{NetworkSettings, is_major_importing};
use ethsync::NetworkConfiguration;
use util::{Colour, version, U256};
use io::{MayPanic, ForwardPanic, PanicHandler};
use ethcore::client::{Mode, DatabaseCompactionProfile, VMType, ChainNotify, BlockChainClient};
use ethcore::service::ClientService;
use ethcore::account_provider::AccountProvider;
use ethcore::miner::{Miner, MinerService, ExternalMiner, MinerOptions};
use ethcore::snapshot;
use ethsync::SyncConfig;
use informant::Informant;
use rpc::{HttpServer, IpcServer, HttpConfiguration, IpcConfiguration};
use signer::SignerServer;
use dapps::WebappServer;
use io_handler::ClientIoHandler;
use params::{
SpecType, Pruning, AccountsConfig, GasPricerConfig, MinerExtras, Switch,
tracing_switch_to_bool, fatdb_switch_to_bool,
};
use helpers::{to_client_config, execute_upgrades, passwords_from_files};
use dir::Directories;
use cache::CacheConfig;
use user_defaults::UserDefaults;
use dapps;
use signer;
use modules;
use rpc_apis;
use rpc;
use url;
// how often to take periodic snapshots.
const SNAPSHOT_PERIOD: u64 = 10000;
// how many blocks to wait before starting a periodic snapshot.
const SNAPSHOT_HISTORY: u64 = 500;
#[derive(Debug, PartialEq)]
pub struct RunCmd {
pub cache_config: CacheConfig,
pub dirs: Directories,
pub spec: SpecType,
pub pruning: Pruning,
pub pruning_history: u64,
/// Some if execution should be daemonized. Contains pid_file path.
pub daemon: Option<String>,
pub logger_config: LogConfig,
pub miner_options: MinerOptions,
pub http_conf: HttpConfiguration,
pub ipc_conf: IpcConfiguration,
pub net_conf: NetworkConfiguration,
pub network_id: Option<U256>,
pub warp_sync: bool,
pub acc_conf: AccountsConfig,
pub gas_pricer: GasPricerConfig,
pub miner_extras: MinerExtras,
pub mode: Mode,
pub tracing: Switch,
pub fat_db: Switch,
pub compaction: DatabaseCompactionProfile,
pub wal: bool,
pub vm_type: VMType,
pub enable_network: bool,
pub geth_compatibility: bool,
pub signer_port: Option<u16>,
pub net_settings: NetworkSettings,
pub dapps_conf: dapps::Configuration,
pub signer_conf: signer::Configuration,
pub ui: bool,
pub name: String,
pub custom_bootnodes: bool,
pub no_periodic_snapshot: bool,
pub check_seal: bool,
}
pub fn execute(cmd: RunCmd) -> Result<(), String> {
// set up panic handler
let panic_handler = PanicHandler::new_in_arc();
// set up logger
let logger = try!(setup_log(&cmd.logger_config));
// increase max number of open files
raise_fd_limit();
// create dirs used by parity
try!(cmd.dirs.create_dirs());
// load spec
let spec = try!(cmd.spec.spec());
// load genesis hash
let genesis_hash = spec.genesis_header().hash();
// database paths
let db_dirs = cmd.dirs.database(genesis_hash, spec.fork_name.clone());
// user defaults path
let user_defaults_path = db_dirs.user_defaults_path();
// load user defaults
let mut user_defaults = try!(UserDefaults::load(&user_defaults_path));
// select pruning algorithm
let algorithm = cmd.pruning.to_algorithm(&user_defaults);
// check if tracing is on
let tracing = try!(tracing_switch_to_bool(cmd.tracing, &user_defaults));
// check if fatdb is on
let fat_db = try!(fatdb_switch_to_bool(cmd.fat_db, &user_defaults, algorithm));
// prepare client and snapshot paths.
let client_path = db_dirs.client_path(algorithm);
let snapshot_path = db_dirs.snapshot_path();
// execute upgrades
try!(execute_upgrades(&db_dirs, algorithm, cmd.compaction.compaction_profile(db_dirs.fork_path().as_path())));
// run in daemon mode
if let Some(pid_file) = cmd.daemon {
try!(daemonize(pid_file));
}
// display info about used pruning algorithm
info!("Starting {}", Colour::White.bold().paint(version()));
info!("State DB configuation: {}{}{}",
Colour::White.bold().paint(algorithm.as_str()),
match fat_db {
true => Colour::White.bold().paint(" +Fat").to_string(),
false => "".to_owned(),
},
match tracing {
true => Colour::White.bold().paint(" +Trace").to_string(),
false => "".to_owned(),
}
);
// display warning about using experimental journaldb alorithm
if!algorithm.is_stable() {
warn!("Your chosen strategy is {}! You can re-run with --pruning to change.", Colour::Red.bold().paint("unstable"));
}
// create sync config
let mut sync_config = SyncConfig::default();
sync_config.network_id = match cmd.network_id {
Some(id) => id,
None => spec.network_id(),
};
if spec.subprotocol_name().len()!= 3 {
warn!("Your chain specification's subprotocol length is not 3. Ignoring.");
} else {
sync_config.subprotocol_name.clone_from_slice(spec.subprotocol_name().as_bytes());
}
sync_config.fork_block = spec.fork_block();
sync_config.warp_sync = cmd.warp_sync;
// prepare account provider
let account_provider = Arc::new(try!(prepare_account_provider(&cmd.dirs, cmd.acc_conf)));
// create miner
let miner = Miner::new(cmd.miner_options, cmd.gas_pricer.into(), &spec, Some(account_provider.clone()));
miner.set_author(cmd.miner_extras.author);
miner.set_gas_floor_target(cmd.miner_extras.gas_floor_target);
miner.set_gas_ceil_target(cmd.miner_extras.gas_ceil_target);
miner.set_extra_data(cmd.miner_extras.extra_data);
miner.set_transactions_limit(cmd.miner_extras.transactions_limit);
// create client config
let client_config = to_client_config(
&cmd.cache_config,
cmd.mode,
tracing,
fat_db,
cmd.compaction,
cmd.wal,
cmd.vm_type,
cmd.name,
algorithm,
cmd.pruning_history,
cmd.check_seal,
);
// set up bootnodes
let mut net_conf = cmd.net_conf;
if!cmd.custom_bootnodes {
net_conf.boot_nodes = spec.nodes.clone();
}
// set network path.
net_conf.net_config_path = Some(db_dirs.network_path().to_string_lossy().into_owned());
// create supervisor
let mut hypervisor = modules::hypervisor(&cmd.dirs.ipc_path());
// create client service.
let service = try!(ClientService::start(
client_config,
&spec,
&client_path,
&snapshot_path,
&cmd.dirs.ipc_path(),
miner.clone(),
).map_err(|e| format!("Client service error: {:?}", e)));
// forward panics from service
panic_handler.forward_from(&service);
// take handle to client
let client = service.client();
let snapshot_service = service.snapshot_service();
// create external miner
let external_miner = Arc::new(ExternalMiner::default());
// create sync object
let (sync_provider, manage_network, chain_notify) = try!(modules::sync(
&mut hypervisor, sync_config, net_conf.into(), client.clone(), snapshot_service.clone(), &cmd.logger_config,
).map_err(|e| format!("Sync error: {}", e)));
service.add_notify(chain_notify.clone());
// start network
if cmd.enable_network {
chain_notify.start();
}
// set up dependencies for rpc servers
let signer_path = cmd.signer_conf.signer_path.clone();
let deps_for_rpc_apis = Arc::new(rpc_apis::Dependencies {
signer_service: Arc::new(rpc_apis::SignerService::new(move || {
signer::generate_new_token(signer_path.clone()).map_err(|e| format!("{:?}", e))
}, cmd.signer_port)),
client: client.clone(),
sync: sync_provider.clone(),
net: manage_network.clone(),
secret_store: account_provider.clone(),
miner: miner.clone(),
external_miner: external_miner.clone(),
logger: logger.clone(),
settings: Arc::new(cmd.net_settings.clone()),
net_service: manage_network.clone(),
geth_compatibility: cmd.geth_compatibility,
dapps_port: match cmd.dapps_conf.enabled {
true => Some(cmd.dapps_conf.port),
false => None,
},
});
let dependencies = rpc::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
};
// start rpc servers
let http_server = try!(rpc::new_http(cmd.http_conf, &dependencies));
let ipc_server = try!(rpc::new_ipc(cmd.ipc_conf, &dependencies));
let dapps_deps = dapps::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
client: client.clone(),
sync: sync_provider.clone(),
};
// start dapps server
let dapps_server = try!(dapps::new(cmd.dapps_conf.clone(), dapps_deps));
let signer_deps = signer::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
};
// start signer server
let signer_server = try!(signer::start(cmd.signer_conf, signer_deps));
let informant = Arc::new(Informant::new(
service.client(),
Some(sync_provider.clone()),
Some(manage_network.clone()),
Some(snapshot_service.clone()),
cmd.logger_config.color
));
let info_notify: Arc<ChainNotify> = informant.clone();
service.add_notify(info_notify);
let io_handler = Arc::new(ClientIoHandler {
client: service.client(),
info: informant,
sync: sync_provider.clone(),
net: manage_network.clone(),
accounts: account_provider.clone(),
shutdown: Default::default(),
});
service.register_io_handler(io_handler.clone()).expect("Error registering IO handler");
// the watcher must be kept alive.
let _watcher = match cmd.no_periodic_snapshot {
true => None,
false => {
let sync = sync_provider.clone();
let watcher = Arc::new(snapshot::Watcher::new(
service.client(),
move || is_major_importing(Some(sync.status().state), client.queue_info()),
service.io().channel(),
SNAPSHOT_PERIOD,
SNAPSHOT_HISTORY,
));
service.add_notify(watcher.clone());
Some(watcher)
},
};
// start ui
if cmd.ui {
if!cmd.dapps_conf.enabled {
return Err("Cannot use UI command with Dapps turned off.".into())
}
url::open(&format!("http://{}:{}/", cmd.dapps_conf.interface, cmd.dapps_conf.port));
}
// save user defaults
user_defaults.pruning = algorithm;
user_defaults.tracing = tracing;
try!(user_defaults.save(&user_defaults_path));
// Handle exit
wait_for_exit(panic_handler, http_server, ipc_server, dapps_server, signer_server);
// to make sure timer does not spawn requests while shutdown is in progress
io_handler.shutdown.store(true, ::std::sync::atomic::Ordering::SeqCst);
// just Arc is dropping here, to allow other reference release in its default time
drop(io_handler);
// hypervisor should be shutdown first while everything still works and can be
// terminated gracefully
drop(hypervisor);
Ok(())
}
#[cfg(not(windows))]
fn daemonize(pid_file: String) -> Result<(), String> {
extern crate daemonize;
daemonize::Daemonize::new()
.pid_file(pid_file)
.chown_pid_file(true)
.start()
.map(|_| ())
.map_err(|e| format!("Couldn't daemonize; {}", e))
}
#[cfg(windows)]
fn daemonize(_pid_file: String) -> Result<(), String> {
Err("daemon is no supported on windows".into())
}
fn prepare_account_provider(dirs: &Directories, cfg: AccountsConfig) -> Result<AccountProvider, String> {
use ethcore::ethstore::EthStore;
use ethcore::ethstore::dir::DiskDirectory;
let passwords = try!(passwords_from_files(cfg.password_files));
let dir = Box::new(try!(DiskDirectory::create(dirs.keys.clone()).map_err(|e| format!("Could not open keys directory: {}", e))));
let account_service = AccountProvider::new(Box::new(
try!(EthStore::open_with_iterations(dir, cfg.iterations).map_err(|e| format!("Could not open keys directory: {}", e)))
));
for a in cfg.unlocked_accounts {
if passwords.iter().find(|p| account_service.unlock_account_permanently(a, (*p).clone()).is_ok()).is_none() {
return Err(format!("No password found to unlock account {}. Make sure valid password is present in files passed using `--password`.", a));
}
}
Ok(account_service)
}
fn | (
panic_handler: Arc<PanicHandler>,
_http_server: Option<HttpServer>,
_ipc_server: Option<IpcServer>,
_dapps_server: Option<WebappServer>,
_signer_server: Option<SignerServer>
) {
let exit = Arc::new(Condvar::new());
// Handle possible exits
let e = exit.clone();
CtrlC::set_handler(move || { e.notify_all(); });
// Handle panics
let e = exit.clone();
panic_handler.on_panic(move |_reason| { e.notify_all(); });
// Wait for signal
let mutex = Mutex::new(());
let _ = exit.wait(mutex.lock().unwrap());
info!("Finishing work, please wait...");
}
| wait_for_exit | identifier_name |
run.rs | // Copyright 2015, 2016 Ethcore (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
use std::sync::{Arc, Mutex, Condvar};
use ctrlc::CtrlC;
use fdlimit::raise_fd_limit;
use ethcore_logger::{Config as LogConfig, setup_log};
use ethcore_rpc::{NetworkSettings, is_major_importing};
use ethsync::NetworkConfiguration;
use util::{Colour, version, U256};
use io::{MayPanic, ForwardPanic, PanicHandler};
use ethcore::client::{Mode, DatabaseCompactionProfile, VMType, ChainNotify, BlockChainClient};
use ethcore::service::ClientService;
use ethcore::account_provider::AccountProvider;
use ethcore::miner::{Miner, MinerService, ExternalMiner, MinerOptions};
use ethcore::snapshot;
use ethsync::SyncConfig;
use informant::Informant;
use rpc::{HttpServer, IpcServer, HttpConfiguration, IpcConfiguration};
use signer::SignerServer;
use dapps::WebappServer;
use io_handler::ClientIoHandler;
use params::{
SpecType, Pruning, AccountsConfig, GasPricerConfig, MinerExtras, Switch,
tracing_switch_to_bool, fatdb_switch_to_bool,
};
use helpers::{to_client_config, execute_upgrades, passwords_from_files};
use dir::Directories;
use cache::CacheConfig;
use user_defaults::UserDefaults;
use dapps;
use signer;
use modules;
use rpc_apis;
use rpc;
use url;
// how often to take periodic snapshots.
const SNAPSHOT_PERIOD: u64 = 10000;
// how many blocks to wait before starting a periodic snapshot.
const SNAPSHOT_HISTORY: u64 = 500;
#[derive(Debug, PartialEq)]
pub struct RunCmd {
pub cache_config: CacheConfig,
pub dirs: Directories,
pub spec: SpecType,
pub pruning: Pruning,
pub pruning_history: u64,
/// Some if execution should be daemonized. Contains pid_file path.
pub daemon: Option<String>,
pub logger_config: LogConfig,
pub miner_options: MinerOptions,
pub http_conf: HttpConfiguration,
pub ipc_conf: IpcConfiguration,
pub net_conf: NetworkConfiguration,
pub network_id: Option<U256>,
pub warp_sync: bool,
pub acc_conf: AccountsConfig,
pub gas_pricer: GasPricerConfig,
pub miner_extras: MinerExtras,
pub mode: Mode,
pub tracing: Switch,
pub fat_db: Switch,
pub compaction: DatabaseCompactionProfile,
pub wal: bool,
pub vm_type: VMType,
pub enable_network: bool,
pub geth_compatibility: bool,
pub signer_port: Option<u16>,
pub net_settings: NetworkSettings,
pub dapps_conf: dapps::Configuration,
pub signer_conf: signer::Configuration,
pub ui: bool,
pub name: String,
pub custom_bootnodes: bool,
pub no_periodic_snapshot: bool,
pub check_seal: bool,
}
pub fn execute(cmd: RunCmd) -> Result<(), String> {
// set up panic handler
let panic_handler = PanicHandler::new_in_arc();
// set up logger
let logger = try!(setup_log(&cmd.logger_config));
// increase max number of open files
raise_fd_limit();
// create dirs used by parity
try!(cmd.dirs.create_dirs());
// load spec
let spec = try!(cmd.spec.spec());
// load genesis hash
let genesis_hash = spec.genesis_header().hash();
// database paths
let db_dirs = cmd.dirs.database(genesis_hash, spec.fork_name.clone());
// user defaults path
let user_defaults_path = db_dirs.user_defaults_path();
// load user defaults
let mut user_defaults = try!(UserDefaults::load(&user_defaults_path));
// select pruning algorithm
let algorithm = cmd.pruning.to_algorithm(&user_defaults);
// check if tracing is on
let tracing = try!(tracing_switch_to_bool(cmd.tracing, &user_defaults));
// check if fatdb is on
let fat_db = try!(fatdb_switch_to_bool(cmd.fat_db, &user_defaults, algorithm));
// prepare client and snapshot paths.
let client_path = db_dirs.client_path(algorithm);
let snapshot_path = db_dirs.snapshot_path();
// execute upgrades
try!(execute_upgrades(&db_dirs, algorithm, cmd.compaction.compaction_profile(db_dirs.fork_path().as_path())));
// run in daemon mode
if let Some(pid_file) = cmd.daemon {
try!(daemonize(pid_file));
}
// display info about used pruning algorithm
info!("Starting {}", Colour::White.bold().paint(version()));
info!("State DB configuation: {}{}{}",
Colour::White.bold().paint(algorithm.as_str()),
match fat_db {
true => Colour::White.bold().paint(" +Fat").to_string(),
false => "".to_owned(),
},
match tracing {
true => Colour::White.bold().paint(" +Trace").to_string(),
false => "".to_owned(),
}
);
// display warning about using experimental journaldb alorithm
if!algorithm.is_stable() {
warn!("Your chosen strategy is {}! You can re-run with --pruning to change.", Colour::Red.bold().paint("unstable"));
}
// create sync config
let mut sync_config = SyncConfig::default();
sync_config.network_id = match cmd.network_id {
Some(id) => id,
None => spec.network_id(),
};
if spec.subprotocol_name().len()!= 3 {
warn!("Your chain specification's subprotocol length is not 3. Ignoring.");
} else {
sync_config.subprotocol_name.clone_from_slice(spec.subprotocol_name().as_bytes());
}
sync_config.fork_block = spec.fork_block();
sync_config.warp_sync = cmd.warp_sync;
// prepare account provider
let account_provider = Arc::new(try!(prepare_account_provider(&cmd.dirs, cmd.acc_conf))); | let miner = Miner::new(cmd.miner_options, cmd.gas_pricer.into(), &spec, Some(account_provider.clone()));
miner.set_author(cmd.miner_extras.author);
miner.set_gas_floor_target(cmd.miner_extras.gas_floor_target);
miner.set_gas_ceil_target(cmd.miner_extras.gas_ceil_target);
miner.set_extra_data(cmd.miner_extras.extra_data);
miner.set_transactions_limit(cmd.miner_extras.transactions_limit);
// create client config
let client_config = to_client_config(
&cmd.cache_config,
cmd.mode,
tracing,
fat_db,
cmd.compaction,
cmd.wal,
cmd.vm_type,
cmd.name,
algorithm,
cmd.pruning_history,
cmd.check_seal,
);
// set up bootnodes
let mut net_conf = cmd.net_conf;
if!cmd.custom_bootnodes {
net_conf.boot_nodes = spec.nodes.clone();
}
// set network path.
net_conf.net_config_path = Some(db_dirs.network_path().to_string_lossy().into_owned());
// create supervisor
let mut hypervisor = modules::hypervisor(&cmd.dirs.ipc_path());
// create client service.
let service = try!(ClientService::start(
client_config,
&spec,
&client_path,
&snapshot_path,
&cmd.dirs.ipc_path(),
miner.clone(),
).map_err(|e| format!("Client service error: {:?}", e)));
// forward panics from service
panic_handler.forward_from(&service);
// take handle to client
let client = service.client();
let snapshot_service = service.snapshot_service();
// create external miner
let external_miner = Arc::new(ExternalMiner::default());
// create sync object
let (sync_provider, manage_network, chain_notify) = try!(modules::sync(
&mut hypervisor, sync_config, net_conf.into(), client.clone(), snapshot_service.clone(), &cmd.logger_config,
).map_err(|e| format!("Sync error: {}", e)));
service.add_notify(chain_notify.clone());
// start network
if cmd.enable_network {
chain_notify.start();
}
// set up dependencies for rpc servers
let signer_path = cmd.signer_conf.signer_path.clone();
let deps_for_rpc_apis = Arc::new(rpc_apis::Dependencies {
signer_service: Arc::new(rpc_apis::SignerService::new(move || {
signer::generate_new_token(signer_path.clone()).map_err(|e| format!("{:?}", e))
}, cmd.signer_port)),
client: client.clone(),
sync: sync_provider.clone(),
net: manage_network.clone(),
secret_store: account_provider.clone(),
miner: miner.clone(),
external_miner: external_miner.clone(),
logger: logger.clone(),
settings: Arc::new(cmd.net_settings.clone()),
net_service: manage_network.clone(),
geth_compatibility: cmd.geth_compatibility,
dapps_port: match cmd.dapps_conf.enabled {
true => Some(cmd.dapps_conf.port),
false => None,
},
});
let dependencies = rpc::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
};
// start rpc servers
let http_server = try!(rpc::new_http(cmd.http_conf, &dependencies));
let ipc_server = try!(rpc::new_ipc(cmd.ipc_conf, &dependencies));
let dapps_deps = dapps::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
client: client.clone(),
sync: sync_provider.clone(),
};
// start dapps server
let dapps_server = try!(dapps::new(cmd.dapps_conf.clone(), dapps_deps));
let signer_deps = signer::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
};
// start signer server
let signer_server = try!(signer::start(cmd.signer_conf, signer_deps));
let informant = Arc::new(Informant::new(
service.client(),
Some(sync_provider.clone()),
Some(manage_network.clone()),
Some(snapshot_service.clone()),
cmd.logger_config.color
));
let info_notify: Arc<ChainNotify> = informant.clone();
service.add_notify(info_notify);
let io_handler = Arc::new(ClientIoHandler {
client: service.client(),
info: informant,
sync: sync_provider.clone(),
net: manage_network.clone(),
accounts: account_provider.clone(),
shutdown: Default::default(),
});
service.register_io_handler(io_handler.clone()).expect("Error registering IO handler");
// the watcher must be kept alive.
let _watcher = match cmd.no_periodic_snapshot {
true => None,
false => {
let sync = sync_provider.clone();
let watcher = Arc::new(snapshot::Watcher::new(
service.client(),
move || is_major_importing(Some(sync.status().state), client.queue_info()),
service.io().channel(),
SNAPSHOT_PERIOD,
SNAPSHOT_HISTORY,
));
service.add_notify(watcher.clone());
Some(watcher)
},
};
// start ui
if cmd.ui {
if!cmd.dapps_conf.enabled {
return Err("Cannot use UI command with Dapps turned off.".into())
}
url::open(&format!("http://{}:{}/", cmd.dapps_conf.interface, cmd.dapps_conf.port));
}
// save user defaults
user_defaults.pruning = algorithm;
user_defaults.tracing = tracing;
try!(user_defaults.save(&user_defaults_path));
// Handle exit
wait_for_exit(panic_handler, http_server, ipc_server, dapps_server, signer_server);
// to make sure timer does not spawn requests while shutdown is in progress
io_handler.shutdown.store(true, ::std::sync::atomic::Ordering::SeqCst);
// just Arc is dropping here, to allow other reference release in its default time
drop(io_handler);
// hypervisor should be shutdown first while everything still works and can be
// terminated gracefully
drop(hypervisor);
Ok(())
}
#[cfg(not(windows))]
fn daemonize(pid_file: String) -> Result<(), String> {
extern crate daemonize;
daemonize::Daemonize::new()
.pid_file(pid_file)
.chown_pid_file(true)
.start()
.map(|_| ())
.map_err(|e| format!("Couldn't daemonize; {}", e))
}
#[cfg(windows)]
fn daemonize(_pid_file: String) -> Result<(), String> {
Err("daemon is no supported on windows".into())
}
fn prepare_account_provider(dirs: &Directories, cfg: AccountsConfig) -> Result<AccountProvider, String> {
use ethcore::ethstore::EthStore;
use ethcore::ethstore::dir::DiskDirectory;
let passwords = try!(passwords_from_files(cfg.password_files));
let dir = Box::new(try!(DiskDirectory::create(dirs.keys.clone()).map_err(|e| format!("Could not open keys directory: {}", e))));
let account_service = AccountProvider::new(Box::new(
try!(EthStore::open_with_iterations(dir, cfg.iterations).map_err(|e| format!("Could not open keys directory: {}", e)))
));
for a in cfg.unlocked_accounts {
if passwords.iter().find(|p| account_service.unlock_account_permanently(a, (*p).clone()).is_ok()).is_none() {
return Err(format!("No password found to unlock account {}. Make sure valid password is present in files passed using `--password`.", a));
}
}
Ok(account_service)
}
fn wait_for_exit(
panic_handler: Arc<PanicHandler>,
_http_server: Option<HttpServer>,
_ipc_server: Option<IpcServer>,
_dapps_server: Option<WebappServer>,
_signer_server: Option<SignerServer>
) {
let exit = Arc::new(Condvar::new());
// Handle possible exits
let e = exit.clone();
CtrlC::set_handler(move || { e.notify_all(); });
// Handle panics
let e = exit.clone();
panic_handler.on_panic(move |_reason| { e.notify_all(); });
// Wait for signal
let mutex = Mutex::new(());
let _ = exit.wait(mutex.lock().unwrap());
info!("Finishing work, please wait...");
} |
// create miner | random_line_split |
run.rs | // Copyright 2015, 2016 Ethcore (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
use std::sync::{Arc, Mutex, Condvar};
use ctrlc::CtrlC;
use fdlimit::raise_fd_limit;
use ethcore_logger::{Config as LogConfig, setup_log};
use ethcore_rpc::{NetworkSettings, is_major_importing};
use ethsync::NetworkConfiguration;
use util::{Colour, version, U256};
use io::{MayPanic, ForwardPanic, PanicHandler};
use ethcore::client::{Mode, DatabaseCompactionProfile, VMType, ChainNotify, BlockChainClient};
use ethcore::service::ClientService;
use ethcore::account_provider::AccountProvider;
use ethcore::miner::{Miner, MinerService, ExternalMiner, MinerOptions};
use ethcore::snapshot;
use ethsync::SyncConfig;
use informant::Informant;
use rpc::{HttpServer, IpcServer, HttpConfiguration, IpcConfiguration};
use signer::SignerServer;
use dapps::WebappServer;
use io_handler::ClientIoHandler;
use params::{
SpecType, Pruning, AccountsConfig, GasPricerConfig, MinerExtras, Switch,
tracing_switch_to_bool, fatdb_switch_to_bool,
};
use helpers::{to_client_config, execute_upgrades, passwords_from_files};
use dir::Directories;
use cache::CacheConfig;
use user_defaults::UserDefaults;
use dapps;
use signer;
use modules;
use rpc_apis;
use rpc;
use url;
// how often to take periodic snapshots.
const SNAPSHOT_PERIOD: u64 = 10000;
// how many blocks to wait before starting a periodic snapshot.
const SNAPSHOT_HISTORY: u64 = 500;
#[derive(Debug, PartialEq)]
pub struct RunCmd {
pub cache_config: CacheConfig,
pub dirs: Directories,
pub spec: SpecType,
pub pruning: Pruning,
pub pruning_history: u64,
/// Some if execution should be daemonized. Contains pid_file path.
pub daemon: Option<String>,
pub logger_config: LogConfig,
pub miner_options: MinerOptions,
pub http_conf: HttpConfiguration,
pub ipc_conf: IpcConfiguration,
pub net_conf: NetworkConfiguration,
pub network_id: Option<U256>,
pub warp_sync: bool,
pub acc_conf: AccountsConfig,
pub gas_pricer: GasPricerConfig,
pub miner_extras: MinerExtras,
pub mode: Mode,
pub tracing: Switch,
pub fat_db: Switch,
pub compaction: DatabaseCompactionProfile,
pub wal: bool,
pub vm_type: VMType,
pub enable_network: bool,
pub geth_compatibility: bool,
pub signer_port: Option<u16>,
pub net_settings: NetworkSettings,
pub dapps_conf: dapps::Configuration,
pub signer_conf: signer::Configuration,
pub ui: bool,
pub name: String,
pub custom_bootnodes: bool,
pub no_periodic_snapshot: bool,
pub check_seal: bool,
}
pub fn execute(cmd: RunCmd) -> Result<(), String> {
// set up panic handler
let panic_handler = PanicHandler::new_in_arc();
// set up logger
let logger = try!(setup_log(&cmd.logger_config));
// increase max number of open files
raise_fd_limit();
// create dirs used by parity
try!(cmd.dirs.create_dirs());
// load spec
let spec = try!(cmd.spec.spec());
// load genesis hash
let genesis_hash = spec.genesis_header().hash();
// database paths
let db_dirs = cmd.dirs.database(genesis_hash, spec.fork_name.clone());
// user defaults path
let user_defaults_path = db_dirs.user_defaults_path();
// load user defaults
let mut user_defaults = try!(UserDefaults::load(&user_defaults_path));
// select pruning algorithm
let algorithm = cmd.pruning.to_algorithm(&user_defaults);
// check if tracing is on
let tracing = try!(tracing_switch_to_bool(cmd.tracing, &user_defaults));
// check if fatdb is on
let fat_db = try!(fatdb_switch_to_bool(cmd.fat_db, &user_defaults, algorithm));
// prepare client and snapshot paths.
let client_path = db_dirs.client_path(algorithm);
let snapshot_path = db_dirs.snapshot_path();
// execute upgrades
try!(execute_upgrades(&db_dirs, algorithm, cmd.compaction.compaction_profile(db_dirs.fork_path().as_path())));
// run in daemon mode
if let Some(pid_file) = cmd.daemon {
try!(daemonize(pid_file));
}
// display info about used pruning algorithm
info!("Starting {}", Colour::White.bold().paint(version()));
info!("State DB configuation: {}{}{}",
Colour::White.bold().paint(algorithm.as_str()),
match fat_db {
true => Colour::White.bold().paint(" +Fat").to_string(),
false => "".to_owned(),
},
match tracing {
true => Colour::White.bold().paint(" +Trace").to_string(),
false => "".to_owned(),
}
);
// display warning about using experimental journaldb alorithm
if!algorithm.is_stable() {
warn!("Your chosen strategy is {}! You can re-run with --pruning to change.", Colour::Red.bold().paint("unstable"));
}
// create sync config
let mut sync_config = SyncConfig::default();
sync_config.network_id = match cmd.network_id {
Some(id) => id,
None => spec.network_id(),
};
if spec.subprotocol_name().len()!= 3 | else {
sync_config.subprotocol_name.clone_from_slice(spec.subprotocol_name().as_bytes());
}
sync_config.fork_block = spec.fork_block();
sync_config.warp_sync = cmd.warp_sync;
// prepare account provider
let account_provider = Arc::new(try!(prepare_account_provider(&cmd.dirs, cmd.acc_conf)));
// create miner
let miner = Miner::new(cmd.miner_options, cmd.gas_pricer.into(), &spec, Some(account_provider.clone()));
miner.set_author(cmd.miner_extras.author);
miner.set_gas_floor_target(cmd.miner_extras.gas_floor_target);
miner.set_gas_ceil_target(cmd.miner_extras.gas_ceil_target);
miner.set_extra_data(cmd.miner_extras.extra_data);
miner.set_transactions_limit(cmd.miner_extras.transactions_limit);
// create client config
let client_config = to_client_config(
&cmd.cache_config,
cmd.mode,
tracing,
fat_db,
cmd.compaction,
cmd.wal,
cmd.vm_type,
cmd.name,
algorithm,
cmd.pruning_history,
cmd.check_seal,
);
// set up bootnodes
let mut net_conf = cmd.net_conf;
if!cmd.custom_bootnodes {
net_conf.boot_nodes = spec.nodes.clone();
}
// set network path.
net_conf.net_config_path = Some(db_dirs.network_path().to_string_lossy().into_owned());
// create supervisor
let mut hypervisor = modules::hypervisor(&cmd.dirs.ipc_path());
// create client service.
let service = try!(ClientService::start(
client_config,
&spec,
&client_path,
&snapshot_path,
&cmd.dirs.ipc_path(),
miner.clone(),
).map_err(|e| format!("Client service error: {:?}", e)));
// forward panics from service
panic_handler.forward_from(&service);
// take handle to client
let client = service.client();
let snapshot_service = service.snapshot_service();
// create external miner
let external_miner = Arc::new(ExternalMiner::default());
// create sync object
let (sync_provider, manage_network, chain_notify) = try!(modules::sync(
&mut hypervisor, sync_config, net_conf.into(), client.clone(), snapshot_service.clone(), &cmd.logger_config,
).map_err(|e| format!("Sync error: {}", e)));
service.add_notify(chain_notify.clone());
// start network
if cmd.enable_network {
chain_notify.start();
}
// set up dependencies for rpc servers
let signer_path = cmd.signer_conf.signer_path.clone();
let deps_for_rpc_apis = Arc::new(rpc_apis::Dependencies {
signer_service: Arc::new(rpc_apis::SignerService::new(move || {
signer::generate_new_token(signer_path.clone()).map_err(|e| format!("{:?}", e))
}, cmd.signer_port)),
client: client.clone(),
sync: sync_provider.clone(),
net: manage_network.clone(),
secret_store: account_provider.clone(),
miner: miner.clone(),
external_miner: external_miner.clone(),
logger: logger.clone(),
settings: Arc::new(cmd.net_settings.clone()),
net_service: manage_network.clone(),
geth_compatibility: cmd.geth_compatibility,
dapps_port: match cmd.dapps_conf.enabled {
true => Some(cmd.dapps_conf.port),
false => None,
},
});
let dependencies = rpc::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
};
// start rpc servers
let http_server = try!(rpc::new_http(cmd.http_conf, &dependencies));
let ipc_server = try!(rpc::new_ipc(cmd.ipc_conf, &dependencies));
let dapps_deps = dapps::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
client: client.clone(),
sync: sync_provider.clone(),
};
// start dapps server
let dapps_server = try!(dapps::new(cmd.dapps_conf.clone(), dapps_deps));
let signer_deps = signer::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
};
// start signer server
let signer_server = try!(signer::start(cmd.signer_conf, signer_deps));
let informant = Arc::new(Informant::new(
service.client(),
Some(sync_provider.clone()),
Some(manage_network.clone()),
Some(snapshot_service.clone()),
cmd.logger_config.color
));
let info_notify: Arc<ChainNotify> = informant.clone();
service.add_notify(info_notify);
let io_handler = Arc::new(ClientIoHandler {
client: service.client(),
info: informant,
sync: sync_provider.clone(),
net: manage_network.clone(),
accounts: account_provider.clone(),
shutdown: Default::default(),
});
service.register_io_handler(io_handler.clone()).expect("Error registering IO handler");
// the watcher must be kept alive.
let _watcher = match cmd.no_periodic_snapshot {
true => None,
false => {
let sync = sync_provider.clone();
let watcher = Arc::new(snapshot::Watcher::new(
service.client(),
move || is_major_importing(Some(sync.status().state), client.queue_info()),
service.io().channel(),
SNAPSHOT_PERIOD,
SNAPSHOT_HISTORY,
));
service.add_notify(watcher.clone());
Some(watcher)
},
};
// start ui
if cmd.ui {
if!cmd.dapps_conf.enabled {
return Err("Cannot use UI command with Dapps turned off.".into())
}
url::open(&format!("http://{}:{}/", cmd.dapps_conf.interface, cmd.dapps_conf.port));
}
// save user defaults
user_defaults.pruning = algorithm;
user_defaults.tracing = tracing;
try!(user_defaults.save(&user_defaults_path));
// Handle exit
wait_for_exit(panic_handler, http_server, ipc_server, dapps_server, signer_server);
// to make sure timer does not spawn requests while shutdown is in progress
io_handler.shutdown.store(true, ::std::sync::atomic::Ordering::SeqCst);
// just Arc is dropping here, to allow other reference release in its default time
drop(io_handler);
// hypervisor should be shutdown first while everything still works and can be
// terminated gracefully
drop(hypervisor);
Ok(())
}
#[cfg(not(windows))]
fn daemonize(pid_file: String) -> Result<(), String> {
extern crate daemonize;
daemonize::Daemonize::new()
.pid_file(pid_file)
.chown_pid_file(true)
.start()
.map(|_| ())
.map_err(|e| format!("Couldn't daemonize; {}", e))
}
#[cfg(windows)]
fn daemonize(_pid_file: String) -> Result<(), String> {
Err("daemon is no supported on windows".into())
}
fn prepare_account_provider(dirs: &Directories, cfg: AccountsConfig) -> Result<AccountProvider, String> {
use ethcore::ethstore::EthStore;
use ethcore::ethstore::dir::DiskDirectory;
let passwords = try!(passwords_from_files(cfg.password_files));
let dir = Box::new(try!(DiskDirectory::create(dirs.keys.clone()).map_err(|e| format!("Could not open keys directory: {}", e))));
let account_service = AccountProvider::new(Box::new(
try!(EthStore::open_with_iterations(dir, cfg.iterations).map_err(|e| format!("Could not open keys directory: {}", e)))
));
for a in cfg.unlocked_accounts {
if passwords.iter().find(|p| account_service.unlock_account_permanently(a, (*p).clone()).is_ok()).is_none() {
return Err(format!("No password found to unlock account {}. Make sure valid password is present in files passed using `--password`.", a));
}
}
Ok(account_service)
}
fn wait_for_exit(
panic_handler: Arc<PanicHandler>,
_http_server: Option<HttpServer>,
_ipc_server: Option<IpcServer>,
_dapps_server: Option<WebappServer>,
_signer_server: Option<SignerServer>
) {
let exit = Arc::new(Condvar::new());
// Handle possible exits
let e = exit.clone();
CtrlC::set_handler(move || { e.notify_all(); });
// Handle panics
let e = exit.clone();
panic_handler.on_panic(move |_reason| { e.notify_all(); });
// Wait for signal
let mutex = Mutex::new(());
let _ = exit.wait(mutex.lock().unwrap());
info!("Finishing work, please wait...");
}
| {
warn!("Your chain specification's subprotocol length is not 3. Ignoring.");
} | conditional_block |
run.rs | // Copyright 2015, 2016 Ethcore (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
use std::sync::{Arc, Mutex, Condvar};
use ctrlc::CtrlC;
use fdlimit::raise_fd_limit;
use ethcore_logger::{Config as LogConfig, setup_log};
use ethcore_rpc::{NetworkSettings, is_major_importing};
use ethsync::NetworkConfiguration;
use util::{Colour, version, U256};
use io::{MayPanic, ForwardPanic, PanicHandler};
use ethcore::client::{Mode, DatabaseCompactionProfile, VMType, ChainNotify, BlockChainClient};
use ethcore::service::ClientService;
use ethcore::account_provider::AccountProvider;
use ethcore::miner::{Miner, MinerService, ExternalMiner, MinerOptions};
use ethcore::snapshot;
use ethsync::SyncConfig;
use informant::Informant;
use rpc::{HttpServer, IpcServer, HttpConfiguration, IpcConfiguration};
use signer::SignerServer;
use dapps::WebappServer;
use io_handler::ClientIoHandler;
use params::{
SpecType, Pruning, AccountsConfig, GasPricerConfig, MinerExtras, Switch,
tracing_switch_to_bool, fatdb_switch_to_bool,
};
use helpers::{to_client_config, execute_upgrades, passwords_from_files};
use dir::Directories;
use cache::CacheConfig;
use user_defaults::UserDefaults;
use dapps;
use signer;
use modules;
use rpc_apis;
use rpc;
use url;
// how often to take periodic snapshots.
const SNAPSHOT_PERIOD: u64 = 10000;
// how many blocks to wait before starting a periodic snapshot.
const SNAPSHOT_HISTORY: u64 = 500;
#[derive(Debug, PartialEq)]
pub struct RunCmd {
pub cache_config: CacheConfig,
pub dirs: Directories,
pub spec: SpecType,
pub pruning: Pruning,
pub pruning_history: u64,
/// Some if execution should be daemonized. Contains pid_file path.
pub daemon: Option<String>,
pub logger_config: LogConfig,
pub miner_options: MinerOptions,
pub http_conf: HttpConfiguration,
pub ipc_conf: IpcConfiguration,
pub net_conf: NetworkConfiguration,
pub network_id: Option<U256>,
pub warp_sync: bool,
pub acc_conf: AccountsConfig,
pub gas_pricer: GasPricerConfig,
pub miner_extras: MinerExtras,
pub mode: Mode,
pub tracing: Switch,
pub fat_db: Switch,
pub compaction: DatabaseCompactionProfile,
pub wal: bool,
pub vm_type: VMType,
pub enable_network: bool,
pub geth_compatibility: bool,
pub signer_port: Option<u16>,
pub net_settings: NetworkSettings,
pub dapps_conf: dapps::Configuration,
pub signer_conf: signer::Configuration,
pub ui: bool,
pub name: String,
pub custom_bootnodes: bool,
pub no_periodic_snapshot: bool,
pub check_seal: bool,
}
pub fn execute(cmd: RunCmd) -> Result<(), String> {
// set up panic handler
let panic_handler = PanicHandler::new_in_arc();
// set up logger
let logger = try!(setup_log(&cmd.logger_config));
// increase max number of open files
raise_fd_limit();
// create dirs used by parity
try!(cmd.dirs.create_dirs());
// load spec
let spec = try!(cmd.spec.spec());
// load genesis hash
let genesis_hash = spec.genesis_header().hash();
// database paths
let db_dirs = cmd.dirs.database(genesis_hash, spec.fork_name.clone());
// user defaults path
let user_defaults_path = db_dirs.user_defaults_path();
// load user defaults
let mut user_defaults = try!(UserDefaults::load(&user_defaults_path));
// select pruning algorithm
let algorithm = cmd.pruning.to_algorithm(&user_defaults);
// check if tracing is on
let tracing = try!(tracing_switch_to_bool(cmd.tracing, &user_defaults));
// check if fatdb is on
let fat_db = try!(fatdb_switch_to_bool(cmd.fat_db, &user_defaults, algorithm));
// prepare client and snapshot paths.
let client_path = db_dirs.client_path(algorithm);
let snapshot_path = db_dirs.snapshot_path();
// execute upgrades
try!(execute_upgrades(&db_dirs, algorithm, cmd.compaction.compaction_profile(db_dirs.fork_path().as_path())));
// run in daemon mode
if let Some(pid_file) = cmd.daemon {
try!(daemonize(pid_file));
}
// display info about used pruning algorithm
info!("Starting {}", Colour::White.bold().paint(version()));
info!("State DB configuation: {}{}{}",
Colour::White.bold().paint(algorithm.as_str()),
match fat_db {
true => Colour::White.bold().paint(" +Fat").to_string(),
false => "".to_owned(),
},
match tracing {
true => Colour::White.bold().paint(" +Trace").to_string(),
false => "".to_owned(),
}
);
// display warning about using experimental journaldb alorithm
if!algorithm.is_stable() {
warn!("Your chosen strategy is {}! You can re-run with --pruning to change.", Colour::Red.bold().paint("unstable"));
}
// create sync config
let mut sync_config = SyncConfig::default();
sync_config.network_id = match cmd.network_id {
Some(id) => id,
None => spec.network_id(),
};
if spec.subprotocol_name().len()!= 3 {
warn!("Your chain specification's subprotocol length is not 3. Ignoring.");
} else {
sync_config.subprotocol_name.clone_from_slice(spec.subprotocol_name().as_bytes());
}
sync_config.fork_block = spec.fork_block();
sync_config.warp_sync = cmd.warp_sync;
// prepare account provider
let account_provider = Arc::new(try!(prepare_account_provider(&cmd.dirs, cmd.acc_conf)));
// create miner
let miner = Miner::new(cmd.miner_options, cmd.gas_pricer.into(), &spec, Some(account_provider.clone()));
miner.set_author(cmd.miner_extras.author);
miner.set_gas_floor_target(cmd.miner_extras.gas_floor_target);
miner.set_gas_ceil_target(cmd.miner_extras.gas_ceil_target);
miner.set_extra_data(cmd.miner_extras.extra_data);
miner.set_transactions_limit(cmd.miner_extras.transactions_limit);
// create client config
let client_config = to_client_config(
&cmd.cache_config,
cmd.mode,
tracing,
fat_db,
cmd.compaction,
cmd.wal,
cmd.vm_type,
cmd.name,
algorithm,
cmd.pruning_history,
cmd.check_seal,
);
// set up bootnodes
let mut net_conf = cmd.net_conf;
if!cmd.custom_bootnodes {
net_conf.boot_nodes = spec.nodes.clone();
}
// set network path.
net_conf.net_config_path = Some(db_dirs.network_path().to_string_lossy().into_owned());
// create supervisor
let mut hypervisor = modules::hypervisor(&cmd.dirs.ipc_path());
// create client service.
let service = try!(ClientService::start(
client_config,
&spec,
&client_path,
&snapshot_path,
&cmd.dirs.ipc_path(),
miner.clone(),
).map_err(|e| format!("Client service error: {:?}", e)));
// forward panics from service
panic_handler.forward_from(&service);
// take handle to client
let client = service.client();
let snapshot_service = service.snapshot_service();
// create external miner
let external_miner = Arc::new(ExternalMiner::default());
// create sync object
let (sync_provider, manage_network, chain_notify) = try!(modules::sync(
&mut hypervisor, sync_config, net_conf.into(), client.clone(), snapshot_service.clone(), &cmd.logger_config,
).map_err(|e| format!("Sync error: {}", e)));
service.add_notify(chain_notify.clone());
// start network
if cmd.enable_network {
chain_notify.start();
}
// set up dependencies for rpc servers
let signer_path = cmd.signer_conf.signer_path.clone();
let deps_for_rpc_apis = Arc::new(rpc_apis::Dependencies {
signer_service: Arc::new(rpc_apis::SignerService::new(move || {
signer::generate_new_token(signer_path.clone()).map_err(|e| format!("{:?}", e))
}, cmd.signer_port)),
client: client.clone(),
sync: sync_provider.clone(),
net: manage_network.clone(),
secret_store: account_provider.clone(),
miner: miner.clone(),
external_miner: external_miner.clone(),
logger: logger.clone(),
settings: Arc::new(cmd.net_settings.clone()),
net_service: manage_network.clone(),
geth_compatibility: cmd.geth_compatibility,
dapps_port: match cmd.dapps_conf.enabled {
true => Some(cmd.dapps_conf.port),
false => None,
},
});
let dependencies = rpc::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
};
// start rpc servers
let http_server = try!(rpc::new_http(cmd.http_conf, &dependencies));
let ipc_server = try!(rpc::new_ipc(cmd.ipc_conf, &dependencies));
let dapps_deps = dapps::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
client: client.clone(),
sync: sync_provider.clone(),
};
// start dapps server
let dapps_server = try!(dapps::new(cmd.dapps_conf.clone(), dapps_deps));
let signer_deps = signer::Dependencies {
panic_handler: panic_handler.clone(),
apis: deps_for_rpc_apis.clone(),
};
// start signer server
let signer_server = try!(signer::start(cmd.signer_conf, signer_deps));
let informant = Arc::new(Informant::new(
service.client(),
Some(sync_provider.clone()),
Some(manage_network.clone()),
Some(snapshot_service.clone()),
cmd.logger_config.color
));
let info_notify: Arc<ChainNotify> = informant.clone();
service.add_notify(info_notify);
let io_handler = Arc::new(ClientIoHandler {
client: service.client(),
info: informant,
sync: sync_provider.clone(),
net: manage_network.clone(),
accounts: account_provider.clone(),
shutdown: Default::default(),
});
service.register_io_handler(io_handler.clone()).expect("Error registering IO handler");
// the watcher must be kept alive.
let _watcher = match cmd.no_periodic_snapshot {
true => None,
false => {
let sync = sync_provider.clone();
let watcher = Arc::new(snapshot::Watcher::new(
service.client(),
move || is_major_importing(Some(sync.status().state), client.queue_info()),
service.io().channel(),
SNAPSHOT_PERIOD,
SNAPSHOT_HISTORY,
));
service.add_notify(watcher.clone());
Some(watcher)
},
};
// start ui
if cmd.ui {
if!cmd.dapps_conf.enabled {
return Err("Cannot use UI command with Dapps turned off.".into())
}
url::open(&format!("http://{}:{}/", cmd.dapps_conf.interface, cmd.dapps_conf.port));
}
// save user defaults
user_defaults.pruning = algorithm;
user_defaults.tracing = tracing;
try!(user_defaults.save(&user_defaults_path));
// Handle exit
wait_for_exit(panic_handler, http_server, ipc_server, dapps_server, signer_server);
// to make sure timer does not spawn requests while shutdown is in progress
io_handler.shutdown.store(true, ::std::sync::atomic::Ordering::SeqCst);
// just Arc is dropping here, to allow other reference release in its default time
drop(io_handler);
// hypervisor should be shutdown first while everything still works and can be
// terminated gracefully
drop(hypervisor);
Ok(())
}
#[cfg(not(windows))]
fn daemonize(pid_file: String) -> Result<(), String> {
extern crate daemonize;
daemonize::Daemonize::new()
.pid_file(pid_file)
.chown_pid_file(true)
.start()
.map(|_| ())
.map_err(|e| format!("Couldn't daemonize; {}", e))
}
#[cfg(windows)]
fn daemonize(_pid_file: String) -> Result<(), String> |
fn prepare_account_provider(dirs: &Directories, cfg: AccountsConfig) -> Result<AccountProvider, String> {
use ethcore::ethstore::EthStore;
use ethcore::ethstore::dir::DiskDirectory;
let passwords = try!(passwords_from_files(cfg.password_files));
let dir = Box::new(try!(DiskDirectory::create(dirs.keys.clone()).map_err(|e| format!("Could not open keys directory: {}", e))));
let account_service = AccountProvider::new(Box::new(
try!(EthStore::open_with_iterations(dir, cfg.iterations).map_err(|e| format!("Could not open keys directory: {}", e)))
));
for a in cfg.unlocked_accounts {
if passwords.iter().find(|p| account_service.unlock_account_permanently(a, (*p).clone()).is_ok()).is_none() {
return Err(format!("No password found to unlock account {}. Make sure valid password is present in files passed using `--password`.", a));
}
}
Ok(account_service)
}
fn wait_for_exit(
panic_handler: Arc<PanicHandler>,
_http_server: Option<HttpServer>,
_ipc_server: Option<IpcServer>,
_dapps_server: Option<WebappServer>,
_signer_server: Option<SignerServer>
) {
let exit = Arc::new(Condvar::new());
// Handle possible exits
let e = exit.clone();
CtrlC::set_handler(move || { e.notify_all(); });
// Handle panics
let e = exit.clone();
panic_handler.on_panic(move |_reason| { e.notify_all(); });
// Wait for signal
let mutex = Mutex::new(());
let _ = exit.wait(mutex.lock().unwrap());
info!("Finishing work, please wait...");
}
| {
Err("daemon is no supported on windows".into())
} | identifier_body |
util.rs | // Copyright 2017 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
#![allow(unknown_lints)]
// client and server share different parts of utils.
#![allow(dead_code)]
#![allow(cast_lossless)]
use std::f64::consts::PI;
use serde_json;
use grpcio_proto::example::route_guide::*;
#[derive(Serialize, Deserialize, Debug)]
struct PointRef {
latitude: i32,
longitude: i32,
}
#[derive(Serialize, Deserialize, Debug)]
struct | {
location: PointRef,
name: String,
}
impl From<FeatureRef> for Feature {
fn from(r: FeatureRef) -> Feature {
let mut f = Feature::default();
f.set_name(r.name);
f.mut_location().set_latitude(r.location.latitude);
f.mut_location().set_longitude(r.location.longitude);
f
}
}
pub fn load_db() -> Vec<Feature> {
let data = include_str!("db.json");
let features: Vec<FeatureRef> = serde_json::from_str(data).unwrap();
features.into_iter().map(From::from).collect()
}
pub fn same_point(lhs: &Point, rhs: &Point) -> bool {
lhs.get_longitude() == rhs.get_longitude() && lhs.get_latitude() == rhs.get_latitude()
}
pub fn fit_in(lhs: &Point, rhs: &Rectangle) -> bool {
let hi = rhs.get_hi();
let lo = rhs.get_lo();
lhs.get_longitude() <= hi.get_longitude()
&& lhs.get_longitude() >= lo.get_longitude()
&& lhs.get_latitude() <= hi.get_latitude()
&& lhs.get_latitude() >= lo.get_latitude()
}
const COORD_FACTOR: f64 = 10000000.0;
pub fn convert_to_rad(num: f64) -> f64 {
num * PI / 180.0
}
pub fn format_point(p: &Point) -> String {
format!(
"{}, {}",
p.get_latitude() as f64 / COORD_FACTOR,
p.get_longitude() as f64 / COORD_FACTOR
)
}
pub fn cal_distance(lhs: &Point, rhs: &Point) -> f64 {
let lat1 = lhs.get_latitude() as f64 / COORD_FACTOR;
let lon1 = lhs.get_longitude() as f64 / COORD_FACTOR;
let lat2 = rhs.get_latitude() as f64 / COORD_FACTOR;
let lon2 = rhs.get_longitude() as f64 / COORD_FACTOR;
let lat_rad_1 = convert_to_rad(lat1);
let lat_rad_2 = convert_to_rad(lat2);
let delta_lat_rad = convert_to_rad(lat2 - lat1);
let delta_lon_rad = convert_to_rad(lon2 - lon1);
let a = (delta_lat_rad / 2.0).sin().powi(2)
+ lat_rad_1.cos() * lat_rad_2.cos() * (delta_lon_rad / 2.0).sin().powi(2);
let c = 2.0 * a.sqrt().atan2((1.0 - a).sqrt());
let r = 6371000.0; // metres
r * c
}
| FeatureRef | identifier_name |
util.rs | // Copyright 2017 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
#![allow(unknown_lints)]
// client and server share different parts of utils.
#![allow(dead_code)]
#![allow(cast_lossless)]
use std::f64::consts::PI;
use serde_json;
use grpcio_proto::example::route_guide::*;
#[derive(Serialize, Deserialize, Debug)]
struct PointRef {
latitude: i32,
longitude: i32,
}
#[derive(Serialize, Deserialize, Debug)]
struct FeatureRef {
location: PointRef,
name: String,
}
impl From<FeatureRef> for Feature {
fn from(r: FeatureRef) -> Feature {
let mut f = Feature::default();
f.set_name(r.name);
f.mut_location().set_latitude(r.location.latitude); | f.mut_location().set_longitude(r.location.longitude);
f
}
}
pub fn load_db() -> Vec<Feature> {
let data = include_str!("db.json");
let features: Vec<FeatureRef> = serde_json::from_str(data).unwrap();
features.into_iter().map(From::from).collect()
}
pub fn same_point(lhs: &Point, rhs: &Point) -> bool {
lhs.get_longitude() == rhs.get_longitude() && lhs.get_latitude() == rhs.get_latitude()
}
pub fn fit_in(lhs: &Point, rhs: &Rectangle) -> bool {
let hi = rhs.get_hi();
let lo = rhs.get_lo();
lhs.get_longitude() <= hi.get_longitude()
&& lhs.get_longitude() >= lo.get_longitude()
&& lhs.get_latitude() <= hi.get_latitude()
&& lhs.get_latitude() >= lo.get_latitude()
}
const COORD_FACTOR: f64 = 10000000.0;
pub fn convert_to_rad(num: f64) -> f64 {
num * PI / 180.0
}
pub fn format_point(p: &Point) -> String {
format!(
"{}, {}",
p.get_latitude() as f64 / COORD_FACTOR,
p.get_longitude() as f64 / COORD_FACTOR
)
}
pub fn cal_distance(lhs: &Point, rhs: &Point) -> f64 {
let lat1 = lhs.get_latitude() as f64 / COORD_FACTOR;
let lon1 = lhs.get_longitude() as f64 / COORD_FACTOR;
let lat2 = rhs.get_latitude() as f64 / COORD_FACTOR;
let lon2 = rhs.get_longitude() as f64 / COORD_FACTOR;
let lat_rad_1 = convert_to_rad(lat1);
let lat_rad_2 = convert_to_rad(lat2);
let delta_lat_rad = convert_to_rad(lat2 - lat1);
let delta_lon_rad = convert_to_rad(lon2 - lon1);
let a = (delta_lat_rad / 2.0).sin().powi(2)
+ lat_rad_1.cos() * lat_rad_2.cos() * (delta_lon_rad / 2.0).sin().powi(2);
let c = 2.0 * a.sqrt().atan2((1.0 - a).sqrt());
let r = 6371000.0; // metres
r * c
} | random_line_split |
|
init.rs | use std::sync::{atomic, mpsc};
use std::{io, process, thread};
use ctrlc;
use crate::control::acio;
use crate::{args, control, disk, log, rpc, throttle, tracker};
use crate::{CONFIG, SHUTDOWN, THROT_TOKS};
pub fn init(args: args::Args) -> Result<(), ()> {
if let Some(level) = args.level {
log::log_init(level);
} else if cfg!(debug_assertions) {
log::log_init(log::LogLevel::Debug);
} else {
log::log_init(log::LogLevel::Info);
}
info!("Initializing");
// Since the config is lazy loaded, dereference now to check it.
CONFIG.port;
if let Err(e) = init_signals() {
error!("Failed to initialize signal handlers: {}", e);
return Err(());
}
Ok(())
}
pub fn run() -> Result<(), ()> {
match init_threads() {
Ok(threads) => {
for thread in threads {
if thread.join().is_err() {
error!("Unclean shutdown detected, terminating");
return Err(());
}
}
info!("Shutdown complete");
Ok(())
}
Err(e) => {
error!("Couldn't initialize synapse: {}", e);
Err(())
}
}
}
fn init_threads() -> io::Result<Vec<thread::JoinHandle<()>>> {
let cpoll = amy::Poller::new()?;
let mut creg = cpoll.get_registrar();
let (dh, disk_broadcast, dhj) = disk::start(&mut creg)?;
let (rh, rhj) = rpc::RPC::start(&mut creg, disk_broadcast.clone())?;
let (th, thj) = tracker::Tracker::start(&mut creg, disk_broadcast.clone())?;
let chans = acio::ACChans {
disk_tx: dh.tx,
disk_rx: dh.rx,
rpc_tx: rh.tx,
rpc_rx: rh.rx,
trk_tx: th.tx,
trk_rx: th.rx,
};
let (tx, rx) = mpsc::channel();
let cdb = disk_broadcast.clone();
let chj = thread::Builder::new()
.name("control".to_string())
.spawn(move || {
let throttler = throttle::Throttler::new(None, None, THROT_TOKS, &creg).unwrap();
let acio = acio::ACIO::new(cpoll, creg, chans).expect("Could not initialize IO");
match control::Control::new(acio, throttler, cdb) {
Ok(mut c) => {
tx.send(Ok(())).unwrap();
c.run();
}
Err(e) => {
tx.send(Err(e)).unwrap();
}
}
})
.unwrap();
rx.recv().unwrap()?;
Ok(vec![chj, dhj, rhj, thj])
}
fn init_signals() -> Result<(), ctrlc::Error> | {
ctrlc::set_handler(move || {
if SHUTDOWN.load(atomic::Ordering::SeqCst) {
info!("Terminating process!");
process::abort();
} else {
info!("Shutting down cleanly. Interrupt again to shut down immediately.");
SHUTDOWN.store(true, atomic::Ordering::SeqCst);
}
})
} | identifier_body |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.