text stringlengths 2.5k 6.39M | kind stringclasses 3
values |
|---|---|
use crate::{
db::CorosyncResourceRecord,
db::{
AuthGroupRecord, AuthUserGroupRecord, AuthUserRecord, ContentTypeRecord,
CorosyncConfigurationRecord, CorosyncResourceBanRecord, Id, LnetConfigurationRecord,
ManagedTargetRecord, OstPoolOstsRecord, OstPoolRecord, PacemakerConfigurationRecord... | the_stack |
//! The main edit view.
use std::cmp::min;
use std::ops::Range;
use std::any::Any;
use std::sync::{Mutex, Weak};
use std::mem;
use serde_json::Value;
use winapi::um::winuser::*;
use direct2d::brush::SolidColorBrush;
use direct2d::math::*;
use direct2d::RenderTarget;
use directwrite;
use directwrite::TextFormat;
us... | the_stack |
use crate::codegen::arch::machine::{inst::*, register::*};
use crate::codegen::common::machine::{basic_block::*, function::*};
use crate::util::allocator::{Raw, RawAllocator};
use rustc_hash::FxHashMap;
use std::cmp::Ordering;
use std::fmt;
const IDX_STEP: usize = 16;
pub struct LiveRegMatrix {
pub virt_regs: FxH... | the_stack |
use std::io;
use std::{io::Error, ops::Range};
use text_size::{TextRange, TextSize};
use crate::fmt::Display;
use crate::markup::MarkupBuf;
use crate::{self as rome_console, MarkupNode};
use crate::{
codespan::{LabelStyle, Locus, Severity},
fmt::Formatter,
markup, Markup, MarkupElement,
};
const MAX_LINE... | the_stack |
use super::Sign::{self, Minus, NoSign, Plus};
use super::{BigInt, ToBigInt};
use crate::std_alloc::Vec;
#[cfg(has_try_from)]
use crate::TryFromBigIntError;
use crate::{BigUint, ParseBigIntError, ToBigUint};
use core::cmp::Ordering::{Equal, Greater, Less};
#[cfg(has_try_from)]
use core::convert::TryFrom;
use core::str... | the_stack |
use crate::executor::{GraphExecutionInfo, GraphExecutor};
use crate::protocol::common::graph::{
Dependency, KeyDeps, LockedKeyDeps, QuorumDeps, SequentialKeyDeps,
};
use crate::protocol::common::synod::{Synod, SynodMessage};
use fantoch::command::Command;
use fantoch::config::Config;
use fantoch::id::{Dot, ProcessI... | the_stack |
use crate::color;
use crate::errors::*;
use crate::read_write::{
decode, fixpoint_decode, AttributeReader, DataWriter, Encoding, NodeWriter, OpenMode,
PositionEncoding, WriteEncoded, WriteLE,
};
use crate::{attribute_extension, AttributeData, AttributeDataType, Point, PointsBatch};
use byteorder::{LittleEndian,... | the_stack |
use std::{
ops::{Deref, DerefMut, RangeBounds},
path::{Path, PathBuf},
sync::{
atomic::{AtomicBool, Ordering},
Arc,
},
};
use parking_lot::Mutex;
use super::{log::EntryFetcher, LogEntry, State, TransactionLog};
use crate::{
error::{Error, InternalError},
io::{FileManager, Opera... | the_stack |
use base::{error, warn, AsRawDescriptor, Descriptor};
use std::{
ffi::c_void,
future::Future,
marker::{PhantomData, PhantomPinned},
pin::Pin,
ptr::null_mut,
sync::MutexGuard,
task::{Context, Poll, Waker},
};
use sync::Mutex;
use winapi::{
shared::ntdef::FALSE,
um::{
handleapi... | the_stack |
use super::dialog_helpers;
use super::pick_projectpad_item_button;
use super::pick_projectpad_item_button::Msg::ItemSelected as PickPpItemSelected;
use super::pick_projectpad_item_button::Msg::RemoveItem as PickPpItemRemoved;
use super::pick_projectpad_item_button::{PickProjectpadItemButton, PickProjectpadItemParams};
... | the_stack |
pub mod aws_scanning;
pub mod git_scanning;
pub mod google_scanning;
#[macro_use]
extern crate clap;
use anyhow::Result;
use clap::ArgMatches;
use log::{self, debug, error, info, LevelFilter};
use regex::bytes::{Match, Matches, Regex, RegexBuilder};
use serde::Serialize;
use serde_derive::Deserialize;
use serde_json:... | the_stack |
use std::io::{Error, Write};
use std::path::PathBuf;
use std::sync::Arc;
mod directory;
mod line;
mod noop;
pub use line::{AnsiFilterWriter, MultiplexedWriter};
use directory::DirectoryReporter;
use fidl_fuchsia_test_manager as ftest_manager;
use noop::NoopReporter;
type DynReporter = dyn 'static + Reporter + Send +... | the_stack |
use std::fmt;
use super::SendMessage;
use static_assertions::assert_impl_all;
use crate::{
sink::{PollSend, Sink},
stream::{PollRecv, Stream},
sync::{
mpmc_circular_buffer::{BufferReader, MpmcCircularBuffer, TryRead, TryWrite},
shared, ReceiverShared, SenderShared,
},
};
/// Construct... | the_stack |
use super::{
len_checked, BufferHandle, BufferId, Device, DeviceBase, ReadGuard as RawReadGuard, Result,
WriteOnly,
};
use crate::{
rust_shaders,
scalar::{Scalar, ScalarType},
util::{elem_type_name, type_eq},
};
use anyhow::bail;
use bytemuck::Pod;
use serde::{de::Deserializer, ser::Serializer, Dese... | the_stack |
use crate::{
namespaced::NAMESPACE_SEPARATOR, CryptoStorage, Error, GetResponse, KVStorage,
PublicKeyResponse,
};
use chrono::DateTime;
use diem_crypto::{
ed25519::{Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature},
hash::CryptoHash,
};
use diem_infallible::RwLock;
use diem_time_service::{TimeServi... | the_stack |
use crate::{
arch::{
interrupt::InterruptStack,
paging::{
mapper::PageFlushAll,
ActivePageTable, InactivePageTable, Page, PAGE_SIZE, TableKind, VirtualAddress
}
},
common::unique::Unique,
context::{self, signal, Context, ContextId},
event,
scheme::... | the_stack |
use data_encoding::{DecodeError, DecodeKind};
use encoding::{from_slice, Cbor};
use forest_address::{
checksum, validate_checksum, Address, Error, Network, Protocol, BLS_PUB_LEN, PAYLOAD_HASH_LEN,
SECP_PUB_LEN,
};
use std::str::FromStr;
#[test]
fn bytes() {
let data = [0; SECP_PUB_LEN];
let new_addr = ... | the_stack |
// Rust-doc comments were left in the module, but it is no longer publicly exposed from the root
// file of the crate. Do not expect to find those comments in the documentation of the crate.
//! This module parses eBPF assembly language source code.
use combine::{
attempt, between,
char::{alpha_num, char, dig... | the_stack |
extern crate log;
extern crate lazysort;
use ckb_indexer::{
indexer::{Error as IndexerError, Indexer, Key, KeyPrefix, Value},
store::{IteratorDirection, RocksdbStore, Store},
};
use ckb_jsonrpc_types::{BlockNumber, BlockView};
use ckb_types::{
core::{BlockView as CoreBlockView, ScriptHashType},
packed:... | the_stack |
use crate::{
compressor::{Compressor, Level, Stats},
StateGroupEntry,
};
use state_map::StateMap;
use std::collections::BTreeMap;
use string_cache::DefaultAtom as Atom;
#[test]
fn compress_creates_correct_compressor() {
let mut initial: BTreeMap<i64, StateGroupEntry> = BTreeMap::new();
let mut prev = N... | the_stack |
// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgtrackingStateDepA.yaml by generate.py. Do not modify by hand!
use crate::*;
#[test]
fn test_auto_check_sbp_tracking_msgtracking_state_dep_a() {
{
let mut payload = Cursor::new(vec![
85, 22, 0, 195, 4, 66, 1, 0, ... | the_stack |
use std::{ops::Try, fmt, ops::ControlFlow, ops::FromResidual};
/// the result of a syscall in Rust-friendly form; OK or errno
pub type SyscallResult = Result<(), SyscallError>;
/// map a syscall result as the kernel would return it
pub fn syscall_ret(result: SyscallResult) -> SyscallReturn {
match result {
Ok(()) =... | the_stack |
use rug::ops::{AddAssignRound, DivAssignRound, MulAssignRound, SubAssignRound};
use crate::error::Fallible;
use crate::traits::CastInternalReal;
/// Computes the absolute value and returns an error if overflowing.
pub trait AlertingAbs: Sized {
fn alerting_abs(&self) -> Fallible<Self>;
}
/// Addition that return... | the_stack |
#![warn(missing_docs)]
#![cfg_attr(doc_cfg, feature(doc_cfg, doc_auto_cfg))]
//! UTF-8 encoded paths.
//!
//! `camino` is an extension of the `std::path` module that adds new [`Utf8PathBuf`] and [`Utf8Path`]
//! types. These are like the standard library's [`PathBuf`] and [`Path`] types, except they are
//! guaranteed... | the_stack |
use core::{mem, ptr};
use core::ops::{Deref, DerefMut};
use x86_64::structures::paging::{PageSize, PhysFrame};
use x86_64::registers::model_specific::Msr;
use x86_64::instructions::tlb;
use x86_64::{VirtAddr, PhysAddr};
use memory::{allocate_frames, Frame, PhysicalAddress, VirtualAddress};
use self::entry::EntryFlags... | the_stack |
use render::*;
use widget::*;
use editor::*;
use crate::appwindow::*;
use crate::appstorage::*;
use crate::filetree::*;
use crate::buildmanager::*;
use crate::makepadtheme::*;
pub struct App {
pub app_window_state_template: AppWindowState,
pub app_window_template: AppWindow,
pub menu: Menu,
pub menu_si... | the_stack |
use chrono::prelude::Local;
use error::CommonError;
use partial_ordering::PartialOrdering;
use serde::{Deserialize, Deserializer, Serialize};
use std::borrow::Cow;
use std::cmp::Ordering;
use std::collections::HashMap;
pub mod error;
pub mod partial_ordering;
pub type Value = serde_json::Value;
pub type Map<K, V> = s... | the_stack |
#[cfg(not(feature = "build-for-std-app"))]
use core::mem::{size_of, align_of};
#[cfg(not(feature = "build-for-std-app"))]
use spin::Once;
#[cfg(not(feature = "build-for-std-app"))]
use sunrise_libutils::{align_up, cast_mut};
#[cfg(not(feature = "build-for-std-app"))]
use crate::syscalls::query_memory;
// If we are... | the_stack |
use crate::engine::{
fields::{field::Field, grid_option::GridOption},
location::Int2D,
};
use cfg_if::cfg_if;
cfg_if! {
if #[cfg(any(feature = "parallel", feature = "visualization", feature = "visualization_wasm"))]{
use crate::utils::dbdashmap::DBDashMap;
} else {
use crate::rand::Rng... | the_stack |
use crate::sql::{dataframe::TimestampValue, df_type_to_pg_tid};
use bytes::{BufMut, BytesMut};
use chrono::{
format::{
Fixed, Item,
Numeric::{Day, Hour, Minute, Month, Second, Year},
Pad::Zero,
},
prelude::*,
};
use datafusion::arrow::{
array::{
ArrayRef, BooleanArray, Fl... | the_stack |
use super::{ArchiveEvent, ArchiveFormat, BINARIES_METADATA_FILE_NAME, CARGO_METADATA_FILE_NAME};
use crate::{
errors::{ArchiveExtractError, ArchiveReadError},
list::BinaryList,
};
use camino::{Utf8Component, Utf8Path, Utf8PathBuf};
use guppy::{graph::PackageGraph, CargoMetadata};
use nextest_metadata::BinaryLis... | the_stack |
use std::collections::HashMap;
use std::ops::{Index, IndexMut};
use uuid::Uuid;
// use trading::broker::Broker;
use transport::command_server::CommandServer;
use transport::query_server::QueryServer;
use transport::commands::Command;
use trading::objects::BrokerAction;
use trading::broker::BrokerResult;
use trading::... | the_stack |
use std::iter;
use crate::lexer::Lexer;
use crate::parser::Parser;
use crate::{parse_script, ParseOptions};
use ast::source_atom_set::SourceAtomSet;
use ast::source_slice_list::SourceSliceList;
use ast::{arena, source_location::SourceLocation, types::*};
use bumpalo::{self, Bump};
use generated_parser::{self, AstBuild... | the_stack |
use core::fmt::Debug;
use std::collections::HashMap;
use nom::{
character::complete::char, combinator::all_consuming, multi::separated_list0,
sequence::preceded,
};
use zcash_primitives::{
consensus,
memo::{self, MemoBytes},
transaction::components::Amount,
};
#[cfg(any(test, feature = "test-depen... | the_stack |
use serde::{Deserialize, Serialize};
use std::borrow::Cow;
use stateright::{Checker, Expectation, Model};
use stateright::actor::{
Actor, ActorModel, DuplicatingNetwork, Id, majority, model_peers, Out};
use stateright::actor::register::{
RegisterActor, RegisterMsg, RegisterMsg::*};
use stateright::semantics::Li... | the_stack |
use core::cell::RefCell;
use core::fmt;
use core::pin::Pin;
use core::task::Context;
use core::task::Poll;
use core::task::Waker;
use futures::Future;
use heapless::Deque;
use crate::blocking_mutex::kind::MutexKind;
use crate::blocking_mutex::Mutex;
use crate::waitqueue::WakerRegistration;
/// Send values to the ass... | the_stack |
//! Generating random samples from probability distributions.
//!
//! This module is the home of the [`Distribution`] trait and several of its
//! implementations. It is the workhorse behind some of the convenient
//! functionality of the [`Rng`] trait, including [`gen`], [`gen_range`] and
//! of course [`sample`].
//!... | the_stack |
use serde::Deserialize;
use std::{error::Error, fs::File, io::Read, net::SocketAddr};
use super::{Args, Node, Role};
use constellation_internal::{Cpu, Format, Mem};
const DESCRIPTION: &str = r"Run a constellation node.
";
const USAGE: &str = r"USAGE:
constellation <bind> [<nodes.toml>]
OPTIONS:
-h --help ... | the_stack |
mod codegen;
mod debugging;
mod option_group;
mod option_info;
mod parse;
pub use self::codegen::CodegenOptions;
pub use self::debugging::DebuggingOptions;
pub use self::option_group::{
OptionGroup, OptionGroupParseResult, OptionGroupParser, ShowOptionGroupHelp,
};
pub use self::option_info::OptionInfo;
pub use se... | the_stack |
extern crate criterion;
extern crate rtforth;
use criterion::Criterion;
use rtforth::core::Core;
use rtforth::loader::HasLoader;
use rtforth::memory::Memory;
use rtforth::mock_vm::VM;
fn bench_noop(c: &mut Criterion) {
c.bench_function("noop", |b| {
let mut vm = VM::new();
b.iter(|| vm.noop())
... | the_stack |
use ic_config::state_manager::Config;
use ic_cow_state::*;
use ic_interfaces::artifact_manager::ArtifactClient;
use ic_interfaces::certification::Verifier;
use ic_interfaces::state_manager::*;
use ic_metrics::MetricsRegistry;
use ic_registry_subnet_type::SubnetType;
use ic_replicated_state::PageIndex;
use ic_state_mana... | the_stack |
use std::{collections::BTreeMap, mem::MaybeUninit};
use hashbrown::HashMap;
use hibitset::BitSetLike;
use crate::{
storage::{DistinctStorage, UnprotectedStorage},
world::Index,
};
/// Some storages can provide slices to access the underlying data.
///
/// The underlying data may be of type `T`, or it may be ... | the_stack |
use super::{Error, Formatter, FormattingFlags, StrWriterMut, Utf8Encoding};
use core::marker::PhantomData;
////////////////////////////////////////////////////////////////////////////////
/// A wrapper over an array usable to build up a `&str` at compile-time.
///
/// # Calling methods
///
/// [Certain `StrWriter` m... | the_stack |
use codec::{Decode, Encode};
use bitflags::bitflags;
use frame_support::{
ensure,
storage::child,
storage::child::ChildInfo,
traits::{Currency, Time},
};
use frame_system::ensure_signed;
use sp_runtime::{
traits::{Hash, Saturating},
DispatchResult,
};
use pallet_runtime_gateway_rpc_runtime_ap... | the_stack |
#![feature(
const_generics,
const_generic_impls_guard,
const_fn,
const_if_match,
const_panic,
slice_index_methods
)]
#![cfg_attr(feature = "specialization", feature(min_specialization))]
#![allow(incomplete_features)]
#![deny(missing_docs, unreachable_pub)]
#![warn(rust_2018_idioms, intra_doc_li... | the_stack |
use crate::events::IbcEvent;
use crate::ics02_client::height::Height;
use crate::ics04_channel::packet::Packet;
use crate::ics24_host::identifier::{ChannelId, ConnectionId, PortId};
use crate::prelude::*;
use serde_derive::{Deserialize, Serialize};
/// Channel event types
const OPEN_INIT_EVENT_TYPE: &str = "channel_o... | the_stack |
#![allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
use core::convert::TryInto;
use misc::compare_cstr;
use misc::len_cstr;
use utils::increment_overflow;
use utils::is_leap_year;
use super::Time;
use super::TimeTypeInfo;
use super::TimeZoneRule;
use super::*;
/// GMT POSIX Time Zone abreviation.
const GM... | the_stack |
use std::io::{Cursor, ErrorKind};
use std::sync::Arc;
use std::time::{Duration, Instant};
use std::vec::Drain;
use aquatic_common::access_list::AccessListQuery;
use aquatic_http_protocol::request::Request;
use hashbrown::HashMap;
use log::{debug, error, info};
use mio::net::TcpListener;
use mio::{Events, Interest, Pol... | the_stack |
extern crate lazyhtml;
#[macro_use]
extern crate serde;
extern crate serde_json;
#[macro_use]
extern crate html5ever;
// From 'rustc-test' crate.
// Mirrors Rust's internal 'libtest'.
// https://doc.rust-lang.org/1.1.0/test/index.html
extern crate rustc_test as test;
extern crate glob;
mod token;
mod feedback_tok... | the_stack |
extern crate lazy_static;
#[macro_use]
extern crate log;
use std::fs::File;
use std::io::Write;
use std::process::Command;
use clap::{App, Arg};
use intrinsic::Intrinsic;
use rayon::prelude::*;
use types::TypeKind;
mod argument;
mod intrinsic;
mod types;
mod values;
#[derive(Debug, PartialEq)]
pub enum Language {
... | the_stack |
use std::io::Write;
use std::ops::Deref;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
pub type DisplayConfig = libeir_diagnostics::term::Config;
pub type DisplayStyle = libeir_diagnostics::term::DisplayStyle;
pub type DisplayChars = libeir_diagnostics::term::Chars;
pub use libeir_diagnostics::t... | the_stack |
use std::convert::{TryFrom, TryInto};
use std::ffi::CStr;
use std::panic::catch_unwind;
use std::path::{Path, PathBuf};
use libc::{c_char, ssize_t};
use vm_control::{
client::*, BalloonControlCommand, BalloonStats, DiskControlCommand, UsbControlAttachedDevice,
UsbControlResult, VmRequest, VmResponse,
};
fn v... | the_stack |
pub struct ListAliasesPaginator<
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_aliases_input::Builder,
}
impl<C, M, R> ListAliasesP... | the_stack |
use rand;
use self::rand::seq::SliceRandom;
use self::rand::Rng;
use crate::board::{Board, Pos};
use crate::land::LandKind;
use crate::slope::SlopeGen;
use std::cmp::Ordering;
use std::collections::{BinaryHeap, HashMap, HashSet};
use std::rc::Rc;
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
struct Connection<'a... | the_stack |
use crate::geometry::Size;
/// The definition of each corner radius for a rounded rectangle.
///
/// # Examples
///
/// ## Create a radii configuration with equal corners
///
/// This example create a `CornerRadii` instance where each corner has an equal, elliptical radius
/// of 10px x 8px.
///
/// ```rust
/// use em... | the_stack |
use std::ops::Range;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;
use derive_more::Display;
use futures::future::Either;
use holochain_types::prelude::*;
use holochain_zome_types::CellId;
use tokio::sync::{self, broadcast};
// TODO: move these to workflow mod
mod integra... | the_stack |
use crate::event::*;
use crate::board_message::*;
use crate::console::*;
use zzt_file_format::{WorldHeader, BoardMetaData};
use zzt_file_format::dosstring::DosString;
use num::FromPrimitive;
/// When a text input is open in the side bar, this represents the purpose of the input.
#[derive(Clone)]
pub enum TextInputMod... | the_stack |
use std::{cell::RefCell, collections::HashMap, error::Error, fmt};
use num_traits::{self, AsPrimitive, PrimInt, Unsigned};
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use vob::Vob;
use super::{
ast::{self, GrammarValidationError},
firsts::YaccFirsts,
follows::YaccFollows,
parser::{Y... | the_stack |
use backtrace;
use console::style;
use std::borrow::Cow;
use std::fs::File;
use std::io::{self, BufRead, BufReader, ErrorKind, Write};
use std::panic::PanicInfo;
use std::path::{Path, PathBuf};
/// Defines how verbose the backtrace is supposed to be.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub en... | the_stack |
use super::error::Cause;
use platform::cpu::Entry;
use super::physmem::Region;
use core::mem::size_of;
use xmas_elf;
/* supported CPU architectures */
#[derive(Debug)]
enum CPUArch
{
/* see https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md#elf-object-file */
RISC_V
}
/* supported ELF dynam... | the_stack |
use core::any::Any;
use core::fmt::Debug;
use std::borrow::{Cow, ToOwned};
use std::boxed::Box;
use std::env;
use std::fs;
use std::io::{self, BufRead, Write};
use std::path::{Path, PathBuf};
use std::sync::RwLock;
use std::vec::Vec;
use std::string::{String, ToString};
use crate::test_runner::failure_persistence::{Pe... | the_stack |
macro_rules! declare_and_impl_options {
($name: ident, $file_open_options: ident) => {
/// A memory map builder, providing advanced options and flags for specifying memory map file behavior.
///
// TODO: support file lock options
#[derive(Clone)]
pub struct $name {
... | the_stack |
use uuid::Uuid;
use {
super::{
common::Common,
define,
define::SessionType,
errors::{SessionError, SessionErrorValue},
},
//crate::utils::print::print,
crate::{
amf0::Amf0ValueType,
channels::define::ChannelEventProducer,
chunk::{
defi... | the_stack |
use std::{iter, error};
use alsa::{seq, pcm};
use std::ffi::CString;
use dasp::signal;
type Res<T> = Result<T, Box<dyn error::Error>>;
fn connect_midi_source_ports(s: &alsa::Seq, our_port: i32) -> Res<()> {
// Iterate over clients and clients' ports
let our_id = s.client_id()?;
let ci = seq::ClientIter::n... | the_stack |
#![recursion_limit = "1024"]
// check features conflict
#[cfg(any(
all(
feature = "std",
any(feature = "single", feature = "multiple", feature = "full")
),
all(
feature = "single",
any(feature = "std", feature = "multiple", feature = "full")
),
all(
feature =... | the_stack |
use crate::cli::{
fixtures::*,
utils::{distant_subcommand, friendly_recv_line, random_tenant, spawn_line_reader},
};
use assert_cmd::Command;
use assert_fs::prelude::*;
use distant::ExitCode;
use distant_core::{
data::{Error, ErrorKind},
Request, RequestData, Response, ResponseData,
};
use once_cell::sy... | the_stack |
use super::*;
pub trait Location {}
impl Location for VertexId {}
impl Location for FaceId {}
impl Location for HalfEdgeId {}
impl Location for bool {}
#[derive(Copy, Clone, Debug)]
pub enum TraversalError {
VertexHasNoHalfedge(VertexId),
FaceHasNoHalfedge(FaceId),
HalfEdgeHasNoNext(HalfEdgeId),
Half... | the_stack |
use std::ops::Range;
use super::model_viewer::{ModelViewer, MaterialTextureBinding};
use db::{Database, ModelId, AnimationId, PatternId, MatAnimId, FileId};
use connection::Connection;
use glium::Display;
use glium::{Frame, Surface};
use glium::glutin::event::{ElementState, ModifiersState};
use glium::glutin::event::Vi... | the_stack |
use std::collections::HashMap;
use std::time::Duration;
use nalgebra as na;
use crate::exec::{Blip, BlipDieMode, BlipSpawnMode, BlipStatus};
use crate::machine::grid::{self, Dir3};
use crate::render;
/// A subset of fields of `Blip` that are relevant for determining the blip's
/// animation. Most importantly, this e... | the_stack |
use style::{Display, Style};
use dom::{ElementData, LayoutType, Node, NodeType};
use float::Floats;
use font::{Font, FontSlant, FontWeight};
use inline::LineMaker;
use style;
use default_style;
use css::{parse_attr_style, Declaration, Rule, Selector, SimpleSelector, Specificity, Stylesheet,
Value};
use std::... | the_stack |
pub use core::sync::atomic::Ordering;
use core::cell::UnsafeCell;
use core::mem::size_of;
union Transmute<T: Copy, U: Copy> {
from: T,
to: U,
}
const unsafe fn transmute_const<T: Copy, U: Copy>(from: T) -> U {
Transmute::<T, U> { from }.to
}
macro_rules! call_atomic {
($func:ident, $($param:expr),*) ... | the_stack |
pub fn normal_to_xy(normal: glam::Vec3) -> (glam::Vec3, glam::Vec3) {
if normal.dot(glam::Vec3::unit_z()).abs() > 0.9999 {
// Can't cross the Z axis with the up vector, so special case that here
(glam::Vec3::unit_x(), glam::Vec3::unit_y())
} else {
let x_dir = normal.cross(glam::Vec3::un... | the_stack |
libc,
alloc,
plugin,
unsafe_no_drop_flag,
filling_drop,
str_utf16,
heap_api,
oom,
custom_derive,
associated_type_defaults)]
#![plugin(callc)]
#![plugin(num_macros)]
extern crate cef_sys as ffi;
#[macro_use]
extern crate b... | the_stack |
use bitcoin::blockdata::opcodes;
use bitcoin::blockdata::script::Builder;
use bitcoin::hashes::hex::FromHex;
use bitcoin::util::psbt::serialize::Serialize;
use bitcoin::{Network, OutPoint, Script, SigHashType, Transaction, TxIn, TxOut};
use bitcoin_hashes::sha256d;
use bitcoin_wallet::account::{Account, AccountAddress... | the_stack |
use std::{convert::TryInto, error::Error, fmt, str::FromStr};
use bech32::{self, FromBase32, ToBase32, Variant};
use crate::{kind::*, AddressKind, Network, ZcashAddress};
/// An error while attempting to parse a string as a Zcash address.
#[derive(Debug, PartialEq)]
pub enum ParseError {
/// The string is an inv... | the_stack |
use crate::cipherstate::CipherState;
use crate::handshakepattern::{HandshakePattern, Token};
use crate::symmetricstate::SymmetricState;
use crate::traits::{Cipher, Hash, U8Array, DH};
use arrayvec::{ArrayString, ArrayVec};
use core::fmt::{Display, Error as FmtError, Formatter, Write};
#[cfg(feature = "use_alloc... | the_stack |
use compiletest_rs as compiletest;
use compiletest_rs::common::Mode as TestMode;
use std::collections::HashMap;
use std::env::{self, remove_var, set_var, var_os};
use std::ffi::{OsStr, OsString};
use std::fs;
use std::io;
use std::path::{Path, PathBuf};
mod cargo;
// whether to run internal tests or not
const RUN_IN... | the_stack |
use crate::fragment::CellText;
use crate::{
buffer::{fragment_buffer::FragmentTree, Fragment, StringBuffer},
util::parser,
};
pub use cell::{Cell, CellGrid};
pub use contacts::Contacts;
use itertools::Itertools;
use sauron::{
html,
html::{attributes::*, *},
svg::{attributes::*, *},
Node,
};
pub ... | the_stack |
//! # Implementation of `ucal.h`.
//!
//! As a general piece of advice, since a lot of documentation is currently elided,
//! see the unit tests for example uses of each of the wrapper functions.
use {
log::trace, rust_icu_common as common, rust_icu_sys as sys, rust_icu_sys::versioned_function,
rust_icu_sys::*... | the_stack |
use crate::beacon_processor::work_reprocessing_queue::QUEUED_ATTESTATION_DELAY;
use crate::beacon_processor::*;
use crate::{service::NetworkMessage, sync::SyncMessage};
use beacon_chain::test_utils::{
AttestationStrategy, BeaconChainHarness, BlockStrategy, EphemeralHarnessType,
};
use beacon_chain::{BeaconChain, MA... | the_stack |
use crate::{
gdb_register::GdbRegister,
log::LogLevel::{LogDebug, LogError, LogInfo, LogWarn},
registers::MAX_REG_SIZE_BYTES,
remote_ptr::{RemotePtr, Void},
replay_timeline::RunDirection,
scoped_fd::ScopedFd,
sig::Sig,
util,
util::{resource_path, str0_to_isize, str16_to_isize, str16_... | the_stack |
//! Contains the worker thread that performs the business logic for Fog
//! Overseer.
//!
//! This is the "core" logic for Overseer.
//!
//! HTTP Client -> Overseer Rocket Server -> OverseerService -> *OverseerWorker*
use crate::{error::OverseerError, metrics};
use mc_api::external;
use mc_common::logger::{log, Logger... | the_stack |
use std::default::Default;
use std::ffi::{CString, CStr, NulError};
use std::net::SocketAddr;
use std::os::raw::{c_char, c_uchar, c_int, c_void};
use std::path::{PathBuf, Path};
use std::ptr;
use std::slice;
use std::str;
use hyper::header::{Headers, ContentLength, ContentType, Cookie};
use hyper::{self, Response};
u... | the_stack |
use std::cell::RefCell;
use std::collections::{HashMap, HashSet};
use std::rc::Rc;
use xcbgen::defs as xcbdefs;
use super::output::Output;
use super::requests_replies::{EnumCases, PerModuleEnumCases};
use super::{get_ns_name_prefix, special_cases};
mod expr_to_str;
mod header;
pub(super) mod helpers;
mod parse;
mod ... | the_stack |
use serde_derive::*;
use std::fs;
use std::fs::{create_dir, read_to_string, File};
use std::io::{Error, ErrorKind, Write};
use std::path::Path;
use std::process;
use std::process::Command;
use std::str::FromStr;
use std::thread;
use std::time::{Duration, Instant};
use api::service::{
Disk, DiskType, Disks, JiraIn... | the_stack |
use futures::{channel::mpsc, prelude::*, stream::iter, SinkExt, StreamExt};
use log::debug;
use std::{
collections::VecDeque,
io::{self, ErrorKind},
pin::Pin,
sync::{atomic::Ordering, Arc},
task::{Context, Poll},
};
use tokio::io::AsyncWrite;
use tokio_util::codec::{length_delimited::LengthDelimited... | the_stack |
use crate::camera::Mode;
use crate::window::Window;
use crate::{BackgroundColor, Options};
use pathfinder_color::ColorU;
use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::vector::{Vector2I, vec2i};
use pathfinder_gpu::allocator::GPUMemoryAllocator;
use pathfinder_gpu::{Device, TextureFormat};
use pathfinde... | the_stack |
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListUsersOutput {
/// <p>A list of <code>User</code> objects in the identity store.</p>
pub users: std::option::Option<std::vec::Vec<crate::model::User>>,
/// <p>The pagina... | the_stack |
use std::cmp;
use std::collections::BTreeMap;
use std::fmt::{Debug, Error as FmtError, Formatter};
use std::usize;
use x86::teddy_simd::TeddySIMD;
/// A list of masks. This has length equal to the length of the fingerprint.
/// The length of the fingerprint is always `max(3, len(smallest_substring))`.
#[derive(Debug, ... | the_stack |
//! Implementation of the [Identify] protocol.
//!
//! This implementation of the protocol periodically exchanges
//! [`IdentifyInfo`] messages between the peers on an established connection.
//!
//! At least one identification request is sent on a newly established
//! connection, beyond which the behaviour does not k... | the_stack |
use crate::{
error::*, semantic_analysis::*, type_engine::*, CallPath, CompileResult, Ident, TypeInfo,
TypedDeclaration, TypedFunctionDeclaration,
};
use super::{module::Module, namespace::Namespace, Path};
use sway_types::{span::Span, Spanned};
use std::collections::VecDeque;
/// The root module, from whic... | the_stack |
use address::{Addressable, Address};
use messages::outgoing;
use mio;
use node::Node;
use routing_table::{InsertOutcome, InsertionResult, RoutingTable};
use servers::Server;
use std::collections::{HashMap, HashSet};
use std::io::Cursor;
use std::sync::mpsc;
use std::thread;
use transaction::{TransactionId, TransactionI... | the_stack |
use libc::c_void;
use std::alloc::{alloc_zeroed, dealloc, Layout};
use std::convert::TryInto;
use std::fs::{File, Metadata};
use std::io::{self, Read, Seek, SeekFrom, Write};
use std::os::unix::io::{AsRawFd, RawFd};
use std::slice;
use vmm_sys_util::{seek_hole::SeekHole, write_zeroes::PunchHole, write_zeroes::WriteZero... | the_stack |
use std::collections::BTreeMap;
use std::collections::HashSet;
use std::path::Path;
use std::path::PathBuf;
use anyhow::Result;
use deno_ast::apply_text_changes;
use deno_ast::parse_module;
use deno_ast::view::NodeTrait;
use deno_ast::view::Program;
use deno_ast::ModuleSpecifier;
use deno_ast::ParseParams;
use deno_as... | the_stack |
use crate::colormap::{Colormap, Jet, Monochrome, PURPLISH};
use crate::utils::{get_image_path, get_meta_pb_path};
use crate::Meta;
use clap::Clap;
use fnv::{FnvHashMap, FnvHashSet};
use image::{self, GenericImage, ImageResult, Rgba, RgbaImage};
use imageproc::map::map_colors;
use nalgebra::{Isometry3, Point2, Point3, V... | the_stack |
use std::io;
use std::ptr;
use std::slice;
use winapi::shared::minwindef as winapi;
use winapi::shared::ntdef;
use winapi::um::winbase;
use winapi::um::wincrypt;
use crate::Inner;
use crate::crypt_key::CryptKey;
/// A CryptoAPI handle to a provider of a key.
pub struct CryptProv(wincrypt::HCRYPTPROV);
impl Drop for ... | the_stack |
//! EQL APIs
//!
//! [Event Query Language (EQL)](https://www.elastic.co/guide/en/elasticsearch/reference/master/eql.html) is a query
//! language for event-based time series data, such as logs, metrics, and traces.
//!
//!
#![allow(unused_imports)]
use crate::{
client::Elasticsearch,
error::Error,
http::{... | the_stack |
use html5ever::tree_builder::QuirksMode;
use html5ever::QualName;
use std::cell::{Cell, RefCell};
use std::fmt;
use std::ops::Deref;
use std::rc::{Rc, Weak};
use crate::attributes::{Attribute, Attributes, ExpandedName};
use crate::cell_extras::*;
use crate::iter::NodeIterator;
/// Node data specific to the node type.... | the_stack |
use crate::settings::{read_policies_file, read_verification_file, Policy, VerificationSettings};
use anyhow::{anyhow, Result};
use clap::{crate_authors, crate_description, crate_name, crate_version, App, Arg};
use itertools::Itertools;
use lazy_static::lazy_static;
use policy_evaluator::burrego::opa::builtins as opa_bu... | the_stack |
#![cfg(feature = "power-of-two")]
#![doc(hidden)]
use crate::options::{Options, RoundMode};
use crate::shared;
use lexical_util::algorithm::rtrim_char_count;
use lexical_util::constants::{FormattedSize, BUFFER_SIZE};
use lexical_util::format::NumberFormat;
use lexical_util::num::{as_cast, Float, Integer, UnsignedInteg... | the_stack |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.