text stringlengths 2.5k 6.39M | kind stringclasses 3
values |
|---|---|
use std::error::Error;
use std::fmt::Write;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use walkdir::WalkDir;
mod groups;
pub struct LintExtractor<'a> {
/// Path to the `src` directory, where it will scan for `.rs` files to
/// find lint declarations.
pub src_path: &'a Path,
... | the_stack |
#![deny(warnings, missing_docs)]
extern crate futures;
extern crate tokio_io;
extern crate tokio_core;
extern crate tokio_proto;
extern crate tokio_service;
extern crate bytes;
use futures::{Future, Stream, Poll};
use futures::sync::mpsc;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_io::codec::{Encoder, Decoder,... | the_stack |
mod connection;
mod connection_visibility;
mod current_user;
mod current_user_guild;
mod flags;
mod premium_type;
mod profile;
pub use self::{
connection::Connection, connection_visibility::ConnectionVisibility, current_user::CurrentUser,
current_user_guild::CurrentUserGuild, flags::UserFlags, premium_type::Pr... | the_stack |
use byteorder::{ByteOrder, LittleEndian};
use std::fmt::{self, Debug};
use std::io::{self, Read, Write};
use crate::masked_crc::MaskedCrc;
// From [TensorFlow `record_writer.cc` comments][1]:
// Format of a single record:
// uint64 length
// uint32 masked crc of length
// byte data[length]
// uint32 ... | the_stack |
mod sequential;
// This module contains the definition of `LockedKeyDeps`.
mod locked;
// Re-exports.
pub use locked::LockedKeyDeps;
pub use sequential::SequentialKeyDeps;
use fantoch::command::Command;
use fantoch::id::{Dot, ShardId};
use fantoch::HashSet;
use serde::{Deserialize, Serialize};
use std::collections::... | the_stack |
#![allow(unused_unsafe, warnings)]
pub mod intrinsics;
pub mod mid;
use core::cell::UnsafeCell;
use core::sync::atomic::Ordering;
use paste::paste;
#[allow(dead_code)]
fn fail_order(order: Ordering) -> Ordering {
match order {
Ordering::Release | Ordering::Relaxed => Ordering::Relaxed,
Ordering::... | the_stack |
use std::convert::TryFrom;
use crate::parenthesized::Parenthesized;
use heck::CamelCase;
use proc_macro::TokenStream;
use proc_macro2::Span;
use quote::ToTokens;
use syn::{
parse_macro_input, parse_quote, spanned::Spanned, Attribute, Error, FnArg, Ident, ItemTrait,
ReturnType, TraitItem, Type,
};
/// Implemen... | the_stack |
use atomic_lib::{agents::generate_public_key, mapping::Mapping};
use atomic_lib::{agents::Agent, config::Config};
use atomic_lib::{errors::AtomicResult, Storelike};
use clap::{crate_version, App, AppSettings, Arg, ArgMatches, SubCommand};
use colored::*;
use dirs::home_dir;
use std::{cell::RefCell, path::PathBuf, sync:... | the_stack |
use crate::frame::*;
use crate::botdef;
use crate::heightmap_phy;
use crate::mobile::*;
use crate::utils::*;
use crossbeam_channel::{Receiver, Sender};
use fnv::{FnvHashMap, FnvHashSet};
use na::{Matrix4, Point3, Vector2, Vector3};
use std::time::Instant;
pub enum ToFrameServer {
DataToComputeNextFrame(DataToComp... | the_stack |
use std::fmt::Debug;
use std::cmp::Ordering;
use timely::order::PartialOrder;
use timely::progress::Timestamp;
use timely::dataflow::Scope;
use timely::dataflow::operators::generic::{Operator, OutputHandle};
use timely::dataflow::channels::pact::Pipeline;
use timely::dataflow::operators::Capability;
use timely::datafl... | the_stack |
#[cfg(not(feature = "indexmap"))]
pub type PropertiesMap<K, V> = std::collections::HashMap<K, V>;
#[cfg(feature = "indexmap")]
pub type PropertiesMap<K, V> = indexmap::IndexMap<K, V>;
use std::borrow::Cow;
use memchr::memrchr2;
use nom::{
branch::alt,
bytes::complete::{tag, take_until, take_while},
chara... | the_stack |
use std::{i32, u32, u64, f64};
use std::iter::{Iterator, IntoIterator};
/// Smallest power of two such that two raised to that power is greater than or equal to the given number.
///
/// - `n` - Find the smallest power of two that equals or exceeds this value.
/// - Returns - The power, not the number (unlike u... | the_stack |
//! Array-backed set types.
//!
//! At the moment, we are using the bumpalo allocator for arena allocation.
//! Because the stdlib types do not yet provide the ability to choose the
//! allocator used when they are allocated or resized, the bumpalo library
//! provides its own growable Vec and String types. Since bumpa... | the_stack |
use {
lru_cache::LruCache,
parking_lot::Mutex,
rustls::{
internal::msgs::{
codec::{Codec, Reader},
enums::{NamedGroup, ProtocolVersion},
persist::ClientSessionValue,
},
StoresClientSessions,
},
std::{collections::VecDeque, fmt::Debug, sync:... | the_stack |
use borsh::{
BorshDeserialize,
BorshSerialize,
};
use byteorder::{
BigEndian,
WriteBytesExt,
};
use hex_literal::hex;
use secp256k1::{
Message as Secp256k1Message,
PublicKey,
SecretKey,
};
use sha3::Digest;
use solana_client::{
client_error::ClientError,
rpc_client::RpcClient,
rp... | the_stack |
pub mod entry;
pub mod example;
use crate::prelude::*;
use crate::model::module::MethodId;
use crate::model::suggestion_database::entry::Kind;
use crate::notification;
use double_representation::module::QualifiedName;
use engine_protocol::language_server;
use engine_protocol::language_server::SuggestionId;
use enso_... | the_stack |
use crate::{ShellCmdApi, CommonEnv};
use root_keys::api::{AesRootkeyType, Block};
use xous_ipc::String;
#[derive(Debug)]
pub struct Keys {
testing_range: xous::MemoryRange,
spinor: spinor::Spinor,
rootkeys: root_keys::RootKeys,
}
const TEST_SIZE: usize = 0x4000;
const TEST_BASE: usize = 0x608_0000;
impl Ke... | the_stack |
use crate::header::uniform_type::Array;
use crate::header::{
normalize, uniform_type, Engine, Object, ObjectSettings, Pipeline, Renderer, RotateAxis,
UniformBuffer, Vertex,
};
use crate::utils::default_resources::{DEFAULT_MATRIX_4, DEFAULT_SHADER};
pub mod two_dimensions;
impl Engine {
/// Creates... | the_stack |
use crate::auth::{AuthContext, Permission};
use crate::error::ApiError;
use tornado_engine_api_dto::runtime_config::{
LoggerConfigDto, SetApmPriorityConfigurationRequestDto, SetLoggerApmRequestDto,
SetLoggerLevelRequestDto, SetLoggerStdoutRequestDto, SetStdoutPriorityConfigurationRequestDto,
};
/// The ApiHand... | the_stack |
use alloc::vec::Vec;
use arrayvec::ArrayVec;
use crate::{LengthU32, Color, SpreadMode, PremultipliedColor, PremultipliedColorU8};
use crate::{Transform, PixmapRef};
pub use blitter::RasterPipelineBlitter;
use crate::floating_point::NormalizedF32;
use crate::geom::ScreenIntRect;
use crate::math::LENGTH_U32_ONE;
use ... | the_stack |
use crate::error::Error;
use crate::module::{AddrDetails, GlobalSpec, HeapSpec, Module, ModuleInternal, TableElement};
use libc::c_void;
use lucet_module::owned::{
OwnedExportFunction, OwnedFunctionMetadata, OwnedGlobalSpec, OwnedImportFunction,
OwnedLinearMemorySpec, OwnedModuleData, OwnedSparseData,
};
use lu... | the_stack |
use crate::compression::CompressionMethod;
use crate::read::{central_header_to_zip_file, ZipArchive, ZipFile};
use crate::result::{ZipError, ZipResult};
use crate::spec;
use crate::types::{DateTime, System, ZipFileData, DEFAULT_VERSION};
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use crc32fast::Hasher;... | the_stack |
use std::{
env,
ffi::CStr,
intrinsics::transmute,
io::ErrorKind,
mem::size_of,
net::{SocketAddr, SocketAddrV4},
os::raw::{c_char, c_int},
process::Command,
ptr::null,
thread,
time::{Duration, Instant},
};
use anyhow::Error;
use bytes::Bytes;
use futures::{future::try_join, j... | the_stack |
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeAcceleratorOfferingsError {
/// Kind of error that occurred.
pub kind: DescribeAcceleratorOfferingsErrorKind,
/// Additional metadata about the error, including error code, message, and request ID.
pub(crate) meta: aws_smithy_types::Error,
... | the_stack |
use ff::{Field, SqrtField};
use rand::{Rand, Rng};
use super::super::Fr as Fq;
use super::super::FrRepr as FqRepr;
use std::cmp::Ordering;
const NON_RESIDUE: Fq = Fq(FqRepr([
0xffffffffffffffa1,
0xffffffffffffffff,
0xffffffffffffffff,
0x07fffffffffff9b0
]));
const MINUS_ONE: Fq = Fq(FqRepr([
0x0... | the_stack |
use std::path::Path;
use std::process::exit;
use fuzzy_matcher::skim::SkimMatcherV2;
use iced::futures::channel::mpsc::{Sender, TrySendError};
use iced::{
scrollable, text_input, window, Alignment, Application, Color, Column, Command, Container,
Element, Length, Row, Scrollable, Settings, Subscription, TextInp... | the_stack |
#![forbid(unsafe_code)]
use js_sys::{
Array, Date, Error, Function, JsString, Map, Object, Promise, Reflect, RegExp, Set, Symbol,
WeakSet,
};
use std::{
collections::{BTreeMap, BTreeSet, HashSet},
fmt::{Debug, Display, Formatter, Result as FmtResult},
rc::Rc,
};
use wasm_bindgen::{JsCast, JsValue};... | the_stack |
use anyhow::{anyhow, bail};
use anyhow::{Context, Result};
use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
use control_plane::compute::ComputeControlPlane;
use control_plane::local_env;
use control_plane::local_env::LocalEnv;
use control_plane::safekeeper::SafekeeperNode;
use control_plane::storage::PageServ... | the_stack |
use std::cmp::Ordering;
use ieee754::Ieee754;
use indexmap::map::IndexMap;
use itertools::Itertools;
use ndarray;
use crate::{base, proto, Warnable};
use crate::base::{DataType, IndexKey, NodeProperties, SensitivitySpace, Value, ValueProperties};
use crate::components::{Accuracy, Mechanism, Sensitivity};
use crate::c... | the_stack |
use crate::eth::{
receipt::Log,
utils::{enveloped, to_access_list},
};
use ethers_core::{
types::{
transaction::eip2930::{AccessList, AccessListItem},
Address, Bloom, Bytes, Signature, SignatureError, TxHash, H256, U256,
},
utils::{
keccak256, rlp,
rlp::{Decodable, De... | the_stack |
use std::collections::BTreeMap;
use serde_json::Value;
use crate::common::data::{MockMatcherFunction, RequestRequirements};
use crate::Regex;
pub(crate) trait ValueRefSource<T> {
fn parse_from_mock<'a>(&self, mock: &'a RequestRequirements) -> Option<Vec<&'a T>>;
}
pub(crate) trait MultiValueSource<T, U> {
f... | the_stack |
use std::collections::{VecDeque, HashMap, HashSet};
use std::net::SocketAddr;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use abstract_ns::{Name, Resolve, HostResolve, Address, IpList, Error};
use dir_signature::v1::Hashes;
use rand::{thread_rng};
use rand::seq::sample_iter;
use futures::{Futu... | the_stack |
use std::cmp;
use std::collections::VecDeque;
use rand::Rng;
use hbbft::{ConsensusProtocol, CpStep};
use crate::util::randomly;
use crate::{CrankError, NetMessage, NetworkMessage, Node, VirtualNet};
/// Immutable network handle.
///
/// Allows querying public information of the network or getting immutable handles ... | the_stack |
extern crate tokio;
use futures::future::try_join;
use std::collections::HashMap;
use std::net::SocketAddr;
use std::str::FromStr;
use std::sync::mpsc::{Receiver, Sender};
use std::sync::Arc;
use tokio::io;
use tokio::net::{TcpListener, TcpStream};
mod backend;
use self::backend::{get_next, run_health_checker, Backe... | the_stack |
use std::collections::{BTreeMap, BTreeSet};
use std::convert::TryInto;
use beserial::{Deserialize, Serialize};
use nimiq_account::*;
use nimiq_bls::CompressedPublicKey as BlsPublicKey;
use nimiq_bls::KeyPair as BlsKeyPair;
use nimiq_bls::SecretKey as BlsSecretKey;
use nimiq_collections::BitSet;
use nimiq_database::vol... | the_stack |
use core::{
any,
fmt::{
self,
Binary,
Debug,
Display,
Formatter,
Pointer,
},
marker::PhantomData,
mem,
ptr::{
self,
NonNull,
},
};
use tap::Pipe;
use wyz::{
comu::{
Address,
Const,
Mut,
Mutability,
NullPtrError,
Reference,
Referential,
},
fmt::FmtForward,
};
use super::{
BitPt... | the_stack |
//! Widget representing patcher surface.
use std::any::Any;
use std::collections::HashMap;
use itertools::Itertools;
use direct2d::RenderTarget;
use direct2d::brush::SolidColorBrush;
use direct2d::enums::{AntialiasMode, CapStyle};
use direct2d::math::Ellipse;
use direct2d::stroke_style::{StrokeStyle, StrokeStyleBuil... | the_stack |
mod error;
mod mini_v8;
use std::{
collections::HashMap, fs, future::Future, pin::Pin, result::Result as StdResult, sync::Arc,
};
use arrow::{
array::{ArrayData, ArrayDataRef},
buffer::{Buffer, MutableBuffer},
datatypes::{DataType, Schema},
ipc::writer::schema_to_bytes,
};
use futures::FutureExt;
... | the_stack |
use colored::*;
use prettytable::{Cell, Row, Table};
use reqwest;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs::File;
use std::io::*;
use std::path::{Path, PathBuf};
use itertools::Itertools;
use strsim::normalized_levenshtein;
static GLOBSTAR: &str = "**";
#[derive(Serialize, Deser... | the_stack |
use bridge::abort;
use std::io::Write;
use crate::help;
use crate::node::*;
use crate::t_eprint;
use crate::xetex_consts::*;
use crate::xetex_errors::{confusion, error, fatal_error};
use crate::xetex_ext::{apply_tfm_font_mapping, make_font_def};
use crate::xetex_ini::shell_escape_enabled;
use crate::xetex_ini::Selecto... | the_stack |
#![feature(rustc_attrs, conservative_impl_trait, associated_consts, custom_derive, slice_patterns)]
extern crate uuid;
extern crate libflate;
extern crate hyper;
extern crate chrono;
extern crate tickgrinder_util;
#[macro_use]
extern crate lazy_static;
extern crate tempdir;
extern crate serde;
#[macro_use]
extern crat... | the_stack |
use crate::{der, Error};
use ring::signature;
/// X.509 certificates and related items that are signed are almost always
/// encoded in the format "tbs||signatureAlgorithm||signature". This structure
/// captures this pattern.
pub struct SignedData<'a> {
/// The signed data. This would be `tbsCertificate` in the c... | the_stack |
use std::collections::HashMap;
use std::mem;
use client::{Client, ConnectionStatus};
use mqtt3::{TopicPath, SubscribeTopic, ToTopicPath};
use error::Result;
// NOTE: split subscription list into concrete & and wild card subscriptions
// all concrete subscription clients could be fetched in O(1)~
#[derive(Debug)]
pub... | the_stack |
// Substrate is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Substrate is distributed in the hope that it will be useful,
// but... | the_stack |
use lexer::{Keyword, Lexer, Pos, Symbol, Token, TokenKind};
use node::{ASTKind, Bits, AST};
use node;
use types::{Sign, StorageClass, Type};
use std::str;
use std::boxed::Box;
use std::io::{stderr, Write};
use std::collections::{hash_map, HashMap, VecDeque};
// use CODEGEN;
extern crate llvm_sys as llvm;
extern cra... | the_stack |
use ahash::AHashMap;
use feather_items::{Item, ItemStack};
use feather_loot_model as model;
use inlinable_string::InlinableString;
use itertools::Itertools;
use model::{Condition, Entry, EntryKind, Function, FunctionKind, LootTableSet, Pool};
use once_cell::sync::Lazy;
use rand::Rng;
use smallvec::SmallVec;
use std::it... | the_stack |
use {
crate::log_if_err,
crate::message::Message,
crate::node::Node,
anyhow::{format_err, Context, Result},
async_trait::async_trait,
fidl_fuchsia_ui_activity as factivity,
fuchsia_component::client::connect_to_protocol,
fuchsia_inspect::{self as inspect, Property},
futures::future::... | the_stack |
use std::borrow::Borrow;
use std::collections::HashMap;
use std::sync::Arc;
use builtin::adt_constructor;
use builtin::record_access;
use constructors::type_bool;
use errors::*;
use interpreter::runtime_stack::RuntimeStack;
use loader::AnalyzedModule;
use loader::Declaration;
use loader::RuntimeModule;
use rust_intero... | the_stack |
#![allow(unsafe_code)]
use super::super::arch::choose::{
syscall0_readonly, syscall1, syscall1_noreturn, syscall1_readonly, syscall2, syscall2_readonly,
syscall3, syscall3_readonly, syscall4,
};
use super::super::c;
use super::super::conv::{
borrowed_fd, by_mut, c_int, c_str, c_uint, out, pass_usize, ret, ... | the_stack |
use std::collections::HashMap;
use std::env;
use std::fs::File;
use std::io::{self, Error as IoError, Read, Write};
use std::mem;
use std::path::{Path, PathBuf};
use pulldown_cmark::{CodeBlockKind, Event, Parser, Tag};
pub mod rt;
#[cfg(test)]
mod tests;
/// Returns a list of markdown files under a directory.
///
//... | the_stack |
use composer::*;
use composer::util::join;
use std::collections::HashSet;
use serde_json;
use subprocess::{Popen, PopenConfig, Redirection};
/// A trait that defines the function names associated with splitters.
trait SplitTypeFunctions {
/// Returns the name of the splitter initialization function.
fn split... | the_stack |
// Implementation notes:
//
// The implementation is utterly and horribly unsafe. This whole module is an
// unsafety boundary. It is believed that the API here is, in principle, sound,
// but the implementation might have bugs.
//
// The core type is `NodeData` -- a heap-allocated reference counted object,
// which po... | the_stack |
use common_datavalues::prelude::*;
use common_exception::Result;
use common_functions::scalars::Blake3HashFunction;
use common_functions::scalars::Md5HashFunction;
use common_functions::scalars::Sha1HashFunction;
use common_functions::scalars::Sha2HashFunction;
use common_functions::scalars::SipHashFunction;
use common... | the_stack |
pub mod create;
pub mod colors;
pub mod config;
pub mod daemon;
pub mod test;
use colored::*;
use clap::{crate_description, crate_name, crate_version, App, Arg, SubCommand, AppSettings, ArgSettings};
/////UNSAFE
fn string_to_unsafe_static_str(s: String) -> &'static str {
Box::leak(s.into_boxed_str())
}
pub fn bu... | the_stack |
use crate::prelude::*;
use ast::crumbs::Located;
use std::cmp::Ordering;
// ==================
// === Identifier ===
// ==================
// === Errors ===
#[allow(missing_docs)]
#[derive(Clone, Debug, Fail)]
#[fail(display = "Identifier contains operator `{}`, so it cannot be made into var.", _0)]
pub struct Op... | the_stack |
use ecdsa::elliptic_curve::{
consts::U33, generic_array::GenericArray, group::GroupEncoding, Field,
};
use k256::elliptic_curve::sec1::{FromEncodedPoint, ToEncodedPoint};
use rand::{CryptoRng, RngCore};
use serde::{de, de::Error, de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
use zeroize::Zeroize;
... | the_stack |
extern crate syn;
use syn::spanned::Spanned;
use syn::visit::Visit;
use syn::*;
// for etc.
use crate::identifier::Dim;
// represents a parameter of a kernel
//
// every time someone does gpu_do!(launch()), we try to launch a kernel by
// using the next for loop we find
// the parameters of a kernel are basically eve... | the_stack |
/// Error type for parsing [MIDINoteType](struct.MIDINoteType.html) from `&str`
#[derive(Debug, PartialEq, thiserror::Error)]
pub enum ParseMIDINoteTypeError {
#[error("Unknown note type {input}")]
UnknownNoteType { input: String },
}
/// MIDI note type
///
/// Represents each note in an octave, where each "*S... | 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 fallible_iterator::FallibleIterator;
use std::borrow::Cow;
use std::collections::BTreeMap;
use std::collections::HashMap;
use std::convert::Infallible;
use std::error::Error;
use std::fmt;
use std::fs;
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::str;
use disc_v::*;
use goblin::elf::Elf;
use rust... | the_stack |
use super::device::EGL_FUNCTIONS;
use super::error::ToWindowingApiError;
use super::ffi::EGL_CONTEXT_OPENGL_PROFILE_MASK;
use super::ffi::{EGL_CONTEXT_MINOR_VERSION_KHR, EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT};
use super::surface::{EGLBackedSurface, ExternalEGLSurfaces};
use crate::context::{self, CREATE_CONTEXT_... | the_stack |
use std::io::{Cursor, Read};
use std::iter::Iterator;
use anyhow::Result;
use blstrs::Scalar as Fr;
use filecoin_proofs::{
add_piece, commitment_from_fr,
pieces::{
compute_comm_d, get_piece_alignment, get_piece_start_byte, piece_hash, verify_pieces,
zero_padding, EmptySource, PieceAlignment,
... | the_stack |
#![cfg_attr(not(feature = "std"), no_std)]
extern crate alloc;
use alloc::vec::Vec;
use evm::{executor::PrecompileOutput, Context, ExitError, ExitSucceed};
use fp_evm::Precompile;
use num::{BigUint, FromPrimitive, One, ToPrimitive, Zero};
use core::cmp::max;
use core::ops::BitAnd;
pub struct Modexp;
const MIN_GAS_... | the_stack |
use crate::parsers::{
blend::{Block, BlockData, Header as BlendHeader, RawBlend},
dna::{Dna, DnaStruct, DnaType},
field::{parse_field, FieldInfo},
primitive::*,
Endianness, PointerSize,
};
use linked_hash_map::LinkedHashMap;
use std::fmt;
use std::{io::Read, mem::size_of, num::NonZeroU64, path::Path... | the_stack |
use std::ffi::OsStr;
use std::io::{self, Read, Write};
use std::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
use std::sync::atomic::Ordering::{Relaxed, SeqCst};
use std::sync::atomic::{AtomicBool, AtomicUsize};
use std::sync::{Arc, Mutex};
use std::{fmt, mem, slice};
use miow::iocp::{Comple... | the_stack |
pub type c_char = u8;
pub type wchar_t = u32;
pub type greg_t = i32;
pub type mcontext_t = sigcontext;
s! {
pub struct sigcontext {
pub trap_no: ::c_ulong,
pub error_code: ::c_ulong,
pub oldmask: ::c_ulong,
pub arm_r0: ::c_ulong,
pub arm_r1: ::c_ulong,
pub arm_r2: ::... | the_stack |
use anyhow::Result;
use std::collections::BTreeMap;
use crate::{
ast::{Condition, ConditionKind, Exp, ExpData, Operation, Spec, TempIndex},
model::{FunId, GlobalEnv, QualifiedId},
simplifier::pass::SpecRewriter,
symbol::Symbol,
};
/// A spec rewriter that produces a new spec by inlining all expression... | the_stack |
use super::utils::{
make_pointer, make_scalar, write_word, ObjectIdx, GC, MAX_MARK_STACK_SIZE, WORD_SIZE,
};
use motoko_rts::gc::mark_compact::mark_stack::INIT_STACK_SIZE;
use motoko_rts::memory::Memory;
use motoko_rts::types::*;
use std::cell::{Ref, RefCell};
use std::convert::TryFrom;
use std::rc::Rc;
use fxha... | the_stack |
use std::iter::once;
use std::collections::HashMap;
use std::collections::vec_deque::VecDeque;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use gc::Gc;
use crate::syntax::{Database, Environment, Assertion, Term, Atom,
string_of_env, make_complementary, generate_contrapositives... | the_stack |
// There are two similar things (both stored as `Ast`s) we should distinguish!
// (1) syntax for types, as written by the user
// (2) types themselves, the result of type synthesis
//
// These things are almost identical,
// which is why postive synth_type is usually implemented with `LiteralLike`.
// Performing `Synt... | the_stack |
use std;
use core::{self, ALPROTO_UNKNOWN, AppProto, Flow};
use libc;
use log::*;
use std::mem::transmute;
use applayer::{self, LoggerFlags};
use parser::*;
use std::ffi::CString;
use nom;
use super::parser;
static mut ALPROTO_TEMPLATE: AppProto = ALPROTO_UNKNOWN;
pub struct TemplateTransaction {
tx_id: u64,
... | the_stack |
use super::{
assign_deadlines, deadline_is_mutable, deadlines::new_deadline_info,
new_deadline_info_from_offset_and_epoch, policy::*, quant_spec_for_deadline, types::*,
BitFieldQueue, Deadline, DeadlineSectorMap, Deadlines, PowerPair, Sectors, TerminationResult,
VestingFunds,
};
use crate::{make_empty_m... | the_stack |
mod document;
mod fallback;
mod interest;
mod simd;
use std::{mem, str};
use interest::*;
use simd::Simd;
pub use document::*;
impl<'input> Document<'input> {
/**
Scan a JSON object byte buffer into an indexable document.
# What does _trusted_ mean?
The parser validates UTF8, but otherwise assume... | the_stack |
use crate::alloc::{align_u128, RawArray};
use crate::repr::ByteRepr;
use std::mem::size_of;
use std::slice::from_raw_parts;
use std::sync::Arc;
#[derive(Debug, Clone)]
pub enum Array {
Owned {
/// Aligned vector to store arbitrary elements using binary format.
/// The implicit conversion uses nativ... | the_stack |
use decoder::{Decoder, MAX_COMPONENTS};
use error::{Error, Result};
use huffman::HuffmanDecoder;
use marker::Marker;
use parser::Predictor;
use parser::{Component, FrameInfo, ScanInfo};
use std::io::Read;
impl<R: Read> Decoder<R> {
/// decode_scan_lossless
pub fn decode_scan_lossless(
&mut self,
... | the_stack |
use std::cmp::max;
use std::collections::BTreeMap;
use either::Either;
use super::decl::check_declaration;
use super::read_back::generate_value;
use super::subtype::check_subtype;
use super::tcm::{update_gamma, TCE, TCM, TCS};
use crate::ast::{Branch, Closure, Expression, GenericCase, Level, Typed, Value};
/// $$
//... | the_stack |
use crate::outline::{Contour, PointFlags, PushSegmentFlags};
use crate::segment::{CubicSegment, Segment};
use arrayvec::ArrayVec;
use pathfinder_geometry::line_segment::LineSegment2F;
use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::util::lerp;
use pathfinder_geometry::vector::{Vector2F, Vector4F};
use sm... | the_stack |
//! File system interaction.
use crate::console::Console;
use crate::storage::Storage;
use async_trait::async_trait;
use endbasic_core::ast::{ArgSep, Expr, Value, VarType};
use endbasic_core::exec::Machine;
use endbasic_core::syms::{
CallError, CallableMetadata, CallableMetadataBuilder, Command, CommandResult,
};
... | the_stack |
use crate::consensus::{metrics::ConsensusGossipMetrics, pool_reader::PoolReader, prelude::*};
use ic_interfaces::consensus_pool::{ConsensusPool, HeightIndexedPool, HeightRange};
use ic_types::artifact::{ConsensusMessageId, Priority, Priority::*, PriorityFn};
use prometheus::Histogram;
use std::collections::BTreeSet;
/... | the_stack |
use chrono::prelude::*;
use serde::{Deserialize, Serialize};
use std::clone::Clone;
use crate::qaprotocol::mifi::mifibase::Handler;
#[derive(Serialize, Deserialize, Debug)]
pub struct FullData {
pub amount: f64,
pub close: f64,
pub code: String,
pub high: f64,
pub low: f64,
pub market: String,... | the_stack |
use crate::block::hashtable::get_table_size;
use crate::block::hashtable::HashTable;
use crate::block::hashtable::{HashTableU16, HashTableU32, HashTableUsize};
use crate::block::END_OFFSET;
use crate::block::LZ4_MIN_LENGTH;
use crate::block::MAX_DISTANCE;
use crate::block::MFLIMIT;
use crate::block::MINMATCH;
use crate... | the_stack |
use crate::datastore::{KeyDirEntry, KeysDir};
use crate::errors::EdgeKVError;
use crate::schema::{DataEntry, Decoder, Encoder, HintEntry};
use crate::Result;
use chrono::Utc;
use fs2::FileExt;
use fs_extra::dir::DirOptions;
use std::collections::BTreeMap;
use std::fs::{File, OpenOptions};
use std::io::{BufReader, BufWr... | the_stack |
extern crate pom;
use pom::parser::{Parser,is_a,one_of,sym, none_of,seq};
use pom::char_class::alpha;
use std::str::{self, FromStr};
use self::pom::char_class::{alphanum, digit};
use std::fs::File;
use std::io::Read;
use crate::net::BrowserError;
use crate::css::Value::{Length, Keyword, StringLiteral, UnicodeRange, Un... | the_stack |
use crate::{AsyncBlockSourceResult, BlockHeaderData, BlockSource, BlockSourceError, BlockSourceResult};
use bitcoin::blockdata::block::Block;
use bitcoin::hash_types::BlockHash;
use bitcoin::network::constants::Network;
use std::ops::Deref;
/// The `Poll` trait defines behavior for polling block sources for a chain ... | the_stack |
use chrono::{DateTime, Utc};
use diesel::dsl::exists;
use diesel::{select, ExpressionMethods, QueryDsl, RunQueryDsl};
use egs_api::api::types::asset_info::AssetInfo;
use glib::ObjectExt;
use gtk4::gdk_pixbuf::prelude::PixbufLoaderExt;
use gtk4::gdk_pixbuf::Pixbuf;
use gtk4::gio::prelude::SettingsExt;
use gtk4::{gdk_pix... | the_stack |
use codespan_reporting::diagnostic::{Diagnostic, LabelStyle, Severity};
use codespan_reporting::files::{Files, SimpleFiles};
use codespan_reporting::term;
use codespan_reporting::term::termcolor::{BufferWriter, ColorChoice};
use fathom::lang::FileId;
use fathom::pass::{core_to_pretty, core_to_surface, surface_to_core, ... | the_stack |
use std::collections::HashSet;
use proc_macro2::{Span, TokenStream};
use quote::quote;
use crate::attr::{
ensure_no_field_attrs, ContainerAttrs, EnumVariantAttrs, FieldAttrs, TypeDefault,
};
use crate::bound::{where_clause_with_bound, with_lifetime_bound};
pub fn derive_deserialize(input: &mut syn::DeriveInput) ... | the_stack |
use super::path_index::*;
use crate::path::*;
use crate::region::*;
use flo_curves::*;
use flo_curves::bezier::path::*;
use flo_canvas::*;
use itertools::*;
use std::cmp::{Ordering};
use std::sync::*;
use std::time::{Duration};
use std::collections::{HashMap};
///
/// Represents the bounding box of a possibly over... | the_stack |
use std::collections::{HashMap, VecDeque};
use std::net::SocketAddr;
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use bytes::BytesMut;
use futures::task::{Context, Poll, Waker};
use futures::{Future, Stream};
use tokio::io::{AsyncRead, AsyncWrite};
use tokio::net::TcpStream;
use tokio_uti... | 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 und... | the_stack |
use std::sync::Arc;
// pbrt
use crate::core::camera::Camera;
use crate::core::geometry::{vec3_abs_dot_nrmf, vec3_dot_nrmf};
use crate::core::geometry::{Bounds2i, Normal3f, Ray, RayDifferential, Vector3f};
use crate::core::interaction::{Interaction, InteractionCommon, SurfaceInteraction};
use crate::core::light::Visibil... | the_stack |
use std::collections::BinaryHeap;
use crate::constants::Weight;
use crate::constants::{NodeId, INVALID_NODE, WEIGHT_MAX, WEIGHT_ZERO};
use crate::heap_item::HeapItem;
use crate::preparation_graph::PreparationGraph;
use crate::valid_flags::ValidFlags;
pub struct WitnessSearch {
num_nodes: usize,
data: Vec<Data... | the_stack |
use std::{
any::type_name,
borrow::Cow,
collections::HashMap,
convert::AsRef,
env::{current_dir, var},
error::Error,
fmt::{self, Debug, Write as fmtWrite},
fs::{self, create_dir_all, read_to_string, File},
hash::Hash,
io::{self, Write},
marker::PhantomData,
path::{Path, P... | the_stack |
use std::borrow::Cow;
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote};
use syn::{
parse::{Parse, ParseStream},
DeriveInput, Ident, LitStr, Token,
};
use crate::event_parse::{EventKind, EventKindVariation};
mod kw {
// This `content` field is kept when the event is redacted.
syn... | the_stack |
////////////////////////////////////////////////////////////////////////////////
// WARNING: This file is auto-generated from Open Data Fabric Schemas
// See: http://opendatafabric.org/
////////////////////////////////////////////////////////////////////////////////
#![allow(unused_variables)]
use super::odf_generated... | the_stack |
use crate::{
date,
event_instance::EventInstance,
shared::entity::{Entity, ID},
timespan::TimeSpan,
CompatibleInstances, Meta, Metadata,
};
use chrono::{prelude::*, Duration};
use chrono_tz::Tz;
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, str::FromStr};
#[derive(Debug, Clon... | the_stack |
#![allow(dead_code)]
use crate::cx_apple::*;
use crate::*;
use std::collections::HashMap;
use std::convert::TryInto;
use std::os::raw::c_void;
use std::path::Path;
use std::time::{Duration, Instant};
//use core_graphics::display::CGDisplay;
//use time::precise_time_ns;
const NSVIEW_CLASS_NAME: &str = "RenderViewClass... | the_stack |
mod idt;
use super::qlib::addr::*;
use super::task::*;
use super::qlib::common::*;
use super::qlib::linux_def::*;
use super::threadmgr::task_sched::*;
use super::SignalDef::*;
use super::MainRun;
use super::asm::*;
use super::qlib::perf_tunning::*;
use super::SHARESPACE;
use super::qlib::singleton::*;
#[derive(Clone,... | the_stack |
use crate::commands::{EndpointCommand, SpecCommand};
use crate::events::HttpInteraction;
use crate::projections::endpoint::{Edge, EndpointProjection, Node, ROOT_PATH_ID};
use crate::projections::endpoint::{
QueryParametersDescriptor, RequestDescriptor, ResponseBodyDescriptor,
};
use crate::state::endpoint::{
HttpMe... | the_stack |
use futures::{SinkExt, StreamExt};
use log::{debug, trace};
use std::{cmp::Ordering, io};
use tokio::io::{AsyncRead, AsyncWrite};
use tokio_util::codec::length_delimited::Builder;
use crate::{
codec::{secure_stream::SecureStream, Hmac},
crypto::{cipher::CipherType, new_stream, BoxStreamCipher, CryptoMode},
... | the_stack |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.