text stringlengths 2.5k 6.39M | kind stringclasses 3
values |
|---|---|
use crate::certificate_waiter::CertificateWaiter;
use crate::core::Core;
use crate::error::DagError;
use crate::garbage_collector::GarbageCollector;
use crate::header_waiter::HeaderWaiter;
use crate::helper::Helper;
use crate::messages::{Certificate, Header, Vote};
use crate::payload_receiver::PayloadReceiver;
use crat... | the_stack |
use crate::{
arch::Architecture,
bindings::{
kernel::{timeval, _LINUX_CAPABILITY_U32S_3, _LINUX_CAPABILITY_VERSION_3},
signal::{SI_KERNEL, TRAP_BRKPT},
},
event::{Event, EventType, SignalDeterministic, SyscallState},
flags::{Checksum, DumpOn, Flags},
kernel_abi::{native_arch, Clo... | the_stack |
extern crate bddisasm_sys as ffi;
pub use crate::cpu_modes::CpuModes;
pub use crate::cpuid::Cpuid;
pub use crate::decode_error::DecodeError;
pub use crate::fpu_flags::FpuFlags;
pub use crate::instruction_category::Category;
pub use crate::isa_set::IsaSet;
pub use crate::mnemonic::Mnemonic;
pub use crate::operand;
pub ... | the_stack |
use crate::{futures_util::FuturesOps, PartialOp};
use futures::prelude::*;
use pin_project::pin_project;
use std::{
fmt, io,
pin::Pin,
task::{Context, Poll},
};
/// A wrapper that breaks inner `AsyncRead` instances up according to the
/// provided iterator.
///
/// Available with the `futures03` feature fo... | the_stack |
pub mod args;
pub mod arithmetic_ops;
pub mod attributed_variables;
pub mod code_walker;
#[macro_use]
pub mod loader;
pub mod compile;
pub mod copier;
pub mod dispatch;
pub mod gc;
pub mod heap;
pub mod load_state;
pub mod machine_errors;
pub mod machine_indices;
pub mod machine_state;
pub mod machine_state_impl;
pub m... | the_stack |
use std::mem::size_of;
pub type time_t = syscall_slong_t;
pub type off_t = syscall_slong_t;
pub type blkcnt_t = syscall_slong_t;
pub type blksize_t = syscall_slong_t;
pub type rlim_t = syscall_ulong_t;
pub type fsblkcnt_t = syscall_ulong_t;
pub type fsfilcnt_t = syscall_ulong_t;
pub type ino_t = syscall_ulong_t;
pub t... | the_stack |
use std::env;
use std::f64;
use std::f32::consts::PI;
// use std::fs;
use std::io::{Error, ErrorKind};
use std::path;
use std::str;
use std::time::Instant;
use std::sync::mpsc;
use std::sync::Arc;
use std::thread;
use whitebox_common::utils::{ get_formatted_elapsed_time, wrapped_print };
use whitebox_common::structures... | the_stack |
use std::mem::size_of;
use crate::errors::{ErrorKind, Result, ResultExt};
use byteorder::{BigEndian, ByteOrder};
pub const CLK_PHANDLE: u32 = 1;
pub const GIC_PHANDLE: u32 = 2;
pub const GIC_ITS_PHANDLE: u32 = 3;
pub const CPU_PHANDLE_START: u32 = 10;
pub const GIC_FDT_IRQ_TYPE_SPI: u32 = 0;
pub const GIC_FDT_IRQ_TY... | the_stack |
use super::{
base::CommandLineSearch, History, HistoryItem, HistoryItemId, HistorySessionId,
SearchDirection, SearchQuery,
};
use crate::{
result::{ReedlineError, ReedlineErrorVariants},
Result,
};
use std::{
collections::VecDeque,
fs::OpenOptions,
io::{BufRead, BufReader, BufWriter, Seek, ... | the_stack |
use std::arch::x86::*;
#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;
use std::alloc;
static BYTE_LUT: [u8; 128] = {
let mut lut = [0u8; 128];
lut[b'a' as usize] = 0b000;
lut[b'c' as usize] = 0b001;
lut[b't' as usize] = 0b010;
lut[b'u' as usize] = 0b010;
lut[b'g' as usize] = 0b011;
... | the_stack |
use crate::common;
use move_core_types::{
account_address::AccountAddress,
language_storage::{ModuleId, TypeTag},
};
use serde_generate::{
indent::{IndentConfig, IndentedWriter},
rust, CodeGeneratorConfig,
};
use starcoin_vm_types::transaction::{
ArgumentABI, ScriptABI, ScriptFunctionABI, Transactio... | the_stack |
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under th... | the_stack |
use git2::{Blob, Diff, DiffOptions, Error, Object, ObjectType, Oid, Repository};
use git2::{DiffDelta, DiffFindOptions, DiffFormat, DiffHunk, DiffLine};
use std::str;
use structopt::StructOpt;
#[derive(StructOpt)]
#[allow(non_snake_case)]
struct Args {
#[structopt(name = "from_oid")]
arg_from_oid: Option<Strin... | the_stack |
use std::cmp::Ordering;
use gazebo::prelude::*;
use thiserror::Error;
use crate::{
codemap::Spanned,
collections::symbol_map::Symbol,
environment::slots::ModuleSlotId,
errors::did_you_mean::did_you_mean,
eval::{
compiler::{
scope::{AssignCount, Captured, CstExpr, ResolvedIdent,... | the_stack |
use crate::events::types::Moniker;
use fidl_fuchsia_diagnostics::Selector;
use futures::channel::mpsc::{UnboundedReceiver, UnboundedSender};
use futures::{Stream, StreamExt};
use std::{
cmp::Ordering,
fmt::Debug,
marker::Unpin,
pin::Pin,
task::{Context, Poll},
};
use tracing::trace;
pub type PinStr... | the_stack |
use crate::errors::{Error, Result};
use crate::permge::{PriorityMerge, M};
use crate::registry::ServantId;
use crate::repository::PipelineArtefact;
use crate::url::TremorUrl;
use crate::{offramp, onramp};
use async_channel::{bounded, unbounded};
use async_std::stream::StreamExt;
use async_std::task::{self, JoinHandle};... | the_stack |
mod util;
use buttplug::{
core::{
errors::{ButtplugDeviceError, ButtplugError},
messages::{
self,
ButtplugDeviceMessageType,
ButtplugServerMessage,
BUTTPLUG_CURRENT_MESSAGE_SPEC_VERSION,
},
},
device::Endpoint,
server::comm_managers::test::TestDeviceCommunicationManagerBuilde... | the_stack |
use crate::handler::{IdentifyHandler, IdentifyHandlerEvent, IdentifyPush};
use crate::protocol::{IdentifyInfo, ReplySubstream};
use futures::prelude::*;
use libp2p_core::{
connection::{ConnectionId, ListenerId},
upgrade::UpgradeError,
ConnectedPoint, Multiaddr, PeerId, PublicKey,
};
use libp2p_swarm::{
... | the_stack |
use super::internal::*;
use super::layer::*;
use crate::storage::*;
use std::collections::{HashMap, HashSet};
use std::io;
use std::pin::Pin;
use std::sync::Arc;
use futures::future::Future;
use rayon::prelude::*;
/// A layer builder trait with no generic typing.
///
/// Lack of generic types allows layer builders w... | the_stack |
use super::{NewRequireIdentity, NewStripProxyError, ProxyConnectionClose};
use crate::Outbound;
use linkerd_app_core::{
classify, config, errors, http_tracing, metrics,
proxy::{http, tap},
svc::{self, ExtractParam},
tls, Error, Result, CANONICAL_DST_HEADER,
};
use tokio::io;
#[derive(Copy, Clone, Debug... | the_stack |
mod activities;
mod config;
mod dispatcher;
mod wft_delivery;
pub use config::{WorkerConfig, WorkerConfigBuilder};
pub(crate) use activities::{ExecutingLAId, LocalActRequest, LocalActivityResolution, NewLocalAct};
pub(crate) use dispatcher::WorkerDispatcher;
use crate::{
errors::CompleteWfError,
machines::{E... | the_stack |
use {
crate::core::{
collection::{Components, ManifestData, Manifests, Zbi},
package::collector::ROOT_RESOURCE,
},
crate::verify::collection::V2ComponentTree,
anyhow::{anyhow, Context, Result},
cm_fidl_analyzer::component_tree::ComponentTreeBuilder,
cm_rust::{ComponentDecl, FidlI... | the_stack |
use crate::{
camera::PickingOptions, gui::make_dropdown_list_option_with_height, load_image,
utils::enable_widget, AddModelCommand, AssetItem, AssetKind, ChangeSelectionCommand,
CommandGroup, DropdownListBuilder, EditorScene, GameEngine, GraphSelection, InteractionMode,
InteractionModeKind, Message, Mod... | the_stack |
use super::autodetect::BUFFER_SIZE;
use crate::{rounds::Rounds, BLOCK_SIZE, CONSTANTS, IV_SIZE, KEY_SIZE};
use core::{convert::TryInto, marker::PhantomData};
#[cfg(target_arch = "x86")]
use core::arch::x86::*;
#[cfg(target_arch = "x86_64")]
use core::arch::x86_64::*;
/// The ChaCha20 core function (SSE2 accelerated i... | the_stack |
//! This crate contains utility traits, functions, and macros used by other crates of Winterfell
//! STARK prover and verifier.
#![cfg_attr(not(feature = "std"), no_std)]
#[cfg(not(feature = "std"))]
#[macro_use]
extern crate alloc;
use core::{convert::TryInto, mem, slice};
pub mod collections;
use collections::Vec... | the_stack |
//! This module provides the executor for tasks that are spawned with an API request and deliver a
//! USB response. Terminology: host = computer, device = BitBox02.
extern crate alloc;
use crate::bb02_async::{option, spin as spin_task, Task};
use alloc::boxed::Box;
use alloc::vec::Vec;
use core::cell::RefCell;
use c... | the_stack |
use crate::thread_parker::{ThreadParker, ThreadParkerT, UnparkHandleT};
use crate::util::UncheckedOptionExt;
use crate::word_lock::WordLock;
use core::{
cell::{Cell, UnsafeCell},
ptr,
sync::atomic::{AtomicPtr, AtomicUsize, Ordering},
};
use instant::Instant;
use smallvec::SmallVec;
use std::time::Duration;
... | the_stack |
use super::{poly::*, *};
use core::f64::consts::{LN_10, LN_2, LOG2_E, SQRT_2};
impl<S: Simd> SimdVectorizedMathInternal<S> for f64
where
<S as Simd>::Vf64: SimdFloatVector<S, Element = f64>,
{
const __EPSILON: Self = f64::EPSILON;
const __SQRT_EPSILON: Self = 1.49011611938476563142659199999999998614165560... | the_stack |
#![cfg(not(tarpaulin_include))]
use crate::source::prelude::*;
use chrono::{DateTime, Utc};
use cron::Schedule;
use std::clone::Clone;
use std::cmp::Reverse;
use std::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
use std::collections::BinaryHeap;
use std::convert::TryFrom;
use std::fmt;
use std::str::FromStr;
use t... | the_stack |
use crate::math::{Isometry, Point, Vector};
use crate::query::algorithms::special_support_maps::ConstantOrigin;
use crate::query::algorithms::{gjk, CSOPoint, VoronoiSimplex};
use crate::query::PointQueryWithLocation;
use crate::shape::{SupportMap, Triangle, TrianglePointLocation};
use crate::utils;
use na::{self, RealF... | the_stack |
#[macro_export]
macro_rules! concatcp {
()=>{""};
($($arg: expr),* $(,)?)=>({
use $crate::__cf_osRcTFl4A;
$crate::pmr::__concatcp_impl!{
$( ( $arg ), )*
}
});
}
#[doc(hidden)]
#[macro_export]
#[cfg(not(feature = "const_generics"))]
macro_rules! __concatcp_inner {
($v... | the_stack |
use contracts::debug_ensures;
use once_cell::sync::OnceCell;
use std::cell::RefCell;
use std::sync::Arc;
use crate::lang::core::{
Constant, Globals, LocalLevel, LocalSize, Locals, Term, TermData, UniverseLevel, UniverseOffset,
};
/// Values in the core language.
#[derive(Clone, Debug)]
pub enum Value {
/// A ... | the_stack |
mod neighbor_advert;
mod neighbor_solicit;
mod options;
mod redirect;
mod router_advert;
mod router_solicit;
pub use self::neighbor_advert::*;
pub use self::neighbor_solicit::*;
pub use self::options::*;
pub use self::redirect::*;
pub use self::router_advert::*;
pub use self::router_solicit::*;
use crate::dpdk::Buffe... | the_stack |
extern crate pirate;
extern crate tomllib;
extern crate csv;
extern crate env_logger;
use std::fs::File;
use std::env;
use std::io;
use std::io::{Read, Error, Write};
use pirate::{Matches, Match, Vars, matches, usage, vars};
use tomllib::TOMLParser;
use tomllib::types::{ParseResult, Children, Value, TOMLError, TimeOffs... | the_stack |
use std::ops::Not;
use proc_macro2::TokenStream;
use quote::{quote, quote_spanned};
use syn::spanned::Spanned;
use syn::Ident;
#[allow(clippy::wildcard_imports)]
use crate::codegen::sanitization::*;
use crate::parser::write::StructField;
use crate::parser::{CondEndian, Map, PassedArgs, TempableField, WriteMode};
pub... | the_stack |
//
// Copyright (c) 2019 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 crate::controls::ControlHandle;
use crate::win32::window::bind_raw_event_handler_inner;
use crate::win32::window_helper as wh;
use crate::NwgError;
use winapi::shared::windef::{HWND};
use std::rc::Rc;
use std::cell::RefCell;
use std::ptr;
/// A control item in a GridLayout
#[derive(Debug)]
pub struct GridLayoutIt... | the_stack |
use std::borrow::Borrow;
use std::collections::HashMap;
use std::error;
use std::fmt;
use std::io;
use std::result;
use super::{CHUNK_SIZE, TrieSetSlice};
// This implementation was pretty much cribbed from raphlinus' contribution
// to the standard library: https://github.com/rust-lang/rust/pull/33098/files
//
// Th... | the_stack |
use std::collections::{HashMap, HashSet};
use zebra_chain::{
amount, block,
transparent::{self, CoinbaseSpendRestriction::*},
};
use crate::{
constants::MIN_TRANSPARENT_COINBASE_MATURITY,
service::finalized_state::FinalizedState,
PreparedBlock,
ValidateContextError::{
self, DuplicateTr... | the_stack |
//use std::io::{Error, ErrorKind};
use std::cmp::Ordering;
use std::fmt;
use std::hash::{Hash, Hasher};
use std::net::{Ipv4Addr, Ipv6Addr};
use derive_more::{Display, Error, From};
use rand::random;
use serde_derive::{Deserialize, Serialize};
use crate::dns::buffer::{PacketBuffer, VectorPacketBuffer};
#[derive(Debug... | the_stack |
use crate::npyffi::{
array::PY_ARRAY_API,
npy_intp, npy_uint32,
objects::{NpyIter, PyArrayObject},
types::{NPY_CASTING, NPY_ORDER},
NPY_ARRAY_WRITEABLE, NPY_ITER_BUFFERED, NPY_ITER_COMMON_DTYPE, NPY_ITER_COPY_IF_OVERLAP,
NPY_ITER_DELAY_BUFALLOC, NPY_ITER_DONT_NEGATE_STRIDES, NPY_ITER_GROWINNER, ... | the_stack |
use crate::bit_utils;
mod noise_channel;
mod pulse_channel;
mod wave_channel;
use self::noise_channel::NoiseChannel;
use self::pulse_channel::PulseChannel;
use self::wave_channel::WaveChannel;
const READ_BYTE_OR_MASKS: [u8; 23] = [
0x80, 0x3f, 0x00, 0xff, 0xbf, 0xff, 0x3f, 0x00, 0xff, 0xbf, 0x7f, 0xff, 0x9f, 0xf... | the_stack |
use super::{
imports::*,
util::{empty_cstr, empty_cstring, eunreachable},
MAX_UDSOCKET_PATH_LEN,
};
use std::{
borrow::Cow,
convert::TryFrom,
ffi::{CStr, CString, NulError, OsStr, OsString},
io,
mem::{replace, size_of_val, zeroed},
path::{Path, PathBuf},
ptr,
};
/// Represents a... | the_stack |
use makepad_live_derive::*;
use crate::id::{Id, IdType, IdFmt};
use std::fmt;
use crate::span::Span;
use crate::util::PrettyPrintedF64;
use crate::token::{TokenWithSpan, TokenId};
use crate::liveerror::LiveError;
use crate::livenode::{LiveNode, LiveValue};
use crate::liveregistry::CrateModule;
use crate::id::LiveNodePt... | the_stack |
extern crate include_dir;
mod alias;
pub mod data;
mod errors;
mod filter;
mod funcs;
pub mod lang;
pub mod operator;
mod printer;
mod render;
mod typecheck;
pub mod pipeline {
use crate::data::{DisplayConfig, Record, Row};
pub use crate::errors::{ErrorReporter, QueryContainer, TermErrorReporter};
use cra... | the_stack |
use std::ops::Deref;
use std::sync::Arc;
use std::thread::{self, ThreadId};
use anyhow::anyhow;
use log::debug;
use liblumen_codegen as codegen;
use liblumen_codegen::meta::CompiledModule;
use liblumen_llvm::{self as llvm, target::TargetMachineConfig};
use liblumen_mlir as mlir;
use liblumen_session::{Input, InputTy... | the_stack |
use ink_lang as ink;
#[ink::contract(version = "0.1.0")]
mod matchingengine {
use ink_core::storage;
#[ink(storage)]
struct MatchingEngine {
/// Contract owner
owner: storage::Value<AccountId>,
/// Contract admin (server that will input/output quote currency)
admin: storag... | the_stack |
use crate::descriptor::HashDescriptor;
use crate::header::Header;
use crate::key::{Key, SignFailure, SIGNATURE_SIZE};
use ring::digest;
use zerocopy::AsBytes;
const HASH_SIZE: u64 = 0x40;
#[derive(Debug)]
/// A struct for creating the VBMeta image to be read on startup for verified boot.
///
/// This holds both the ... | the_stack |
//! Permission management.
use super::ContractCallExt;
use std::collections::HashMap;
use std::str::FromStr;
use crate::contracts::tools::{decode as decode_tools, method as method_tools};
use crate::libexecutor::executor::Executor;
use crate::types::block_number::BlockTag;
use crate::types::reserved_addresses;
use c... | the_stack |
use crate::error::{ParseError, ShapingError};
use crate::gsub::{self, FeatureMask, GlyphData, GlyphOrigin, RawGlyph};
use crate::layout::{GDEFTable, LayoutCache, LayoutTable, GSUB};
use crate::tag;
use crate::unicode::mcc::{
modified_combining_class, sort_by_modified_combining_class, ModifiedCombiningClass,
};
use... | the_stack |
use super::*;
use crate::test_utils::malformed_secret_threshold_key_test_vectors;
use proptest::prelude::*;
const SNOWMAN: &str = "☃";
const SNOWCODE: &str = "4piD";
use crate::types::arbitrary::threshold_sig_public_key_bytes;
use ic_crypto_internal_types::sign::threshold_sig::public_key::bls12_381::{
PublicKeyByt... | the_stack |
use huffman_tree::{VorbisHuffmanTree, PeekedDataLookupResult};
/// A Cursor on slices to read numbers and bitflags, bit aligned.
pub struct BitpackCursor <'a> {
bit_cursor :u8,
byte_cursor :usize,
inner :&'a[u8],
}
macro_rules! sign_extend {
($num:expr, $desttype:ident, $bit_cnt_large:expr, $bit_cnt_small:expr) =... | the_stack |
use glib::translate::*;
use glib::StaticType;
use muldiv::MulDiv;
use num_integer::div_rem;
use opt_ops::prelude::*;
use std::borrow::Borrow;
use std::convert::{From, TryFrom};
use std::io::{self, prelude::*};
use std::ops;
use std::time::Duration;
use std::{cmp, fmt, str};
#[derive(PartialEq, Eq, PartialOrd, Ord, Has... | the_stack |
use std::collections::hash_map::{Entry, HashMap};
use std::convert::{TryFrom, TryInto};
use derive_more::{From, TryInto};
use syntax::ast::{Expr, Ident, Item, Lit, Pat, Path, Stmt, Ty};
use syntax::token::{Token, TokenKind, LitKind as TokenLitKind};
use syntax::ptr::P;
use syntax::source_map::DUMMY_SP;
use syntax::sym... | the_stack |
use nom::{
branch::alt,
bytes::complete::tag,
combinator::{complete, map, rest, verify},
error::Error as NomError,
multi::{length_data, length_value, many0, many1},
number::complete::{le_u16, le_u8},
sequence::{delimited, pair, preceded, terminated, tuple},
IResult,
};
use num_traits::Fr... | the_stack |
#[warn(unused_parens)]
use std::convert::From;
use std::thread;
use std::thread::JoinHandle;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering};
use std::time::Duration;
use std::panic::{self, AssertUnwindSafe};
use crate::operator::OperatorWrapper;
use crate::channel::IOError;
use crate::w... | the_stack |
use bitvec::prelude::*;
use log::{debug, info, trace, warn};
use serde::{Deserialize, Serialize};
use std::cmp::max;
use crate::{
config, context,
io::Io,
mbc::{Mbc, MbcTrait},
ppu,
util::{pack, trait_alias},
};
#[derive(Serialize, Deserialize)]
pub struct Bus {
#[serde(with = "serde_bytes")]
... | the_stack |
use std::fmt;
#[derive(Clone)]
pub struct Game {
pub numbers: [Option<u8>; 81],
}
impl Game {
/// Creates a new game with the provided values
pub fn new(numbers: [Option<u8>; 81]) -> Game {
Game { numbers }
}
pub fn random_new(cell_count: u8) -> Game {
let mut game = Game::full();... | the_stack |
use crate::error::{WikitError, Context, WikitResult, AnyResult, NomResult};
use crate::elog;
use crate::index;
use crate::mdict;
use crate::util;
use crate::reader;
use crate::config;
use std::path::{Path, PathBuf};
use std::fs::File;
use std::io::{BufWriter, Write, Seek, SeekFrom, Read};
use serde::{Deserialize, Ser... | the_stack |
extern crate termion;
extern crate extra;
use termion::{clear, color, cursor, style};
use termion::raw::{IntoRawMode, RawTerminal};
use std::io::{self, Write, Read};
use extra::rand::Randomizer;
use std::collections::HashSet;
use std::env;
fn main() {
let stdin = io::stdin();
let stdout = io::stdout();
l... | the_stack |
use super::{
comm_managers::DeviceCommunicationEvent,
device_manager::DeviceUserConfig,
ping_timer::PingTimer,
};
use crate::{
core::messages::{
ButtplugServerMessage,
DeviceAdded,
DeviceRemoved,
ScanningFinished,
StopDeviceCmd,
},
device::{
configuration_manager::DeviceConfiguration... | the_stack |
//! Push-buttons
use std::fmt::{self, Debug};
use std::rc::Rc;
use kas::draw::{color::Rgb, TextClass};
use kas::event::{self, VirtualKeyCode, VirtualKeyCodes};
use kas::prelude::*;
/// A push-button with a generic label
///
/// Default alignment is centred. Content (label) alignment is derived from the
/// button al... | the_stack |
use std::{fs, os::unix::fs::PermissionsExt};
use super::Status;
use crate as ion_shell;
use crate::{
shell::{Shell, Value},
types,
};
use builtins_proc::builtin;
#[builtin(
desc = "check whether items exist",
man = "
SYNOPSIS
exists [EXPRESSION]
DESCRIPTION
Checks whether the given item exist... | the_stack |
use parity_wasm::builder;
use parity_wasm::elements::{
BlockType, FuncBody, GlobalEntry, GlobalType, InitExpr, Instruction, Instructions, Internal,
Local, Module, Section, ValueType,
ImportCountType,
};
use std::collections::HashMap;
use std::error::Error;
use std::iter::FromIterator;
// Converts a Wasm i... | the_stack |
use log::*;
use std::collections::HashMap;
use lam_beam::external_term;
use lam_beam::{
AtomTable, Chunk, CodeTable, CompactTerm, ExportTable, ExternalTerm, ImportTable, LambdaTable,
LiteralTable, OpCode, BEAM,
};
use lam_emu::{
FnCall, FnKind, FunctionLabel, Instruction, Label, List, Literal, Module, Prog... | the_stack |
use crate::utils::*;
use std::convert::TryFrom;
use std::prelude::v1::*;
use teaclave_proto::teaclave_common::*;
use teaclave_proto::teaclave_common::{ExecutorCommand, ExecutorStatus};
use teaclave_proto::teaclave_frontend_service::*;
use teaclave_proto::teaclave_scheduler_service::*;
use teaclave_test_utils::test_case... | the_stack |
pub use vm_memory_upstream::{
address, bitmap::Bitmap, mmap::MmapRegionBuilder, mmap::MmapRegionError, Address, ByteValued,
Bytes, Error, FileOffset, GuestAddress, GuestMemory, GuestMemoryError, GuestMemoryRegion,
GuestUsize, MemoryRegionAddress,
};
use std::io::Error as IoError;
use std::os::unix::io::AsR... | the_stack |
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum ErrorCode {
#[allow(missing_docs)] // documentation missing in mod... | the_stack |
use neon::{prelude::*, result::Throw};
use sleighcraft::{
arch, CollectingAssemblyEmit, CollectingPcodeEmit, PlainLoadImage, SleighBuilder,
};
use sleighcraft::{Address, Instruction, PcodeInstruction, PcodeVarnodeData};
#[derive(Clone, PartialEq)]
pub struct JsAddr {
space: String,
offset: u64,
}
impl ToSt... | the_stack |
use super::*;
#[rstest::rstest]
fn insert_value_in_non_existent_column(with_schema: TransactionManager) {
let txn = with_schema.start_transaction();
assert_statement(
&txn,
"create table schema_name.table_name (column_test smallint);",
vec![OutboundMessage::TableCreated, OutboundMessag... | the_stack |
use simdutf8::basic::from_utf8 as basic_from_utf8;
use simdutf8::basic::from_utf8_mut as basic_from_utf8_mut;
use simdutf8::compat::from_utf8 as compat_from_utf8;
use simdutf8::compat::from_utf8_mut as compat_from_utf8_mut;
#[cfg(not(features = "std"))]
extern crate std;
#[cfg(not(features = "std"))]
use std::{borrow... | the_stack |
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under th... | the_stack |
use std::collections::{HashMap};
use std::str::Chars;
#[derive(Default)]
pub struct TomlParser {
pub cur: char,
pub line: usize,
pub col: usize
}
#[derive(PartialEq, Debug)]
pub enum TomlTok {
Ident(String),
Str(String),
U64(u64),
I64(i64),
F64(f64),
Bool(bool),
Nan(bool),
... | the_stack |
use bytes::Bytes;
use command::CommandError;
use config::Config;
use cubes::*;
use dht::{RingDescription, DHT};
use fabric::*;
use metrics::{self, Gauge};
use rand::{thread_rng, Rng};
use resp::RespValue;
use std::sync::{Arc, Mutex, RwLock};
use std::{net, time};
use storage::{Storage, StorageManager};
pub use types::*... | the_stack |
use std::cmp::Ordering;
use std::hash::Hash;
use ndarray::{ArrayD, Axis};
use ndarray::prelude::*;
use smartnoise_validator::{Float, Integer, proto};
use smartnoise_validator::base::{Array, IndexKey, Jagged, ReleaseNode, Value};
use smartnoise_validator::errors::*;
use smartnoise_validator::utilities::{standardize_nu... | the_stack |
use crate::format;
use crate::log;
use std::fmt;
use std::rc;
// ======================================================
// === The global logs (EVENTS and the METADATA_LOGS) ===
// ======================================================
thread_local! {
static EVENT_LOG: log::Log<Event> = log::Log::new();
}
/// ... | the_stack |
use futures::channel::mpsc as async_mpsc;
use gettextrs::{gettext, ngettext};
use gtk::prelude::*;
use log::{debug, error};
use std::{borrow::ToOwned, cell::RefCell, collections::HashSet, path::PathBuf, rc::Rc, sync::Arc};
use application::{CommandLineArguments, APP_ID, CONFIG};
use media::{MediaEvent, PlaybackStat... | the_stack |
use bars_duration_ticks;
use conrod_core::{self as conrod, widget};
use env;
use ruler;
use time_calc::{self as time, Ticks};
use track;
pub use env::{Point, PointTrait, Toggle as ToggleValue, Trait as EnvelopeTrait};
/// The envelope type compatible with the `Toggle` automation track.
pub type Envelope = env::bounde... | the_stack |
use std::any::Any;
use std::collections::{HashMap, VecDeque};
use std::mem;
use std::sync::{Arc, Mutex, RwLock, Weak};
use actors::{Actor, ActorPath, ActorRef, ActorSystem, Message, Props};
use actors::future::{Computation, Complete, Future, FutureState};
use actors::name_resolver::ResolveRequest;
use actors::props::A... | the_stack |
use {
proc_macro2::Span,
std::{collections::HashSet, ops, rc::Rc},
syn::{Error, Type},
thunderdome::{Arena, Index},
};
use crate::{flow::FlowAnalysis, target::Target, CompileError, Spanned};
/// A single entry for a node in the CFG.
#[derive(Debug, Clone)]
pub struct CfgNode {
/// The variant of t... | the_stack |
extern crate common;
extern crate snapshot;
extern crate dirs;
extern crate libc;
extern crate load;
extern crate rand;
extern crate yaml_rust;
mod helpers;
#[cfg(test)]
mod test {
mod load {
use common::rand_names;
use dirs::home_dir;
use helpers::test_with_contents;
use std::fs;... | the_stack |
use math::*;
use uni_gl::*;
use std::cell::RefCell;
use std::collections::{BTreeMap, BTreeSet, HashMap};
use std::rc::{Rc, Weak};
use std::sync::Arc;
use engine::asset::{AssetError, AssetResult, AssetSystem};
use engine::context::EngineContext;
use engine::core::{Component, ComponentArena, ComponentBased, G... | the_stack |
use super::interrupter::{Error as InterrupterError, Interrupter};
use super::scatter_gather_buffer::{Error as BufferError, ScatterGatherBuffer};
use super::usb_hub::{Error as HubError, UsbPort};
use super::xhci_abi::{
AddressedTrb, Error as TrbError, EventDataTrb, SetupStageTrb, TransferDescriptor, TrbCast,
Trb... | the_stack |
use glib::ffi::{gconstpointer, gpointer};
use glib::translate::*;
use glib::value::{FromValue, ToValue};
use glib::StaticType;
use glib::Value;
use std::ffi::CString;
use std::fmt;
use std::iter;
use std::marker::PhantomData;
use std::mem;
use std::ptr;
use std::sync::Arc;
use thiserror::Error;
#[derive(Clone, Copy, D... | the_stack |
use es_core;
use es_data;
use serde_json;
use std::f32::consts::E;
use std::io::{Read, Write};
use std::mem;
use self::es_core::evolution::Genes;
use self::es_core::model::SerDe;
use self::es_core::model::{Evaluator, GradientFuser, Initializer, WeightUpdater};
use self::es_data::datatypes::Sparse;
use self::es_data:... | the_stack |
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
std::clone::Clone,
std::cmp::Eq,
std::cmp::Ord,
std::cmp::PartialEq,
std::cmp::PartialOrd,
std::fmt::Debug,
std::hash::Hash,
)]
pub enum WebserverAccessMode {
#[allow(missing_docs)] // documentation miss... | the_stack |
mod readmem;
mod vmmap;
mod writemem;
use crate::target::{registers::Registers, thread::Thread};
use crate::CrabResult;
use libc::pid_t;
use mach::{
kern_return, mach_types, mach_types::ipc_space_t, message::mach_msg_type_number_t, port,
port::mach_port_name_t, port::mach_port_t, traps, traps::current_task,
};... | the_stack |
use std::{
env,
ffi::CString,
net::Ipv4Addr,
os::raw::{c_char, c_void},
pin::Pin,
sync::{
atomic::{AtomicBool, Ordering::SeqCst},
Arc,
Mutex,
},
time::Duration,
};
use byte_unit::{Byte, ByteUnit};
use futures::{channel::oneshot, future};
use git_version::git_vers... | the_stack |
use crate::{
de::Deserializer,
error::{Error, Result},
format::*,
ser::Serializer,
value::Value,
};
use once_cell::sync::Lazy;
use serde::{de::DeserializeSeed, Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};
/// A map of container formats.
pub type Registry = BTreeMap<String, C... | the_stack |
use std::net::*;
use std::pin::Pin;
use std::str::FromStr;
use std::sync::{
atomic::{AtomicIsize, Ordering},
Arc,
};
use std::task::Poll;
use futures::executor::block_on;
use futures::{future, Future};
use trust_dns_client::op::Query;
use trust_dns_client::rr::{Name, RecordType};
use trust_dns_integration::mo... | the_stack |
use super::map_xterm_err;
use crate::output::OutputChange;
use crossbeam_channel::{unbounded, Receiver};
use crossterm as xterm;
use std::{
collections::VecDeque,
fmt,
io::{self, stdout, Stdout, Write},
};
use xterm::{
cursor::*,
event::{
Event::{self, *},
KeyCode::*,
KeyEven... | the_stack |
use pretty_assertions::assert_eq;
use std::fmt;
use std::iter::FromIterator;
use toml_edit::{array, table, value, Document, Item, Key, Table, Value};
macro_rules! parse_key {
($s:expr) => {{
let key = $s.parse::<Key>();
assert!(key.is_ok());
key.unwrap()
}};
}
macro_rules! as_table {
... | the_stack |
use std::borrow::ToOwned;
use std::fs::File;
use std::io::{Error, ErrorKind, Read, Result};
use std::str::{self, FromStr};
use byteorder::{ByteOrder, LittleEndian};
use libc::clock_t;
use nom::{
alphanumeric,
digit,
Err,
IResult,
is_digit,
not_line_ending,
space
};
use nom::ErrorKind::Digit... | the_stack |
use {
crate::{
error::SourceRange,
identifier::Identifier,
token::{
ASYMMETRIC_KEYWORD, AS_KEYWORD, BOOL_KEYWORD, BYTES_KEYWORD, CHOICE_KEYWORD,
DELETED_KEYWORD, F64_KEYWORD, IMPORT_KEYWORD, OPTIONAL_KEYWORD, S64_KEYWORD,
STRING_KEYWORD, STRUCT_KEYWORD, U6... | the_stack |
use shared::guiddef::GUID;
use shared::lmcons::NET_API_STATUS;
use shared::minwindef::{DWORD, LPBYTE, LPDWORD, ULONG, USHORT};
use um::winnt::{LPWSTR, PSECURITY_DESCRIPTOR, PWSTR, SECURITY_INFORMATION, ULONGLONG, WCHAR};
pub const DFS_VOLUME_STATES: DWORD = 0xF;
pub const DFS_VOLUME_STATE_OK: DWORD = 1;
pub const DFS_V... | the_stack |
use std::cmp::Ordering;
use std::collections::HashMap;
use std::mem::size_of;
use cgmath::prelude::*;
use cgmath::Vector3;
use hal::{
Backend,
Device,
PhysicalDevice,
Surface,
SwapchainConfig,
Swapchain,
Adapter,
CommandPool,
pass::{
self,
},
image::{
self,
... | the_stack |
use std::cmp::max;
use std::sync::*;
use std::sync::atomic::{Ordering, AtomicU64};
use std::time::*;
use crossbeam_channel::Receiver;
use tokio::sync::Mutex;
use crate::engine_traits::{EngineOperations, PrivateOverlayOperations};
use catchain::utils::get_hash;
use ton_block::{BlockIdExt, ShardIdent, ValidatorSet};
use... | the_stack |
pub struct DescribeDomainAutoTunesPaginator<
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::describe_domain_auto_tunes_input::Builder,
}
... | the_stack |
//! This module provides some utilities to define the tree hierarchy to trace memory.
//!
//! A memory trace is a tree that records how much memory its children and itself
//! uses, It doesn't need to match any function stacktrace, instead it should
//! have logically meaningful layout.
//!
//! For example, memory usag... | the_stack |
use std::collections::HashMap;
use std::fs;
use std::fs::OpenOptions;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::Command;
use tempfile::tempdir;
/// Config for generating Swift packages
pub struct CreatePackageConfig {
/// The directory containing the generated bridges
pub bridge_dir... | the_stack |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.