text stringlengths 2.5k 6.39M | kind stringclasses 3
values |
|---|---|
// You should have received a copy of the MIT License
// along with the Jellyfish library. If not, see <https://mit-license.org/>.
//! An argument system that proves/verifies multiple instances in a batch.
use crate::{
circuit::{customized::ecc::SWToTEConParam, Circuit, PlonkCircuit},
errors::{PlonkError, Snar... | the_stack |
#[cfg(feature = "diesel")]
pub(in crate) mod diesel;
pub mod error;
use crate::paging::Paging;
#[cfg(feature = "diesel")]
pub use self::diesel::{DieselConnectionProductStore, DieselProductStore};
pub use error::{ProductBuilderError, ProductStoreError};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Produ... | the_stack |
use std::collections::BTreeMap;
use std::sync::Arc;
use base::Event;
use devices::serial_device::{SerialHardware, SerialParameters, SerialType};
use devices::{Bus, ProxyDevice, Serial};
use hypervisor::ProtectionType;
use minijail::Minijail;
use remain::sorted;
use sync::Mutex;
use thiserror::Error as ThisError;
use ... | the_stack |
use core::mem;
use serde::Serialize;
use crate::{
align_up,
err::{Error, Result},
};
const WORD_SIZE: usize = mem::size_of::<u32>();
pub fn to_slice<'a, 'b, T>(value: &'b T, buf: &'a mut [u32]) -> Result<&'a [u32]>
where
T: Serialize + ?Sized,
{
let mut serializer = Serializer::new(Slice::new(buf));... | the_stack |
use proc_macro::{TokenTree, Span, TokenStream, Delimiter, Group, Literal, Ident, Punct, Spacing};
use proc_macro::token_stream::IntoIter;
// little macro utility lib
pub fn error_span(err: &str, span: Span) -> TokenStream {
let mut tb = TokenBuilder::new();
tb.ident_with_span("compile_error", span).add("! (")... | the_stack |
use crate::addon_transport::AddonTransport;
use crate::runtime::{Env, EnvError, TryEnvFuture};
use crate::types::addon::{Manifest, ResourcePath, ResourceResponse};
use crate::types::resource::{MetaItem, MetaItemPreview, Stream, Subtitles};
use futures::{future, FutureExt, TryFutureExt};
use http::Request;
use serde::De... | the_stack |
use dates::Date;
use dates::datetime::DateTime;
use core::qm;
use std::collections::HashMap;
use std::sync::Arc;
use std::ops::Deref;
use serde as sd;
/// A fixing table is a collection of fixing curves, keyed by instrument id.
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct FixingTable {
fixings_known_... | the_stack |
use std::collections::HashSet;
use std::ffi::{CStr, CString};
use std::mem;
use std::ptr;
use std::sync::Mutex;
use libc::{self, c_char, c_int, c_uint, c_void};
use ffi;
use ffi2;
use tx::TxHandle;
use ::{Fd, FileMode, Result};
/// Flags used when opening an LMDB environment.
pub mod open {
use libc;
use ffi;... | the_stack |
use ffi;
use libc;
use BrowserClientWrapper;
use Browser;
use BrowserClient;
use WindowInfo;
use CefString;
use CefRc;
use State;
use upcast_ptr;
use std::mem::{transmute, zeroed};
use string;
use cast_to_interface;
use upcast;
use Interface;
use Is;
use std::ptr::null_mut;
use std::default::Default;
mod keys;
#[de... | the_stack |
use std::marker::PhantomData;
use crate::{
GetStaticEquivalent,
StableAbi,
InterfaceType,
type_level::{
impl_enum::{Implemented,Unimplemented}
},
};
////////////////////////////////////////////////////////////////////////////////
#[repr(C)]
#[derive(StableAbi)]
#[sabi(impl_InterfaceType... | the_stack |
//! Geometry data types
use crate::cast::Conv;
use crate::dir::Directional;
#[cfg(feature = "winit")]
use winit::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize, Pixel};
mod vector;
pub use vector::{DVec2, Quad, Vec2, Vec3};
macro_rules! impl_common {
($T:ty) => {
impl $T {
/// The cons... | the_stack |
use build::{BlockAnd, BlockAndExtension, Builder, CFG, ScopeAuxiliary, ScopeId};
use data_structures::indexed_vec::Idx;
use mir::*;
use std::collections::{BTreeSet, HashSet};
use syntax::ast;
use syntax::codemap::Span;
#[derive(Debug)]
pub struct Scope {
/// the scope-id within the scope_auxiliary
id: ScopeId,... | the_stack |
use core;
use interface::{DivansResult, ErrMsg, DivansOpResult, StreamMuxer, StreamDemuxer};
use super::interface::ContextMapType;
use super::priors::{PredictionModePriorType};
use alloc::{Allocator, SliceWrapper, SliceWrapperMut};
use alloc_util::{RepurposingAlloc, AllocatedMemoryPrefix, UninitializedOnAlloc};
use sup... | the_stack |
use flo_curves::*;
use flo_curves::arc::*;
use flo_curves::bezier::path::*;
use std::f64;
#[test]
pub fn create_and_read_simple_graph_path() {
let path = (Coord2(10.0, 11.0), vec![(Coord2(15.0, 16.0), Coord2(17.0, 18.0), Coord2(19.0, 20.0)), (Coord2(21.0, 22.0), Coord2(23.0, 24.0), Coord2(25.0, 26.0))]... | the_stack |
#![deny(missing_docs)]
use {
crate::{content::*, error::*, options::*},
std::cell::RefCell,
std::collections::HashMap,
std::collections::HashSet,
std::rc::Rc,
};
pub(crate) struct SubpathOptions {
/// Options for the matching property name, including subpath-options for nested containers.
/... | the_stack |
use std::collections::HashMap;
use crate::{
description::Description,
directive::{Directive, DirectiveLocation},
name::Name,
ty::Ty,
DocumentBuilder,
};
use arbitrary::Result;
#[derive(Debug, Clone, PartialEq)]
pub enum InputValue {
Variable(Name),
Int(i32),
Float(f64),
String(Str... | the_stack |
use crate::game::toplevel::Signal;
use crate::gui::{
animation::AnimationState, input::Grabbable, sprites::Sprites, sprites::*, ui_state::*,
utils::colors::*, utils::*, z::*,
};
use crate::{
game::{
components::*, fight::*, forestry::ForestrySystem, movement::MoveSystem,
story::entity_trigge... | the_stack |
use block::Block;
use cocoa::base::{id, BOOL};
use cocoa::foundation::NSRect;
use core_graphics::base::CGFloat;
use core_graphics::geometry::CGPoint;
use libc::c_double;
#[link(name = "WebKit", kind = "framework")]
extern "C" {
pub static WKWebView: id;
}
pub trait WKWebView: Sized {
/// # Safety
/// All ... | the_stack |
use crate::*;
use std::any::Any;
use std::cell::RefCell;
use std::collections::BTreeMap;
use std::{mem, ptr};
use std::sync::{Arc, Mutex, Condvar};
use std::thread;
use std::string::String as StdString;
use std::time::Duration;
/// The entry point into the JavaScript execution environment.
pub struct MiniV8 {
pub(... | the_stack |
#![no_std]
// TODO(tarcieri): safe parallel implementation
// See: https://github.com/RustCrypto/password-hashes/issues/154
#![cfg_attr(not(feature = "parallel"), forbid(unsafe_code))]
#![cfg_attr(docsrs, feature(doc_cfg))]
#![doc(
html_logo_url = "https://raw.githubusercontent.com/RustCrypto/media/8f1a9894/logo.sv... | the_stack |
use std::collections::HashSet;
use fnv::FnvBuildHasher;
use hashbrown::HashMap;
type FnvHashMap<K, V> = HashMap<K, V, FnvBuildHasher>;
use petgraph::algo::dominators::Dominators;
use cranelift_bforest::{Set, SetForest};
use crate::{Block, Value};
use crate::{CallKind, Function, MatchKind, OpKind};
#[derive(Debug)]... | the_stack |
use clap_conf::convert::Holder;
use clap_conf::convert::Localizer;
use clap_conf::env::Enver;
use clap_conf::*;
use serde::Serialize;
use simple_error::SimpleError;
use std::fs;
use std::fs::File;
use std::io::Write;
use std::path::Path;
use std::path::PathBuf;
use toml::Value;
use uuid::Uuid;
#[derive(Default, Debug, ... | the_stack |
use std::{
cmp::min,
collections::HashMap,
os::windows::io::RawHandle,
sync::{Arc, Mutex},
time::Duration,
};
use winapi::{
shared::{
minwindef::{DWORD, FALSE},
winerror::{ERROR_INVALID_PARAMETER, WAIT_TIMEOUT},
},
um::{synchapi::WaitForMultipleObjects, winbase::WAIT_OBJ... | the_stack |
use std::io;
use std::io::Read;
use std::fs;
use std::slice;
use std::path::Path;
use std::collections::hash_map::{self, HashMap};
use loc::{Unit, Pos, Span, Spanned, WithLoc};
use loc::{unit_from_u32, pos_from_u32, span_from_u32};
/// Yields each span for lines in the `SourceFile`, in the order.
#[derive(Clone)]
pub ... | the_stack |
use crate::error::Error;
use addr2line::fallible_iterator::FallibleIterator;
use addr2line::Location;
use object::read::File;
use object::Object;
use object::ObjectSection;
use object::ObjectSymbol;
use object::ObjectSymbolTable;
use std::borrow::Cow;
use std::collections::{hash_map, HashMap};
use std::fmt;
use std::io... | the_stack |
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::{stdout, Write};
use anyhow::{anyhow, bail, Context, Result};
use clap::ArgMatches;
use crate::cli::{get_float_arg, get_int_arg, parse_filter_options, parse_sketch_options};
use finch::distance::distance;
use finch::serialization::{
write_f... | the_stack |
use crate::graphql::Pattern;
use crate::Request;
use graphql_parser::query::Definition::Operation;
use graphql_parser::query::OperationDefinition;
use log::{trace, warn};
pub trait RequestMatcher {
fn matches(&self, request: &Request) -> bool;
}
/// A abac::Policy comprises:
///
/// * a list of `MatchAttribute`s,... | the_stack |
use std::ops::Range;
pub type EncodeErrorResult<S, B, E> = Result<(EncodeReplace<S, B>, usize), E>;
pub type DecodeErrorResult<S, B, E> = Result<(S, Option<B>, usize), E>;
pub trait StrBuffer: AsRef<str> {
fn is_ascii(&self) -> bool {
self.as_ref().is_ascii()
}
}
pub trait ErrorHandler {
type Er... | the_stack |
//! vulkano_gralloc: Implements swapchain allocation and memory mapping
//! using Vulkano.
//!
//! External code found at https://github.com/vulkano-rs/vulkano.
#![cfg(feature = "vulkano")]
use std::{collections::BTreeMap as Map, convert::TryInto, sync::Arc};
use base::MappedRegion;
use crate::rutabaga_gralloc::gra... | 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 unde... | the_stack |
extern crate enigma_runtime_t;
#[macro_use]
extern crate enigma_tools_t;
extern crate enigma_crypto;
extern crate enigma_tools_m;
extern crate enigma_types;
//#[cfg(not(target_env = "sgx"))]
#[macro_use]
extern crate sgx_tstd as std;
extern crate sgx_types;
#[macro_use]
extern crate serde_json;
#[macro_use]
extern cr... | the_stack |
extern crate num_traits;
use num_traits::Float;
use std::iter::Sum;
use crate::tree::{BoundingBox, Cut, Internal, Node, Tree};
/// Description of the result of a point deletion operation on a tree by a
/// `PointDeleter`.
///
/// This enum has the following possible values:
/// * `EmptyTree` - the deletion was perfo... | the_stack |
extern crate mio;
use std::io;
use std::net::SocketAddr;
use std::str::FromStr;
use std::sync::{Arc, Mutex};
use mio::*;
use mio::buf::ByteBuf;
use mio::tcp::{TcpListener, TcpStream};
use mio::util::Slab;
use std::collections::VecDeque;
use std::ops::Drop;
use backend::{RoundRobinBackend, GetBackend};
const BUFFER... | the_stack |
use operand::Operand;
use memory::Memory;
use constants::*;
use super::{Result, Size, Exception,OpcodeInstance,generate};
use PC;
use Words;
use OpcodeInfo;
fn decode_destination_ea(opcode: u16, size: Size, pc: PC, mem: &Memory) -> (Words, Operand) {
let mode = ((opcode >> 6) & 0b111) as u8;
let reg_y = ((opco... | the_stack |
use std::{collections::BTreeSet, time::{Duration, Instant}};
use rewind_core::mem::{self, X64VirtualAddressSpace};
use rewind_core::trace::{self, ProcessorState, Context, Params, Tracer, Trace, EmulationStatus, CoverageMode, TracerError};
use rewind_core::snapshot::Snapshot;
use whvp::PartitionError;
use crate... | the_stack |
use std::{
borrow::Borrow,
collections::BTreeMap,
convert::TryFrom,
fmt::Display,
hash::Hasher,
sync::{
atomic::{AtomicU64, AtomicUsize, Ordering::SeqCst},
Arc,
},
};
use anyhow::bail;
use dashmap::{mapref::one::Ref as DmRef, DashMap, DashSet};
use locutus_runtime::prelude::... | the_stack |
use crate::guc::GucState;
use crate::io::Stream;
use crate::utils::err::errcode;
use anyhow::Context;
use kbio::FdGuard;
use kbio::Uring;
pub use oids::*;
#[cfg(debug_assertions)]
use std::io::Stdout;
use std::net::SocketAddr;
use std::sync::atomic::{AtomicU64, Ordering::Relaxed};
use std::sync::Arc;
use tokio::io::{As... | the_stack |
#![warn(missing_docs)]
extern crate fnv;
extern crate fungui_syntax as syntax;
extern crate ref_filter_map;
extern crate bitflags;
mod query;
pub use query::Query;
mod error;
pub use error::Error;
#[macro_use]
mod macros;
#[cfg(any(test, feature="tests"))]
pub mod tests;
mod style;
use style::*;
mod expr;
use expr::*... | the_stack |
use thiserror::Error;
#[derive(Error, Debug)]
pub enum CimXmlError {
#[error("Property {0} not found")]
PropertyNotfound(String),
}
pub mod req {
use quick_xml::{
events::{self, Event},
Writer,
};
use std::io::Cursor;
type EVs<'a> = Vec<events::Event<'a>>;
pub(crate) fn d... | the_stack |
use std::{
fs,
path::{Path, PathBuf},
sync::Arc,
time::Instant,
};
use anyhow::anyhow;
use jsonrpc_lite::{JsonRpc, Params};
use lmdb::DatabaseFlags;
use reqwest::Client;
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use serde_json::json;
use tokio::{
fs::File,
io::{AsyncReadExt, As... | the_stack |
//! Combobox
use super::{menu::MenuEntry, Column, Mark, PopupFrame, StringLabel};
use kas::event::{Command, Scroll, ScrollDelta};
use kas::prelude::*;
use kas::theme::{MarkStyle, TextClass};
use kas::WindowId;
use std::fmt::Debug;
use std::rc::Rc;
#[derive(Clone, Debug)]
struct IndexMsg(usize);
impl_scope! {
///... | the_stack |
use anyhow::{Error, Result};
use chrono::{DateTime, Datelike, Duration, NaiveDate, Utc};
use std::iter::empty;
use crate::{
data_combination::data_points::data_point::{
CalcScreenActiveTime,
CalcScreenEnterCount,
CalcWasActiveEachPastPeriod,
CalcWasActivePastNDays,
DataPoint... | the_stack |
use super::{
dns_name::{self, DnsNameRef},
ip_address,
};
use crate::{
cert::{Cert, EndEntityOrCa},
der, Error,
};
pub fn verify_cert_dns_name(
cert: &crate::EndEntityCert,
dns_name: DnsNameRef,
) -> Result<(), Error> {
let cert = cert.inner();
let dns_name = untrusted::Input::from(dns_... | the_stack |
use std::collections::HashMap;
use libc::c_void;
use rand::{self, Rng};
use futures::{Future, Sink};
use futures::sync::mpsc::Sender;
use uuid::Uuid;
use tickgrinder_util::strategies::{ManagedStrategy, Helper, StrategyAction, Tickstream, Merged};
use tickgrinder_util::trading::broker::{Broker, BrokerResult};
use tic... | the_stack |
#![allow(clippy::float_cmp)]
use crate::{
buffer::{streaming::StreamingBuffer, SoundBufferResource, SoundBufferState},
context::DistanceModel,
error::SoundError,
listener::Listener,
};
use fyrox_core::{
algebra::Vector3,
inspect::{Inspect, PropertyInfo},
visitor::{Visit, VisitResult, Visito... | the_stack |
#![deny(missing_docs)]
mod data_segments;
use data_segments::DataSegments;
use heck::SnakeCase;
use lazy_static::lazy_static;
use std::borrow::Cow;
use std::convert::TryFrom;
use std::ops::Range;
use std::path::PathBuf;
use std::{collections::HashMap, mem};
use wasm_encoder::Instruction;
use wit_bindgen_gen_core::{
... | the_stack |
use crate::parse::{self, Cursor};
use crate::{Delimiter, Spacing, TokenTree};
#[cfg(span_locations)]
use std::cell::RefCell;
#[cfg(span_locations)]
use std::cmp;
use std::fmt::{self, Debug, Display};
use std::iter::FromIterator;
use std::mem;
use std::ops::RangeBounds;
#[cfg(procmacro2_semver_exempt)]
use std::path::Pa... | the_stack |
use crate::distribution::Continuous;
use crate::distribution::Normal;
use crate::statistics::{Max, MeanN, Min, Mode, VarianceN};
use crate::{Result, StatsError};
use nalgebra::{
base::allocator::Allocator, base::dimension::DimName, Cholesky, DefaultAllocator, Dim, DimMin,
LU, U1,
};
use nalgebra::{DMatrix, DVec... | the_stack |
mod helpers;
use chrono::{Duration, Utc, Weekday};
use helpers::setup::spawn_app;
use helpers::utils::{assert_equal_user_lists, format_datetime};
use nettu_scheduler_domain::{BusyCalendar, ServiceMultiPersonOptions, TimePlan, ID};
use nettu_scheduler_sdk::{
AddBusyCalendar, AddServiceUserInput, Calendar, CreateBoo... | the_stack |
#[macro_use]
mod args;
use args::{KernelArgument, KernelArguments};
mod murmur3;
use core::num::NonZeroUsize;
use core::{mem, ptr, slice};
pub type XousPid = u8;
pub const PAGE_SIZE: usize = 4096;
const WORD_SIZE: usize = mem::size_of::<usize>();
const USER_STACK_TOP: usize = 0x8000_0000;
const PAGE_TABLE_OFFSET: u... | the_stack |
use crate::webauthn::validate_webauthn_sig;
use ic_crypto::{user_public_key_from_bytes, KeyBytesContentType};
use ic_interfaces::crypto::IngressSigVerifier;
use ic_types::crypto::{CanisterSig, CanisterSigOf};
use ic_types::{
crypto::{AlgorithmId, BasicSig, BasicSigOf, CryptoError, UserPublicKey},
ingress::{MAX_... | the_stack |
#[cfg(any(feature = "v3_24", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
use crate::AnchorHints;
use crate::Cursor;
use crate::Device;
use crate::Display;
use crate::DragProtocol;
#[cfg(any(feature = "v3_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
u... | the_stack |
use hex::FromHex;
use rand::{rngs::OsRng, Rng};
use serde::{de::Error as _, Deserialize, Deserializer, Serialize, Serializer};
use std::{convert::TryFrom, fmt, str::FromStr};
/// A struct that represents an account address.
#[derive(Ord, PartialOrd, Eq, PartialEq, Hash, Clone, Copy)]
#[cfg_attr(any(test, feature = "fu... | the_stack |
// spell-checker:ignore (ToDO) hdsf ghead gtail
use std::convert::TryFrom;
use std::error::Error;
use std::fmt;
use crate::display::Quotable;
/// Parse a size string into a number of bytes.
///
/// A size string comprises an integer and an optional unit. The unit
/// may be K, M, G, T, P, E, Z or Y (powers of 1024),... | the_stack |
use core::cell::Cell;
use core::marker::{PhantomData, PhantomPinned};
use core::pin::Pin;
use core::ptr;
use pin_project::{pin_project, pinned_drop};
use super::strong_pin::StrongPinMut;
/// A doubly linked list.
/// Can only contain types that implement the `ListNode` trait.
/// Use only after initialization.
///
/... | the_stack |
use crate::sys;
use std::{
ffi::{c_void, CStr, CString},
fmt::Debug,
marker::PhantomData,
mem, ptr,
};
macro_rules! check {
($expr:expr) => {
#[allow(unused_unsafe)]
{
let err = unsafe { $expr };
if err != crate::sys::ze_result_t::ZE_RESULT_SUCCE... | the_stack |
mod application;
pub mod callbacks;
pub mod config;
mod creation;
pub mod errors;
pub mod events;
mod exporting;
mod membership;
mod processing;
mod resumption;
mod ser;
#[cfg(test)]
mod test_managed_group;
mod updates;
use crate::credentials::CredentialBundle;
use openmls_traits::{key_store::OpenMlsKeyStore, OpenMlsC... | the_stack |
use crate::{
dom::{
created_node,
created_node::{ActiveClosure, CreatedNode},
},
html::attributes::AttributeValue,
mt_dom::patch::{
AddAttributes, AppendChildren, InsertNode, RemoveAttributes,
RemoveNode, ReplaceNode,
},
Dispatch, Patch,
};
use js_sys::Function;
u... | the_stack |
use {
crate::model::{
component::{
ComponentInstance, ComponentManagerInstance, ExtendedInstance, WeakExtendedInstance,
},
resolver::{ResolvedComponent, Resolver, ResolverError, ResolverRegistry},
},
::routing::environment::EnvironmentInterface,
async_trait::async_tra... | the_stack |
use super::{builder::FileLogWriterBuilder, state::State};
#[cfg(feature = "async")]
use crate::util::eprint_msg;
use crate::util::{buffer_with, eprint_err, io_err, ERRCODE};
#[cfg(feature = "async")]
use crate::util::{ASYNC_FLUSH, ASYNC_SHUTDOWN};
use crate::DeferredNow;
use crate::FlexiLoggerError;
use crate::FormatFu... | the_stack |
use crate::{bits, memcmp, MemchrSearcher, Needle};
use seq_macro::seq;
#[cfg(target_arch = "x86")]
use std::arch::x86::*;
#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;
trait NeedleWithSize: Needle {
#[inline]
fn size(&self) -> usize {
if let Some(size) = Self::SIZE {
size
... | the_stack |
use std::collections::HashMap;
use lexer::errors::LexerError;
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub enum Token
{
Newline,
Indent,
Dedent,
False,
None,
True,
And,
As,
Assert,
//Async,
//Await,
Break,
Class,
Continue,
Def,
Del,
Elif,
Else,
Except,
Fi... | the_stack |
//! Non-physical true random number generator based on timing jitter.
// Note: the C implementation of `Jitterentropy` relies on being compiled
// without optimizations. This implementation goes through lengths to make the
// compiler not optimize out code which does influence timing jitter, but is
// technically dead... | the_stack |
use serde_json::Value;
use crate::client::ClientContext;
use crate::error::ClientResult;
use crate::net::{ParamsOfQueryCollection, ServerLink, MESSAGES_COLLECTION};
use crate::abi::{decode_message_body, Abi, DecodedMessageBody, ParamsOfDecodeMessageBody};
use std::collections::{HashMap, HashSet};
use std::ite... | the_stack |
#![deny(warnings)]
#![cfg_attr(test, feature(proc_macro_hygiene))]
#![cfg_attr(not(feature = "std"), no_std)]
mod ext;
pub mod types;
#[cfg(any(feature = "runtime-benchmarks", test))]
mod benchmarking;
mod default_weights;
pub use default_weights::WeightInfo;
#[cfg(test)]
mod tests;
#[cfg(test)]
mod mock;
#[cfg(... | the_stack |
use bytes::BytesMut;
use lazy_static::lazy_static;
use std::convert::Infallible;
use std::error::Error;
use std::fmt::{self, Display, Formatter};
use crate::header::map::{HeaderMap, HeaderMapExtension, TypedHeader};
use crate::header::name::HeaderName;
use crate::header::value::HeaderValue;
use crate::reason::ReasonPh... | the_stack |
use std::sync::atomic::{AtomicUsize, Ordering};
use std::borrow::Borrow;
use std::mem;
use futures::task::{self, Task};
use futures::{StartSend, AsyncSink, Async, Sink, Stream, Poll};
use handle::{Handle, IdHandle, ResizingHandle, BoundedHandle, HandleInner};
use primitives::index_allocator::IndexAllocator;
use contai... | the_stack |
use std::{
io::{self, Read},
str,
};
use byteorder::{LittleEndian, ReadBytesExt};
use noodles_vcf::{
self as vcf,
record::{
genotypes::{
genotype::field::{Key, Value},
Genotype, Keys,
},
Genotypes,
},
};
const NUL: u8 = 0x00;
use crate::{
header... | the_stack |
pub struct DescribeCacheClustersPaginator<
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_cache_clusters_input::Builder,
}
impl<... | the_stack |
use super::*;
use crate::core::{
idempotency::*,
scale_with_precision_loss,
types::{
Convert, ConvertDetails, LeftoversStore, SettlementAccount, SettlementEngineDetails,
SettlementStore,
},
};
use bytes::Bytes;
use hyper::StatusCode;
use interledger_packet::{Address, ErrorCode, FulfillBu... | the_stack |
use cbor_event::{self, de::Deserializer, se::Serializer};
use cryptoxide::ed25519;
#[cfg(feature = "generic-serialization")]
use serde;
use util::hex;
use std::{
cmp, fmt,
io::{BufRead, Write},
result,
};
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
#[cfg_attr(feature = "generic-serializa... | the_stack |
use crate::message::OrderedMessage;
use log::*;
use std::collections::HashMap;
/// Stores messages and emits them in order.
///
/// Only contiguous messages with an index less than or equal to `next_index`
/// will be returned - this avoids returning gaps while we wait for the buffer
/// to fill up with the full seque... | the_stack |
use crate::api_client::RateLimitedClient;
use crate::publishers::{PublisherData, PublisherKind};
use flate2::read::GzDecoder;
use serde::{Deserialize, Serialize};
use std::iter::FromIterator;
use std::{
collections::{BTreeSet, HashMap},
fs,
io::{self, ErrorKind},
mem,
path::PathBuf,
time::Durati... | the_stack |
use mun_runtime::StructRef;
use mun_test::CompileAndRunTestDriver;
#[macro_use]
mod util;
#[test]
fn gc_trace() {
let driver = CompileAndRunTestDriver::new(
r#"
pub struct Foo {
quz: f64,
bar: Bar,
}
pub struct Bar {
baz: i64
}
pub fn new_foo() -> Foo {
... | the_stack |
use error::*;
use intern::{Symbol, UNKNOWN_SYMBOL};
use raw::*;
use report::{self, Report};
use utils::*;
use fixedbitset::FixedBitSet;
use petgraph::Direction;
use petgraph::graph::{DiGraph, EdgeIndex, EdgeReference, NodeIndex};
use petgraph::visit::{Dfs, EdgeFiltered, EdgeRef, IntoNodeReferences};
use std::{cmp, io... | the_stack |
use crate::bank::BankBox;
use crate::equations::reserve_ratio;
use crate::error::ProtocolError;
use crate::input_boxes::{ReserveCoinBox, StableCoinBox};
use crate::parameters::{
BANK_NFT_ID, COOLING_OFF_HEIGHT, IMPLEMENTOR_FEE_PERCENT, MAX_RESERVE_RATIO, MIN_BOX_VALUE,
MIN_RESERVE_RATIO, RESERVECOIN_DEFAULT_PRI... | the_stack |
// https://github.com/Manishearth/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![al... | the_stack |
use super::super::*;
use std::io::Cursor;
use proptest::prelude::*;
use self::byteorder::{ByteOrder, BigEndian};
use std::slice;
#[test]
fn default() {
let default : TcpHeader = Default::default();
assert_eq!(0, default.source_port);
assert_eq!(0, default.destination_port);
assert_eq!(0, default.sequ... | the_stack |
use crate::{
indexes::{PointVec, PointIndex, HullVec, HullIndex, EdgeIndex, EMPTY_HULL},
};
const N: usize = 1 << 10;
#[derive(Clone, Copy, Debug)]
struct Node {
/// Pseudo-angle of the point
angle: f64,
/// `EdgeIndex` of the edge to the right of this point, i.e. having this
/// point as its `ds... | the_stack |
pub struct PKTYPE {
pub kind: usize,
pub hash: usize,
pub curve: usize,
pub len: usize,
}
pub struct FDTYPE {
pub index: usize,
pub length: usize,
}
// Supported Encryption/Signature Methods
pub const ECC:usize = 1;
pub const RSA:usize = 2;
pub const ECD:usize = 3; // for Ed25519
// Support... | the_stack |
use std::collections::HashMap;
use std::ops::{Range, RangeFrom, RangeTo};
use crate::{
chain::{Chain, Link},
collect::Chains,
node::State,
resource::{AccessFlags, Buffer, Image, Resource},
schedule::{Queue, QueueId, Schedule, SubmissionId},
Id,
};
/// Semaphore identifier.
/// It allows to dis... | the_stack |
#[cfg(feature = "use_bindgen")]
extern crate bindgen;
extern crate cc;
#[cfg(feature = "use_bindgen")]
extern crate regex;
#[cfg(feature = "use_bindgen")]
use {
regex::Regex,
std::{fs::File, io::Write},
};
use std::env;
use std::fs::copy;
use std::path::PathBuf;
include!("common.rs");
const CAPSTONE_DIR: ... | the_stack |
use crate::{
buffers::{Buffers, DefaultBuffers},
lexer::{Lexer, Token, TokenType},
words::{Atom, Word, WordsOrComments},
Callbacks, Comment, GCode, Line, Mnemonic, Nop,
};
use core::{iter::Peekable, marker::PhantomData};
/// Parse each [`GCode`] in some text, ignoring any errors that may occur or
/// [... | the_stack |
extern crate timely;
extern crate graph_map;
extern crate alg3_dynamic;
use std::sync::{Arc, Mutex};
use std::io::BufReader;
use std::error::Error;
use std::fs::File;
use std::io::prelude::*;
use std::path::Path;
use timely::dataflow::*;
use timely::dataflow::operators::*;
use alg3_dynamic::*;
fn main () {
let... | the_stack |
use crate::executor::TaskQueueHandle;
use nix::sys;
use std::{
fmt,
sync::{
atomic::{AtomicBool, Ordering},
Arc,
},
thread::{self, JoinHandle},
time::{Duration, Instant},
};
pub struct StallDetection<'a> {
executor: usize,
queue_handle: TaskQueueHandle,
queue_name: &'a s... | the_stack |
#![allow(deprecated)]
use mio::{Events,Poll,PollOpt,Ready,Token};
use mio::channel::{channel,Receiver,Sender};
use std::collections::HashMap;
use mio::tcp::TcpListener;
use std::fmt;
use std::io;
use std::mem;
use std::ops::Range;
use std::net::{SocketAddr,ToSocketAddrs};
use std::sync::{Arc,Mutex};
use std::sync::mps... | the_stack |
use std::io;
use std::mem;
use std::os::windows::io::AsRawHandle;
use std::time::Duration;
use tokio::io::AsyncWriteExt;
use tokio::net::windows::named_pipe::{ClientOptions, PipeMode, ServerOptions};
use tokio::time;
use winapi::shared::winerror;
#[tokio::test]
async fn test_named_pipe_client_drop() -> io::Result<()> ... | the_stack |
use proc_macro2::Span;
use std::collections::HashMap;
use syn::{
braced, bracketed, parenthesized, parse, spanned::Spanned, token, GenericArgument, Ident,
Lifetime, PathArguments, Token, Type,
};
#[derive(Debug)]
pub struct StateMachine {
pub temporary_context_type: Option<Type>,
pub guard_error: Optio... | the_stack |
use std::{collections::HashSet, fmt::Display, iter::Take, ops::RangeInclusive};
use criterion::{Criterion, Throughput};
use nanorand::{Pcg64, Rng};
use serde::{Deserialize, Serialize};
use crate::{BenchConfig, SimpleBench, UnversionedBenchmark, VersionedBenchmark};
#[cfg(feature = "couchdb")]
mod couchdb;
mod nebari... | the_stack |
use std::fs::File;
use std::io;
use std::net::{IpAddr};
use std::os::unix::io::{AsRawFd, RawFd};
use std::mem::{self, size_of};
use std::process;
use blake2::{self, Digest};
use failure::{Error, ResultExt};
use ipnetwork::IpNetwork;
use libc::{close};
use nix::sched::{setns};
use nix::sched::CloneFlags;
use nix::sys::... | the_stack |
use crate::sys;
#[repr(i32)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Error {
Generic = sys::MA_ERROR,
InvalidArgs = sys::MA_INVALID_ARGS,
InvalidOperation = sys::MA_INVALID_OPERATION,
OutOfMemory = sys::MA_OUT_OF_MEMORY,
OutOfRange = sys::MA_OUT_OF_RANGE,
AccessDenied = sys::MA_ACCESS_DE... | the_stack |
use std::collections::HashMap;
use std::fmt;
use std::io::Error;
use std::rc::Rc;
use crate::rules::AttributeList;
use sulis_core::image::{Image, LayeredImage};
use sulis_core::io::GraphicsRenderer;
use sulis_core::resource::ResourceSet;
use sulis_core::ui::Color;
use sulis_core::util::{unable_to_create_error, Offset,... | the_stack |
use exonum::{
blockchain::Blockchain,
crypto::{Hash, PublicKey},
merkledb::{BinaryValue, Snapshot},
runtime::{
migrations::{InitMigrationError, MigrationScript},
oneshot,
versioning::Version,
ArtifactId, Caller, ExecutionContext, ExecutionError, InstanceId, InstanceSpec, ... | the_stack |
use std::borrow::Cow;
use std::convert::TryFrom;
use std::ffi::{OsStr, OsString};
use std::os::raw::c_void;
use std::os::windows::ffi::{OsStrExt, OsStringExt};
use std::path::PathBuf;
use std::ptr;
use std::time::Duration;
use std::{io, mem};
use widestring::{NulError, WideCStr, WideCString, WideString};
use winapi::s... | the_stack |
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_cas... | the_stack |
use anyhow::{Context, Result};
use smithay::backend::{
drm::DrmSurface,
egl::{
EGLError, SwapBuffersError,
display::EGLDisplayHandle,
native::{EGLNativeDisplay, EGLNativeSurface, EGLPlatform}
}
};
use smithay::reexports::{
drm::control::{
Device as ControlDevice,
... | the_stack |
use core::{fmt, ops::Range, time::Duration};
use insta::assert_debug_snapshot;
use plotters::prelude::*;
use s2n_quic_core::{
packet::number::PacketNumberSpace,
path::MINIMUM_MTU,
random,
recovery::{CongestionController, CubicCongestionController, RttEstimator},
time::{Clock, NoopClock, Timestamp},
... | the_stack |
use crate::private::bytelevel::{
self as blv,
slot::{Pub, Priv},
slot::{bytes::kind, *},
PCons, PNil, ReferenceBytes,
};
use crate::private::layout::{Layout, AlignedTo};
use crate::private::num::{self, UInt, UTerm};
use super::from_type::FromType;
use super::{Variant, Invariant, Static, Unchecked, Enfor... | the_stack |
// TODO:
// - When different cores are accessing this, do we have false cache line sharing issues?
// - Currently, when we're resizing, every time we move a pointer from the current bucket to its
// new bucket, we just call insert() on the new bucket. This re-traverses the bucket from the
// beginning. We can do be... | the_stack |
use crossbeam_channel::{Receiver, Sender};
use fnv::FnvHashMap;
use rafx_api::{
RafxCommandBuffer, RafxCommandBufferDef, RafxCommandPool, RafxCommandPoolDef, RafxQueue,
RafxResult,
};
use std::collections::BTreeMap;
use std::ops::Deref;
use std::sync::{Arc, Mutex};
pub struct DynCommandBuffer(Arc<RafxCommandBu... | the_stack |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.