text stringlengths 2.5k 6.39M | kind stringclasses 3
values |
|---|---|
use any_ascii::any_ascii;
use config::{Config, ReplaceMode, RunMode};
use dumpfile;
use error::*;
use fileutils::{cleanup_paths, create_backup, get_paths};
use solver;
use solver::{Operation, Operations, RenameMap};
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Arc;
pub struct Renamer {
config: Arc<C... | the_stack |
// use std::future::Future;
use std::ops::Deref;
use crate::{
env::{Env, EnvBinding},
error::Error,
request::Request,
response::Response,
Result,
};
use async_trait::async_trait;
use js_sys::{Map, Object};
use serde::{Deserialize, Serialize};
use wasm_bindgen::{prelude::*, JsCast};
use worker_sys:... | the_stack |
use crate::error::EitherType;
use crate::module::PrimitiveTypeInfo;
use crate::mutators::peephole::eggsy::analysis::PeepholeMutationAnalysis;
use crate::mutators::peephole::eggsy::encoder::Encoder;
use crate::mutators::peephole::eggsy::lang::Lang;
use egg::{rewrite, AstSize, Id, RecExpr, Rewrite, Runner, Subst};
use ra... | the_stack |
use crate::rules::CustomRules;
use std::io::{BufRead, BufReader, Write};
use std::net::{Shutdown, TcpListener, TcpStream};
use std::sync::{Arc, Mutex};
use std::{io, thread, thread::JoinHandle, time};
use weasel::event::{ClientSink, EventSink, EventSinkId, ServerSink};
use weasel::team::TeamId;
use weasel::{
Battle... | the_stack |
use std::rc::Rc;
use std::borrow::Cow;
use std::cell::RefCell;
use std::collections::HashMap;
use std::mem;
use std::fmt;
use std::fmt::Debug;
use std::ops::{Deref, DerefMut};
use cast::DatumCast;
use compiler::{Compiler, PrimitiveSyntax};
use datum::{SimpleDatum, TryConv};
use eqv::DatumEqv;
use error::{CompileError,... | the_stack |
//! Support for custom slice-based DSTs.
//!
//! By handling allocation manually, we can manually allocate the `Box` for a custom DST.
//! So long as the size lines up with what it should be, once the metadata is created,
//! Rust actually already handles the DSTs it already supports perfectly well, safely!
//! Setting... | the_stack |
use proc_macro2::{Span, TokenStream, TokenTree};
use quote::ToTokens;
use syn;
#[derive(Debug)]
struct Inlet {
// The name of the inlet field.
name: syn::Ident,
// The type of the inlet field.
ty: syn::Type,
// An optionally specified function for processing a value received on an inlet.
proces... | the_stack |
use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
use std::io;
use std::iter;
use std::path::Path;
use ::keys::Address;
use config::genesis::GenesisConfig;
use config::ChainConfig;
use log::info;
use proto::common::AccountType;
use proto::state as state_pb;
use rocks::prelude::*;
use super::keys;
use supe... | the_stack |
#[allow(dead_code)]
#[link_section=".fontdata"]
#[no_mangle]
#[used]
/// Packed glyph pattern data.
/// Record format:
/// [offset+0]: ((w as u8) << 16) | ((h as u8) << 8) | (yOffset as u8)
/// [offset+1..=ceil(w*h/32)]: packed 1-bit pixels; 0=clear, 1=set
/// Pixels are packed in top to bottom, left to right order w... | the_stack |
use std::fmt;
use std::path::Path;
use std::cell::RefCell;
use std::collections::HashMap;
use regex::Regex;
use crate::JvmValue;
use crate::InterpLocalVars;
use crate::otfield::OtField;
use crate::otmethod::OtMethod;
use crate::otklass::OtKlass;
use ocelotter_util::file_to_bytes;
use ocelotter_util::ZipFiles;
/////... | the_stack |
//! This module implements conversion from/to `Value` for `time` v0.3.x crate types.
#![cfg(feature = "time03")]
use std::{convert::TryFrom, str::from_utf8};
use time03::{
error::{Parse, TryFromParsed},
format_description::{modifier, Component, FormatItem},
Date, PrimitiveDateTime, Time,
};
use crate::v... | the_stack |
extern crate test;
use super::*;
use alloc_stdlib::StandardAlloc;
static RANDOM_THEN_UNICODE: &'static [u8] = include_bytes!("../../../testdata/random_then_unicode");
static FINALIZE_DATA: &'static [u8] = &[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,20,
... | the_stack |
use crate::{
csi::cursor_ext,
search::{NullSearcher, Search},
tab::TabExpand,
term,
unicode_divide::UnicodeStrDivider,
};
use std::cell::RefCell;
use std::cmp;
use std::fmt;
use std::io::{self, BufRead, BufReader, Write};
use std::io::{Seek, SeekFrom};
use std::ops;
use std::rc::Rc;
use unicode_widt... | the_stack |
use crate::{
config,
stats::{
ColumnStatsOutput, EnumColumnStatsOutput, NumberColumnStatsOutput, TextColumnStatsOutput,
TextColumnStatsOutputTopNGramsEntry,
},
};
use fnv::FnvBuildHasher;
use indexmap::IndexMap;
use num::ToPrimitive;
use tangram_text::NGram;
pub fn choose_feature_groups_linear(
column_stats: &... | the_stack |
use std::{
mem::ManuallyDrop,
ptr::NonNull,
};
use crate::{
marker_type::NonOwningPhantom,
sabi_types::{MovePtr, RRef, RMut},
utils::Transmuter,
};
#[allow(unused_imports)]
use core_extensions::utils::transmute_ignore_size;
///
/// Determines whether the referent of a pointer is dropped when the
... | the_stack |
use super::{output_str, output_time, output_time_span, output_vec};
use crate::{
run::{NullableOwnedRun, OwnedRun},
shared_timer::OwnedSharedTimer,
};
use livesplit_core::{run::saver, Run, Time, TimeSpan, Timer, TimerPhase, TimingMethod};
use std::{os::raw::c_char, ptr};
/// type
pub type OwnedTimer = Box<Time... | the_stack |
use std::borrow::BorrowMut;
use std::fmt;
use std::fmt::Formatter;
use messaging::*;
use crate::*;
use super::builtin_functions::evaluate_builtin;
use super::builtin_functions::throw_error;
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub(crate) struct KeyActionCondition {
pub(crate) window_class_name: Option<S... | the_stack |
use std::cmp::{max, min};
use std::collections::{hash_map::Entry, HashMap, VecDeque};
/// Prefix trie, easily augmentable by adding more fields and/or methods
pub struct Trie<C: std::hash::Hash + Eq> {
links: Vec<HashMap<C, usize>>,
}
impl<C: std::hash::Hash + Eq> Default for Trie<C> {
/// Creates an empty tr... | the_stack |
use crate::reader::parser::*;
use std::fmt;
use std::collections::HashMap;
use std::rc::Rc;
use std::cell::RefCell;
pub fn new() -> Interpreter {
Interpreter::new()
}
#[derive(Clone)]
pub struct Interpreter {
root: Rc<RefCell<Environment>>
}
impl Interpreter {
pub fn new() -> Interpreter {
Inter... | the_stack |
use std::collections::HashMap;
use std::ffi::OsStr;
use std::fs::{self, File};
use std::io::{Error, Read};
use std::path::{Path, PathBuf};
use crate::image::animated_image::AnimatedImageBuilder;
use crate::image::composed_image::ComposedImageBuilder;
use crate::image::simple_image::SimpleImageBuilder;
use cra... | the_stack |
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_cas... | the_stack |
use anyhow::Result;
use bevy_easings::EasingsPlugin;
use bevy_tiled_camera::TiledCameraPlugin;
use log::{error, info, log_enabled};
use std::{
cmp::min,
collections::VecDeque,
path::{Path, PathBuf},
sync::{Arc, Mutex},
};
use bevy::{
diagnostic::{Diagnostics, FrameTimeDiagnosticsPlugin},
input:... | the_stack |
use crate::interp::{Interp2F, Interp4F};
use crate::utils::{FrameAccumulator, Sample};
use dasp_frame::Frame;
use smallvec::{smallvec, SmallVec};
use UpsamplingScanner::*;
#[derive(Debug)]
enum UpsamplingScanner {
Mono2F(Interp2F<[f32; 1]>),
Stereo2F(Interp2F<[f32; 2]>),
Quad2F(Interp2F<[f32; 4]>),
Su... | the_stack |
extern crate lazy_static;
#[macro_use]
extern crate serde_derive;
mod conf;
mod fmt;
mod human_date;
mod stats;
mod tml;
use std::env;
use std::path::Path;
use std::process::exit;
use std::str::FromStr;
use todo_lib::*;
const TASK_HIDDEN_OFF: &str = "0";
const TASK_HIDDEN_FLD: &str = "h";
type FnUpdateData = fn(ta... | the_stack |
use crate::FxHashSet;
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::get_attr;
use clippy_utils::source::{indent_of, snippet};
use rustc_errors::{Applicability, Diagnostic};
use rustc_hir::intravisit::{walk_expr, Visitor};
use rustc_hir::{Expr, ExprKind, MatchSource};
use rustc_lint::{LateContext,... | the_stack |
use crate::codegen::TargetProperties;
use crate::codegen::{controls, functions, values, ObjectCache};
use crate::mir::block::{Function, Statement};
use crate::mir::{Block, Node, NodeData, Surface, ValueGroup, ValueGroupSource};
use inkwell::context::Context;
use inkwell::types::{BasicType, BasicTypeEnum, StructType};
u... | the_stack |
use crate::{BoundingBox, Display, Entity, Overflow, PropGet, PropSet, Property, SelectorRelation, Rule, Selector, State, Tree, TreeExt, Visibility};
pub fn apply_z_ordering(state: &mut State, tree: &Tree) {
for entity in tree.into_iter() {
if entity == Entity::root() {
continue;
}
... | the_stack |
use std::{sync::Arc, time::Duration};
use beefy_node_runtime::{self, opaque::Block, RuntimeApi};
use sc_client_api::ExecutorProvider;
use sc_consensus_aura::{ImportQueueParams, SlotProportion, StartAuraParams};
use sc_executor::native_executor_instance;
use sc_finality_grandpa::SharedVoterState;
use sc_service::{error... | the_stack |
use std::{
collections::HashMap,
ffi::OsString,
fmt::Display,
io,
panic::catch_unwind,
path::{Path, PathBuf},
sync::atomic::{AtomicUsize, Ordering},
time::{Duration, Instant},
};
use crossbeam::channel::{unbounded, Receiver, Sender};
use rayon::join;
use rome_console::{
codespan::Lo... | the_stack |
use std::fmt::Debug;
use std::marker;
use std::ops::{Add, Mul, Sub};
use cgmath::num_traits::{Float, NumCast};
use cgmath::{BaseFloat, EuclideanSpace, InnerSpace, One, Rotation, Zero};
use collision::Contact;
use super::{Inertia, Mass, Material, PartialCrossProduct, Velocity};
use {NextFrame, Pose};
const POSITIONAL... | the_stack |
use shared::*;
use spirv_std::glam::{
const_vec4, vec2, vec3, vec4, Mat3, Vec2, Vec2Swizzles, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles,
};
// Note: This cfg is incorrect on its surface, it really should be "are we compiling with std", but
// we tie #[no_std] above to the same condition, so it's fine.
#[cfg(target_ar... | the_stack |
use chrono::prelude::{
DateTime,
Utc
};
use crate::arbitraries::search::{
search_create::SearchInfoMap,
search_input::{
get_search_inputs_arbitrary,
SearchInputConcrete,
SearchInputConcreteFieldType
}
};
use graphql_parser::schema::{
Document,
ObjectType
};
use propte... | the_stack |
use std::{
fs,
path::Path,
};
use tempfile::Builder;
use rkv::{
backend::{
Lmdb,
LmdbEnvironment,
SafeMode,
SafeModeEnvironment,
},
Manager,
Migrator,
Rkv,
StoreOptions,
Value,
};
macro_rules! populate_store {
($env:expr) => {
let store ... | the_stack |
mod listener;
pub use listener::DfsListener;
use magnitude::Magnitude;
use std::cell::RefCell;
use super::Color;
use crate::provide::{self, IdMap};
/// Visits graph vertices in a depth-first manner.
pub struct Dfs<'a, L: DfsListener> {
stack: Vec<usize>,
colors: Vec<Color>,
discovered: Vec<Magnitude<usi... | the_stack |
use super::{Component, Scope};
use crate::scheduler::{self, Runnable, Shared};
use crate::virtual_dom::{VDiff, VNode};
use crate::{Context, NodeRef};
use std::rc::Rc;
use web_sys::Element;
pub(crate) struct ComponentState<COMP: Component> {
pub(crate) component: Box<COMP>,
pub(crate) root_node: VNode,
con... | the_stack |
extern crate clap;
extern crate env_logger;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate log;
use serde::{Deserialize, Serialize};
#[cfg(feature = "chan")]
#[macro_use]
extern crate chan;
/**
If this is set to `true`, the digests used for package IDs will be replaced with "stub" to make testing a... | the_stack |
use diagnostics_data::LifecycleType;
use diagnostics_reader::{ArchiveReader, Lifecycle};
use fidl_fuchsia_diagnostics_persist::{DataPersistenceMarker, PersistResult};
use fidl_fuchsia_sys::ComponentControllerEvent;
use fuchsia_async::futures::StreamExt;
use fuchsia_component::client::{launcher, App, AppBuilder};
use fu... | the_stack |
use super::encoding::{
Ascii, Binary, InvalidMetadataValue, InvalidMetadataValueBytes, ValueEncoding,
};
use super::key::MetadataKey;
use bytes::Bytes;
use http::header::HeaderValue;
use std::error::Error;
use std::marker::PhantomData;
use std::str::FromStr;
use std::{cmp, fmt};
/// Represents a custom metadata f... | the_stack |
use std::{env, panic};
use git2::{Reference, Repository};
use git_url_parse::GitUrl;
#[derive(Debug, Clone, PartialEq)]
pub struct GitContext {
pub branch: Option<String>,
pub author: Option<String>,
pub commit: Option<String>,
pub remote_url: Option<String>,
}
impl GitContext {
pub fn new_with_o... | the_stack |
use std::collections::BTreeMap;
use std::path::Path;
use k8s_openapi::{
api::core::v1::{
DownwardAPIVolumeFile, ObjectFieldSelector, ResourceFieldSelector, Volume as KubeVolume,
},
apimachinery::pkg::api::resource::Quantity as KubeQuantity,
};
use tracing::warn;
use crate::container::Container;
us... | the_stack |
use std::{error, fmt, io};
use std::str::FromStr;
use std::sync::Arc;
use chrono::Utc;
use chrono::format::{Item, Numeric, Pad};
use log::{error, info};
use rpki::repository::resources::AsId;
use crate::payload;
use crate::error::Failed;
use crate::payload::{AddressPrefix, OriginInfo, PayloadSnapshot, RouteOrigin};
use... | the_stack |
//! Various utilities for building scripts and deriving keys related to channels. These are
//! largely of interest for those implementing chain::keysinterface::Sign message signing by hand.
use bitcoin::blockdata::script::{Script,Builder};
use bitcoin::blockdata::opcodes;
use bitcoin::blockdata::transaction::{TxIn,Tx... | the_stack |
/// The trait Aml can be implemented by the ACPI objects to translate itself
/// into the AML raw data. So that these AML raw data can be added into the
/// ACPI DSDT for guest.
pub trait Aml {
/// Translate an ACPI object into AML code and append to the vector
/// buffer.
/// * `bytes` - The vector used to... | the_stack |
mod test;
use std::{collections::HashMap, fmt, ops::Deref, sync::Arc, time::Duration};
use rand::{rngs::SmallRng, seq::SliceRandom, SeedableRng};
use super::TopologyDescription;
use crate::{
error::{ErrorKind, Result},
options::ServerAddress,
sdam::{
description::{
server::{ServerDesc... | the_stack |
// Cincinnati client.
mod client;
pub use client::{CincinnatiError, Node};
#[cfg(test)]
mod mock_tests;
use crate::config::inputs;
use crate::identity::Identity;
use crate::rpm_ostree::Release;
use anyhow::{Context, Result};
use fn_error_context::context;
use futures::prelude::*;
use futures::TryFutureExt;
use promet... | the_stack |
use std::time::{Duration, Instant};
use crate::util;
use ic_fondue::ic_manager::IcHandle;
use ic_universal_canister::UNIVERSAL_CANISTER_WASM;
use ic_universal_canister::{call_args, wasm};
use ic_utils::call::AsyncCall;
use ic_utils::interfaces::ManagementCanister;
const HEARTBEAT_TIMEOUT: Duration = Duration::from_se... | the_stack |
use crate::guc;
use crate::utils::{ser, AttrNumber};
use crate::{errctx, kbanyhow, kbensure, Oid, OptOid, Sock};
use anyhow::Context;
use std::collections::HashMap;
use std::convert::TryInto;
use std::io::{self, Cursor};
use std::mem::size_of;
use std::str::from_utf8;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use t... | the_stack |
use crate::error::{Error, TryError};
use cid::Cid;
use core::convert::{TryFrom, TryInto};
use libp2p::PeerId;
use std::fmt;
use std::str::FromStr;
/// Abstraction over Ipfs paths, which are used to target sub-trees or sub-documents on top of
/// content addressable ([`Cid`]) trees. The most common use case is to speci... | the_stack |
use bit_field::{BitArray, BitField};
use fastnbt::LongArray;
use serde::Deserialize;
// Various data versions for the anvil format
const V1_17_0: i32 = 2724;
const V1_17_1: i32 = 2730;
const SNAPSHOT_21W44A: i32 = 2845;
/// PackedBits can be used in place of blockstates in chunks to avoid
/// allocating memory for th... | the_stack |
pub mod cursor;
pub mod font;
pub mod glyph;
pub mod layout;
pub mod line;
pub mod rt {
//! Re-exported RustType geometric types.
pub use rusttype::{gpu_cache, point, vector, Point, Rect, Vector};
}
// Re-export all relevant rusttype types here.
pub use self::layout::Layout;
pub use rusttype::gpu_cache::Cache ... | the_stack |
use regex::Regex;
use serde::{Deserialize, Serialize};
use std::{
borrow::Cow,
collections::{HashMap, HashSet},
path::PathBuf,
str::FromStr,
time::Instant,
};
use crate::{
app::{layout_manager::*, *},
canvas::ColourScheme,
constants::*,
units::data_units::DataUnit,
utils::error:... | the_stack |
use crate::axum_http_server_factory::AxumHttpServerFactory;
use crate::configuration::Configuration;
use crate::configuration::{validate_configuration, ListenAddr};
use crate::reload::Error as ReloadError;
use crate::router_factory::YamlRouterServiceFactory;
use crate::state_machine::StateMachine;
use derivative::Deriv... | the_stack |
use guid_create::GUID;
use minimp3::{Decoder, Error};
use structopt::StructOpt;
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
// TODO: Remove file GUID creation for fast option, use something predictable instead.
// Sometimes GUID filenames might clash, even if i... | the_stack |
use std::mem;
use crate::math::{ field, fft };
use crate::utils::{ uninit_vector, filled_vector };
// POLYNOMIAL EVALUATION
// ================================================================================================
/// Evaluates polynomial `p` at coordinate `x`
pub fn eval(p: &[u128], x: u128) -> u128 {
... | the_stack |
extern crate clap;
extern crate fibers_rpc;
extern crate frugalos;
extern crate frugalos_config;
extern crate frugalos_segment;
extern crate hostname;
extern crate jemallocator;
extern crate libfrugalos;
#[macro_use]
extern crate slog;
extern crate sloggers;
#[macro_use]
extern crate trackable;
use clap::{App, Arg, Ar... | the_stack |
use crate::expr;
use crate::scanner;
use crate::syntax_extensions;
use std::fmt;
struct Parser {
tokens: Vec<scanner::Token>,
current: usize,
in_fundec: bool,
extensions: syntax_extensions::Extensions,
}
impl Default for Parser {
fn default() -> Parser {
Parser {
tokens: Defau... | the_stack |
use std::io::Write;
use std::os::unix::io::{AsRawFd, RawFd};
use std::sync::atomic::{AtomicU32, Ordering};
use std::sync::{Arc, Mutex};
use std::{
cmp::{self, Reverse},
time::Duration,
};
use address_space::{
AddressSpace, FlatRange, GuestAddress, Listener, ListenerReqType, RegionIoEventFd, RegionType,
};
... | the_stack |
use std::any::TypeId;
use mopa::Any;
use std::fmt;
use std::borrow::Cow;
use std::mem;
use std::collections::hash_map::HashMap;
use std::collections::hash_map::Entry::{Occupied, Vacant};
use tendril::{ByteTendril, StrTendril};
use smallvec::SmallVec;
use self::internals::Item;
pub use mucell::Ref;
pub use self::inte... | the_stack |
use crate::common::{DebugArangesOffset, DebugInfoOffset, Encoding, SectionId};
use crate::endianity::Endianity;
use crate::read::{EndianSlice, Error, Range, Reader, ReaderOffset, Result, Section};
/// The `DebugAranges` struct represents the DWARF address range information
/// found in the `.debug_aranges` section.
#[... | the_stack |
pub mod access_token;
pub mod audio_key;
pub mod mercury;
use std::{
io,
net::{Shutdown, TcpStream},
sync::{
atomic::{AtomicBool, Ordering},
Arc,
},
thread::{self, JoinHandle},
};
use crossbeam_channel::{unbounded, Receiver, Sender};
use parking_lot::Mutex;
use quick_protobuf::Mess... | the_stack |
mod direnv;
pub mod error;
use crate::build_loop::BuildLoop;
use crate::build_loop::{Event, EventI, ReasonI};
use crate::builder::OutputPath;
use crate::cas::ContentAddressable;
use crate::changelog;
use crate::cli;
use crate::cli::ShellOptions;
use crate::cli::StartUserShellOptions_;
use crate::cli::WatchOptions;
use... | the_stack |
use crate::memreader::{MemReader, Address};
use std::convert::TryInto;
macro_rules! impl_from_memreader {
($name:ident) => (
impl $name {
pub fn from_memreader<R: MemReader>(addr: Address, memreader: &mut R) -> $name {
let mut data = [0u8; std::mem::size_of::<$name>()];
... | the_stack |
use std::collections::HashMap;
use crate::{
material::{
material::Material,
node::node::{
MaterialNode,
UniformContents,
},
},
math::{
matrix3::Matrix3,
matrix3gpu::Matrix3GPU,
matrix4::Matrix4,
},
renderer::{
wgpu_samplers::WGPUSamplers,
wgpu_textures::WGPUTextures,
},
resource::resource:... | the_stack |
use std::collections::HashMap;
use std::time::*;
use tokio::io::SeekFrom;
use async_trait::async_trait;
use regex::Regex;
use rustcommon_metrics::*;
use tokio::fs::File;
use tokio::io::{AsyncBufReadExt, AsyncSeekExt, BufReader};
use crate::config::SamplerConfig;
use crate::samplers::Common;
use crate::Sampler;
mod c... | the_stack |
use crate::parser::{ParsedSyntax, ParserProgress, RecoveryResult};
use crate::state::{
EnableStrictMode, EnterClassPropertyInitializer, EnterClassStaticInitializationBlock,
EnterParameters, SignatureFlags,
};
use crate::syntax::binding::parse_binding;
use crate::syntax::expr::{
parse_assignment_expression_o... | the_stack |
use crate::base::{Dependency, Entity, SettingType};
use crate::handler::base::Error;
use crate::ingress::registration::{self, Registrant, Registrar};
use crate::job::source::Seeder;
use crate::service::message::Delegate;
use fidl_fuchsia_settings::{
AccessibilityRequestStream, AudioRequestStream, DeviceRequestStrea... | the_stack |
use std::{
marker::PhantomData,
mem,
os::raw::{c_int, c_void},
ptr, slice,
};
use ndarray::{
Array, ArrayBase, ArrayView, ArrayViewMut, Axis, Data, Dim, Dimension, IntoDimension, Ix0, Ix1,
Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, RawArrayView, RawArrayViewMut, RawData, ShapeBuilder,
StrideShape,
};
... | the_stack |
mod de;
mod se;
mod value;
pub use self::se::*;
pub use self::value::*;
use crate::{stry, Deserializer, Error, ErrorType, Result};
use crate::{BorrowedValue, OwnedValue};
use crate::{Node, StaticNode};
use serde::de::DeserializeOwned;
use serde_ext::Deserialize;
use std::convert::{TryFrom, TryInto};
use std::fmt;
use s... | the_stack |
use std::{
collections::HashMap,
ffi::{CStr, CString},
sync::{
atomic::{AtomicBool, Ordering},
Arc, Mutex, Weak,
},
};
use crate::utils::errors::{DriverInteractionError, GenericError, IllegalArgumentError};
use crate::{
concurrent::{
agent_runner::Agent,
atomic_buffe... | the_stack |
extern crate alloc;
extern crate log;
extern crate spin;
use crate::cpu;
use crate::drivers::display::fb_text::{FramebufferLines, FramebufferText};
use crate::drivers::display::font::{FONT_HEIGHT, FONT_WIDTH};
use crate::drivers::display::framebuffer::{Framebuffer, Pixel};
use crate::drivers::keyboard::PC_KEYBOARD;
u... | the_stack |
use ctypes::{c_float, c_int, c_void};
use shared::minwindef::{BOOL, BYTE, DWORD, HINSTANCE, HRGN, LPARAM, UINT, ULONG, WORD};
use shared::windef::{COLORREF, HBITMAP, HBRUSH, HDC, HWND, LPCRECT, LPRECT, POINT, RECT, SIZE};
use um::commctrl::HIMAGELIST;
use um::wingdi::{BLENDFUNCTION, LOGFONTW, RGBQUAD, TEXTMETRICW};
use... | the_stack |
// crates used here need to go in build-dependencies as well !!!
use clap::{Arg, ArgMatches, Command};
#[cfg(target_os = "macos")]
use simplelog::*;
std::include!("help-common.in");
#[cfg(target_os = "macos")]
std::include!("help-macos.in");
#[cfg(target_os = "windows")]
std::include!("help-windows.in");
#[cfg(ta... | the_stack |
use crate::{block::block_op,
buffer::Buffer,
cpu::{dump_registers, Registers, TrapFrame, gp},
elf,
fs,
gpu,
input::{Event, ABS_EVENTS, KEY_EVENTS},
page::{map, virt_to_phys, EntryBits, Table, PAGE_SIZE, zalloc},
process::{add_kernel_... | the_stack |
use crate::definitions::{Position, Score};
use image::{GenericImageView, GrayImage};
/// A location and score for a detected corner.
/// The scores need not be comparable between different
/// corner detectors.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Corner {
/// x-coordinate of the corner.
pub x: ... | the_stack |
use libc::{ c_char, c_int, c_short, c_uint, c_ulong, c_void, FILE };
pub type c_bool = ::libc::c_uchar;
/* Intrinsic types. */
#[cfg(feature="wide_chtype")]
pub type chtype = u64;
#[cfg(not(feature="wide_chtype"))]
pub type chtype = u32;
pub type winttype = c_uint;
pub type mmask_t = chtype;
pub type attr_t = chtype... | the_stack |
use ttf_parser::GlyphId;
use crate::{Direction, Face};
use crate::face::GlyphExtents;
use crate::buffer::{Buffer, GlyphPosition};
use crate::unicode::{space, modified_combining_class, CanonicalCombiningClass, GeneralCategory};
use crate::plan::ShapePlan;
pub fn recategorize_marks(_: &ShapePlan, _: &Face, buffer: &mut... | the_stack |
use crate::{
core::{
security::AuthenticatedApplication,
types::{
ApplicationIdOrUid, EndpointId, EndpointIdOrUid, EventChannel, EventTypeNameSet,
MessageAttemptId, MessageAttemptTriggerType, MessageEndpointId, MessageId,
MessageIdOrUid, MessageStatus, StatusCodeC... | the_stack |
mod futures;
mod runtime;
//==============================================================================
// Exports
//==============================================================================
pub use self::{
futures::OperationResult,
runtime::PosixRuntime,
};
//========================================... | the_stack |
use hyper::{self, Server, Request, Response, Body, Method};
use hyper::service::{service_fn, make_service_fn};
use hyper::body::Bytes;
use http::request::Parts;
use tokio::runtime::Runtime;
use tokio::task;
use queen_log::color::Print;
pub use self::route::Route;
pub use self::group::Group;
use self::middleware::Midd... | the_stack |
use crate::array::*;
use crate::fixed_point::*;
use crate::ieee::*;
use crate::integer::*;
use crate::math::*;
use core::ops::{Add, Div, Mul, Sub};
use scale::*;
/**************************************
* Generic Routines Used by math.rs *
**************************************/
/**********************************... | the_stack |
use actix::prelude::*;
use cpal::traits::HostTrait;
use serde::Serialize;
use std::pin::Pin;
use thiserror::Error;
use crate::audio_io::audio_thread;
use crate::audio_io::audio_thread::AudioThread;
pub use models::*;
use storage::{AudioIOStorageService, StorageConfig};
use crate::audio_io::audio_thread::options::{Aud... | the_stack |
use super::*;
/// `N`-element vector.
///
/// Vectors can be constructed from arrays of any type and size. There are
/// convenience constructor functions provided for the most common sizes.
///
/// ```
/// # use al_jabr::*;
/// let a: Vector::<u32, 4> = vector!( 0u32, 1, 2, 3 );
/// assert_eq!(
/// a,
/// Vec... | the_stack |
use crate::*;
// ======================
// === Token Literals ===
// =====================
/// Token representing blank.
pub const BLANK_TOKEN: char = '_';
/// Symbol appearing after base of the number literal.
pub const NUMBER_BASE_SEPARATOR: char = '_';
/// Suffix to made a modifier from an operator
pub const MOD... | the_stack |
use std::collections::HashSet;
use std::sync::Arc;
use apollo_parser::ast::AstChildren;
use apollo_parser::{ast, Parser, SyntaxTree};
use uuid::Uuid;
use crate::diagnostics::{ApolloDiagnostic, ErrorDiagnostic};
use crate::values::*;
#[salsa::database(ASTDatabase)]
#[derive(Default)]
pub struct Database {
storage... | the_stack |
use crate::error::{Error, Result};
use itertools::Itertools;
use itertools::multipeek;
use itertools::MultiPeek;
use std::str::Chars;
#[derive(Eq, PartialEq, Debug, Clone)]
pub enum Token {
/// MatchAll is produced by lexing an empty string.
/// It can be followed only by InputEnd.
MatchAll,
/// BangP... | the_stack |
#![allow(dead_code)]
mod blueprint;
mod bpf;
mod cpu_info;
mod debugfs;
mod error;
mod maps;
mod perf;
mod program_group;
mod program_version;
pub use blueprint::{ProgramBlueprint, SectionType};
pub use error::OxidebpfError;
pub use maps::{ArrayMap, BpfHashMap, RWMap};
pub use program_group::ProgramGroup;
pub use pro... | the_stack |
mod flatten_item;
mod groups;
mod simple_argument;
use crate::prelude::*;
use crate::utils::member_chain::flatten_item::FlattenItem;
use crate::utils::member_chain::groups::{Groups, HeadGroup};
use rome_formatter::{format_args, write, Buffer, PreambleBuffer};
use rome_js_syntax::{
JsCallExpression, JsComputedMembe... | the_stack |
// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT MODIFY IT DIRECTLY, UPDATE THE
// SVD DEFINITION IN SUPPORT/SVD/DATA AND RE-GENERATE, ADDING THE CHANGES MADE
// INTO THE RELEVANT CHANGELOG ENTRY.
//! ioregs definition based on data/STMicro/STM32F103xx.xml
use volatile_cell::VolatileCell;
use core::ops::Drop;
ioregs!... | the_stack |
use crate::builtin::constructors::{C_BIND, C_MATCH};
use crate::elaborate::{Context, ElabError, ErrorKind};
use crate::types::{Constructor, Type};
use crate::{Decl, Expr, ExprKind, Lambda, Pat, PatKind, Row, Rule, SortedRecord, Var};
use rustc_hash::{FxHashMap, FxHashSet};
use sml_util::diagnostics::Level;
use sml_util... | the_stack |
// You should have received a copy of the MIT License
// along with the Jellyfish library. If not, see <https://mit-license.org/>.
//! Circuits for the building blocks in Plonk verifiers.
use crate::{
circuit::{
customized::{
ecc::{PointVariable, SWToTEConParam},
transcript::RescueT... | the_stack |
use crate::slab::{ParseSlab, CompileSlab};
use crate::parser::{Expression, ExprPair, Value, UnaryOp::{self, EPos, ENeg, ENot, EParentheses}, BinaryOp::{self, EOR, EAND, ENE, EEQ, EGTE, ELTE, EGT, ELT, EAdd, ESub, EMul, EDiv, EMod, EExp}, StdFunc::{self, EVar, EFunc, EFuncInt, EFuncCeil, EFuncFloor, EFuncAbs, EFuncSign,... | the_stack |
// https://github.com/Manishearth/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy)]
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#.
use chrono::Utc;
use chrono::{DateTime, Duration};
use serde::De... | the_stack |
use crate::serde_helpers;
use crate::spec::ProbeArgSpecification;
use crate::{TracersError, TracersResult};
use proc_macro2::Span;
use serde::{Deserialize, Serialize};
use std::fmt;
use syn::spanned::Spanned;
use syn::Visibility;
use syn::{FnArg, Ident, ItemTrait, ReturnType, TraitItemMethod};
#[derive(Serialize, Dese... | the_stack |
use std::{ptr, mem};
use std::sync::atomic::{AtomicUsize, AtomicBool};
use std::sync::atomic::Ordering::{SeqCst};
use std::sync::{Mutex, Condvar};
use alloc::heap::{allocate, deallocate};
use std::cell::{Cell};
use select::{_Selectable, WaitQueue, Payload};
use alloc::{oom};
use {Error, Sendable};
#[cfg(target_pointe... | the_stack |
use crate::calc::raw_log::RawLog;
use crate::TimeTrackerError;
use std::cmp::max;
use std::cmp::min;
use std::collections::HashMap;
use std::convert::TryFrom;
use std::fmt;
use std::fmt::Display;
use std::fmt::Formatter;
const MAX_SECONDS_BETWEEN_RECORDS_IN_SPAN: u64 = 5 * 60;
pub struct Span {
pub name: String,
... | the_stack |
use indexmap::{IndexMap, IndexSet};
use swc_common::DUMMY_SP;
use swc_ecma_ast::*;
use swc_ecma_visit::{noop_fold_type, Fold};
#[derive(Clone, Debug)]
pub enum IdentKind {
Lit(Lit),
Alias(String),
Object(Vec<PropOrSpread>),
Class(Class),
Fn(FnDesc),
Reexport(String),
Unkonwn,
}
#[derive(Clone, Debug)]
pub stru... | the_stack |
/// Abstraction over [Sputnik EVM](https://github.com/rust-blockchain/evm)
pub mod sputnik;
#[cfg(feature = "sputnik")]
use crate::sputnik::cheatcodes::debugger::DebugArena;
/// Abstraction over [evmodin](https://github.com/rust-blockchain/evm)
#[cfg(feature = "evmodin")]
pub mod evmodin;
mod blocking_provider;
use c... | the_stack |
use super::{
error::Error,
key::{self, PublicKey},
state::Npk,
Container, RepositoryId,
};
use crate::{npk::npk, runtime::pipe::RawFdExt};
use bytes::Bytes;
use floating_duration::TimeAsFloat;
use futures::{
future::{join_all, ready, OptionFuture},
FutureExt,
};
use log::{debug, info, warn};
use... | the_stack |
extern crate skryn;
extern crate webrender;
use std::any::Any;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
use skryn::data::*;
use skryn::elements::*;
use skryn::gui::font::FontStore;
use skryn::gui::properties::{Extent, IdGenerator, Properties, Property};
use webrender::api::{ColorF, Disp... | the_stack |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.