text stringlengths 2.5k 6.39M | kind stringclasses 3
values |
|---|---|
use crate::api_registry::ApiRegistry;
use crate::extractors::{RpcExtractor, WsExtractor};
use anyhow::Result;
use futures::stream::*;
use futures::{FutureExt, StreamExt};
use jsonrpc_core::futures::channel::mpsc;
use jsonrpc_core::MetaIoHandler;
use jsonrpc_core_client::{
transports::{duplex, local::LocalRpc},
... | the_stack |
use super::{FromInput, Input};
use crate::{
Ctx, Error, FromJs, Function, IntoJs, Method, MutFn, OnceFn, ParallelSend, Result, This, Value,
};
use std::ops::Range;
#[cfg(feature = "classes")]
use crate::{Class, ClassDef, Constructor};
#[cfg(feature = "futures")]
use crate::{Async, Promised};
#[cfg(feature = "futu... | the_stack |
use devise::{*, ext::{TypeExt, SpanDiagnosticExt}};
use syn::{visit_mut::VisitMut, visit::Visit};
use proc_macro2::{TokenStream, TokenTree, Span};
use quote::{ToTokens, TokenStreamExt};
use crate::syn_ext::IdentExt;
use crate::name::Name;
#[derive(Debug)]
pub enum FieldName {
Cased(Name),
Uncased(Name),
}
#... | the_stack |
use crate::profile::Profile;
use crate::ProfileChangeType::{CreateKey, RotateKey};
use crate::{
EntityError, EventIdentifier, KeyAttributes, MetaKeyAttributes, ProfileChange,
ProfileChangeEvent, ProfileChangeProof, ProfileVault, SignatureType,
};
use ockam_core::compat::{string::ToString, vec::Vec};
use ockam_c... | the_stack |
use std::cmp;
use std::cmp::Ordering;
use std::fs;
use std::io::{self, Write};
use std::ops;
/// Refer to the module documentation.
pub trait Storage<'a> {
type Reader: io::Read + io::Seek + 'a;
type Writer: io::Write + io::Seek + 'a;
/// Opens the storage for reading.
fn reader(&'a mut self) -> io::R... | the_stack |
// #[PerformanceCriticalPath] called by raftstore
use std::cmp::Ordering;
use std::convert::TryInto;
use std::marker::PhantomData;
use std::sync::atomic::{AtomicU64, Ordering as AtomicOrdering};
use std::sync::Arc;
use crate::storage::mvcc::{Lock, LockType, WriteRef, WriteType};
use engine_traits::{
IterOptions, I... | the_stack |
use std::collections::HashMap;
use std::fmt::{self, Debug};
use std::path::{Path, PathBuf};
use std::u16;
use rmp_serde::{Deserializer, Serializer};
use serde::{Deserialize, Serialize};
use super::local_cache::{LocalCache, LocalCacheRef};
use crate::base::crypto::{Crypto, HashKey, Key};
use crate::error::{Error, Resu... | the_stack |
use log::*;
use reqwest::blocking::{Client, Request, Response};
use reqwest::header::{self, HeaderValue};
use reqwest::StatusCode;
use std::io;
use std::mem;
use std::thread;
use std::time::Duration;
pub fn retry_execute(client: &Client, request: Request) -> reqwest::Result<Response> {
let mut err = None;
for ... | the_stack |
use std::collections::HashSet;
use std::fs::File;
use std::iter::FromIterator;
use std::path::Path;
use std::sync::Arc;
use failure::ResultExt;
use itertools::Itertools;
use log::{debug, info};
use ndarray::prelude::*;
use snips_nlu_ontology::IntentClassifierResult;
use crate::errors::*;
use crate::intent_classifier:... | the_stack |
#![recursion_limit = "512"]
// === Features ===
#![feature(option_result_contains)]
#![feature(trait_alias)]
// === Standard Linter Configuration ===
#![deny(non_ascii_idents)]
#![warn(unsafe_code)]
// === Non-Standard Linter Configuration ===
#![warn(missing_copy_implementations)]
#![warn(missing_debug_implementations... | the_stack |
use crate::arch::Arch;
use crate::common::Signal;
use crate::target::ext::breakpoints::WatchKind;
use crate::target::ext::catch_syscalls::CatchSyscallPosition;
use crate::target::{Target, TargetResult};
use super::{ReplayLogPosition, SingleRegisterAccessOps};
/// Base debugging operations for single threaded targets.... | the_stack |
#![cfg(feature = "radix")]
#![doc(hidden)]
use crate::bellerophon::BellerophonPowers;
#[cfg(feature = "compact")]
use crate::table_bellerophon_decimal::BASE10_POWERS;
/// Get Bellerophon powers from radix.
#[inline]
pub const fn bellerophon_powers(radix: u32) -> &'static BellerophonPowers {
match radix {
... | the_stack |
pub struct GetExecutionHistoryPaginator<
C = aws_smithy_client::erase::DynConnector,
M = crate::middleware::DefaultMiddleware,
R = aws_smithy_client::retry::Standard,
> {
handle: std::sync::Arc<crate::client::Handle<C, M, R>>,
builder: crate::input::get_execution_history_input::Builder,
}
impl<C, M... | the_stack |
use crate::arch;
use crate::arch::mem::MemoryMapping;
pub use crate::arch::process::Process as ArchProcess;
pub use crate::arch::process::Thread;
use xous_kernel::MemoryRange;
use core::num::NonZeroU8;
use crate::filled_array;
use crate::server::Server;
// use core::mem;
use xous_kernel::{
pid_from_usize, Error, ... | the_stack |
use crate::countminsketch::CountMinSketch;
use std::cmp::Ordering;
use std::collections::hash_map::Entry;
use std::collections::{BTreeSet, HashMap};
use std::fmt;
use std::hash::Hash;
use std::rc::Rc;
#[derive(Debug)]
struct TreeEntry<T>
where
T: Eq + Ord,
{
obj: Rc<T>,
n: usize,
}
impl<T> Clone for TreeE... | the_stack |
use crate::config::{
self, ClientConfig, ExperimentConfig, ProcessType, ProtocolConfig,
RegionIndex,
};
use crate::machine::{Machine, Machines};
use crate::progress::TracingProgressBar;
use crate::{FantochFeature, Protocol, RunMode, SerializationFormat, Testbed};
use color_eyre::eyre::{self, WrapErr};
use color... | the_stack |
use crate::metadata::*;
use crate::types::*;
use crate::*;
//#[link(name = "sgx_tstdc")]
extern "C" {
//
// sgx_cpuid.h
//
pub fn sgx_cpuid(cpuinfo: *mut [int32_t; 4], leaf: int32_t) -> sgx_status_t;
pub fn sgx_cpuidex(cpuinfo: *mut [int32_t; 4], leaf: int32_t, subleaf: int32_t)
-> sgx_stat... | the_stack |
use ash::extensions::{
ext::DebugReport,
khr::{Surface, Swapchain},
};
use ash::version::{DeviceV1_0, EntryV1_0, InstanceV1_0, InstanceV1_1};
use ash::{vk, Device, Entry, Instance};
use std::error::Error;
use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_void};
unsafe extern "system" fn vulkan_debug_... | the_stack |
use crate::address::{AddressOutput, AddressWrapper, OutputKind};
use rand::{prelude::SliceRandom, thread_rng};
use std::{
cmp::Ordering,
sync::atomic::{AtomicI64, Ordering as AtomicOrdering},
};
const DUST_ALLOWANCE_VALUE: u64 = 1_000_000;
const MAX_INPUT_SELECTION_TRIES: i64 = 10_000_000;
#[derive(Debug, Clo... | the_stack |
use derivative::Derivative;
use num_traits::{One, Zero};
use serde::{Deserialize, Serialize};
use std::{
fmt::{Display, Formatter, Result as FmtResult},
marker::PhantomData,
ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign},
};
use crate::{
biginteger::BigInteger,
fields::{Field, FpParamet... | the_stack |
use arrayvec::ArrayVec;
use std::collections::VecDeque;
use std::iter::IntoIterator;
use theon::ops::Interpolate;
use typenum::{Cmp, Greater, U1};
use crate::constant::{Constant, ToType, TypeOf};
use crate::primitive::{
BoundedPolygon, Edge, NGon, Polygonal, Tetragon, Topological, Trigon, UnboundedPolygon,
};
use ... | the_stack |
use serde::{Deserialize, Serialize};
use thiserror::Error;
use super::Chunker;
use xaynet_core::{
crypto::{PublicEncryptKey, SecretSigningKey, SigningKeyPair},
message::{Chunk, Message, Payload, Tag, ToBytes},
};
/// An encoder for multipart messages. It implements
/// `Iterator<Item=Vec<u8>>`, which yields m... | the_stack |
mod tests {
use crate::util::alloc::*;
use rkyv::{
archived_root,
ser::{serializers::WriteSerializer, Serializer},
AlignedBytes, Archive, Deserialize, Serialize,
};
use std::collections::{HashMap, HashSet};
#[cfg(feature = "wasm")]
use wasm_bindgen_test::*;
#[test]
... | the_stack |
use players;
use players::Player;
use players::Players;
use players::ExplorerData;
use players::GnomeData;
use inventory;
use inventory::Thing;
use std::io;
// 5 by 5 room game board
pub type Board = [[Room; 5]; 5];
enum Wall {
Solid,
Opening,
Magical { word: String }
}
struct Room {
north: Wall,
... | the_stack |
pub struct ListBootstrapActionsPaginator<
C = aws_smithy_client::erase::DynConnector,
M = crate::middleware::DefaultMiddleware,
R = aws_smithy_client::retry::Standard,
> {
handle: std::sync::Arc<crate::client::Handle<C, M, R>>,
builder: crate::input::list_bootstrap_actions_input::Builder,
}
impl<C,... | the_stack |
//
// This tests require docker on the host machine
//
use std::time::Duration;
use actix::clock::sleep;
use log::*;
use reqwest::Client;
use serde_json::Value;
use serial_test::serial;
use std::sync::Arc;
use testcontainers::images::generic::GenericImage;
use testcontainers::*;
use tokio::time;
use tornado_common::a... | the_stack |
use std::io;
use std::process;
use std::fs::File;
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
#[cfg(feature = "discovery")]
use std::io::{BufRead, BufReader};
use fs2::FileExt;
use openssl::ssl::SslConnectorBuilder;
use crate::utils;
use crate::config::{PersistentConfig, PublicIdentity};
use crate... | the_stack |
use gstreamer_sdp_sys::*;
use std::env;
use std::error::Error;
use std::ffi::OsString;
use std::mem::{align_of, size_of};
use std::path::Path;
use std::process::Command;
use std::str;
use tempfile::Builder;
static PACKAGES: &[&str] = &["gstreamer-sdp-1.0"];
#[derive(Clone, Debug)]
struct Compiler {
pub args: Vec<... | the_stack |
use {
crate::check::{PreflightCheck, PreflightCheckResult, PreflightCheckResult::*},
crate::command_runner::CommandRunner,
crate::config::*,
anyhow::{anyhow, Context, Result},
async_trait::async_trait,
};
const LINUX_PACKAGES: &[&str] = &["curl", "git", "unzip"];
const MACOS_MINIMUM_MAJOR_VERSION: ... | the_stack |
use crate::errors::CircuitError;
use crate::pipeline::*;
use crate::qubits::*;
use crate::state_ops::*;
use crate::Complex;
use num::Zero;
use std::fmt;
use std::rc::Rc;
/// A function which takes a builder, a Register, and a set of measured values, and constructs a
/// circuit, outputting the resulting Register.
type... | the_stack |
use crate::{
object,
syntax::{Keyword, Term},
util, Id, Indexed, Object, Objects, Reference, ToReference,
};
use cc_traits::MapInsert;
use generic_json::{JsonClone, JsonHash};
use iref::{Iri, IriBuf};
use std::collections::HashSet;
use std::convert::TryFrom;
use std::hash::{Hash, Hasher};
pub mod properties;
pub mo... | the_stack |
extern crate nom;
use std::io::BufRead;
use nom::{
bytes::complete::tag,
character::complete::multispace0,
error::{ErrorKind, ParseError},
multi::{many0, many0_count},
sequence::{preceded, tuple},
IResult,
};
static WHITESPACE: &str = " \t\r\n";
#[derive(Debug, PartialEq)]
enum InternalError... | the_stack |
use super::parse::ast::*;
use super::parse::token::Lit;
use super::storage::{Database, Column, Table, Rows, ResultSet, Engine, EngineID, Error};
use super::storage::types::SqlType;
use super::storage;
use super::auth;
use super::parse::parser::ParseError;
use std::io::{Write, Read, Seek};
use std::fs::File;
use std::io... | the_stack |
use ff::*;
fn query_tensor_decomposition_element_matrix_over_identyty_matrix<F: PrimeField>(
submatrix: &(Vec<F>, (usize, usize)),
idx: (usize, usize)
) -> F {
// this is a tensor decomposition query that takes matrix
// in a form of
// |a|0|0|0| |1|0|0|0|
// |0|a|0|0| = a \cr... | the_stack |
use super::node::*;
use crate::codegen::arch::machine::register::{ty2rc, RegisterClassKind as RC};
use crate::codegen::common::{machine::register::RegistersInfo, types::MVType};
use crate::ir::types::Type;
use id_arena::Arena;
use rustc_hash::FxHashMap;
use std::ops::BitOr;
pub type GenFn = fn(&FxHashMap<&'static str,... | the_stack |
mod components;
mod buffer;
mod square;
mod triangle;
mod noise;
mod dmc;
use Settings;
use apu::buffer::*;
use apu::dmc::*;
use apu::noise::*;
use apu::square::*;
use apu::triangle::*;
use audio::AudioOut;
use cpu::IrqInterrupt;
use std::cell::RefCell;
use std::cmp;
use std::rc::Rc;
pub type Sampl... | the_stack |
use pretty::{BoxDoc, Doc};
use std::borrow::Cow;
use super::{syntax, var, AppMode, UniverseLevel};
pub fn parens<'doc, A>(
inner: impl Into<Doc<'doc, BoxDoc<'doc, A>, A>>,
) -> Doc<'doc, BoxDoc<'doc, A>, A> {
Doc::nil().append("(").append(inner.into()).append(")")
}
pub fn declaration<'doc, A>(
label: im... | the_stack |
use std::{borrow::Borrow, convert::TryFrom, marker::PhantomData};
use crate::{
base58::{FromBase58Check, FromBase58CheckError, ToBase58Check},
blake2b::{self, Blake2bError},
};
use serde::{Deserialize, Serialize};
use thiserror::Error;
mod prefix_bytes {
pub const CHAIN_ID: [u8; 3] = [87, 82, 0];
pub ... | the_stack |
use futures::sync::oneshot::{
Sender as OneshotSender
};
use futures::future::Future;
use futures::stream::{
self,
Stream
};
use futures::sink::Sink;
use futures::stream::{
SplitSink,
SplitStream
};
use std::fmt;
use std::mem;
use std::collections::{
VecDeque,
BTreeMap
};
use crate::protocol::utils as ... | the_stack |
//! Implements the traits found in [ecma402_traits::numberformat].
use {
ecma402_traits, rust_icu_common as common, rust_icu_unumberformatter as unumf,
std::convert::TryInto, std::fmt,
};
#[derive(Debug)]
pub struct NumberFormat {
// The internal representation of number formatting.
rep: unumf::UNumbe... | the_stack |
// std
use std::f32::consts::PI;
use std::sync::Arc;
// pbrt
use crate::core::geometry::{spherical_direction_vec3, vec3_coordinate_system, vec3_dot_vec3f};
use crate::core::geometry::{Point2f, Ray, Vector3f, XYEnum};
use crate::core::interaction::MediumInteraction;
use crate::core::pbrt::INV_4_PI;
use crate::core::pbrt... | the_stack |
use std::{fmt, sync::Arc};
#[cfg(any(test, feature = "proptest-impl"))]
use proptest_derive::Arbitrary;
use crate::{
amount::{Amount, NonNegative},
serialization::ZcashSerialize,
transaction::{
AuthDigest, Hash,
Transaction::{self, *},
WtxId,
},
};
use UnminedTxId::*;
/// The... | the_stack |
use proc_macro2 as pm;
use proc_macro2::Span;
use crate::bigint::BigInt;
use std::char;
use std::ops::{Index, RangeFrom};
/// A literal token
#[derive(Debug, Clone)]
pub struct Literal {
pub kind: LitKind,
pub span: Span,
}
// XXXManishearth technically all literals except booleans
// can have arbitrary suf... | the_stack |
use crossterm::ExecutableCommand;
use futures::stream::{BoxStream, StreamExt};
use kitsune_p2p_proxy::tx2::*;
use kitsune_p2p_proxy::ProxyUrl;
use kitsune_p2p_transport_quic::tx2::*;
use kitsune_p2p_types::tx2::tx2_api::*;
use kitsune_p2p_types::tx2::tx2_pool_promote::*;
use kitsune_p2p_types::*;
use std::collections::... | the_stack |
use std::collections::HashMap;
use std::net::SocketAddr;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::time::{self, Duration, SystemTime};
use bytes::{buf::BufMutExt, Bytes, BytesMut};
use futures3::channel::mpsc::{self, Sender};
use futures3::sink::SinkExt;
use futures3::stream::StreamExt;
use futures... | the_stack |
use crate::internal::*;
use crate::ops::cnn::padding::ComputedPaddedDim;
use crate::ops::cnn::{KernelFormat, PoolSpec};
use crate::ops::nn::DataShape;
use tract_ndarray::prelude::*;
/*
(N) (G) C H W
Reshaped Input (N) (G) C HW
Kernel (N) (G) OHkWk C
Gemm (N) (G) OHkWk HW (Gemm:... | the_stack |
use itertools::Itertools;
use crate::token::{Token, TokenKind};
pub struct RawLexer {
source: Vec<char>,
cursor: usize,
interp_count: u8,
braces_count: u8,
buffer: Vec<Token>,
pub is_new_line: bool,
}
impl RawLexer {
pub fn new(source: String) -> RawLexer {
RawLexer {
... | the_stack |
use proc_macro::TokenStream;
use proc_macro_error::{
proc_macro2::{Group, Ident, Span},
*,
};
use proc_quote::quote;
use std::collections::HashMap;
use syn::parse::{Parse, ParseStream};
use syn::{parse_macro_input, Error, LitInt, Token};
type TS = proc_macro2::TokenStream;
struct Registers {
class: Vec<(S... | the_stack |
mod peg {
#![allow(unused_imports, dead_code, clippy::all)]
use std::collections::HashMap;
use regex::Regex;
use unicode_xid::UnicodeXID;
#[derive(Clone, Debug)]
pub struct Node {
pub rule: Rule,
pub start: usize,
pub end: usize,
pub children: Vec<Node>,
pub label: Option<&'static str>,
pub alt... | the_stack |
use std::io::Write;
use std::net::TcpStream;
use std::path::PathBuf;
use std::process::Command;
use std::time::Duration;
use std::{io, result, thread};
use anyhow::bail;
use nix::errno::Errno;
use nix::sys::signal::{kill, Signal};
use nix::unistd::Pid;
use pageserver::http::models::{BranchCreateRequest, TenantCreateRe... | the_stack |
//! Testing-related utilities.
use alloc::borrow::ToOwned;
use alloc::collections::{BinaryHeap, HashMap};
use alloc::string::{String, ToString};
use alloc::vec;
use alloc::vec::Vec;
use core::fmt::{self, Debug, Formatter};
use core::hash::Hash;
use core::ops;
use core::time::Duration;
use log::{debug, trace};
use net... | the_stack |
use crate::{
application::storage::PeerMetadataStorage,
constants,
peer::DisconnectReason,
peer_manager::{
conn_notifs_channel, error::PeerManagerError, ConnectionNotification, ConnectionRequest,
PeerManager, PeerManagerNotification, PeerManagerRequest, TransportNotification,
},
... | the_stack |
use crate::infer::canonical::substitute::{substitute_value, CanonicalExt};
use crate::infer::canonical::{
Canonical, CanonicalVarValues, CanonicalizedQueryResponse, Certainty, OriginalQueryValues,
QueryOutlivesConstraint, QueryRegionConstraints, QueryResponse,
};
use crate::infer::nll_relate::{NormalizationStra... | the_stack |
use super::*;
use crate::{
bench::Bencher,
console::OutputLocation,
formatters::PrettyFormatter,
options::OutputFormat,
test::{
filter_tests,
parse_opts,
run_test,
DynTestFn,
DynTestName,
MetricMap,
RunIgnored,
RunStrategy,
Sho... | the_stack |
use audius_eth_registry::*;
use borsh::BorshDeserialize;
use libsecp256k1::{PublicKey, SecretKey};
use rand::rngs::ThreadRng;
use rand::{thread_rng, Rng};
use sha3::Digest;
use solana_program::secp256k1_program;
use solana_program::{hash::Hash, instruction::Instruction, pubkey::Pubkey, system_instruction};
use solana_... | the_stack |
use crate::AsyncResult;
use crate::Cancellable;
use crate::InputStream;
use crate::OutputStreamSpliceFlags;
use glib::object::IsA;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem;
use std::pin::Pin;
use std::ptr;
glib::wrapper! {
#[doc(alias = "GOutputStream")]
pub struct Output... | the_stack |
use crate::wasm_flat_vector::WasmFlatVector;
use crate::wasm_vector::WasmVector;
use paste::paste;
use std::convert::TryInto;
use wasm_bindgen::prelude::*;
// use std::sync::Arc;
// use commitment_dlog::srs::SRS;
// use kimchi::index::{expr_linearization, VerifierIndex as DlogVerifierIndex};
// use ark_poly::{Evaluatio... | the_stack |
use std::collections::{HashMap, HashSet, VecDeque};
use std::hash::Hash;
use std::rc::Rc;
use timely::dataflow::channels::pact::{Exchange, Pipeline};
use timely::dataflow::operators::{Concatenate, Operator, Partition};
use timely::dataflow::scopes::child::Iterative;
use timely::dataflow::Scope;
use timely::order::Prod... | the_stack |
//! Manages chain synchronisation process.
//! - tries to download most recent header from the other peers
//! - also supplies downloaded data to other peers
//!
//! Also responsible for:
//! -- managing attribute current head
//! -- start test chain (if needed)
//! -- validate blocks with protocol
//! -- ...
use std:... | the_stack |
use diem_proptest_helpers::pick_slice_idxs;
use move_binary_format::{
errors::{bounds_error, PartialVMError},
file_format::{
AddressIdentifierIndex, CompiledModule, CompiledModuleMut, FunctionHandleIndex,
IdentifierIndex, ModuleHandleIndex, SignatureIndex, StructDefinitionIndex,
StructHa... | the_stack |
use parking_lot::RwLock;
use pyo3::exceptions::{PyException, PyRuntimeError, PyValueError};
use pyo3::prelude::*;
use pyo3_asyncio::tokio::future_into_py;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use temporal_client::{
ClientOptions, ClientOptionsBuilder, ConfiguredClient, RetryCl... | the_stack |
use rustc_middle::mir::{
self,
interpret::{InterpError, UndefinedBehaviorInfo},
};
use rustc_middle::ty::{subst::Subst, ParamEnv, TyKind, TypeAndMut};
use rustc_mir::interpret::{
Allocation, Frame, Immediate, InterpResult, MemPlaceMeta, OpTy, Operand, Pointer, Scalar,
ScalarMaybeUninit,
};
use rustc_tar... | the_stack |
// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineNEDDepA.yaml by generate.py. Do not modify by hand!
use crate::*;
#[test]
fn test_auto_check_sbp_navigation_msg_baseline_ned_dep_a() {
{
let mut payload = Cursor::new(vec![
85, 3, 2, 246, 215, 22, 20, ... | the_stack |
use crate::args::AutoTestGeneratorCommand;
use crate::cm_parser::read_cm;
use crate::generate_build::BuildGenerator;
use crate::generate_manifest::ManifestGenerator;
use crate::generate_rust_test::{CodeGenerator, RustTestCode, RustTestCodeGenerator};
use anyhow::{format_err, Result};
use fidl_fuchsia_sys2::*;
use rege... | the_stack |
use crate::atom_table::*;
use crate::parser::ast::*;
use crate::forms::*;
use crate::instructions::*;
use fxhash::FxBuildHasher;
use indexmap::IndexMap;
use std::collections::VecDeque;
use std::hash::Hash;
use std::iter::once;
use std::mem;
#[derive(Debug, Clone, Copy)]
enum OptArgIndexKeyType {
Structure,
... | the_stack |
use std::fs;
use std::path::PathBuf;
use crate::tests::util::Dir;
use crate::WalkDir;
#[test]
fn send_sync_traits() {
use crate::{FilterEntry, IntoIter};
fn assert_send<T: Send>() {}
fn assert_sync<T: Sync>() {}
assert_send::<WalkDir>();
assert_sync::<WalkDir>();
assert_send::<IntoIter>();
... | the_stack |
use crate::bitmap::Bitmap;
use crate::error::{Error, Result};
use crate::repr::{ByteRepr, LeadingNonZeroByte, SMARepr};
use crate::sel::Sel;
use smallvec::SmallVec;
use std::ops::Index;
use std::sync::Arc;
#[derive(Debug)]
pub struct SMA {
pub min: SmallVec<[u8; 16]>,
pub max: SmallVec<[u8; 16]>,
pub kind:... | the_stack |
use crate::entry_def::EntryDefStoreKey;
use crate::prelude::SignedValidationReceipt;
use crate::query::from_blob;
use crate::query::to_blob;
use crate::schedule::fn_is_scheduled;
use crate::scratch::Scratch;
use crate::validation_db::ValidationLimboStatus;
use holo_hash::encode::blake2b_256;
use holo_hash::*;
use holoc... | the_stack |
use json::object::Object;
use rusqlite::{params, Connection, LoadExtensionGuard, OpenFlags, Result};
use std::collections::HashMap;
use std::env;
#[cfg(feature = "bundle_libgenomicsqlite")]
use std::fs::File;
#[cfg(feature = "bundle_libgenomicsqlite")]
use std::io::prelude::*;
use std::path::Path;
use std::sync::Once;
... | the_stack |
#![feature(plugin, test, conservative_impl_trait, custom_derive)]
extern crate uuid;
extern crate redis;
extern crate tickgrinder_util;
extern crate futures;
extern crate test;
extern crate serde;
extern crate serde_json;
extern crate ws;
#[macro_use]
extern crate serde_derive;
extern crate tantivy;
use std::sync::{A... | the_stack |
mod isr;
use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use crate::{priority, util, rast};
use crate::rast::{RasterCtx, TargetBuffer};
use crate::timing::{self, Polarity};
use crate::util::spin_lock::{SpinLock, SpinLockGuard};
use cortex_m::peripheral as cm;
use stm32f4::stm32f407 as device;
use corte... | the_stack |
use crate::workflows::definitions::{WorkflowDefinition, WorkflowStepDefinition, WorkflowStepType};
use crate::workflows::runner::test_context::TestContext;
use crate::workflows::steps::factory::WorkflowStepFactory;
use crate::workflows::steps::StepStatus;
use crate::workflows::MediaNotificationContent::StreamDisconnect... | the_stack |
// This module contains the `Connection` type and associated helpers.
// A `Connection` wraps an underlying (async) I/O resource and multiplexes
// `Stream`s over it.
//
// The overall idea is as follows: The `Connection` makes progress via calls
// to its `next_stream` method which polls several futures, one that deco... | the_stack |
use super::prelude::*;
use rand::distributions::uniform::SampleRange;
use num::{CheckedAdd, One, Zero};
use std::ops::{Bound, RangeBounds};
/// A custom extension of all the range types that uses
/// [`Bound`](std::ops::Bound) on the left and on the right.
#[derive(Clone)]
struct AnyRange<N> {
low: Bound<N>,
... | the_stack |
use greenwasm_structure::types::*;
use greenwasm_structure::modules::*;
use greenwasm_validation::ValidatedModule;
use std::result::Result as StdResult;
use std::iter;
use runtime_structure::*;
use instructions::*;
use DEBUG_EXECUTION;
use frounding;
// TODO: more central definition
pub const WASM_PAGE_SIZE: usize =... | the_stack |
use crate::{BSVErrors, HARDENED_KEY_OFFSET, KDF, XPRIV_VERSION_BYTE};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use getrandom::*;
use k256::SecretKey;
use std::{
io::{Cursor, Read, Write},
ops::Add,
vec,
};
#[cfg(target_arch = "wasm32")]
use wasm_bindgen::{prelude::*, throw_str};
use crate:... | the_stack |
use nom::bytes::complete::{tag, take_until, take_while1};
use nom::combinator::{all_consuming, map, cut, opt, rest, peek, value};
use nom::multi::separated_nonempty_list;
use nom::branch::alt;
use crate::rules::parser::{Span, var_name, ParserError, var_name_access, IResult, parse_value, type_name};
use nom::sequence::{... | the_stack |
use codec::{Compact, Encode};
use sp_runtime::generic::Era;
use sp_runtime::RuntimeAppPublic;
use sp_std::vec;
use sp_std::vec::*;
use sp_version::RuntimeVersion;
use t3rn_primitives::transfers::TransferEntry;
use t3rn_primitives::*;
use crate::message_assembly::chain_generic_metadata::Metadata;
use crate::message_a... | the_stack |
use std::marker::PhantomData;
use std::sync::Arc;
use std::time::Instant;
use std::u64;
use log::{error, info};
use protobuf::{parse_from_bytes, Message};
use crate::config::Config;
use crate::consistency::ConsistencyChecker;
use crate::event_listener::EventListener;
use crate::file_builder::*;
use crate::file_pipe_l... | the_stack |
use crate::link::CompanyId;
use crate::uuid::{IsUuid, Uuid128, Uuid16, Uuid32, UuidKind};
use crate::{bytes::*, Error};
use bitflags::bitflags;
/// A list of AD structures can be sent along with an advertising packet or scan response.
///
/// This mechanism allows a scanner to, for example, receive the device's name w... | the_stack |
use std::env;
use std::ffi::OsString;
use std::fs;
use std::io::{self, BufRead};
use std::net::SocketAddr;
use std::path::{Path, PathBuf};
use std::str::FromStr;
use std::time::Duration;
use std::{collections::HashMap, collections::HashSet, fmt::Debug};
use clap::{App, Arg};
use slog::Logger;
use crypto::hash::BlockH... | the_stack |
use crate::cell::UnsafeCell;
use crate::fmt;
use crate::future::Future;
use crate::ops::{Deref, DerefMut};
use crate::pin::Pin;
use crate::ptr::{NonNull, Unique};
use crate::stream::Stream;
use crate::task::{Context, Poll};
/// A marker trait which represents "panic safe" types in Rust.
///
/// This trait is implement... | the_stack |
use crate::Result;
use crate::inthost::*;
use crate::BindingsList;
use crate::{
bus::MessageBus, dispatch::WasccNativeDispatcher, plugins::PluginManager, Authorizer,
Invocation, InvocationResponse, Middleware, RouteKey,
};
use crate::{middleware, NativeCapability};
use crossbeam::{Receiver, Sender};
use cross... | the_stack |
use std::{str::FromStr, sync::Arc};
use anyhow::Result;
use chrono::offset::Utc;
use cio_api::{
companies::Company,
configs::{
get_configs_from_repo, sync_buildings, sync_certificates, sync_conference_rooms,
sync_github_outside_collaborators, sync_groups, sync_links, sync_users,
},
repo... | the_stack |
use crate::avx2::*;
#[cfg(target_arch = "wasm32")]
use crate::simd128::*;
use crate::scores::*;
use std::{cmp, ptr, i16};
use std::marker::PhantomData;
const NULL: u8 = b'A' + 26u8; // this null byte value works for both amino acids and nucleotides
// Notes:
//
// BLOSUM62 matrix max = 11, min = -4; gap open = -11... | the_stack |
use std::io;
use std::pin::Pin;
use std::task::{Context, Poll};
use byteorder::WriteBytesExt;
use byteorder::{LittleEndian, ReadBytesExt};
use futures::ready;
use tokio::io::ReadBuf;
use tokio::io::{AsyncBufRead, AsyncRead};
use clickhouse_driver_cthrs::city_hash_128;
pub use clickhouse_driver_lz4::{
LZ4_Compress... | the_stack |
use crate::priv_prelude::*;
pub mod item_abi;
pub mod item_const;
pub mod item_enum;
pub mod item_fn;
pub mod item_impl;
pub mod item_storage;
pub mod item_struct;
pub mod item_trait;
pub mod item_use;
pub type Item = Annotated<ItemKind>;
impl Spanned for Item {
fn span(&self) -> Span {
match self.attrib... | the_stack |
use std::sync::Arc;
use sui_config::ValidatorInfo;
use sui_core::{
authority_client::{AuthorityAPI, NetworkAuthorityClient},
gateway_state::{GatewayAPI, GatewayState},
};
use sui_types::object::OBJECT_START_VERSION;
use sui_types::{
base_types::ObjectRef,
error::SuiResult,
messages::{
CallAr... | the_stack |
use std::cell::RefCell;
use std::rc::{Rc, Weak};
use actix_router::ResourceDef;
use ahash::AHashMap;
use url::Url;
use crate::error::UrlGenerationError;
use crate::request::HttpRequest;
#[derive(Clone, Debug)]
pub struct ResourceMap {
pattern: ResourceDef,
/// Named resources within the tree or, for externa... | the_stack |
use super::{
msr::*,
structs::{MsrList, VmInstructionError, VmxPage},
timer::PitTimer,
utils::{cr0_is_valid, cr4_is_valid, tr_base},
vmcs::*,
vmcs::{VmcsField16::*, VmcsField32::*, VmcsField64::*, VmcsFieldXX::*},
vmexit::vmexit_handler,
Guest,
};
use crate::interrupt::InterruptControlle... | the_stack |
#![deny(unsafe_code)]
use super::gmp::mpz::Mpz;
use super::gmp::mpz::ProbabPrimeResult::NotPrime;
use super::ClassGroup;
use num_traits::{One, Zero};
use std::{
borrow::Borrow,
cell::RefCell,
mem::swap,
ops::{Mul, MulAssign},
};
mod congruence;
pub(super) mod ffi;
#[derive(PartialEq, PartialOrd, Eq, Or... | the_stack |
use crate::constants::*;
#[cfg(feature = "cookies")]
use crate::cookie::Cookie;
use crate::deref;
use crate::path::is_ctl;
use crate::path::PathBuf;
use crate::query::parse_query;
#[cfg(feature = "extended_queries")]
use crate::query::{parse_extended_query, QueryValue};
use crate::util::Spliterator;
use octane_http::Ht... | the_stack |
use core::convert::{From, TryFrom};
use crate::pac::{DCB, DWT};
#[cfg(feature = "enumset")]
use enumset::{EnumSet, EnumSetType};
use void::Void;
use crate::hal::timer::{Cancel, CountDown, Periodic};
#[allow(unused)]
use crate::pac::{self, RCC};
use crate::rcc::{self, Clocks};
use crate::time::{duration, fixed_point::... | the_stack |
use crate::{
datatype::DataType,
errors::AtomicResult,
schema::{Class, Property},
urls, Storelike, Value,
};
/// Populates a store with some of the most fundamental Properties and Classes needed to bootstrap the whole.
/// This is necessary to prevent a loop where Property X (like the `shortname` Prope... | the_stack |
#![feature(repr_simd)]
#![allow(improper_ctypes_definitions)]
#![allow(unused)]
/// Utilities that capture the common structures in SIMD operations
/// using 2nd order functions
mod vector {
/// Implemented by types that support 4-element vectors
/// Provides methods to construct, destruct and convert vectors... | the_stack |
use super::*;
decl!(u32x8: u32 => __m256i);
impl<S: Simd> Default for u32x8<S> {
#[inline(always)]
fn default() -> Self {
Self::new(unsafe { _mm256_setzero_si256() })
}
}
#[rustfmt::skip]
macro_rules! log_reduce_epu32_avx1 {
($value:expr; $op:ident) => {unsafe {
let ymm0 = $value;
... | the_stack |
//! Contains the implementation of the `Connection`
use crate::{
ack::interest::Provider as _,
connection::{
self,
close_sender::CloseSender,
id::{ConnectionInfo, Interest},
limits::Limits,
local_id_registry::LocalIdRegistrationError,
ConnectionIdMapper, Connecti... | the_stack |
use crate::{
baggage::{BaggageExt, KeyValueMetadata},
propagation::{text_map_propagator::FieldIter, Extractor, Injector, TextMapPropagator},
Context,
};
use percent_encoding::{percent_decode_str, utf8_percent_encode, AsciiSet, CONTROLS};
use std::iter;
static BAGGAGE_HEADER: &str = "baggage";
const FRAGMEN... | the_stack |
use anyhow::{ensure, Context};
use log::trace;
use paired::bls12_381::Fr;
use sha2raw::Sha256;
use storage_proofs_core::{
error::Result,
hasher::{Domain, Hasher},
merkle::{MerkleProofTrait, MerkleTreeTrait},
proof::ProofScheme,
};
use super::{
batch_hasher::{batch_hash_expanded, truncate_hash},
... | the_stack |
use crate::{
chart::{
ActiveHoverRegion, ChartImpl, DrawChartOptions, DrawChartOutput, DrawOverlayOptions,
HoverRegion,
},
common::{
compute_rects, compute_x_axis_grid_line_info, draw_x_axis, draw_x_axis_grid_lines,
draw_x_axis_labels, draw_x_axis_title, draw_y_axis, draw_y_axis_grid_lines,
draw_y_axis_lab... | the_stack |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.