lang
stringclasses 10
values | seed
stringlengths 5
2.12k
|
|---|---|
rust | self.explored_positions += 1;
if depth == 0 {
panic!("that makes no sense");
}
let possible_moves = board.possible_moves();
if possible_moves.is_empty() {
return (board.current_score(), None); |
rust | mod style;
mod theme;
mod tick;
mod widgets;
pub use self::color::*;
pub use self::font::*;
pub use self::obj::*;
pub use self::style::*;
pub use self::theme::*;
pub use self::tick::*;
pub use self::widgets::*;
|
rust | })
}
/// Initialize the unix socket address struct with invalid/dummy data.
pub fn dummy_init_unix() -> Self {
SockAddr::Unix(libc::sockaddr_un {
sun_family: 123u16,
sun_path: [1; 108],
})
} |
rust | #[test]
fn string() -> ExpressionNode {
let source = "\"foo\"";
assert_eq!(
source,
Ok(ExpressionNode {
id: DUMMY_NODE_ID,
kind: ExpressionKind::Literal(LiteralNode {
symbol: Symbol::intern("foo"),
kind: LiteralKind::String,
}), |
rust |
impl serde::Serialize for KitsuneP2pTuningParams {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeMap;
let mut m = serializer.serialize_map(Some(1))?;
m.serialize_entry(
"gossip_loop_iteration_delay_ms",
&format!("{}", self.gossip_loop_iteration_delay_ms),
)?; |
rust | Keyframe { frame_info: Keyframe },
/// mark the event as a custom event
Custom,
}
/// A keyframe is a start point of a phase, the Tendermint-like algorithm always
/// through a series of steps to reach a consensus like this
/// ```graph
/// +-----------------------------------------------+
/// | epoch 1 |
/// +--+---------------------------------------+----+ |
rust | pub struct CssFontFaceRule {
inner: web_sys::CssFontFaceRule,
}
impl CssFontFaceRule {
pub fn style(&self) -> CssStyleDeclaration { |
rust | for i in 1..src.len() {
if i <= r {
z[i] = min(r - i + 1, z[i - l]);
}
while i + z[i] < src.len() && bytes[z[i]] == bytes[i + z[i]] {
z[i] += 1;
}
if i + z[i] - 1 > r {
l = i;
r = i + z[i] - 1;
}
} |
rust | {
match segments.next() {
Some(seg) => T::parse(ctx, msg, seg).await.map(Some).map_err(ArgumentError::Argument),
None => Ok(None),
}
}
/// Tries to parse many arguments from a list of segments using the [std::str::FromStr] trait.
///
/// Each segment in the list is parsed into a vector of arguments. If parsing |
rust | }
pub fn has_guidePoint(&self) -> bool {
self.guidePoint.is_some()
}
// Param is passed by value, moved
pub fn set_guidePoint(&mut self, v: RoadPoint) {
self.guidePoint = ::protobuf::SingularPtrField::some(v);
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_guidePoint(&mut self) -> &mut RoadPoint {
if self.guidePoint.is_none() { |
rust | pub enum OpError {
// todo add operations errors
Unknown(String),
}
#[cfg(feature = "rocks_db")]
impl From<::rocksdb::Error> for OpError {
fn from(err: ::rocksdb::Error) -> Self {
OpError::Unknown(err.into_string())
}
}
pub use ledger_diff::LedgerDiffOps;
pub use milestone::MilestoneOps;
pub use transaction::TransactionOps; |
rust |
fn visit_varlit(&mut self, value : Box<String>) -> Node
{
//take a lookup in ctx.symbol_table with key value
Node::VarLiteral(value) |
rust | {
fn from(order: OrderClause<Expr>) -> Self {
Some(Box::new(order.0))
}
}
impl<'a, DB> From<NoOrderClause> for Option<Box<dyn QueryFragment<DB> + Send + 'a>>
where
DB: Backend,
{
fn from(_: NoOrderClause) -> Self {
None
} |
rust | use alloc::boxed::Box;
use retry_backoff::RetryBackoff;
use retry_predicate::RetryPredicate;
use crate::retry_policy::RetryPolicy; |
rust |
#[cfg(unix)]
pub mod unix;
pub mod service; |
rust | instructions.result_conditional_execute("condition".to_string(), None);
instructions.end_expression();
let mut expression_runtime = ExpressionRuntime::new(&instructions);
let result = expression_runtime.execute("main").unwrap();
|
rust | Some(sheet_id) => Ok(sheet_id.parse::<u64>()?),
None => {
let error_msg = "Usage: rows_delete <sheet_id>";
error!("{}", error_msg);
Err(Box::new(Error::new(ErrorKind::InvalidInput, error_msg)))
}
}
}
#[tokio::main]
async fn main() -> Result<()> {
sensible_env_logger::init!();
let sheet_id = fetch_args().await?;
|
rust | #[cfg(test)]
mod tests {
use crate::computer::IntCodeComputer;
#[test]
fn part1() {
let comp = IntCodeComputer::from_input_file("dec05.txt", 1);
assert_eq!(comp.last(), Some(9_219_874));
}
#[test]
fn part2() { |
rust | Self {
total,
avail: total.saturating_sub((stats.active_count as u64).wrapping_add(stats.inactive_count as u64)
.wrapping_add(stats.wire_count as u64)
.wrapping_add(stats.speculative_count as u64)
.wrapping_sub(stats.purgeable_count as u64)
.saturating_mul(page_size)
) |
rust | #[doc = "DCH0CPTR register"]
pub struct DCH0CPTR {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "DCH0CPTR register"]
pub mod dch0cptr;
#[doc = "DCH0CPTRCLR register"]
pub struct DCH0CPTRCLR { |
rust |
use crate::action::Action;
fn main() {
let matches = App::new(env!("CARGO_PKG_NAME"))
.version(env!("CARGO_PKG_VERSION")) |
rust | left: `{:#010b}`,
right: `{:#010b}`"#, left_val, right_val)
}
}
}
});
}
pub fn create_sx1278() -> (SX1278<MockSpi, MockPin, LoRa>, Rc<RefCell<MockDevice>>) {
let device = Rc::new(RefCell::new(MockDevice::new()));
let sx = SX1278::new_lora(
MockSpi::new(Rc::clone(&device)),
MockPin::new(Rc::clone(&device)) |
rust | trap_frame.set_register_xi(rd, load_value);
// println!("[rustsbi trap handler] Load misaligned! epc: {:016x?}, ins: {:016x}, addr: {:016x}", ins_vaddr , ins, load_vaddr);
// println!("[rustsbi trap handler] (uncompressed) rd: {:?} value: {:016x}", rd,load_value);
mepc::write(mepc::read().wrapping_add(4)); // 跳过指令
}
2 => { |
rust | sum
}
}
//#[test]
fn test_example() { |
rust | use std::fs;
fn main() {
let mut fare: Vec<f64> = Vec::new();
let mut survived: Vec<f64> = Vec::new();
let file =
fs::read_to_string("resources/data.csv").expect("Something went wrong reading the file");
for l in file.lines() {
let split: Vec<f64> = l.split(',').map(|x| x.parse::<f64>().unwrap()).collect();
fare.push(split[0]);
survived.push(split[1]);
}
let w_ = vec![1.0; fare.len()];
let mut disc = Discretizer::new(Some(5.0), Some(10), Some(0.001), Some(1.0), Some(1)); |
rust | pub mod usbvecint;
#[doc = "USBMAINT register accessor: an alias for `Reg<USBMAINT_SPEC>`"]
pub type USBMAINT = crate::Reg<usbmaint::USBMAINT_SPEC>;
#[doc = "USB maintenance register"]
pub mod usbmaint;
#[doc = "USBTSREG register accessor: an alias for `Reg<USBTSREG_SPEC>`"]
pub type USBTSREG = crate::Reg<usbtsreg::USBTSREG_SPEC>;
#[doc = "USB Time Stamp register"]
pub mod usbtsreg; |
rust | AND table_name = '{}';", table_name);
let table_exists = conn.query_map(
if_exist,
|count: usize| {
count
}
).unwrap();
match & table_exists[0] {
0 => Ok(false),
1 => Ok(true),
_ => Err(mysql::Error::MySqlError(MySqlError { message: "Error in fetching the table status".to_string(), state: "MySqlError".to_string(), code: 1004 }))
}
} |
rust | mod tegra_dds;
#[repr(C)]
struct FileInfo {
file_data_ptr: *const u8, |
rust | }
#[doc = "Undefined Behaviour. Probably unmasks the Power Down event."]
#[inline(always)]
pub fn undefined(self) -> &'a mut W {
self.variant(M4S0_PD_EVENT_MASK_A::UNDEFINED)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W { |
rust | 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x0, 0x0, 0x0,
0x22, 0x17, 0x41, 0x0, 0x32, 0x20
];
#[rustfmt::skip] |
rust | #[doc = "`write(|w| ..)` method takes [ucb0ifg_spi::W](ucb0ifg_spi::W) writer structure"]
impl crate::Writable for UCB0IFG_SPI {}
#[doc = "USCI B0 Interrupt Flags Register"]
pub mod ucb0ifg_spi;
#[doc = "USCI B0 Interrupt Vector Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ucb0iv_spi](ucb0iv_spi) module"]
pub type UCB0IV_SPI = crate::Reg<u16, _UCB0IV_SPI>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _UCB0IV_SPI;
#[doc = "`read()` method returns [ucb0iv_spi::R](ucb0iv_spi::R) reader structure"]
impl crate::Readable for UCB0IV_SPI {}
#[doc = "`write(|w| ..)` method takes [ucb0iv_spi::W](ucb0iv_spi::W) writer structure"] |
rust | // timestamp: String,
pub comment: Option<String>,
pub text: String,
}
|
rust | #[derive(Eq, PartialEq, Debug, Copy, Clone)]
#[repr(u8)]
pub enum EncryptionType {
No = crate::AUTH_LOGIN_PASS,
Aes128Gcm = crate::AUTH_KEY_AES128_GCM,
Aes256Gcm = crate::AUTH_KEY_AES256_GCM,
}
impl EncryptionType { |
rust | /// An alias for the type that represents the ID of an HTTP/2 stream
pub type StreamId = u32;
|
rust | use crate::ray::Ray;
use crate::{FloatTy, Pt3, Vec3};
mod dielectric;
mod lambertian;
mod light;
mod metal;
mod utils;
pub use dielectric::*;
pub use lambertian::*; |
rust | Ok(Command::cargo_bin(BIN_NAME)?)
}
pub fn git_dir() -> Result<PathBuf> {
let tmp_dir = tempdir()?; |
rust |
extern crate lib;
use lib::{CV, WrapperB, WrapperC};
fn main() {
let a = WrapperC(CV);
let b = WrapperC(CV);
if false {
let _ = a * b;
}
} |
rust | pub use self::grinbox_address::{
hrp_bytes, GrinboxAddress, GRINRELAY_ADDRESS_HRP_MAINNET, GRINRELAY_ADDRESS_HRP_TESTNET,
};
pub use self::grinbox_address::{set_running_mode, ChainTypes};
pub use self::grinbox_message::GrinboxMessage;
pub use self::grinbox_request::GrinboxRequest;
pub use self::grinbox_response::{GrinboxError, GrinboxResponse};
pub use self::tx_proof::{ErrorKind as TxProofErrorKind, TxProof};
|
rust | }
impl Pattern {
pub fn is_wildcard(&self) -> bool {
match self {
Self::Constructor(_, _) => false,
Self::Wildcard => true,
} |
rust | pub mod work;
use crate::WORLD;
use activity::ActivityTypes;
use housing::HousingTypes;
use work::WorkTypes;
use serde::{Deserialize, Serialize};
use crate::state::state_container::StateContainer;
#[derive(Serialize, Deserialize, Clone, Copy, Debug)]
pub struct Input {
pub work: WorkTypes, |
rust |
#[derive(Debug, Error, From)]
pub struct IntegrityErrors {
pub errors: Vec<IntegrityError>,
}
impl IntegrityErrors {
fn try_from(errors: Vec<IntegrityError>) -> Result<(), IntegrityErrors> {
if errors.is_empty() {
Ok(()) |
rust | Quit,
}
fn accumulate_stats(name: String, source: String, rx: mpsc::Receiver<StatJob>) {
info!("stat_thread starting up");
let mut filter_stats = FSType::new();
let mut non_cpg_read_profile: Option<Vec<[usize; 4]>> = None;
let mut vcf_stats: Option<VcfStats> = None;
loop {
match rx.recv() {
Ok(StatJob::Quit) => {
debug!("stat_thread recieved quit signal - generating report");
let mut stats = Stats::new(name, source, vcf_stats, filter_stats);
stats.stats.total_stats().methylation().non_cpg_read_profile = non_cpg_read_profile;
break; |
rust | #[inline]
fn from(id: NodeId) -> Self {
id.0
}
}
impl From<NodeId> for u16 {
#[inline]
fn from(id: NodeId) -> Self {
id.0 as u16
}
}
impl From<NodeId> for u32 { |
rust | break;
}
// Only process non-empty lines, otherwise ask the user again
let line = line.trim();
if line.len() > 0 { |
rust | use std::cmp;
use std::mem;
/// A struct representing an internal node of an avl tree.
pub struct Node<T, U> { |
rust | mod structs;
#[path = "src/util.rs"]
mod util;
use std::{env, fs, path::PathBuf};
use structs::DefData;
use util::parse_jsonc;
fn main() {
let manifest = env::var_os("CARGO_MANIFEST_DIR").unwrap();
// parse default definitions
let content = fs::read_to_string(PathBuf::from(manifest).join("src/data/definitions.json")) |
rust |
#[derive(Display, Debug)]
pub enum FramingError {
EncodeErr(String),
DecodeErr(String),
IoError(String)
}
impl Error for FramingError {}
impl From<std::io::Error> for FramingError {
fn from(err: std::io::Error) -> FramingError {
FramingError::IoError(err.to_string())
} |
rust | use cardano_serialization_lib::StakeRegistration as RStakeRegistration;
use std::convert::{TryFrom, TryInto};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct StakeRegistration {
stake_credential: StakeCredential,
}
impl From<StakeRegistration> for RStakeRegistration {
fn from(stake_registration: StakeRegistration) -> Self {
RStakeRegistration::new(&stake_registration.stake_credential.into())
}
}
|
rust | transform_variable_invocation(variable_invocation)
}
}
}
fn expression_to_regex(expression: &Expression) -> String {
match expression {
Expression::Group(group) => transform_group(group),
Expression::Atom(atom) => String::from(atom),
Expression::Range(range) => transform_range(range), |
rust | #![deny(missing_docs)]
#![deny(unreachable_patterns)]
#![deny(unused_extern_crates)]
#![deny(unused_imports)]
#![deny(unused_qualifications)]
extern crate argparse;
extern crate ilda;
extern crate lase;
use ilda::animation::Animation;
use lase::Point;
use lase::tools::find_first_etherdream_dac; |
rust | mod interpret;
use std::str::FromStr;
use std::io::{self, Read};
use pcws_domain::{Allocator, register_static_t};
use pcws_domain::values;
use pcws_syntax::cst::Expr;
use env::{Env, EnvBuffer};
use inject::Inject; |
rust | use super::config::Config;
use super::player::Player;
use super::world::World;
use bevy::prelude::*;
pub struct Gameone;
impl Plugin for Gameone {
fn build(&self, app: &mut AppBuilder) {
app.add_plugin(Config).add_plugin(Player).add_plugin(World);
}
}
|
rust | use {Error, protocol};
use server::client::{ClientState, Action};
/// Handle the 'PWD' command.
pub fn handle(client: &mut ClientState) -> Result<Action, Error> {
let session = client.session.expect_ready()?;
Ok(Action::Reply(protocol::reply::pwd::success(&session.working_dir)))
}
|
rust |
use gkquad::prelude::{integral, integral2, DynamicY};
fn main() {
println!("1D: {}", 2.0 * 1.0);
println!(
"2D: {}",
2.0 * integral(|x: f64| (1.0 - x * x).sqrt(), -1.0..1.0)
.unwrap()
.estimate
);
|
rust | pub mod render_template;
pub mod write_to_file;
|
rust | //! Module for generator with distribution
pub use normal_generator::*;
mod normal_generator;
|
rust | // dataprovider struct and matcher above, and update the expected logic here.
fn get_data_providers() -> Vec<SyncTestDataProvider> {
// To keep everything on one line:
type STDP = SyncTestDataProvider;
type NLT = NetworkListType;
type AM = AutoMode;
vec![
STDP::new(None, NLT::ContainsKnown, AM::Ask, false),
STDP::new(None, NLT::ContainsKnown, AM::First, false),
STDP::new(None, NLT::ContainsKnown, AM::KnownOrAsk, false), |
rust | impl PhysicalExpr for CastExpr {
fn evaluate(&self, df: &DataFrame, state: &ExecutionState) -> Result<Series> {
let series = self.input.evaluate(df, state)?;
series.cast_with_dtype(&self.data_type)
}
fn to_field(&self, input_schema: &Schema) -> Result<Field> {
self.input.to_field(input_schema)
} |
rust | use blog_target_cpu::*;
use criterion::{criterion_group, criterion_main, Criterion};
use rand::distributions::Standard;
use rand::prelude::*;
use std::default::Default;
fn prepare_data(width: usize, height: usize) -> (Vec<u8>, Vec<RGBA32>, Vec<RGBA32>) {
let samples = width * height;
let palette = {
let mut p = Vec::new();
let mut i = 0u8; |
rust |
/// The length Nis1 Aes IV in bytes.
pub const NIS_AES_IV_LENGTH: usize = 16;
/// The length Nis1 Salt in bytes.
pub const NIS_SALT_LENGTH: usize = 32;
/// The length Symbol Aes Tag in bytes.
pub const AES_TAG_LENGTH: usize = 16; |
rust | use std::io;
use std::io::{Read, Write};
fn main() {
let mut buffer = [0; 256];
let mut stdin = io::stdin();
let n = stdin.read(&mut buffer).unwrap();
io::stdout().write_all(&buffer[..n]).unwrap();
}
|
rust |
#[cfg(test)]
mod tests {
use super::*;
|
rust | impl<'a> ShellCmdApi<'a> for Ver {
cmd_api!(ver); // inserts boilerplate for command API
fn process(&mut self, args: String::<1024>, env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> {
use core::fmt::Write;
let mut ret = String::<1024>::new();
let helpstring = "ver options: ec, wf200, soc, dna";
let mut tokens = args.as_str().unwrap().split(' ');
if let Some(sub_cmd) = tokens.next() {
match sub_cmd {
"ec" => {
let (rev, dirty) = env.com.get_ec_git_rev().unwrap();
let dirtystr = if dirty { "dirty" } else { "clean" }; |
rust | pub index: Option<syn::Index>,
}
impl quote::ToTokens for FieldWrapper<'_> {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
if let Some(field) = self.field {
field.to_tokens(tokens);
} else if let Some(index) = &self.index {
index.to_tokens(tokens);
|
rust | impl crate::ResetValue for super::CRS {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `CRS`"]
pub type CRS_R = crate::R<u16, u16>; |
rust | /// "Invisible" mark, used in `Annotation` to ensure that a span is visible
/// within the snippet. Does _not_ add any visual indicators to the
/// output, and does not accept a label.
Show,
/// Low-priority visual marking.
Mark(Option<LabelStr>),
/// High-priority visual marking, used to call attention to the marked span
/// using a distinctive visual style.
Highlight(Option<LabelStr>)
}
|
rust | blob_refs: HashMap<Uuid, HashMap<String, Box<dyn BlobRef>>>,
}
impl MemoryMetaStorage {
pub fn new(config: MemoryMetaStorageConfig) -> Result<Self, MetaStorageError> {
Ok(Self { metas: HashMap::new(), blob_refs: HashMap::new() })
}
}
impl MetaStorage for MemoryMetaStorage { |
rust | <gh_stars>0
pub mod commands;
pub mod filesystem;
pub mod server;
pub mod reconnect;
pub const NAME: &str = "orbit_agent"; // agent's name
pub const VERSION: u64 = 2; // agent's version |
rust | use std::ops::Range;
pub const POSTGRESQL_URL: &'static str = "postgresql://admin@localhost:5432/youtube";
pub const CACHE_SIZE: usize = 1000;
pub const DRAIN_RANGE: Range<usize> = 0..CACHE_SIZE;
pub const INSERT: &'static str = "INSERT INTO youtube.stats.subs (id, subs) VALUES ($1, $2)"; |
rust | }
pub fn parse() -> Result<Configuration, Error> {
let args = App::new("usync")
.version("1.0")
.author("Elisabeth '<NAME>")
.arg(Arg::with_name("force-pipeline")
.hidden(true)
.long("force-pipeline")
)
.arg(
Arg::with_name("rebuild manifest")
.help("rebuild the required manifest(s), even if it already exists") |
rust | let actual = format!("{}", version);
assert_eq!(actual, expected);
}
#[test]
fn add_fix_should_replace_old_prelease_date_fix_with_new_date() {
let mut version = ChocoVersion::parse("5.1.7-ceta-20100602").unwrap(); |
rust | [u8; bits_to_bytes(T::BITS)]: Sized,
{
mem: [u8; bits_to_bytes(T::BITS)],
_marker: PhantomData<T>,
}
impl<T: BitType> Bit<T>
where
[u8; bits_to_bytes(T::BITS)]: Sized,
{
/// Get an immutable accessor |
rust | /// `maybe_dir`, a function for controlling whether an open should
/// attempt to succeed on a directory. On Posix-ish platforms, opening
/// a directory always succeeds, but on Windows, opening a directory
/// needs this option.
pub trait OpenOptionsMaybeDirExt {
/// Sets the option for disabling an error that might be generated
/// by the opened object being a directory.
fn maybe_dir(&mut self, maybe_dir: bool) -> &mut Self;
}
impl OpenOptionsMaybeDirExt for cap_primitives::fs::OpenOptions { |
rust | fn main() {
// adding panic = 'abort' to a cargo.toml file will force it to abort instead of unwind
// for example:
// [profile.release]
// panic = 'abort'
panic!("crash and burn");
} |
rust | use rust::gen::github::v3;
fn main() -> Result<(), rust::gen::reproto::Error> {
let client = reqwest::Client::new();
let github = v3::Github_Reqwest::new(client, None)?;
let rate_limit = github.get_rate_limit()?;
println!("{:?}", rate_limit);
let gists = github.get_user_gists("udoprog".to_string())?;
|
rust |
pub fn read_i32_be(&self, offset: usize) -> i32 {
i32::from_be_bytes(self.piece(offset, size_of::<i32>()).try_into().unwrap())
}
pub fn read_u32_le(&self, offset: usize) -> u32 {
u32::from_le_bytes(self.piece(offset, size_of::<u32>()).try_into().unwrap())
}
pub fn read_u32_be(&self, offset: usize) -> u32 {
u32::from_be_bytes(self.piece(offset, size_of::<u32>()).try_into().unwrap())
}
pub fn read_i64_le(&self, offset: usize) -> i64 {
i64::from_le_bytes(self.piece(offset, size_of::<i64>()).try_into().unwrap()) |
rust |
impl From<ParseError> for LoadError {
fn from(error: ParseError) -> LoadError {
LoadError::ParseError(error)
}
}
impl Program {
pub fn load(source: String) -> Result<Program, LoadError> {
let mut defines = HashMap::<String, String>::default();
let source = preprocess(source, &mut defines)?;
let lexer = LexerContext::lex(&source, &defines);
|
rust | // `(2 * c + 1)` cells (where `c` was the old number) should be enough.
// Lucky for us, we automatically get this by building a centered supercell.
trace!("bond graph: true supercell: centered_diagonal({:?})", coeffs);
Ok(supercell::centered_diagonal(coeffs)) |
rust | fn input_move_right(&self, controls: &Controls, stack: &Stack) -> Self {
self.try_moving_piece(stack, controls.right, controls.left, |piece| {
piece.move_right()
})
}
fn input_rotate_left(&self, controls: &Controls, stack: &Stack) -> Self {
self.try_moving_piece(stack, controls.primary, controls.secondary, |piece| {
piece.rotate_left()
})
}
fn input_rotate_right(&self, controls: &Controls, stack: &Stack) -> Self {
self.try_moving_piece(stack, controls.secondary, controls.primary, |piece| { |
rust | let offset = y * self.row_size;
for x in left..right {
self.bits[(offset + (x / 32)) as usize] |= 1 << (x & 0x1f);
}
}
return Ok(());
}
pub fn get_row(&self, y: isize, row: Option<Box<BitArray>>) -> Box<BitArray> {
let mut new_row: Box<BitArray>;
if let Some(row) = row { |
rust | USR_DATA4_R::new(self.bits as u32)
}
}
#[doc = "Register 4 of BLOCK3 (user).\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rd_usr_data4](index.html) module"]
pub struct RD_USR_DATA4_SPEC;
impl crate::RegisterSpec for RD_USR_DATA4_SPEC { |
rust | &self,
symbol: &str,
order_id: u64,
) -> Fallible<impl Future<Output = Fallible<OrderCanceled>>> {
let params = json! {{"symbol":symbol, "orderId":order_id}};
let order_canceled = self.transport.signed_delete(FAPI_V1_ORDER, Some(params))?;
Ok(order_canceled)
}
// Trade history
pub fn trade_history(
&self, |
rust | let v2_base = warp::path("v2")
.and(warp::get())
.and(warp::path::end())
.map(move || empty_json)
.with(warp::reply::with::header(
"Content-Length",
empty_json.len(), |
rust | Negative,
/// CBOR Byte stream (sequence of 0 to many bytes)
Bytes,
/// CBOR Text (sequence of 0 to many utf8 encoded character)
Text,
/// CBOR Array (sequence of 0 to many CBOR elements)
Array,
/// CBOR Map (sequence of 0 to many tuple of CBOR key/value elements)
Map,
/// CBOR Tag (unsigned integer followed by a CBOR element)
Tag,
/// CBOR False constant |
rust | fn write_metadata (
) -> Result <(), io::Error> {
let mut file =
File::create (
"src/metadata.rs", |
rust | #[cfg(target_os = "linux")]
fn clean() -> io::Result<ExitStatus>{
Command::new("clear").status()
}
#[cfg(target_os = "windows")]
fn clean() -> io::Result<ExitStatus> {
Command::new("cls").status()
}
pub trait View {
|
rust | // = x + factor * u
for column in (minor + 1)..n {
// factor = <x, u>/(a * qrdata[k * n + k])
let mut x_dot_u : T = num::zero();
for row in minor..m {
x_dot_u = x_dot_u + qrdata[row * n + minor] * qrdata[row * n + column];
}
let factor = x_dot_u / (a * qrdata[minor * n + minor]);
// Hx = x + factor * u
for row in minor..m {
qrdata[row * n + column] = qrdata[row * n + column] + factor * qrdata[row * n + minor];
} |
rust | fuel = fuel / 3 - 2;
if fuel > 0 {
total_fuel += fuel;
}
else {
break;
} |
rust | fn dangle() -> &String { // dangle returns a reference to a String
let s = String::from("hello");
&s // we return a reference to the String, s
} // Here, s goes out of scope, and is dropped. Its memory goes away.
// Danger! |
rust | use crate::vector::Vector;
pub trait SparseVector<'vec> : Vector<'vec> {} |
rust | DEFAULT_BLOCK_TIME,
1,
(U512::from(ACCOUNT_1_BOND),),
)
.commit()
.finish();
let response = result
.builder()
.get_exec_response(1)
.expect("should have a response")
.to_owned();
let error_message = {
let execution_result = test_support::get_success_result(&response); |
rust | pub mod mknodat;
pub mod prctl;
|
rust | pub mod links;
pub mod view;
pub type ArticleView = view::ArticleView;
|
rust | self.board.add_piece(&self.actual_piece, x_coordinate, y_coordinate);
return false;
}
y_coordinate -= 1
}
MoveDirection::Right => {
if y_coordinate >= self.board.columns - 1 {
self.board.add_piece(&self.actual_piece, x_coordinate, y_coordinate);
return false;
}
y_coordinate += 1
}
}
|
rust | causetx: TuringStringNonValuePlace::Placeholder,
});
assert!(cc.is_known_empty());
}
#[test] |
rust |
pub fn direct_child_str(&self, query: &str) -> Option<String> {
claim_direct_child_str(self, &query)
}
pub fn direct_descendant(&self, query: &Claim) -> Option<String> {
claim_direct_descendant(self, &query)
}
pub fn direct_descendant_str(&self, query: &str) -> Option<String> {
claim_direct_descendant_str(self, &query)
}
}
|
rust | fn test_array() {
let code = "
let
type intArray = array of int
var intArray := intArray[10] of 0
in
intArray[3] := 20
end |
rust | #[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if (&tmp.message).is_none() {
tmp.message = _error_message;
}
tmp
}),
}, |
rust | #![cfg_attr(not(feature = "use_std"), no_std)]
#[macro_use]
extern crate cfg_if;
#[cfg(feature = "use_std")]
extern crate core;
mod cache_padded;
pub mod atomic;
#[cfg(feature = "use_std")]
pub mod thread;
pub use cache_padded::CachePadded; |
rust | adr: u8,
}
impl Device {
pub const fn new(address: u8) -> Self { |
Subsets and Splits