text stringlengths 2.5k 6.39M | kind stringclasses 3
values |
|---|---|
use ff::PrimeField;
use crate::polynomials::*;
use crate::arp::*;
use crate::air::*;
use crate::fft::multicore::Worker;
use crate::SynthesisError;
use crate::domains::*;
use crate::precomputations::*;
use crate::transcript::Transcript;
use indexmap::IndexSet;
use indexmap::IndexMap;
// use std::collections::{IndexMa... | the_stack |
use std::iter;
use std::mem;
use std::collections::{HashMap, BTreeSet};
use std::hash::BuildHasherDefault;
use fnv::FnvHasher;
use thiserror::Error;
type FastMap64<K, V> = HashMap<K, V, BuildHasherDefault<FnvHasher>>;
/// Guest virtual address
pub type Gva = u64;
/// Guest physical address
pub type Gpa = u64;
///... | the_stack |
use ::error::{Error, Result};
use ::ipc;
use ::server::api_table;
use ::server::ipc_bridge;
use ::server::plugin_core;
use ::spinner;
use ::rpc;
use mio;
use std::collections::hash_map::Entry;
use std::collections::{HashMap, HashSet};
use std::sync::mpsc;
use std::thread;
const CORE_FUNCTIONS_PREFIX: &'static str = "c... | the_stack |
use query_engine_tests::*;
#[test_suite(capabilities(Json), exclude(MySQL(5.6)))]
mod json {
use query_engine_tests::{assert_error, jNull, run_query, ConnectorCapability};
use query_tests_setup::Runner;
#[connector_test(schema(json_opt))]
async fn basic(runner: Runner) -> TestResult<()> {
crea... | the_stack |
#[allow(unused)]
fn runner() -> crate::TestRunner {
super::runner()
.mock_file("conflict/_downstream.scss", "@forward \"midstream\" with ($a: b);\n")
.mock_file("conflict/_left.scss", "$a: left;\n")
.mock_file("conflict/_midstream.scss", "@use \"left\" as *;\n@use \"right\" as *;\n\n$a: c !d... | the_stack |
// TODO(blacknon): 以下の情報を参考に開発を進めていく！
// - 【参考】
// - http://www.kis-lab.com/serikashiki/man/ncurses.html#output
// module
use ncurses::*;
use std::convert::TryInto;
use std::sync::Mutex;
// local module
mod diff;
mod watch;
use self::watch::WatchPad;
use cmd::Result;
use view::color::*;
pub struct Watch {
... | the_stack |
/// A port of CPython's tokenizer.c to Rust, with the following significant modifications:
///
/// - PEP 263 (encoding detection) support isn't implemented. We depend on other code to do this for
/// us right now, and expect that the input is utf-8 by the time we see it.
///
/// - Removed support for tokenizing from ... | the_stack |
mod count;
mod duplicates;
mod label;
mod references;
mod walk;
use {
atty::Stream,
clap::{App, AppSettings, Arg, ArgMatches, SubCommand},
colored::Colorize,
regex::{escape, Regex},
std::{
collections::HashMap,
io::BufReader,
path::{Path, PathBuf},
process::exit,
... | the_stack |
use query_engine_tests::*;
// Note: These tests changed from including the relation fields into only including the scalars as per the new relations
// implementation. Tests are retained as they offer a good coverage over scalar + relation field usage.
//
// 1) Checks if relation fields in @id in any constellation work... | the_stack |
use std::cell::RefCell;
use std::collections::HashMap;
use std::fs::{self, File};
use std::io::{Error, ErrorKind, Read};
use std::path::Path;
use std::path::PathBuf;
use lazy_static::lazy_static;
use serde::{Deserialize, Deserializer};
use log::{Level, LevelFilter};
use crate::io::keyboard_event::Key;
use crate::io::... | the_stack |
use anyhow::{anyhow, Result};
/// Character type.
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum CharacterType {
/// Digit character. (e.g. 0, 1, 2, ...)
Digit = b'D',
/// Roman character. (e.g. A, B, C, ...)
Roman = b'R',
/// Japanese Hiragana character. (e.g. あ, い, う, .... | the_stack |
extern crate regex;
#[macro_use] extern crate lazy_static;
extern crate term;
extern crate kailua_env;
extern crate kailua_diag;
#[macro_use] extern crate log;
#[macro_use] extern crate clap;
use std::str;
use std::fmt;
use std::env;
use std::fs;
use std::mem;
use std::panic;
use std::process;
use std::any::Any;
use s... | the_stack |
use core::fmt;
use core::ops::{Add, AddAssign, Deref, DerefMut, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
use approx::{AbsDiffEq, RelativeEq, UlpsEq};
use num_traits::{One, Zero};
#[cfg(feature = "random")]
use rand::distributions::uniform::{SampleBorrow, SampleUniform, Uniform, UniformSampler};
#[cfg(feature =... | the_stack |
use crate::{
cargo::selected_package::{SelectedInclude, SelectedPackages},
config::CargoConfig,
utils::{
apply_sccache_if_possible, log_sccache_stats, project_root, sccache_should_run,
stop_sccache_server,
},
Result,
};
use anyhow::{anyhow, Context};
use cargo_metadata::Message;
use ... | the_stack |
use cargo_test_support::{command_is_available, paths, Execs};
use std::env;
use std::fs;
use std::process::Command;
fn cargo_process(s: &str) -> Execs {
let mut execs = cargo_test_support::cargo_process(s);
execs.cwd(&paths::root()).env("HOME", &paths::home());
execs
}
fn mercurial_available() -> bool {
... | the_stack |
use std::borrow::Cow;
use std::collections::HashMap;
use std::fs::File;
use std::io::{self, BufRead};
use std::path::Path;
use anyhow::Result;
use protobuf::Message;
use regex::Regex;
use crate::config::{external_rule, internal};
#[derive(Debug, Default)]
pub struct Tun {
pub name: Option<String>,
pub addres... | the_stack |
use crate::build_rs::BuildInfo;
use crate::spec::ProbeArgSpecification;
use crate::spec::ProbeSpecification;
use crate::spec::ProviderInitSpecification;
use crate::spec::ProviderSpecification;
use crate::TracersResult;
use heck::SnakeCase;
use proc_macro2::TokenStream;
use quote::ToTokens;
use quote::{quote, quote_span... | the_stack |
extern crate hex;
use bitcoin::types::TransactionInputSource;
pub use bitcoin::{
formatter::{Formattable, TryFormattable},
types::*,
};
pub use btc_relay::{BtcAddress, BtcPublicKey};
use currency::Amount;
use frame_support::traits::GenesisBuild;
pub use frame_support::{
assert_err, assert_noop, assert_ok,
... | the_stack |
use crate::{
ir::IsIrType,
type_info::{TypeInfo, TypeSize},
};
use hir::{FloatBitness, HirDatabase, HirDisplay, IntBitness, ResolveBitness, Ty, TyKind};
use inkwell::{
context::Context,
targets::TargetData,
types::FunctionType,
types::{AnyTypeEnum, BasicType, BasicTypeEnum, FloatType, IntType, S... | the_stack |
use std::mem;
use std::ptr;
use std::alloc;
use crate::cx::*;
use std::collections::BTreeSet;
impl Cx {
pub fn get_default_window_size(&self) -> Vec2 {
return self.platform.window_geom.inner_size;
}
pub fn process_to_wasm<F>(&mut self, msg: u32, mut event_handler: F) -> u32
where F: F... | the_stack |
use std::sync::Arc;
use hdk::prelude::*;
use holochain::{
conductor::api::error::ConductorApiResult,
sweettest::{SweetAgents, SweetConductor, SweetDnaFile},
};
use holochain::{
conductor::{api::error::ConductorApiError, CellError},
core::workflow::error::WorkflowError,
test_utils::WaitOps,
};
use h... | the_stack |
use std::{borrow::Cow, fmt::Debug};
use serde::{de::Visitor, Deserialize};
use serde_bytes::ByteBuf;
use crate::{
de::convert_unsigned_to_signed_raw,
extjson,
oid::ObjectId,
raw::{RawJavaScriptCodeWithScope, RAW_ARRAY_NEWTYPE, RAW_DOCUMENT_NEWTYPE},
spec::BinarySubtype,
Binary,
DateTime,
... | the_stack |
#[macro_use]
mod sys_common;
use cap_std::fs::{DirBuilder, OpenOptions};
use std::io::{self, Read, Write};
use std::path::Path;
use std::str;
use sys_common::io::{tmpdir, TempDir};
use sys_common::symlink_supported;
#[cfg(not(windows))]
fn symlink_dir<P: AsRef<Path>, Q: AsRef<Path>>(src: P, tmpdir: &TempDir, dst: Q) ... | the_stack |
use crate::generate::src::{quote, Src};
use grammer::context::{Context, IRule, IStr};
use grammer::forest::NodeShape;
use grammer::rule::{Fields, MatchesEmpty, Rule, RuleWithFields, SepKind};
use grammer::{proc_macro, scannerless};
use indexmap::{indexmap, IndexMap, IndexSet};
use std::borrow::Cow;
use std::collection... | the_stack |
use std::collections::{HashMap, HashSet};
use std::ops::Deref;
use rustc::hir::def::{DefKind, Namespace, Res};
use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId};
use rustc::hir::map as hir_map;
use rustc::hir::{self, Node, HirId};
use rustc::session::Session;
use rustc::session::config::CrateType;
use rustc::ty::subst:... | the_stack |
#[allow(dead_code)]
#[derive(PartialEq, Clone, Debug)]
pub enum TokType {
LBrace, // {
RBrace, // }
LParen, // (
RParen, // )
LBracket, // [
RBracket, // ]
Semicolon, // ;
Assign, // =
Lt, // <
Gt, // >
Minus, ... | the_stack |
use crate::command::trove::CommandTrove;
use crate::gui::prompts::{prompt_input, prompt_input_validate};
use serde::{Deserialize, Serialize};
pub trait Parsable {
fn parse_arguments(matches: &clap::ArgMatches) -> Self;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HoardCommand {
pub name: Strin... | the_stack |
use super::command::{Command, CommandResp, Commander};
use super::fsm::FSM;
use super::sys_config::GlobalSysConfig;
use crate::contracts::solc::NodeManager;
use crate::core::context::LastHashes;
use crate::header::*;
pub use crate::libexecutor::block::*;
use crate::libexecutor::genesis::Genesis;
use crate::trie_db::Tr... | the_stack |
use reqwest::blocking::Client;
use serde::{Deserialize, Serialize};
use crate::action::api::ServerError;
use crate::error::CliError;
use super::{Pageable, RBAC_PROTOCOL_VERSION};
#[derive(Clone, Deserialize, Serialize)]
#[serde(tag = "identity_type", content = "identity")]
#[serde(rename_all = "lowercase")]
pub enum... | the_stack |
use common::consts::get_version_string;
use platform::process::get_pid;
use platform::time::sleep_secs;
use platform::time::time_now;
use storage::Cache;
use storage::Key as SKey;
use storage::Value as SValue;
use super::Driver;
use super::cmd::Cmd;
use super::cmd::Delete;
use super::cmd::FlushAll;
use super::cmd::Get... | the_stack |
use crate::GraphicsContext;
use alvr_common::{glam::UVec2, prelude::*};
use ash::vk;
use std::{any::Any, ffi::CStr, slice, sync::Arc};
use wgpu::{
Device, DeviceDescriptor, Extent3d, Texture, TextureDescriptor, TextureDimension,
TextureFormat, TextureUsages,
};
use wgpu_hal as hal;
pub const TARGET_VULKAN_VERS... | the_stack |
use crate::error::{CudaResult, DropResult, ToResult};
use crate::memory::device::{AsyncCopyDestination, CopyDestination, DeviceSlice};
use crate::memory::malloc::{cuda_free, cuda_malloc};
use crate::memory::{cuda_free_async, DevicePointer};
use crate::memory::{cuda_malloc_async, DeviceCopy};
use crate::stream::Stream;
... | the_stack |
//! Functions in this module are used to handle eBPF programs with a higher level representation,
//! for example to disassemble the code into a human-readable format.
use crate::ebpf;
use crate::error::UserDefinedError;
use crate::static_analysis::Analysis;
use crate::vm::InstructionMeter;
fn resolve_label<'a, E: Us... | the_stack |
use hdrhistogram::Histogram;
macro_rules! assert_near {
($a:expr, $b:expr, $tolerance:expr) => {{
let a = $a as f64;
let b = $b as f64;
let tol = $tolerance as f64;
assert!(
(a - b).abs() <= b * tol,
"assertion failed: `(left ~= right) (left: `{}`, right: `{}... | the_stack |
//! This is the Fuchsia Installer implementation that talks to fuchsia.update.installer FIDL API.
use crate::install_plan::FuchsiaInstallPlan;
use anyhow::{anyhow, Context as _};
use fidl_connector::{Connect, ServiceReconnector};
use fidl_fuchsia_hardware_power_statecontrol::RebootReason;
use fidl_fuchsia_update_insta... | the_stack |
use crate::config::CFG;
use crate::content::Content;
use crate::error::NoteError;
use crate::error::FRONT_MATTER_ERROR_MAX_LINES;
use crate::filename;
use crate::filename::MarkupLanguage;
use crate::filter::ContextWrapper;
use crate::filter::TERA;
use crate::note_error_tera_template;
use crate::settings::CLIPBOARD;
use... | the_stack |
use {
crate::{
capability_routing::{
error::CapabilityRouteError, route::RouteSegment, source::CapabilitySourceType,
},
component_tree::{ComponentNode, ComponentTree, NodePath},
},
cm_rust::{CapabilityDecl, CapabilityName, ExposeDecl, OfferDecl, UseDecl},
moniker::Par... | the_stack |
// NOTE: this is not SkPathBuilder, but rather a reimplementation of SkPath.
use alloc::vec;
use alloc::vec::Vec;
use crate::{Point, Rect, Path};
use crate::path_geometry;
use crate::path::PathVerb;
use crate::scalar::{Scalar, SCALAR_ROOT_2_OVER_2};
#[derive(Copy, Clone, PartialEq, Debug)]
pub enum PathDirection {... | the_stack |
use super::{CGFloat, CGPoint, CGRect, CGSize};
/// An affine transformation matrix for use in drawing 2D graphics.
///
/// See [documentation](https://developer.apple.com/documentation/coregraphics/cgaffinetransform).
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, PartialOrd)]
#[cfg_attr(not(test), derive(PartialEq)... | the_stack |
use bson::{self, Bson};
use super::options::WriteModel;
use common::WriteConcern;
use {Error, Result};
use std::{error, fmt};
/// The error type for Write-related MongoDB operations.
#[derive(Debug, Clone, PartialEq)]
pub struct WriteException {
pub write_concern_error: Option<WriteConcernError>,
pub write_err... | the_stack |
use super::crypto::{KeyPair, PublicKey};
use super::datalog::{Check, Fact, Rule, SymbolTable, Term};
use super::error;
use super::format::SerializedBiscuit;
use builder::{BiscuitBuilder, BlockBuilder};
use prost::Message;
use rand_core::{CryptoRng, RngCore};
use std::collections::HashSet;
use crate::format::{convert::... | the_stack |
use regex::Regex;
use std::str::CharIndices;
use lazy_static::lazy_static;
lazy_static! {
static ref TEST: Regex = Regex::new("...").unwrap();
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub enum Tok<'input> {
// Keywords
Module,
Attributes,
Fun,
Case,
Call,
Apply,
When,
End,
... | the_stack |
use super::*;
use apis_route::{RouteErr, RouteSyncHandler};
use fwd::ip_mask_decode;
use fwd::ipv4::IPv4Table;
use fwd::{adj::Adjacency, ipv4::IPv4Leaf, ipv4::IPv4TableMsg, Fwd};
use l3_ipv4_fwd::IPv4Fwd;
use l3_ipv4_parse::IPv4Parse;
use perf::Perf;
use std::fs::File;
use std::io::prelude::*;
use std::net::Ipv4Addr;
u... | the_stack |
// Based on https://github.com/nrf-rs/nrf52-hal/commit/f05d471996c63f605cab43aa76c8fd990b852460
use core::{
future::Future,
pin::Pin,
sync::atomic::{self, AtomicBool, Ordering},
task::{Context, Poll, Waker},
};
use cortex_m::peripheral::NVIC;
use pac::{Interrupt, UARTE0};
use crate::{BorrowUnchecked ... | the_stack |
use std::{env, fs, io};
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::{BufRead, BufReader, Write};
use std::net::SocketAddr;
use std::path::Path;
use std::str::FromStr;
use chrono::prelude::*;
use clap::{App, AppSettings, Arg};
use dnsclient::UpstreamServer;
use headless_chrome::Browser;
us... | the_stack |
use makepad_render::*;
use makepad_widget::*;
use makepad_hub::*;
use crate::makepadstorage::*;
use crate::searchindex::*;
#[derive(Clone)]
pub struct BuildManager {
pub signal: Signal,
pub active_builds: Vec<ActiveBuild>,
pub exec_when_done: bool,
pub log_items: Vec<HubLogItem>,
pub search_index: ... | the_stack |
use shared::devpropdef::DEVPROPKEY;
DEFINE_DEVPROPKEY!{DEVPKEY_NAME,
0xb725f130, 0x47ef, 0x101a, 0xa5, 0xf1, 0x02, 0x60, 0x8c, 0x9e, 0xeb, 0xac, 10}
DEFINE_DEVPROPKEY!{DEVPKEY_Device_DeviceDesc,
0xa45c254e, 0xdf1c, 0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0, 2}
DEFINE_DEVPROPKEY!{DEVPKEY_Device_Hard... | the_stack |
use merge::Merge;
use std::collections::BTreeMap;
use shipcat_definitions::{
structs::{
autoscaling::AutoScaling,
metadata::{default_format_string, Contact, Context, Language, SlackChannel},
security::DataHandling,
tolerations::Tolerations,
volume::Volume,
ConfigMap,... | the_stack |
extern crate timely;
extern crate differential_dataflow;
// taken from: https://adventofcode.com/2017/day/8
// use differential_dataflow::Collection;
use differential_dataflow::input::Input;
use differential_dataflow::operators::*;
use differential_dataflow::algorithms::prefix_sum::PrefixSum;
fn main() {
let in... | the_stack |
use crate::Integer;
use crate::SignedInteger;
use crate::SourceLocation;
use crate::UnsignedInteger;
use core::cmp;
use core::fmt;
use core::ops;
/// @class bsl::safe_integral
///
/// <!-- description -->
/// @brief Please see safe_integral.hpp for a complete set of details as to
/// what this class is, and how ... | the_stack |
use super::cfg::BlockCFG;
use crate::{
hlir::ast::{Command, Command_, Exp, ExpListItem, UnannotatedExp_, Value, Value_},
naming::ast::{BuiltinTypeName, BuiltinTypeName_},
parser::ast::{BinOp, BinOp_, UnaryOp, UnaryOp_},
};
use move_ir_types::location::*;
use std::convert::TryFrom;
/// returns true if anyth... | the_stack |
use super::file_error::*;
use flo_logging::*;
use rusqlite::*;
use std::result;
use std::path::{Path, PathBuf};
/// The definition file for the latest version of the database
const DEFINITION: &[u8] = include_bytes!["../../sql/file_list_v2.sqlite"];
/// The maximum supported version number
const MAX_VERSIO... | the_stack |
use super::path::*;
use crate::bezier::curve::*;
use crate::geo::*;
use crate::consts::*;
use smallvec::*;
use std::fmt;
use std::cell::*;
mod edge;
mod edge_ref;
mod ray_collision;
mod path_collision;
#[cfg(test)] pub (crate) mod test;
pub use self::edge::*;
pub use self::edge_ref::*;
pub use self::ray_collision:... | the_stack |
use super::SearchError;
use crate::tree::{SuffixTree, ROOT_NODE};
use logspace::LogSpace;
use ndarray::{ArrayBase, Axis, Data, Ix1, Ix2, Ix3};
use ndarray_stats::QuantileExt;
mod logspace {
use std::ops::{Add, AddAssign, Mul, MulAssign};
#[cfg(feature = "fastexp")]
fn exp(a: f32) -> f32 {
use crat... | the_stack |
#![feature(libc, rustc_attrs, core_intrinsics, conservative_impl_trait, associated_consts, custom_derive, test, slice_patterns, rand)]
extern crate test;
extern crate futures;
extern crate uuid;
extern crate serde;
extern crate serde_json;
#[macro_use]
extern crate serde_derive;
extern crate tickgrinder_util;
#[macro_... | the_stack |
use aster::AstBuilder;
use build::transition::{self, Transition};
use mir::*;
use syntax::ast::{self, ExprKind, StmtKind};
use syntax::codemap::respan;
use syntax::ext::base::ExtCtxt;
use syntax::ext::tt::quoted;
use syntax::ext::tt::transcribe;
use syntax::fold::{self, Folder};
use syntax::parse::parser::Parser;
use s... | the_stack |
pub mod actions;
mod error;
pub mod inputs;
pub mod periodic;
#[cfg(not(target_family = "wasm"))]
pub mod queue_drain_runner;
pub mod scripting;
pub mod state_machine;
use actions::{Action, TaskAction};
use ergo_database::object_id::{InputId, PeriodicTriggerId, TaskId, TaskTriggerId};
pub use error::*;
use inputs::Inp... | the_stack |
* HTML5 special entity decoding
*
* HHVM decodes certain HTML entities present in input strings before
* generating bytecode. In order to generate bytecode identical to HHVM's,
* this module performs the same HTML entity decoding as HHVM.
* Mimics: zend-html.cpp
* The list of entities tested was taken from
* htt... | the_stack |
use crate::error::{invalid_data_error, invalid_input_error};
use http::header::{CONNECTION, CONTENT_LENGTH, HOST, TRANSFER_ENCODING};
use http::{Request, Response, Version};
use httparse::Status;
use native_tls::TlsConnector;
use std::cmp::min;
use std::convert::TryInto;
use std::io;
use std::io::{BufRead, BufReader, R... | the_stack |
//! A dynamically sized worker pool.
//!
//! Workers are created on-demand as work is queued and dropped after idling
//! longer than the specified timeout.
//!
//! Idle worker management is implicitly performed on each queueing. To reap
//! idle workers while there are no new work items being queued, call
//! `Workque... | the_stack |
#[allow(unused)]
fn runner() -> crate::TestRunner {
super::runner()
}
mod after {
#[allow(unused)]
use super::runner;
mod at_rule {
#[allow(unused)]
use super::runner;
#[test]
#[ignore] // wrong error
fn css() {
assert_eq!(
runner().err(
... | the_stack |
extern crate regex;
use std::path::Path;
use std::f64;
use std::str::FromStr;
use std::fs::File;
use std::io::prelude::*;
use std::io::{BufReader};
use std::collections::{HashMap,HashSet};
use self::regex::Regex;
use dataflow::topology::Topology;
use dataflow::{Log,Rate,Rates,OperatorId,WorkerId,Epoch,OperatorInstan... | the_stack |
use std::marker::PhantomData;
#[cfg(feature = "parallel")]
use rayon::prelude::*;
use num::Zero;
use crate::counters::Counters;
use crate::geometry::{ContactManager, ParticlesContacts};
use crate::kernel::{CubicSplineKernel, Kernel};
use crate::math::{Real, Vector, DIM};
use crate::object::{Boundary, Fluid};
use cra... | the_stack |
use std::f64::consts::TAU;
use serde::{Deserialize, Serialize};
use super::{
control::Controller,
source::LfSource,
waveform::{InBuffer, Stage},
OutSpec,
};
#[derive(Deserialize, Serialize)]
pub struct Filter<C> {
#[serde(flatten)]
pub kind: FilterKind<C>,
pub in_buffer: InBuffer,
#[s... | the_stack |
use super::{
ifaces::RwLockIface,
ttas::{TTas, TTasGuard},
};
use std::cell::UnsafeCell;
use std::{
fmt,
time::{Duration, Instant},
};
use std::{
marker::PhantomData as marker,
ops::{Deref, DerefMut},
};
use std::{thread, thread::ThreadId};
const READ_OPTIMIZED_ALLOC: usize = 50_usize;
struct ... | the_stack |
use super::lexer::ParseMode;
use super::*;
// Parse
impl<'a> Parser<'a> {
/// Parse char literals.
pub(super) fn parse_char_literal(&mut self) -> Result<Node, ParseErr> {
let loc = self.loc();
let s = self.lexer.read_char_literal()?;
Ok(Node::new_string(s.to_string(), loc.merge(self.pre... | the_stack |
use super::utils::get_real_file_type;
use super::Options;
use bit_vec::BitVec;
use ego_tree::iter::Descendants;
use ego_tree::{NodeMut, NodeRef, Tree};
use std::collections::BinaryHeap;
use std::fs;
use std::io;
use std::iter::{FromIterator, IntoIterator, Iterator, Skip};
use std::path::{Path, PathBuf};
use std::time::... | the_stack |
// Licensed to Elasticsearch B.V under
// one or more agreements.
// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
// See the LICENSE file in the project root for more information
//
// Copyright 2019 Camden Reslink
// MIT License
// https://github.com/camdenreslink/clr-profiler
//
// Permis... | the_stack |
// Various integration tests that run inside a VM and test different aspects
// of the kernel. Check `kernel/tests/integration-test.rs` for the host-side
// counterpart.
use crate::arch::debug::shutdown;
use crate::kcb;
use crate::ExitReason;
type MainFn = fn();
#[cfg(feature = "integration-test")]
const INTEGRATION... | the_stack |
use crate::conf_change::conf_change::Changer;
use crate::conf_change::new_conf_change_single;
use crate::raftpb::raft::ConfChangeType::{
ConfChangeAddLearnerNode, ConfChangeAddNode, ConfChangeRemoveNode,
};
use crate::raftpb::raft::{ConfChange, ConfChangeSingle, ConfChangeType, ConfState};
use crate::tracker::progr... | the_stack |
use std::collections::HashMap;
use std::fmt;
use std::fs::File;
use std::ffi::OsStr;
use std::io::Read;
use std::io::Seek;
use std::io::SeekFrom;
use std::ops::Range;
use std::sync::Arc;
use fuser;
use indexmap::IndexMap;
use sanitize_filename;
use serde_json;
use mirakc_core::config::*;
use mirakc_core::error::Error... | the_stack |
use std::fs::{File, OpenOptions};
use std::io::{SeekFrom, ErrorKind, Seek, Write, Read, BufReader};
use chrono::Local;
use std::io::Error;
use std::io;
use byteorder::{WriteBytesExt, ReadBytesExt, NetworkEndian};
use std::str::from_utf8;
use num::{FromPrimitive, PrimInt};
use std::collections::{HashMap, VecDequ... | the_stack |
use core;
#[allow(unused_imports)]
use interface::{DivansCompressorFactory, BlockSwitch, LiteralBlockSwitch, Command, Compressor, CopyCommand, Decompressor, DictCommand, LiteralCommand, Nop, NewWithAllocator, ArithmeticEncoderOrDecoder, LiteralPredictionModeNibble, PredictionModeContextMap, free_cmd, FeatureFlagSliceTy... | the_stack |
use gst::prelude::*;
use gst::{element_error, gst_info, gst_trace};
use anyhow::Error;
use derive_more::{Display, Error};
#[path = "../examples-common.rs"]
mod examples_common;
// Our custom FIR filter element is defined in this module
mod fir_filter {
use super::*;
use gst_base::subclass::prelude::*;
... | the_stack |
use fmt::Debug;
use std::any::Any;
use std::fmt;
use std::sync::Arc;
use std::task::{Context, Poll};
use tokio::{
sync::mpsc::{channel, Receiver, Sender},
task,
};
use tokio_stream::wrappers::ReceiverStream;
use crate::clients::CachedFile;
use arrow::datatypes::{Schema, SchemaRef};
use arrow::error::{ArrowErro... | the_stack |
// We follow libstd's lead and prefer to define both.
clippy::partialeq_ne_impl,
// This is a really annoying clippy lint, since it's required for so many cases...
clippy::cast_ptr_alignment,
// For macros
clippy::redundant_slicing,
)]
use crate::ArcStr;
use core::ops::{Range, RangeBounds};
#[cfg(feature =... | the_stack |
use std::{collections::HashMap, ops::Deref, sync::Arc};
use heck::ToUpperCamelCase;
use itertools::Itertools;
use crate::{
ast::{
Statement, TypedArg, TypedConstant, TypedExternalFnArg, TypedModule,
TypedRecordConstructor, TypedStatement,
},
docvec,
pretty::{break_, Document, Documenta... | the_stack |
extern crate libc;
extern crate neovim;
extern crate gdk;
extern crate glib;
extern crate gtk;
extern crate rustc_serialize;
extern crate vte;
use gtk::*;
use vte::{Pty, Terminal};
use std::cell::{Cell, RefCell};
use std::collections::{HashMap, HashSet};
use std::env;
use std::fs::{self, metadata};
use std::io::Write;... | the_stack |
use std::{collections::BTreeMap, convert::TryInto, ffi::CStr, ffi::CString, ptr};
use crate::{
datatypes::{
DataType, Extension, Field, IntegerType, IntervalUnit, Metadata, TimeUnit, UnionMode,
},
error::{ArrowError, Result},
};
#[allow(dead_code)]
struct SchemaPrivateData {
name: CString,
... | the_stack |
use crate::{agent_error::ImlAgentError, network_interface_stats};
use combine::{
attempt, choice,
error::ParseError,
many1, optional,
parser::{
char::{char, digit, letter, spaces, string},
repeat::take_until,
},
sep_by1,
stream::Stream,
token, Parser,
};
use iml_wire_type... | the_stack |
extern crate graph;
extern crate jsonrpc_http_server;
extern crate lazy_static;
extern crate serde;
use graph::prelude::futures03::channel::{mpsc, oneshot};
use graph::prelude::futures03::SinkExt;
use graph::prelude::serde_json;
use graph::prelude::{JsonRpcServer as JsonRpcServerTrait, *};
use jsonrpc_http_server::{
... | the_stack |
use crate::join::JoinStage;
use itertools::Itertools;
use mongodb::bson::{doc, Document};
use prisma_models::{OrderBy, SortOrder};
#[derive(Debug)]
pub(crate) struct OrderByData {
pub(crate) join: Option<JoinStage>,
pub(crate) prefix: Option<OrderByPrefix>,
pub(crate) order_by: OrderBy,
}
impl OrderByData... | the_stack |
// Don't cover this file it's only getters
#![cfg(not(tarpaulin_include))]
use crate::{
ast::{
query::raw::{OperatorKindRaw, StmtRaw},
raw::{
AnyFnRaw, ExprRaw, GroupBy, GroupByInt, ImutExprRaw, PathRaw, ReservedPathRaw,
TestExprRaw,
},
Expr, ImutExprInt, Inv... | the_stack |
use super::*;
use crate::schema::*;
use bigdecimal::{BigDecimal, ToPrimitive};
use chrono::prelude::*;
use indexmap::IndexMap;
use prisma_value::PrismaValue;
use std::{borrow::Borrow, collections::HashSet, convert::TryFrom, str::FromStr, sync::Arc};
use uuid::Uuid;
// todo: validate is one of!
pub struct QueryDocumen... | the_stack |
use query_engine_tests::*;
#[test_suite(schema(schemas::json), only(Postgres))]
mod json_path {
use indoc::indoc;
use query_engine_tests::{assert_error, is_one_of, run_query, ConnectorTag, MySqlVersion, Runner};
fn pg_json() -> String {
let schema = indoc! {
r#"model TestModel {
... | the_stack |
use std::io;
use std::time::Duration;
use mortal::{self, PrepareConfig, PrepareState, TerminalReadGuard, TerminalWriteGuard};
use crate::sys;
pub use mortal::{CursorMode, Signal, SignalSet, Size};
/// Default `Terminal` interface
pub struct DefaultTerminal(mortal::Terminal);
/// Represents the result of a `Terminal... | the_stack |
// Author: Alexandru Radovici <msg4alex@gmail.com>
// Author: Philip Levis <pal@cs.stanford.edu>
// Author: Hubert Teo <hubert.teo.hk@gmail.com>
// Author: Brad Campbell <bradjc5@gmail.com>
// Author: Amit Aryeh Levy <amit@amitlevy.com>
use crate::ErrorCode;
use core::option::Option;
/// Data order defines the order ... | the_stack |
use core::cell::Cell;
use core::hint::spin_loop;
use core::ptr;
use core::sync::atomic::{AtomicUsize, Ordering};
use crate::threads::ThreadId;
use crate::tls2::{Environment, ThreadControlBlock};
use crossbeam_queue::ArrayQueue;
use crossbeam_utils::CachePadded;
use log::*;
#[derive(Debug)]
pub struct Mutex {
inn... | the_stack |
use crate::dynamics::solver::DeltaVel;
use crate::dynamics::{
BallJoint, IntegrationParameters, JointGraphEdge, JointIndex, JointParams, RigidBodyIds,
RigidBodyMassProps, RigidBodyPosition, RigidBodyVelocity,
};
use crate::math::{
AngVector, AngularInertia, Isometry, Point, Real, SdpMatrix, SimdReal, Vector... | the_stack |
use std::collections::hash_map::Entry;
use std::collections::HashMap;
use std::net::{IpAddr, SocketAddr};
use std::sync::atomic::{AtomicU32, AtomicUsize, Ordering};
use std::sync::Arc;
use std::time::SystemTime;
use log::{debug, error, info, warn};
use tokio::net::UdpSocket;
use tokio::select;
use tokio::sync::mpsc::e... | the_stack |
mod airport;
use crate::airport::Airport;
mod cli;
use crate::cli::Opts;
mod coverage;
use crate::coverage::{build_tab_coverage, populate_coverage};
mod map;
use crate::map::build_tab_map;
mod stats;
use crate::stats::build_tab_stats;
mod help;
use crate::help::build_tab_help;
mod airplanes;
use std::io::{self, B... | the_stack |
//
// Copyright (c) 2018 Stegos AG
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, ... | the_stack |
use binaryninjacore_sys::BNGetLowLevelILByIndex;
use binaryninjacore_sys::BNLowLevelILInstruction;
use std::fmt;
use std::marker::PhantomData;
use super::operation;
use super::operation::Operation;
use super::*;
use crate::architecture::Architecture;
use crate::architecture::RegisterInfo;
// used as a marker for Ex... | the_stack |
use std::cmp::Ordering;
use std::collections::{HashMap, HashSet};
use std::io::Error;
use std::sync::{Arc, Mutex};
use futures::future::{AbortHandle, Abortable};
use futures::stream::BoxStream;
use keyed_priority_queue::KeyedPriorityQueue;
use parking_lot::{RwLock, RwLockUpgradableReadGuard};
use beserial::Serialize;... | the_stack |
use byteorder::ByteOrder;
use crossbeam_utils::thread;
use libc::{c_void, int64_t, intptr_t};
use fnv::{FnvHashSet, FnvHashMap};
use log::*;
use std::{fmt, mem, slice};
use std::ops::Range;
use std::sync::atomic;
use std::time::{Duration, Instant};
use super::*;
/// A wrapper C function called to invoke a function ca... | the_stack |
use crate::{
graph::{
cargo_version_matches,
feature::{FeatureGraphImpl, FeatureId, FeatureNode},
BuildTarget, BuildTargetId, BuildTargetImpl, BuildTargetKind, Cycles, DependencyDirection,
OwnedBuildTargetId, PackageIx, PackageQuery, PackageSet,
},
petgraph_support::{scc::Scc... | the_stack |
clippy::all,
clippy::pedantic,
clippy::nursery,
clippy::cargo
)]
#![allow(
clippy::non_ascii_literal,
clippy::missing_docs_in_private_items,
clippy::implicit_return,
clippy::print_stdout,
clippy::module_name_repetitions,
clippy::expect_used
)]
mod types;
use crate::types::{Bitness, B... | the_stack |
use std::cell::RefCell;
use smallvec::SmallVec;
use web_sys::{
self, HtmlCanvasElement, WebGlBuffer, WebGlFramebuffer, WebGlProgram, WebGlRenderbuffer,
WebGlShader, WebGlTexture, WebGlUniformLocation, WebGlVertexArrayObject,
};
use wasm_bindgen::JsCast;
use web_sys::WebGl2RenderingContext as WebGL;
use crate... | the_stack |
use rafx::render_feature_prepare_job_predule::*;
use super::*;
use crate::phases::{OpaqueRenderPhase, TransparentRenderPhase};
use crate::shaders;
use fnv::FnvHashMap;
use rafx::api::{RafxBufferDef, RafxDeviceContext, RafxMemoryUsage, RafxResourceType};
use rafx::base::DecimalF32;
use rafx::framework::{ImageViewResour... | the_stack |
use sfml::{
graphics::{
Color, Font, Rect, RectangleShape, RenderTarget, RenderWindow, Shape, Text, Transformable,
},
system::Vector2,
window::{mouse, ContextSettings, Cursor, CursorType, Event, Style},
};
const DRAW_AREA_TOPLEFT: (u16, u16) = (300, 64);
const DRAW_GRID_WH: u8 = 16;
const DRAW_... | the_stack |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.