text stringlengths 8 4.13M |
|---|
// Copyright © 2018 winapi-rs developers
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// All files in the project carrying such notice may not be copied, modified, or distributed
// except according to those terms.
// #include <winapifamily.h>
use shared::basetsd::DWORD64;
use shared::in6addr::IN6_ADDR;
use shared::minwindef::DWORD;
use shared::ntdef::{LARGE_INTEGER, UCHAR, ULONGLONG};
pub const TCPIP_OWNING_MODULE_SIZE: usize = 16;
const ANY_SIZE: usize = 1;
ENUM!{enum MIB_TCP_STATE {
MIB_TCP_STATE_CLOSED = 1,
MIB_TCP_STATE_LISTEN = 2,
MIB_TCP_STATE_SYN_SENT = 3,
MIB_TCP_STATE_SYN_RCVD = 4,
MIB_TCP_STATE_ESTAB = 5,
MIB_TCP_STATE_FIN_WAIT1 = 6,
MIB_TCP_STATE_FIN_WAIT2 = 7,
MIB_TCP_STATE_CLOSE_WAIT = 8,
MIB_TCP_STATE_CLOSING = 9,
MIB_TCP_STATE_LAST_ACK = 10,
MIB_TCP_STATE_TIME_WAIT = 11,
MIB_TCP_STATE_DELETE_TCB = 12,
MIB_TCP_STATE_RESERVED = 100,
}}
ENUM!{enum TCP_CONNECTION_OFFLOAD_STATE {
TcpConnectionOffloadStateInHost,
TcpConnectionOffloadStateOffloading,
TcpConnectionOffloadStateOffloaded,
TcpConnectionOffloadStateUploading,
TcpConnectionOffloadStateMax,
}}
pub type PTCP_CONNECTION_OFFLOAD_STATE = *mut TCP_CONNECTION_OFFLOAD_STATE;
STRUCT!{struct MIB_TCPROW_LH {
State: MIB_TCP_STATE,
dwLocalAddr: DWORD,
dwLocalPort: DWORD,
dwRemoteAddr: DWORD,
dwRemotePort: DWORD,
}}
pub type PMIB_TCPROW_LH = *mut MIB_TCPROW_LH;
STRUCT!{struct MIB_TCPROW_W2K {
dwState: DWORD,
dwLocalAddr: DWORD,
dwLocalPort: DWORD,
dwRemoteAddr: DWORD,
dwRemotePort: DWORD,
}}
pub type PMIB_TCPROW_W2K = *mut MIB_TCPROW_W2K;
// Windows Vista
// pub type MIB_TCPROW = MIB_TCPROW_LH;
pub type MIB_TCPROW = MIB_TCPROW_W2K;
pub type PMIB_TCPROW = *mut MIB_TCPROW;
STRUCT!{struct MIB_TCPTABLE {
dwNumEntries: DWORD,
table: [MIB_TCPROW; ANY_SIZE],
}}
pub type PMIB_TCPTABLE = *mut MIB_TCPTABLE;
STRUCT!{struct MIB_TCPROW2 {
dwState: DWORD,
dwLocalAddr: DWORD,
dwLocalPort: DWORD,
dwRemoteAddr: DWORD,
dwRemotePort: DWORD,
dwOwningPid: DWORD,
dwOffloadState: TCP_CONNECTION_OFFLOAD_STATE,
}}
pub type PMIB_TCPROW2 = *mut MIB_TCPROW2;
STRUCT!{struct MIB_TCPTABLE2 {
dwNumEntries: DWORD,
table: [MIB_TCPROW2; ANY_SIZE],
}}
pub type PMIB_TCPTABLE2 = *mut MIB_TCPTABLE2;
STRUCT!{struct MIB_TCPROW_OWNER_PID {
dwState: DWORD,
dwLocalAddr: DWORD,
dwLocalPort: DWORD,
dwRemoteAddr: DWORD,
dwRemotePort: DWORD,
dwOwningPid: DWORD,
}}
pub type PMIB_TCPROW_OWNER_PID = *mut MIB_TCPROW_OWNER_PID;
STRUCT!{struct MIB_TCPTABLE_OWNER_PID {
dwNumEntries: DWORD,
table: [MIB_TCPROW_OWNER_PID; ANY_SIZE],
}}
pub type PMIB_TCPTABLE_OWNER_PID = *mut MIB_TCPTABLE_OWNER_PID;
STRUCT!{struct MIB_TCPROW_OWNER_MODULE {
dwState: DWORD,
dwLocalAddr: DWORD,
dwLocalPort: DWORD,
dwRemoteAddr: DWORD,
dwRemotePort: DWORD,
dwOwningPid: DWORD,
liCreateTimestamp: LARGE_INTEGER,
OwningModuleInfo: [ULONGLONG; TCPIP_OWNING_MODULE_SIZE],
}}
pub type PMIB_TCPROW_OWNER_MODULE = *mut MIB_TCPROW_OWNER_MODULE;
STRUCT!{struct MIB_TCPTABLE_OWNER_MODULE {
dwNumEntries: DWORD,
table: [MIB_TCPROW_OWNER_MODULE; ANY_SIZE],
}}
pub type PMIB_TCPTABLE_OWNER_MODULE = *mut MIB_TCPTABLE_OWNER_MODULE;
STRUCT!{struct MIB_TCP6ROW {
State: MIB_TCP_STATE,
LocalAddr: IN6_ADDR,
dwLocalScopeId: DWORD,
dwLocalPort: DWORD,
RemoteAddr: IN6_ADDR,
dwRemoteScopeId: DWORD,
dwRemotePort: DWORD,
}}
pub type PMIB_TCP6ROW = *mut MIB_TCP6ROW;
STRUCT!{struct MIB_TCP6TABLE {
dwNumEntries: DWORD,
table: [MIB_TCP6ROW; ANY_SIZE],
}}
pub type PMIB_TCP6TABLE = *mut MIB_TCP6TABLE;
STRUCT!{struct MIB_TCP6ROW2 {
LocalAddr: IN6_ADDR,
dwLocalScopeId: DWORD,
dwLocalPort: DWORD,
RemoteAddr: IN6_ADDR,
dwRemoteScopeId: DWORD,
dwRemotePort: DWORD,
State: MIB_TCP_STATE,
dwOwningPid: DWORD,
dwOffloadState: TCP_CONNECTION_OFFLOAD_STATE,
}}
pub type PMIB_TCP6ROW2 = *mut MIB_TCP6ROW2;
STRUCT!{struct MIB_TCP6TABLE2 {
dwNumEntries: DWORD,
table: [MIB_TCP6ROW2; ANY_SIZE],
}}
pub type PMIB_TCP6TABLE2 = *mut MIB_TCP6TABLE2;
STRUCT!{struct MIB_TCP6ROW_OWNER_PID {
ucLocalAddr: [UCHAR; 16],
dwLocalScopeId: DWORD,
dwLocalPort: DWORD,
ucRemoteAddr: [UCHAR; 16],
dwRemoteScopeId: DWORD,
dwRemotePort: DWORD,
dwState: DWORD,
dwOwningPid: DWORD,
}}
pub type PMIB_TCP6ROW_OWNER_PID = *mut MIB_TCP6ROW_OWNER_PID;
// STRUCT!{struct MIB_TCP6TABLE_OWNER_PID {
// dwNumEntries: DWORD,
// // _Field_size_(dwNumEntries)
// table: [MIB_TCP6ROW_OWNER_PID; ANY_SIZE],
// }}
// pub type PMIB_TCP6TABLE_OWNER_PID = *mut MIB_TCP6TABLE_OWNER_PID;
STRUCT!{struct MIB_TCP6ROW_OWNER_MODULE {
ucLocalAddr: [UCHAR; 16],
dwLocalScopeId: DWORD,
dwLocalPort: DWORD,
ucRemoteAddr: [UCHAR; 16],
dwRemoteScopeId: DWORD,
dwRemotePort: DWORD,
dwState: DWORD,
dwOwningPid: DWORD,
liCreateTimestamp: LARGE_INTEGER,
OwningModuleInfo: [ULONGLONG; TCPIP_OWNING_MODULE_SIZE],
}}
pub type PMIB_TCP6ROW_OWNER_MODULE = *mut MIB_TCP6ROW_OWNER_MODULE;
// STRUCT!{struct MIB_TCP6TABLE_OWNER_MODULE {
// dwNumEntries: DWORD,
// // _Field_size_(dwNumEntries)
// table: [MIB_TCP6ROW_OWNER_MODULE; ANY_SIZE],
// }}
// pub type PMIB_TCP6TABLE_OWNER_MODULE = *mut MIB_TCP6TABLE_OWNER_MODULE;
ENUM!{enum TCP_RTO_ALGORITHM {
TcpRtoAlgorithmOther = 1,
TcpRtoAlgorithmConstant,
TcpRtoAlgorithmRsre,
TcpRtoAlgorithmVanj,
MIB_TCP_RTO_OTHER = 1,
MIB_TCP_RTO_CONSTANT = 2,
MIB_TCP_RTO_RSRE = 3,
MIB_TCP_RTO_VANJ = 4,
}}
pub type PTCP_RTO_ALGORITHM = *mut TCP_RTO_ALGORITHM;
STRUCT!{struct MIB_TCPSTATS_LH {
RtoAlgorithm: TCP_RTO_ALGORITHM,
dwRtoMin: DWORD,
dwRtoMax: DWORD,
dwMaxConn: DWORD,
dwActiveOpens: DWORD,
dwPassiveOpens: DWORD,
dwAttemptFails: DWORD,
dwEstabResets: DWORD,
dwCurrEstab: DWORD,
dwInSegs: DWORD,
dwOutSegs: DWORD,
dwRetransSegs: DWORD,
dwInErrs: DWORD,
dwOutRsts: DWORD,
dwNumConns: DWORD,
}}
pub type PMIB_TCPSTATS_LH = *mut MIB_TCPSTATS_LH;
STRUCT!{struct MIB_TCPSTATS_W2K {
dwRtoAlgorithm: DWORD,
dwRtoMin: DWORD,
dwRtoMax: DWORD,
dwMaxConn: DWORD,
dwActiveOpens: DWORD,
dwPassiveOpens: DWORD,
dwAttemptFails: DWORD,
dwEstabResets: DWORD,
dwCurrEstab: DWORD,
dwInSegs: DWORD,
dwOutSegs: DWORD,
dwRetransSegs: DWORD,
dwInErrs: DWORD,
dwOutRsts: DWORD,
dwNumConns: DWORD,
}}
pub type PMIB_TCPSTATS_W2K = *mut MIB_TCPSTATS_W2K;
// Windows Vista
// pub type MIB_TCPSTATS = MIB_TCPSTATS_LH;
pub type MIB_TCPSTATS = MIB_TCPSTATS_W2K;
pub type PMIB_TCPSTATS = *mut MIB_TCPSTATS;
// if NTDDI_VERSION >= NTDDI_WIN10_RS3
STRUCT!{struct MIB_TCPSTATS2 {
RtoAlgorithm: TCP_RTO_ALGORITHM,
dwRtoMin: DWORD,
dwRtoMax: DWORD,
dwMaxConn: DWORD,
dwActiveOpens: DWORD,
dwPassiveOpens: DWORD,
dwAttemptFails: DWORD,
dwEstabResets: DWORD,
dwCurrEstab: DWORD,
dw64InSegs: DWORD64,
dw64OutSegs: DWORD64,
dwRetransSegs: DWORD,
dwInErrs: DWORD,
dwOutRsts: DWORD,
dwNumConns: DWORD,
}}
pub type PMIB_TCPSTATS2 = *mut MIB_TCPSTATS2;
|
use std::sync::Arc;
use json_utils::json::JsValue;
use json_utils::query::Query;
use crate::core::heq::HEq;
use crate::core::property::Property;
use crate::core::property::Value;
use super::JsPath;
use super::JsValueHEq;
impl Property<JsValue, JsValue> for JsPath {
fn id(&self) -> String {
format!("JsPath{:?}", self.path)
}
fn heq(&self) -> Arc<dyn HEq<JsValue>> {
Arc::new(JsValueHEq)
}
fn value<'a>(&self, input: &'a JsValue) -> Value<'a, JsValue> {
input
.lookup(&self.path)
.map(Value::Ref)
.unwrap_or(Value::Val(JsValue::Null))
}
}
|
use crate::ast::*;
use nom::branch::alt;
use nom::bytes::complete::tag;
use nom::bytes::complete::take_while;
use nom::bytes::complete::take_while1;
use nom::combinator::opt;
use nom::multi::many0;
use nom::sequence::tuple;
use nom::IResult;
fn sp(i: &str) -> IResult<&str, &str> {
let chars = " \t\r\n";
take_while(move |c| chars.contains(c))(i)
}
fn int_literal(i: &str) -> IResult<&str, Expression> {
let (i, num) = take_while1(move |c: char| c.is_numeric())(i)?;
Ok((i, Expression::Int(num.parse().unwrap())))
}
fn bool_literal(i: &str) -> IResult<&str, Expression> {
let (i, val) = alt((tag("true"), tag("false")))(i)?;
Ok((i, Expression::Bool(val == "true")))
}
fn literal(i: &str) -> IResult<&str, Expression> {
alt((int_literal, bool_literal))(i)
}
fn parens(i: &str) -> IResult<&str, Expression> {
let (i, (_, _, expr, _, _)) = tuple((tag("("), sp, expression, sp, tag(")")))(i)?;
Ok((i, expr))
}
// fn identifier(i: &str) -> IResult<&str, Expression> {
// let (i, id) = take_while1(move |c: char| c.is_alphanumeric())(i)?;
// Ok((i, Expression::Id(id.to_string())))
// }
fn terminal(i: &str) -> IResult<&str, Expression> {
alt((parens, literal))(i)
}
fn factor(i: &str) -> IResult<&str, Expression> {
let (i, (ops, expr)) = tuple((many0(tuple((alt((tag("-"), tag("!"))), sp))), terminal))(i)?;
Ok((
i,
ops.into_iter().rev().fold(expr, |prev, (op, _)| match op {
"-" => Expression::UnaryOp(UnaryOp::Minus, Box::new(prev)),
"!" => Expression::UnaryOp(UnaryOp::Not, Box::new(prev)),
_ => unreachable!(),
}),
))
}
fn term(i: &str) -> IResult<&str, Expression> {
let (i, (first, remainder)) = tuple((
factor,
many0(tuple((sp, alt((tag("*"), tag("/"))), sp, factor))),
))(i)?;
Ok((
i,
remainder
.into_iter()
.fold(first, |prev, (_, op, _, next)| match op {
"*" => Expression::BinaryOp(BinaryOp::Multiply, Box::new(prev), Box::new(next)),
"/" => Expression::BinaryOp(BinaryOp::Divide, Box::new(prev), Box::new(next)),
_ => unreachable!(),
}),
))
}
fn additive_expr(i: &str) -> IResult<&str, Expression> {
let (i, (first, remainder)) = tuple((
term,
many0(tuple((sp, alt((tag("+"), tag("-"))), sp, term))),
))(i)?;
Ok((
i,
remainder
.into_iter()
.fold(first, |prev, (_, op, _, next)| match op {
"+" => Expression::BinaryOp(BinaryOp::Add, Box::new(prev), Box::new(next)),
"-" => Expression::BinaryOp(BinaryOp::Sub, Box::new(prev), Box::new(next)),
_ => unreachable!(),
}),
))
}
fn relational_expr(i: &str) -> IResult<&str, Expression> {
let (i, (first, remainder)) = tuple((
additive_expr,
many0(tuple((
sp,
alt((tag("<"), tag(">"))),
opt(tag("=")),
sp,
term,
))),
))(i)?;
Ok((
i,
remainder
.into_iter()
.fold(first, |prev, (_, op, eq, _, next)| match (op, eq) {
("<", None) => {
Expression::BinaryOp(BinaryOp::LessThan, Box::new(prev), Box::new(next))
}
("<", Some("=")) => {
Expression::BinaryOp(BinaryOp::LessThanOrEqual, Box::new(prev), Box::new(next))
}
(">", None) => {
Expression::BinaryOp(BinaryOp::GreaterThan, Box::new(prev), Box::new(next))
}
(">", Some("=")) => Expression::BinaryOp(
BinaryOp::GreaterThanOrEqual,
Box::new(prev),
Box::new(next),
),
_ => unreachable!(),
}),
))
}
fn equality_expr(i: &str) -> IResult<&str, Expression> {
let (i, (first, remainder)) = tuple((
relational_expr,
many0(tuple((
sp,
alt((tag("=="), tag("!="))),
sp,
relational_expr,
))),
))(i)?;
Ok((
i,
remainder
.into_iter()
.fold(first, |prev, (_, op, _, next)| match op {
"==" => Expression::BinaryOp(BinaryOp::Equal, Box::new(prev), Box::new(next)),
"!=" => Expression::BinaryOp(BinaryOp::NotEqual, Box::new(prev), Box::new(next)),
_ => unreachable!(),
}),
))
}
fn logical_and_expr(i: &str) -> IResult<&str, Expression> {
let (i, (first, remainder)) = tuple((
equality_expr,
many0(tuple((sp, tag("&&"), sp, equality_expr))),
))(i)?;
Ok((
i,
remainder
.into_iter()
.fold(first, |prev, (_, _op, _, next)| {
Expression::BinaryOp(BinaryOp::And, Box::new(prev), Box::new(next))
}),
))
}
fn logical_or_expr(i: &str) -> IResult<&str, Expression> {
let (i, (first, remainder)) = tuple((
logical_and_expr,
many0(tuple((sp, tag("||"), sp, logical_and_expr))),
))(i)?;
Ok((
i,
remainder
.into_iter()
.fold(first, |prev, (_, _op, _, next)| {
Expression::BinaryOp(BinaryOp::Or, Box::new(prev), Box::new(next))
}),
))
}
fn conditional_expr(i: &str) -> IResult<&str, Expression> {
let (i, (_, _, cond, _, _, _, exp, _, _, _, _, _, _, _, alt, _, _)) = tuple((
tag("if"),
sp,
expression,
sp,
tag("{"),
sp,
expression,
sp,
tag("}"),
sp,
tag("else"),
sp,
tag("{"),
sp,
expression,
sp,
tag("}"),
))(i)?;
Ok((
i,
Expression::Conditional(Box::new(cond), Box::new(exp), Box::new(alt)),
))
}
pub fn expression(i: &str) -> IResult<&str, Expression> {
alt((conditional_expr, logical_or_expr))(i)
}
#[test]
fn expression_test() {
assert_eq!(
relational_expr("1 < 2"),
Ok((
"",
Expression::BinaryOp(
BinaryOp::LessThan,
Box::new(Expression::Int(1)),
Box::new(Expression::Int(2))
)
))
);
assert_eq!(
relational_expr("1 <= 2"),
Ok((
"",
Expression::BinaryOp(
BinaryOp::LessThanOrEqual,
Box::new(Expression::Int(1)),
Box::new(Expression::Int(2))
)
))
);
assert_eq!(
relational_expr("1 + 1 <= 2"),
Ok((
"",
Expression::BinaryOp(
BinaryOp::LessThanOrEqual,
Box::new(Expression::BinaryOp(
BinaryOp::Add,
Box::new(Expression::Int(1)),
Box::new(Expression::Int(1))
)),
Box::new(Expression::Int(2))
)
))
);
assert_eq!(
relational_expr("1 + -1 <= 2"),
Ok((
"",
Expression::BinaryOp(
BinaryOp::LessThanOrEqual,
Box::new(Expression::BinaryOp(
BinaryOp::Add,
Box::new(Expression::Int(1)),
Box::new(Expression::UnaryOp(
UnaryOp::Minus,
Box::new(Expression::Int(1))
))
)),
Box::new(Expression::Int(2))
)
))
);
}
|
// Copyright 2022 Datafuse Labs.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use common_exception::Result;
use common_expression::types::DataType;
use common_expression::Scalar;
use crate::binder::split_conjunctions;
use crate::optimizer::rule::Rule;
use crate::optimizer::rule::TransformResult;
use crate::optimizer::RuleID;
use crate::optimizer::SExpr;
use crate::plans::AndExpr;
use crate::plans::ConstantExpr;
use crate::plans::Filter;
use crate::plans::OrExpr;
use crate::plans::PatternPlan;
use crate::plans::RelOp;
use crate::plans::ScalarExpr;
#[derive(Clone, PartialEq, Debug)]
enum PredicateScalar {
And { args: Vec<PredicateScalar> },
Or { args: Vec<PredicateScalar> },
Other { expr: Box<ScalarExpr> },
}
fn predicate_scalar(scalar: &ScalarExpr) -> PredicateScalar {
match scalar {
ScalarExpr::AndExpr(and_expr) => {
let args = vec![
predicate_scalar(&and_expr.left),
predicate_scalar(&and_expr.right),
];
PredicateScalar::And { args }
}
ScalarExpr::OrExpr(or_expr) => {
let args = vec![
predicate_scalar(&or_expr.left),
predicate_scalar(&or_expr.right),
];
PredicateScalar::Or { args }
}
_ => PredicateScalar::Other {
expr: Box::from(scalar.clone()),
},
}
}
fn normalize_predicate_scalar(
predicate_scalar: PredicateScalar,
return_type: DataType,
) -> ScalarExpr {
match predicate_scalar {
PredicateScalar::And { args } => {
assert!(args.len() >= 2);
args.into_iter()
.map(|arg| normalize_predicate_scalar(arg, return_type.clone()))
.reduce(|lhs, rhs| {
ScalarExpr::AndExpr(AndExpr {
left: Box::from(lhs),
right: Box::from(rhs),
})
})
.expect("has at least two args")
}
PredicateScalar::Or { args } => {
assert!(args.len() >= 2);
args.into_iter()
.map(|arg| normalize_predicate_scalar(arg, return_type.clone()))
.reduce(|lhs, rhs| {
ScalarExpr::OrExpr(OrExpr {
left: Box::from(lhs),
right: Box::from(rhs),
})
})
.expect("has at least two args")
}
PredicateScalar::Other { expr } => *expr,
}
}
// The rule tries to apply the inverse OR distributive law to the predicate.
// ((A AND B) OR (A AND C)) => (A AND (B OR C))
// It'll find all OR expressions and extract the common terms.
pub struct RuleNormalizeDisjunctiveFilter {
id: RuleID,
pattern: SExpr,
}
impl RuleNormalizeDisjunctiveFilter {
pub fn new() -> Self {
Self {
id: RuleID::NormalizeDisjunctiveFilter,
// Filter
// \
// *
pattern: SExpr::create_unary(
PatternPlan {
plan_type: RelOp::Filter,
}
.into(),
SExpr::create_leaf(
PatternPlan {
plan_type: RelOp::Pattern,
}
.into(),
),
),
}
}
}
impl Rule for RuleNormalizeDisjunctiveFilter {
fn id(&self) -> RuleID {
self.id
}
fn apply(&self, s_expr: &SExpr, state: &mut TransformResult) -> Result<()> {
let filter: Filter = s_expr.plan().clone().try_into()?;
let predicates = filter.predicates;
let mut rewritten_predicates = Vec::with_capacity(predicates.len());
let mut rewritten = false;
for predicate in predicates.iter() {
let predicate_scalar = predicate_scalar(predicate);
let (rewritten_predicate_scalar, has_rewritten) =
rewrite_predicate_ors(predicate_scalar);
if has_rewritten {
rewritten = true;
}
rewritten_predicates.push(normalize_predicate_scalar(
rewritten_predicate_scalar,
predicate.data_type()?,
));
}
let mut split_predicates: Vec<ScalarExpr> = Vec::with_capacity(rewritten_predicates.len());
for predicate in rewritten_predicates.iter() {
split_predicates.extend_from_slice(&split_conjunctions(predicate));
}
if rewritten {
state.add_result(SExpr::create_unary(
Filter {
predicates: split_predicates,
is_having: filter.is_having,
}
.into(),
s_expr.child(0)?.clone(),
));
}
Ok(())
}
fn pattern(&self) -> &SExpr {
&self.pattern
}
}
fn rewrite_predicate_ors(predicate: PredicateScalar) -> (PredicateScalar, bool) {
match predicate {
PredicateScalar::Or { args } => {
let mut or_args = Vec::with_capacity(args.len());
for arg in args.iter() {
or_args.push(rewrite_predicate_ors(arg.clone()).0);
}
or_args = flatten_ors(or_args);
process_duplicate_or_exprs(&or_args)
}
PredicateScalar::And { args } => {
let mut and_args = Vec::with_capacity(args.len());
for arg in args.iter() {
and_args.push(rewrite_predicate_ors(arg.clone()).0);
}
and_args = flatten_ands(and_args);
(PredicateScalar::And { args: and_args }, false)
}
PredicateScalar::Other { .. } => (predicate, false),
}
}
// Recursively flatten the OR expressions.
fn flatten_ors(or_args: impl IntoIterator<Item = PredicateScalar>) -> Vec<PredicateScalar> {
let mut flattened_ors = vec![];
for or_arg in or_args {
match or_arg {
PredicateScalar::Or { args } => flattened_ors.extend(flatten_ors(args)),
_ => flattened_ors.push(or_arg),
}
}
flattened_ors
}
// Recursively flatten the AND expressions.
fn flatten_ands(and_args: impl IntoIterator<Item = PredicateScalar>) -> Vec<PredicateScalar> {
let mut flattened_ands = vec![];
for and_arg in and_args {
match and_arg {
PredicateScalar::And { args } => flattened_ands.extend(flatten_ands(args)),
_ => flattened_ands.push(and_arg),
}
}
flattened_ands
}
// Apply the inverse OR distributive law.
fn process_duplicate_or_exprs(or_args: &[PredicateScalar]) -> (PredicateScalar, bool) {
let mut shortest_exprs: Vec<PredicateScalar> = vec![];
let mut shortest_exprs_len = 0;
if or_args.is_empty() {
return (
PredicateScalar::Other {
expr: Box::from(ScalarExpr::ConstantExpr(ConstantExpr {
span: None,
value: Scalar::Boolean(false),
})),
},
false,
);
}
if or_args.len() == 1 {
return (or_args[0].clone(), false);
}
// choose the shortest AND expression
for or_arg in or_args.iter() {
match or_arg {
PredicateScalar::And { args } => {
let args_num = args.len();
if shortest_exprs.is_empty() || args_num < shortest_exprs_len {
shortest_exprs = (*args).clone();
shortest_exprs_len = args_num;
}
}
_ => {
// if there is no AND expression, it must be the shortest expression.
shortest_exprs = vec![or_arg.clone()];
break;
}
}
}
// dedup shortest_exprs
shortest_exprs.dedup();
// Check each element in shortest_exprs to see if it's in all the OR arguments.
let mut exist_exprs: Vec<PredicateScalar> = vec![];
for expr in shortest_exprs.iter() {
let found = or_args.iter().all(|or_arg| match or_arg {
PredicateScalar::And { args } => args.contains(expr),
_ => or_arg == expr,
});
if found {
exist_exprs.push((*expr).clone());
}
}
if exist_exprs.is_empty() {
return (
PredicateScalar::Or {
args: or_args.to_vec(),
},
false,
);
}
// Rebuild the OR predicate.
// (A AND B) OR A will be optimized to A.
let mut new_or_args = vec![];
for or_arg in or_args.iter() {
match or_arg {
PredicateScalar::And { args } => {
let mut new_args = (*args).clone();
new_args.retain(|expr| !exist_exprs.contains(expr));
if !new_args.is_empty() {
if new_args.len() == 1 {
new_or_args.push(new_args[0].clone());
} else {
new_or_args.push(PredicateScalar::And { args: new_args });
}
} else {
new_or_args.clear();
break;
}
}
_ => {
if exist_exprs.contains(or_arg) {
new_or_args.clear();
break;
}
}
}
}
if !new_or_args.is_empty() {
if new_or_args.len() == 1 {
exist_exprs.push(new_or_args[0].clone());
} else {
exist_exprs.push(PredicateScalar::Or {
args: flatten_ors(new_or_args),
});
}
}
if exist_exprs.len() == 1 {
(exist_exprs[0].clone(), true)
} else {
(
PredicateScalar::And {
args: flatten_ands(exist_exprs),
},
true,
)
}
}
|
use crate::smb2::{
header,
requests::{self, query_info::InfoType},
};
pub const DEFAULT_BUFFER_LENGTH: &[u8; 4] = b"\xff\xff\x00\x00";
/// Builds a working default query info request.
pub fn build_default_query_info_request(
tree_id: Vec<u8>,
session_id: Vec<u8>,
file_id: Vec<u8>,
) -> (
Option<header::SyncHeader>,
Option<requests::query_info::QueryInfo>,
) {
(
Some(super::build_sync_header(
header::Commands::QueryInfo,
1,
7936,
Some(tree_id),
Some(session_id),
5,
)),
Some(build_default_query_info_request_body(file_id)),
)
}
/// Builds a working default query info request body.
pub fn build_default_query_info_request_body(file_id: Vec<u8>) -> requests::query_info::QueryInfo {
let mut query_info = requests::query_info::QueryInfo::default();
query_info.info_type = InfoType::File.unpack_byte_code();
query_info.output_buffer_length = DEFAULT_BUFFER_LENGTH.to_vec();
query_info.flags = vec![0; 4];
query_info.file_id = file_id;
query_info.buffer = vec![0];
query_info
}
|
use std::io;
#[derive(Debug, Clone, Copy)]
enum Instruction {
Noop,
Addx(i64),
}
impl Instruction {
fn num_cycles(self) -> u64 {
match self {
Instruction::Noop => 1,
Instruction::Addx(_) => 2,
}
}
}
#[derive(Debug)]
struct Cpu {
reg_x: i64,
}
impl Default for Cpu {
fn default() -> Self {
Self { reg_x: 1 }
}
}
fn parse_line(line: &str) -> nom::IResult<&str, Instruction> {
use nom::{
branch::alt,
bytes::complete::tag,
character::complete::digit1,
combinator::{map, map_res, opt, recognize},
sequence::{preceded, tuple},
};
alt((
map(tag("noop"), |_| Instruction::Noop),
map(
preceded(
tag("addx "),
map_res(recognize(tuple((opt(tag("-")), digit1))), str::parse),
),
Instruction::Addx,
),
))(line)
}
fn main() -> io::Result<()> {
itertools::process_results(io::stdin().lines(), |lines| {
let mut cpu = Cpu::default();
let mut pos = 0;
for line in lines {
let (remaining, inst) = parse_line(&line)
.map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "invalid instruction"))?;
assert_eq!("", remaining);
for _ in 0..inst.num_cycles() {
if (cpu.reg_x - 1..=cpu.reg_x + 1).contains(&pos) {
print!("#");
} else {
print!(".");
}
pos += 1;
if pos % 40 == 0 {
println!();
pos = 0;
}
}
match inst {
Instruction::Noop => {}
Instruction::Addx(signal) => cpu.reg_x += signal,
}
}
Ok::<_, io::Error>(())
})??;
Ok(())
}
|
pub struct Solution;
impl Solution {
pub fn is_anagram(s: String, t: String) -> bool {
let mut cnt = vec![0i32; 26];
for c in s.chars() {
cnt[c as usize - 'a' as usize] += 1;
}
for c in t.chars() {
cnt[c as usize - 'a' as usize] -= 1;
}
cnt.iter().all(|&n| n == 0)
}
}
#[test]
fn test0242() {
fn case(s: &str, t: &str, want: bool) {
let got = Solution::is_anagram(s.to_string(), t.to_string());
assert_eq!(got, want);
}
case("anagram", "nagaram", true);
case("rat", "car", false);
}
|
use crate::{
bed::{BedDataLine, Chrom, Coordinate},
bedgraph::BedGraphDataLine,
traits::ToChromStartEndVal,
};
impl<V: Clone> ToChromStartEndVal<V> for BedDataLine<V> {
fn to_chrom_start_end_val(
&self,
) -> (Chrom, Coordinate, Coordinate, Option<V>) {
(self.chrom.clone(), self.start, self.end, self.score.clone())
}
}
impl<V: Clone> ToChromStartEndVal<V> for BedGraphDataLine<V> {
fn to_chrom_start_end_val(
&self,
) -> (Chrom, Coordinate, Coordinate, Option<V>) {
(
self.chrom.clone(),
self.start,
self.end_exclusive,
Some(self.value.clone()),
)
}
}
#[cfg(test)]
mod tests {
use crate::{bed::BedDataLine, traits::ToChromStartEndVal};
#[test]
fn test_bed_data_line_to_chorm_start_end_val() {
macro_rules! test_data_line {
($chrom:expr, $start:expr, $end:expr, $score:expr) => {
let data_line = BedDataLine {
chrom: $chrom.to_string(),
start: $start,
end: $end,
name: None,
score: $score,
strand: None,
};
let (chrom, start, end, val) =
data_line.to_chrom_start_end_val();
assert_eq!(&chrom, $chrom);
assert_eq!(start, $start);
assert_eq!(end, $end);
assert_eq!($score, $score);
};
}
test_data_line!("chr1", 2, 10, None::<i32>);
test_data_line!("chrX", 200, 201, Some(19i32));
test_data_line!("chrY", 100, 4000, Some(-2i32));
}
}
|
use std::io;
use std::fs::File;
use std::os::unix::io::{RawFd, FromRawFd, IntoRawFd, AsRawFd};
use mio::{Evented, Poll, Token, Ready, PollOpt};
use mio::unix::EventedFd;
pub struct EventedIo<T> {
inner: T,
}
impl<T> EventedIo<T>
where
T: io::Read + io::Write + AsRawFd,
{
pub fn new(inner: T) -> Self {
EventedIo {
inner: inner,
}
}
pub fn into_inner(self) -> T {
self.inner
}
}
impl<T> Evented for EventedIo<T>
where
T: AsRawFd,
{
fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt)
-> io::Result<()>
{
EventedFd(&self.inner.as_raw_fd()).register(poll, token, interest, opts)
}
fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt)
-> io::Result<()>
{
EventedFd(&self.inner.as_raw_fd()).reregister(poll, token, interest, opts)
}
fn deregister(&self, poll: &Poll) -> io::Result<()> {
EventedFd(&self.inner.as_raw_fd()).deregister(poll)
}
}
impl<T> io::Read for EventedIo<T>
where
T: io::Read,
{
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.inner.read(buf)
}
}
impl<T> io::Write for EventedIo<T>
where
T: io::Write,
{
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.inner.write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.inner.flush()
}
}
impl<T> IntoRawFd for EventedIo<T>
where
T: io::Read + io::Write + AsRawFd + IntoRawFd,
{
fn into_raw_fd(self) -> RawFd {
self.into_inner().into_raw_fd()
}
}
impl<T> AsRawFd for EventedIo<T>
where
T: io::Read + io::Write + AsRawFd + IntoRawFd,
{
fn as_raw_fd(&self) -> RawFd {
self.inner.as_raw_fd()
}
}
pub type EventedFile = EventedIo<File>;
impl FromRawFd for EventedFile {
unsafe fn from_raw_fd(fd: RawFd) -> Self {
EventedFile {
inner: File::from_raw_fd(fd),
}
}
}
|
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize)]
pub struct Budget {
pub budget_id: Option<i64>,
pub owner: Option<String>,
pub name: String,
pub spend_limit: f64,
pub period_length: i64,
pub start_date: String
}
impl Budget {
pub fn new(name: String, spend_limit: f64, period_length: i64, start_date: String) -> Budget {
Budget {
budget_id: None,
owner: None,
name,
spend_limit,
period_length,
start_date
}
}
} |
use liblumen_alloc::erts::term::prelude::Term;
/// Distribution is not supported at this time. Always returns `false`.
#[native_implemented::function(erlang:is_alive/0)]
pub fn result() -> Term {
false.into()
}
|
extern crate fixedbitset;
#[macro_use]
extern crate itertools;
extern crate pest;
#[macro_use]
extern crate pest_derive;
extern crate structopt;
mod parser;
mod pass;
mod puzzle;
use std::io;
use std::io::BufRead;
use parser::NonoParser;
use parser::Rule;
use pass::ContinuousRangeHint;
use pass::ContinuousRangePass;
use pass::CrowdedClue;
use pass::CrowdedCluePass;
use pass::DiscreteRangeHint;
use pass::DiscreteRangePass;
use pest::Parser;
use puzzle::Axis;
use puzzle::LineMut;
use puzzle::LinePassExt;
use puzzle::Theme;
use structopt::StructOpt;
#[derive(StructOpt)]
#[structopt(name = "nono")]
/// A nonogram hint dispenser
///
/// Available display themes: ascii, unicode, brief
struct Opt {
/// Select display theme
#[structopt(short = "t", long = "theme", default_value = "unicode")]
theme: Theme,
}
#[derive(Debug)]
enum Hint {
CrowdedClue(CrowdedClue),
ContinuousRange(ContinuousRangeHint),
DiscreteRange(DiscreteRangeHint),
}
use puzzle::Line;
impl puzzle::LineHint for Hint {
fn check(&self, line: &Line) -> bool {
match self {
Hint::CrowdedClue(inner) => inner.check(line),
Hint::ContinuousRange(inner) => inner.check(line),
Hint::DiscreteRange(inner) => inner.check(line),
}
}
fn apply(&self, line: &mut LineMut) {
match self {
Hint::CrowdedClue(inner) => inner.apply(line),
Hint::ContinuousRange(inner) => inner.apply(line),
Hint::DiscreteRange(inner) => inner.apply(line),
}
}
}
#[derive(Debug)]
enum Pass {
CrowdedClue(CrowdedCluePass),
ContinuousRange(ContinuousRangePass),
DiscreteRange(DiscreteRangePass),
}
impl puzzle::LinePass for Pass {
type Hint = Hint;
fn run(&self, clue: &[usize], line: &Line) -> Vec<Box<Self::Hint>> {
match self {
Pass::CrowdedClue(inner) => inner
.run(clue, line)
.into_iter()
.map(|hint| Box::new(Hint::CrowdedClue(*hint)))
.collect(),
Pass::ContinuousRange(inner) => inner
.run(clue, line)
.into_iter()
.map(|hint| Box::new(Hint::ContinuousRange(*hint)))
.collect(),
Pass::DiscreteRange(inner) => inner
.run(clue, line)
.into_iter()
.map(|hint| Box::new(Hint::DiscreteRange(*hint)))
.collect(),
}
}
}
struct Solver<'a> {
cur_p: usize,
cur_a: usize,
fail_count: usize,
passes: &'a [Pass],
}
impl<'a> Solver<'a> {
fn new(passes: &'a [Pass]) -> Self {
Solver {
cur_p: 0,
cur_a: 0,
fail_count: 0,
passes,
}
}
fn initial(&mut self) -> (&'a Pass, Axis) {
(&self.passes[self.cur_p], Axis::get(self.cur_a).unwrap())
}
fn succeeded(&mut self) -> Option<(&'a Pass, Axis)> {
self.fail_count = 0;
let last_p = self.cur_p;
if self.cur_p > 1 {
self.cur_p = 1;
self.next(last_p)
} else {
self.next(last_p)
}
}
fn failed(&mut self) -> Option<(&'a Pass, Axis)> {
self.fail_count += 1;
let last_p = self.cur_p;
self.next(last_p)
}
fn next(&mut self, last_p: usize) -> Option<(&'a Pass, Axis)> {
if self.fail_count >= 2 {
self.cur_p += 1;
self.fail_count = 0;
}
self.cur_a = 1 - self.cur_a;
if self.cur_a == 0 {
if let Some(Pass::CrowdedClue(_)) = self.passes.get(last_p) {
self.cur_p = 1;
}
}
if let Some(pass) = self.passes.get(self.cur_p) {
return Some((pass, Axis::get(self.cur_a).unwrap()));
} else {
None
}
}
}
fn main() {
let opt = Opt::from_args();
let stdin = io::stdin();
let passes: [Pass; 3] = [
Pass::CrowdedClue(CrowdedCluePass),
Pass::ContinuousRange(ContinuousRangePass),
Pass::DiscreteRange(DiscreteRangePass),
];
for line in stdin.lock().lines() {
let line = line.unwrap();
let ast = NonoParser::parse(Rule::puzzle, &line)
.unwrap_or_else(|e| panic!("{}", e))
.next()
.map(parser::Puzzle::from)
.unwrap();
match puzzle::Puzzle::try_from_ast(ast) {
Ok(mut puzzle) => {
let mut solver = Solver::new(&passes);
println!("{}", opt.theme.view(&puzzle));
let mut next_pass = Some(solver.initial());
let mut pass_counter = 0;
while let Some((pass, axis)) = next_pass {
if puzzle.is_complete() {
break;
}
pass_counter += 1;
let hints = pass.run_puzzle(&axis, &puzzle);
for hint in &hints {
hint.apply(&mut puzzle);
}
if opt.theme != Theme::Brief {
println!("{:?} {:?} ({})", pass, axis, pass_counter);
for hint in &hints {
println!("{:?}", hint);
}
}
if !hints.is_empty() {
println!("{}", opt.theme.view(&puzzle));
}
next_pass = if hints.is_empty() {
solver.failed()
} else {
solver.succeeded()
};
}
}
Err(e) => panic!("{}", e),
}
}
}
|
#![cfg_attr(
not(any(
feature = "vulkan",
feature = "gl",
feature = "dx11",
feature = "dx12",
feature = "metal",
)),
allow(dead_code, unused_extern_crates, unused_imports)
)]
#[cfg(feature = "dx11")]
extern crate gfx_backend_dx11 as back;
#[cfg(feature = "dx12")]
extern crate gfx_backend_dx12 as back;
#[cfg(not(any(
feature = "vulkan",
feature = "gl",
feature = "dx11",
feature = "dx12",
feature = "metal",
)))]
extern crate gfx_backend_empty as back;
#[cfg(feature = "gl")]
extern crate gfx_backend_gl as back;
#[cfg(feature = "metal")]
extern crate gfx_backend_metal as back;
#[cfg(feature = "vulkan")]
extern crate gfx_backend_vulkan as back;
use std::{iter, slice};
use hal::{command as com, image as i, prelude::*};
// AMD chokes on larger region counts...
const SIZE: u32 = 512;
// when 1, we use one-time-submit commands
const RUNS: usize = 2;
const FORMAT: hal::format::Format = hal::format::Format::Rgba8Unorm;
fn main() {
env_logger::init();
let instance =
back::Instance::create("gfx-rs bench", 1).expect("Failed to create an instance!");
let adapter = instance.enumerate_adapters().remove(0);
println!("Running on {}", adapter.info.name);
let memory_properties = adapter.physical_device.memory_properties();
let limits = adapter.physical_device.properties().limits;
let family = adapter
.queue_families
.iter()
.find(|family| family.queue_type().supports_compute())
.unwrap();
unsafe {
let mut gpu = adapter
.physical_device
.open(&[(family, &[1.0])], hal::Features::empty())
.unwrap();
let device = &gpu.device;
let queue_group = gpu.queue_groups.first_mut().unwrap();
// source image
let mut src_image = device
.create_image(
i::Kind::D2(1, 1, 1, 1),
1,
FORMAT,
i::Tiling::Optimal,
i::Usage::TRANSFER_SRC | i::Usage::TRANSFER_DST,
hal::memory::SparseFlags::empty(),
i::ViewCapabilities::empty(),
)
.unwrap();
let src_image_requirements = device.get_image_requirements(&src_image);
let src_image_type = memory_properties
.memory_types
.iter()
.enumerate()
.position(|(id, memory_type)| {
src_image_requirements.type_mask & (1 << id) != 0
&& memory_type
.properties
.contains(hal::memory::Properties::DEVICE_LOCAL)
})
.unwrap()
.into();
let src_memory_image = device
.allocate_memory(src_image_type, src_image_requirements.size)
.unwrap();
device
.bind_image_memory(&src_memory_image, 0, &mut src_image)
.unwrap();
// source buffer
let bytes_per_texel = FORMAT.surface_desc().bits / 8;
let buffer_size = (bytes_per_texel as u64).max(limits.non_coherent_atom_size as u64);
let mut src_buffer = device
.create_buffer(
buffer_size,
hal::buffer::Usage::TRANSFER_SRC,
hal::memory::SparseFlags::empty(),
)
.unwrap();
let src_buffer_requirements = device.get_buffer_requirements(&src_buffer);
let src_buffer_type = memory_properties
.memory_types
.iter()
.enumerate()
.position(|(id, memory_type)| {
src_buffer_requirements.type_mask & (1 << id) != 0
&& memory_type
.properties
.contains(hal::memory::Properties::CPU_VISIBLE)
})
.unwrap()
.into();
let mut src_memory_buffer = device
.allocate_memory(src_buffer_type, src_buffer_requirements.size)
.unwrap();
device
.bind_buffer_memory(&src_memory_buffer, 0, &mut src_buffer)
.unwrap();
let ptr = device
.map_memory(&mut src_memory_buffer, hal::memory::Segment::default())
.unwrap();
*(ptr as *mut u32) = 1;
device
.flush_mapped_memory_ranges(iter::once((
&src_memory_buffer,
hal::memory::Segment::default(),
)))
.unwrap();
device.unmap_memory(&mut src_memory_buffer);
// destination image
let mut dst_image = device
.create_image(
i::Kind::D2(SIZE, SIZE, 1, 1),
1,
FORMAT,
i::Tiling::Optimal,
i::Usage::TRANSFER_DST,
hal::memory::SparseFlags::empty(),
i::ViewCapabilities::empty(),
)
.unwrap();
let dst_requirements = device.get_image_requirements(&dst_image);
let dst_type = memory_properties
.memory_types
.iter()
.enumerate()
.position(|(id, memory_type)| {
dst_requirements.type_mask & (1 << id) != 0
&& memory_type
.properties
.contains(hal::memory::Properties::DEVICE_LOCAL)
})
.unwrap()
.into();
let dst_memory = device
.allocate_memory(dst_type, dst_requirements.size)
.unwrap();
device
.bind_image_memory(&dst_memory, 0, &mut dst_image)
.unwrap();
// Initializing commands
let subresource_layers = i::SubresourceLayers {
aspects: hal::format::Aspects::COLOR,
level: 0,
layers: 0..1,
};
let mut command_pool = device
.create_command_pool(family.id(), hal::pool::CommandPoolCreateFlags::empty())
.expect("Can't create command pool");
let mut fence = device.create_fence(false).unwrap();
{
let mut cmd_init = command_pool.allocate_one(com::Level::Primary);
cmd_init.begin_primary(com::CommandBufferFlags::ONE_TIME_SUBMIT);
cmd_init.pipeline_barrier(
hal::pso::PipelineStage::TOP_OF_PIPE..hal::pso::PipelineStage::TRANSFER,
hal::memory::Dependencies::empty(),
iter::once(hal::memory::Barrier::Image {
states: (i::Access::empty(), i::Layout::Undefined)
..(i::Access::TRANSFER_WRITE, i::Layout::TransferDstOptimal),
families: None,
target: &src_image,
range: i::SubresourceRange {
aspects: hal::format::Aspects::COLOR,
..i::SubresourceRange::default()
},
})
.chain(iter::once(hal::memory::Barrier::Buffer {
states: hal::buffer::Access::MEMORY_WRITE..hal::buffer::Access::TRANSFER_READ,
families: None,
target: &src_buffer,
range: hal::buffer::SubRange::default(),
}))
.chain(iter::once(hal::memory::Barrier::Image {
states: (i::Access::empty(), i::Layout::Undefined)
..(i::Access::TRANSFER_WRITE, i::Layout::TransferDstOptimal),
families: None,
target: &dst_image,
range: i::SubresourceRange {
aspects: hal::format::Aspects::COLOR,
..i::SubresourceRange::default()
},
})),
);
cmd_init.copy_buffer_to_image(
&src_buffer,
&src_image,
i::Layout::TransferDstOptimal,
iter::once(com::BufferImageCopy {
buffer_offset: 0,
buffer_width: 1,
buffer_height: 1,
image_layers: subresource_layers.clone(),
image_offset: i::Offset::ZERO,
image_extent: i::Extent {
width: 1,
height: 1,
depth: 1,
},
}),
);
cmd_init.pipeline_barrier(
hal::pso::PipelineStage::TRANSFER..hal::pso::PipelineStage::TRANSFER,
hal::memory::Dependencies::empty(),
iter::once(hal::memory::Barrier::Image {
states: (i::Access::TRANSFER_WRITE, i::Layout::TransferDstOptimal)
..(i::Access::TRANSFER_READ, i::Layout::TransferSrcOptimal),
families: None,
target: &src_image,
range: i::SubresourceRange {
aspects: hal::format::Aspects::COLOR,
..i::SubresourceRange::default()
},
}),
);
cmd_init.finish();
queue_group.queues[0].submit(
iter::once(&cmd_init),
iter::empty(),
iter::empty(),
Some(&mut fence),
);
device.wait_for_fence(&fence, !0).unwrap();
}
println!(
"Pre-recording commands for {}x{} {:?}...",
SIZE, SIZE, FORMAT
);
let num_queries = 3;
let query_pool = device
.create_query_pool(hal::query::Type::Timestamp, num_queries)
.unwrap();
let mut image_regions = Vec::new();
let mut buffer_regions = Vec::new();
for y in 0..SIZE {
for x in 0..SIZE {
image_regions.push(com::ImageCopy {
src_subresource: subresource_layers.clone(),
src_offset: i::Offset::ZERO,
dst_subresource: subresource_layers.clone(),
dst_offset: i::Offset {
x: x as i32,
y: y as i32,
z: 0,
},
extent: i::Extent {
width: 1,
height: 1,
depth: 1,
},
});
buffer_regions.push(com::BufferImageCopy {
buffer_offset: 0,
buffer_width: 1,
buffer_height: 1,
image_layers: subresource_layers.clone(),
image_offset: i::Offset {
x: x as i32,
y: y as i32,
z: 0,
},
image_extent: i::Extent {
width: 1,
height: 1,
depth: 1,
},
});
}
}
let mut cmd_bench = command_pool.allocate_one(com::Level::Primary);
cmd_bench.begin_primary(if RUNS == 1 {
com::CommandBufferFlags::ONE_TIME_SUBMIT
} else {
com::CommandBufferFlags::empty()
});
cmd_bench.reset_query_pool(&query_pool, 0..num_queries);
cmd_bench.write_timestamp(
hal::pso::PipelineStage::TRANSFER,
hal::query::Query {
pool: &query_pool,
id: 0,
},
);
cmd_bench.copy_image(
&src_image,
i::Layout::TransferSrcOptimal,
&dst_image,
i::Layout::TransferDstOptimal,
image_regions.into_iter(),
);
cmd_bench.write_timestamp(
hal::pso::PipelineStage::TRANSFER,
hal::query::Query {
pool: &query_pool,
id: 1,
},
);
cmd_bench.copy_buffer_to_image(
&src_buffer,
&dst_image,
i::Layout::TransferDstOptimal,
buffer_regions.into_iter(),
);
cmd_bench.write_timestamp(
hal::pso::PipelineStage::TRANSFER,
hal::query::Query {
pool: &query_pool,
id: 2,
},
);
cmd_bench.finish();
println!("Benchmarking...");
let period = queue_group.queues[0].timestamp_period() as f64 / 1_000_000.0;
let mut timings = vec![0u8; num_queries as usize * 8];
for i in 0..RUNS {
device.reset_fence(&mut fence).unwrap();
queue_group.queues[0].submit(
iter::once(&cmd_bench),
iter::empty(),
iter::empty(),
Some(&mut fence),
);
device.wait_for_fence(&fence, !0).unwrap();
device
.get_query_pool_results(
&query_pool,
0..num_queries,
&mut timings,
8,
hal::query::ResultFlags::BITS_64 | hal::query::ResultFlags::WAIT,
)
.unwrap();
let ticks = slice::from_raw_parts(timings.as_ptr() as *const u64, num_queries as usize);
let copy_image_time = ((ticks[1] - ticks[0]) as f64 * period) as u32;
let copy_buffer_time = ((ticks[2] - ticks[1]) as f64 * period) as u32;
println!(
"\tRun[{}]: image->image({} ms), buffer->image({} ms)",
i, copy_image_time, copy_buffer_time
);
}
device.destroy_query_pool(query_pool);
device.destroy_command_pool(command_pool);
device.destroy_image(src_image);
device.destroy_buffer(src_buffer);
device.destroy_image(dst_image);
device.destroy_fence(fence);
device.free_memory(src_memory_image);
device.free_memory(src_memory_buffer);
device.free_memory(dst_memory);
}
}
|
/*
* If not stated otherwise in this file or this component's LICENSE file the
* following copyright and licenses apply:
*
* Copyright 2022 RDK Management
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use std::ffi::CStr;
use std::ffi::CString;
use std::os::raw::{c_char, c_void};
type SendToFunction = unsafe extern "C" fn (u32, *const c_char, plugin_ctx: *const c_void);
pub trait PluginProtocol {
fn send_to(&mut self, channel_id: u32, json: String);
}
pub trait Plugin {
fn on_message(&mut self, json: String, ctx: RequestContext);
fn on_client_connect(&mut self, channel_id: u32);
fn on_client_disconnect(&mut self, channel_id: u32);
}
pub struct RequestContext {
pub channel_id: u32,
pub auth_token: String
}
pub struct ServiceMetadata {
pub name: &'static str,
pub version: (u32, u32, u32),
pub create: fn (Box<dyn PluginProtocol>) -> Box<dyn Plugin>
}
#[macro_export]
macro_rules! export_plugin {
($name:expr, $version:expr, $create:expr) => {
#[no_mangle]
pub static thunder_service_metadata : $crate::ServiceMetadata =
$crate::ServiceMetadata {
name: $name,
version: $version,
create: $create
};
};
}
//===============================================================================
// Internal code only below here
//===============================================================================
#[repr(C)]
pub struct CRequestContext {
channel_id: u32,
auth_token: *const c_char
}
fn cstr_to_string(s : *const c_char) -> String {
if s.is_null() {
String::new()
}
else {
let c_str: &CStr = unsafe{ CStr::from_ptr(s) };
let slice: &str = c_str.to_str().unwrap();
let t: String = slice.to_owned();
t
}
}
pub struct CPlugin {
pub name: String,
pub plugin: Box<dyn Plugin>
}
struct DefaultPluginProtocol {
send_func: SendToFunction,
send_ctx: *const c_void
}
impl PluginProtocol for DefaultPluginProtocol {
fn send_to(&mut self, channel_id: u32, json: String) {
let c_str = CString::new(json).unwrap();
unsafe {
(self.send_func)(channel_id, c_str.as_ptr(), self.send_ctx);
}
}
}
impl CPlugin {
fn on_incoming_message(&mut self, json_req: *const c_char, ctx: CRequestContext) {
let req = cstr_to_string(json_req);
let req_ctx = RequestContext {
channel_id: ctx.channel_id,
auth_token: cstr_to_string(ctx.auth_token)
};
self.plugin.on_message(req, req_ctx);
}
fn on_client_connect(&mut self, channel_id: u32) {
self.plugin.on_client_connect(channel_id);
}
fn on_client_disconnect(&mut self, channel_id: u32) {
self.plugin.on_client_disconnect(channel_id);
}
}
#[no_mangle]
pub extern fn wpe_rust_plugin_create(_name: *const c_char, send_func: SendToFunction,
plugin_ctx: *const c_void, meta_data: *mut ServiceMetadata) -> *mut CPlugin
{
assert!(!meta_data.is_null());
let service_metadata = unsafe{ &*meta_data };
let proto: Box<dyn PluginProtocol> = Box::new(DefaultPluginProtocol {
send_func: send_func,
send_ctx: plugin_ctx});
let plugin: Box<dyn Plugin> = (service_metadata.create)(proto);
let name: String = service_metadata.name.to_string();
let c_plugin: Box<CPlugin> = Box::new(CPlugin {
name: name,
plugin: plugin
});
/* Sorry for the lack of RUST knowledge, this was the only way we */
/* could send back a list with the methods supported by this Rust */
/* plugin. Prefer to send it so Thudner can already filter on non */
/* existing methods. Suggest to return this string as a parameter */
/* on this method call.. */
let methods = CString::new("[ \"add\", \"mul\" ]").unwrap();
unsafe {
// let c_buf = methods.unwrap();
//let c_str: &CStr = unsafe { CStr::from_ptr(c_buf) };
//let str_slice: &str = c_str.to_str().unwrap();
send_func(0, methods.as_ptr(), plugin_ctx);
}
Box::into_raw(c_plugin)
}
#[no_mangle]
pub extern fn wpe_rust_plugin_destroy(ptr: *mut CPlugin) {
assert!(!ptr.is_null());
unsafe {
drop(Box::from_raw(ptr));
}
}
#[no_mangle]
pub extern fn wpe_rust_plugin_init(_ptr: *mut CPlugin, _json: *const c_char) {
// assert!(!ptr.is_null());
// XXX: Create + Init doesn't seem to fit the Rust style. wpe_rust_plugin_create
// is probably enough. Consider getting rid of this function
// let plugin = unsafe{ &mut *ptr };
// println!("{}.init", plugin.name);
}
#[no_mangle]
pub extern fn wpe_rust_plugin_invoke(ptr: *mut CPlugin, json_req: *const c_char, req_ctx: CRequestContext) {
assert!(!ptr.is_null());
assert!(!json_req.is_null());
let plugin = unsafe{ &mut *ptr };
let uncaught_error = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
plugin.on_incoming_message(json_req, req_ctx);
}));
match uncaught_error {
Err(cause) => {
println!("Error calling on_incoming_message");
println!("{:?}", cause);
}
Ok(_) => { }
}
}
#[no_mangle]
pub extern fn wpe_rust_plugin_on_client_connect(ptr: *mut CPlugin, channel_id: u32) {
assert!(!ptr.is_null());
let plugin = unsafe{ &mut *ptr };
let uncaught_error = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
plugin.on_client_connect(channel_id);
}));
match uncaught_error {
Err(cause) => {
println!("Error calling on_client_connect");
println!("{:?}", cause);
}
Ok(_) => { }
}
}
#[no_mangle]
pub extern fn wpe_rust_plugin_on_client_disconnect(ptr: *mut CPlugin, channel_id: u32) {
assert!(!ptr.is_null());
let plugin = unsafe{ &mut *ptr };
let uncaught_error = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
plugin.on_client_disconnect(channel_id);
}));
match uncaught_error {
Err(cause) => {
println!("Error calling on_client_disconnect");
println!("{:?}", cause);
}
Ok(_) => { }
}
}
|
use proconio::input;
macro_rules! chmax {
($a: expr, $b: expr) => {
if let Some(x) = $a {
$a = Some(x.max($b));
} else {
$a = Some($b);
}
};
}
fn main() {
input! {
n: usize,
k: usize,
d: usize,
a: [usize; n],
};
let mut dp = vec![vec![None; k + 1]; d];
dp[0][0] = Some(0);
for x in a {
let mut next = vec![vec![Option::<usize>::None; k + 1]; d];
for m in 0..d {
for j in 0..=k {
if let Some(cur) = dp[m][j] {
chmax!(next[m][j], cur);
if j + 1 <= k {
chmax!(next[(m + x) % d][j + 1], cur + x);
}
}
}
}
dp = next;
}
if let Some(ans) = dp[0][k] {
println!("{}", ans);
} else {
println!("-1");
}
}
|
#[doc = "Reader of register CR"]
pub type R = crate::R<u32, super::CR>;
#[doc = "Writer for register CR"]
pub type W = crate::W<u32, super::CR>;
#[doc = "Register CR `reset()`'s with value 0"]
impl crate::ResetValue for super::CR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `RESET`"]
pub type RESET_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RESET`"]
pub struct RESET_W<'a> {
w: &'a mut W,
}
impl<'a> RESET_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "Reader of field `CLIPEN`"]
pub type CLIPEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `CLIPEN`"]
pub struct CLIPEN_W<'a> {
w: &'a mut W,
}
impl<'a> CLIPEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
self.w
}
}
#[doc = "Reader of field `DMAWEN`"]
pub type DMAWEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `DMAWEN`"]
pub struct DMAWEN_W<'a> {
w: &'a mut W,
}
impl<'a> DMAWEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Reader of field `DMAREN`"]
pub type DMAREN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `DMAREN`"]
pub struct DMAREN_W<'a> {
w: &'a mut W,
}
impl<'a> DMAREN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Reader of field `SATIEN`"]
pub type SATIEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SATIEN`"]
pub struct SATIEN_W<'a> {
w: &'a mut W,
}
impl<'a> SATIEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `UNFLIEN`"]
pub type UNFLIEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `UNFLIEN`"]
pub struct UNFLIEN_W<'a> {
w: &'a mut W,
}
impl<'a> UNFLIEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `OVFLIEN`"]
pub type OVFLIEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `OVFLIEN`"]
pub struct OVFLIEN_W<'a> {
w: &'a mut W,
}
impl<'a> OVFLIEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `WIEN`"]
pub type WIEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WIEN`"]
pub struct WIEN_W<'a> {
w: &'a mut W,
}
impl<'a> WIEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `RIEN`"]
pub type RIEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RIEN`"]
pub struct RIEN_W<'a> {
w: &'a mut W,
}
impl<'a> RIEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
impl R {
#[doc = "Bit 16 - RESET"]
#[inline(always)]
pub fn reset(&self) -> RESET_R {
RESET_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 15 - CLIPEN"]
#[inline(always)]
pub fn clipen(&self) -> CLIPEN_R {
CLIPEN_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 9 - DMAWEN"]
#[inline(always)]
pub fn dmawen(&self) -> DMAWEN_R {
DMAWEN_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8 - DMAREN"]
#[inline(always)]
pub fn dmaren(&self) -> DMAREN_R {
DMAREN_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 4 - SATIEN"]
#[inline(always)]
pub fn satien(&self) -> SATIEN_R {
SATIEN_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - UNFLIEN"]
#[inline(always)]
pub fn unflien(&self) -> UNFLIEN_R {
UNFLIEN_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - OVFLIEN"]
#[inline(always)]
pub fn ovflien(&self) -> OVFLIEN_R {
OVFLIEN_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 1 - WIEN"]
#[inline(always)]
pub fn wien(&self) -> WIEN_R {
WIEN_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0 - RIEN"]
#[inline(always)]
pub fn rien(&self) -> RIEN_R {
RIEN_R::new((self.bits & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 16 - RESET"]
#[inline(always)]
pub fn reset(&mut self) -> RESET_W {
RESET_W { w: self }
}
#[doc = "Bit 15 - CLIPEN"]
#[inline(always)]
pub fn clipen(&mut self) -> CLIPEN_W {
CLIPEN_W { w: self }
}
#[doc = "Bit 9 - DMAWEN"]
#[inline(always)]
pub fn dmawen(&mut self) -> DMAWEN_W {
DMAWEN_W { w: self }
}
#[doc = "Bit 8 - DMAREN"]
#[inline(always)]
pub fn dmaren(&mut self) -> DMAREN_W {
DMAREN_W { w: self }
}
#[doc = "Bit 4 - SATIEN"]
#[inline(always)]
pub fn satien(&mut self) -> SATIEN_W {
SATIEN_W { w: self }
}
#[doc = "Bit 3 - UNFLIEN"]
#[inline(always)]
pub fn unflien(&mut self) -> UNFLIEN_W {
UNFLIEN_W { w: self }
}
#[doc = "Bit 2 - OVFLIEN"]
#[inline(always)]
pub fn ovflien(&mut self) -> OVFLIEN_W {
OVFLIEN_W { w: self }
}
#[doc = "Bit 1 - WIEN"]
#[inline(always)]
pub fn wien(&mut self) -> WIEN_W {
WIEN_W { w: self }
}
#[doc = "Bit 0 - RIEN"]
#[inline(always)]
pub fn rien(&mut self) -> RIEN_W {
RIEN_W { w: self }
}
}
|
extern crate app_dirs;
extern crate preferences;
#[macro_use]
extern crate serde_derive;
use app_dirs::{AppDataType, AppInfo, app_dir, app_root, get_app_root};
use preferences::Preferences;
use std::path::PathBuf;
const APP_INFO: AppInfo = AppInfo {
name: "24daysofrust",
author: "Zbigniew Siciarz",
};
#[derive(Serialize, Deserialize, Debug, Default)]
struct GameConfig {
save_dir: Option<PathBuf>,
autosave: bool,
fov: f32,
render_distance: u32,
}
fn main() {
println!("24 Days of Rust vol. 2 - app_dirs");
println!("{:?}", get_app_root(AppDataType::UserConfig, &APP_INFO));
println!("{:?}", app_root(AppDataType::UserConfig, &APP_INFO));
let save_dir = app_dir(AppDataType::UserData, &APP_INFO, "game/saves")
.expect("Couldn't create directory for game saves");
println!("{}", save_dir.display());
let mut config = match GameConfig::load(&APP_INFO, "game_config") {
Ok(cfg) => cfg,
Err(_) => GameConfig::default(),
};
println!("{:?}", config);
config.save_dir = Some(save_dir);
config.autosave = true;
config.save(&APP_INFO, "game_config").expect(
"Failed to save game config",
);
}
|
// Copyright (c) 2021 Quark Container Authors / 2018 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use alloc::sync::Arc;
use alloc::sync::Weak;
use alloc::string::String;
use alloc::string::ToString;
use spin::Mutex;
use alloc::collections::btree_set::BTreeSet;
use core::ops::Deref;
use core::cmp::*;
use super::super::SignalDef::*;
use super::super::memmgr::mm::*;
use super::super::qlib::linux_def::*;
use super::super::qlib::usage::io::*;
use super::super::fs::mount::*;
use super::super::kernel::kernel::*;
use super::super::kernel::fs_context::*;
use super::super::kernel::fd_table::*;
use super::super::kernel::uts_namespace::*;
use super::super::kernel::ipc_namespace::*;
use super::super::kernel::waiter::queue::*;
use super::super::threadmgr::task_stop::*;
use super::super::threadmgr::task_exit::*;
use super::super::threadmgr::task_block::*;
use super::super::threadmgr::task_sched::*;
use super::super::kernel::time::*;
use super::super::kernel::cpuset::*;
use super::super::kernel::waiter::waitgroup::*;
use super::super::qlib::auth::*;
use super::thread_group::*;
use super::pid_namespace::*;
use super::threads::*;
pub type UniqueID = u64;
pub type ThreadID = i32;
pub type SessionID = i32;
pub type ProcessGroupID = i32;
pub const ROBUST_LIST_LEN: u64 = 0x18;
//#[derive(Default)]
pub struct ThreadInternal {
pub id: ThreadID,
// Name is the thread name set by the prctl(PR_SET_NAME) system call.
pub name: String,
pub taskId: u64,
//the task of the Task Stack
pub blocker: Blocker,
pub k: Kernel,
pub memoryMgr: MemoryManager,
pub fsc: FSContext,
pub fdTbl: FDTable,
// If vforkParent is not nil, it is the task that created this task with
// vfork() or clone(CLONE_VFORK), and should have its vforkStop ended when
// this TaskContext is released.
//
// vforkParent is protected by the TaskSet mutex.
pub vforkParent: Option<Thread>,
pub creds: Credentials,
pub utsns: UTSNamespace,
pub ipcns: IPCNamespace,
pub SignalQueue: Queue,
// tg is the thread group that this task belongs to. The tg pointer is
// immutable.
pub tg: ThreadGroup,
// parent is the task's parent. parent may be nil.
//
// parent is protected by the TaskSet mutex.
pub parent: Option<Thread>,
// children is this task's children.
//
// children is protected by the TaskSet mutex.
pub children: BTreeSet<Thread>,
// If childPIDNamespace is not nil, all new tasks created by this task will
// be members of childPIDNamespace rather than this one. (As a corollary,
// this task becomes unable to create sibling tasks in the same thread
// group.)
//
// childPIDNamespace is exclusive to the task goroutine.
pub childPIDNamespace: Option<PIDNamespace>,
// haveSyscallReturn is true if tc.Arch().Return() represents a value
// returned by a syscall (or set by ptrace after a syscall).
//
// haveSyscallReturn is exclusive to the task goroutine.
pub SysCallReturn: Option<u64>,
// sched contains the current scheduling state of the task.
//
// sched is protected by scedSeq. sched is owned by the task
//pub scedSeq: SeqCount,
pub sched: TaskSchedInfo,
// yieldCount is the number of times the task goroutine has called
// Task.InterruptibleSleepStart, Task.UninterruptibleSleepStart, or
// Task.Yield(), voluntarily ceasing execution.
//
// yieldCount is accessed using atomic memory operations. yieldCount is
// owned by the task goroutine.
pub yieldCount: u64,
// pendingSignals is the set of pending signals that may be handled only by
// this task.
//
// pendingSignals is protected by (taskNode.)tg.signalHandlers.mu
// (hereafter "the signal mutex"); see comment on
// ThreadGroup.signalHandlers.
pub pendingSignals: PendingSignals,
// signalMask is the set of signals whose delivery is currently blocked.
//
// signalMask is accessed using atomic memory operations, and is protected
// by the signal mutex (such that reading signalMask is safe if either the
// signal mutex is locked or if atomic memory operations are used, while
// writing signalMask requires both). signalMask is owned by the task
// goroutine.
pub signalMask: SignalSet,
// If the task goroutine is currently executing Task.sigtimedwait,
// realSignalMask is the previous value of signalMask, which has temporarily
// been replaced by Task.sigtimedwait. Otherwise, realSignalMask is 0.
//
// realSignalMask is exclusive to the task goroutine.
pub realSignalMask: SignalSet,
// If haveSavedSignalMask is true, savedSignalMask is the signal mask that
// should be applied after the task has either delivered one signal to a
// user handler or is about to resume execution in the untrusted
// application.
//
// Both haveSavedSignalMask and savedSignalMask are exclusive to the task
// goroutine.
pub haveSavedSignalMask: bool,
pub savedSignalMask: SignalSet,
// signalStack is the alternate signal stack used by signal handlers for
// which the SA_ONSTACK flag is set.
//
// signalStack is exclusive to the task goroutine.
pub signalStack: SignalStack,
// If groupStopPending is true, the task should participate in a group
// stop in the interrupt path.
//
// groupStopPending is analogous to JOBCTL_STOP_PENDING in Linux.
//
// groupStopPending is protected by the signal mutex.
pub groupStopPending: bool,
// If groupStopAcknowledged is true, the task has already acknowledged that
// it is entering the most recent group stop that has been initiated on its
// thread group.
//
// groupStopAcknowledged is analogous to !JOBCTL_STOP_CONSUME in Linux.
//
// groupStopAcknowledged is protected by the signal mutex.
pub groupStopAcknowledged: bool,
// If trapStopPending is true, the task goroutine should enter a
// PTRACE_INTERRUPT-induced stop from the interrupt path.
//
// trapStopPending is analogous to JOBCTL_TRAP_STOP in Linux, except that
// Linux also sets JOBCTL_TRAP_STOP when a ptraced task detects
// JOBCTL_STOP_PENDING.
//
// trapStopPending is protected by the signal mutex.
pub trapStopPending: bool,
// If trapNotifyPending is true, this task is PTRACE_SEIZEd, and a group
// stop has begun or ended since the last time the task entered a
// ptrace-stop from the group-stop path.
//
// trapNotifyPending is analogous to JOBCTL_TRAP_NOTIFY in Linux.
//
// trapNotifyPending is protected by the signal mutex.
pub trapNotifyPending: bool,
//pub containerID: String,
// This is mostly a fake cpumask just for sched_set/getaffinity as we
// don't really control the affinity.
//
// Invariant: allowedCPUMask.Size() ==
// sched.CPUMaskSize(Kernel.applicationCores).
//
// allowedCPUMask is protected by mu.
pub allowedCPUMask: CPUSet,
// cpu is the fake cpu number returned by getcpu(2). cpu is ignored
// entirely if Kernel.useHostCores is true.
//
// cpu is accessed using atomic memory operations.
pub cpu: i32,
// This is used to keep track of changes made to a process' priority/niceness.
// It is mostly used to provide some reasonable return value from
// getpriority(2) after a call to setpriority(2) has been made.
// We currently do not actually modify a process' scheduling priority.
// NOTE: This represents the userspace view of priority (nice).
// This means that the value should be in the range [-20, 19].
//
// niceness is protected by mu.
pub niceness: i32,
// This is used to track the numa policy for the current thread. This can be
// modified through a set_mempolicy(2) syscall. Since we always report a
// single numa node, all policies are no-ops. We only track this information
// so that we can return reasonable values if the application calls
// get_mempolicy(2) after setting a non-default policy. Note that in the
// real syscall, nodemask can be longer than 4 bytes, but we always report a
// single node so never need to save more than a single bit.
//
// numaPolicy and numaNodeMask are protected by mu.
pub numaPolicy: i32,
pub numaNodeMask: u64,
// If netns is true, the task is in a non-root network namespace. Network
// namespaces aren't currently implemented in full; being in a network
// namespace simply prevents the task from observing any network devices
// (including loopback) or using abstract socket addresses (see unix(7)).
//
// netns is protected by mu. netns is owned by the task goroutine.
pub netns: bool,
// parentDeathSignal is sent to this task's thread group when its parent exits.
//
// parentDeathSignal is protected by mu.
pub parentDeathSignal: Signal,
// If stop is not nil, it is the internally-initiated condition that
// currently prevents the task goroutine from running.
//
// stop is protected by the signal mutex.
pub stop: Option<Arc<TaskStop>>,
// stopCount is the number of active external stops (calls to
// Task.BeginExternalStop that have not been paired with a call to
// Task.EndExternalStop), plus 1 if stop is not nil. Hence stopCount is
// non-zero if the task goroutine should stop.
pub stopCount: WaitGroup,
// exitStatus is the task's exit status.
//
// exitStatus is protected by the signal mutex.
pub exitStatus: ExitStatus,
// exitState is the task's progress through the exit path.
//
// exitState is protected by the TaskSet mutex. exitState is owned by the
// task goroutine.
pub exitState: TaskExitState,
// exitTracerNotified is true if the exit path has either signaled the
// task's tracer to indicate the exit, or determined that no such signal is
// needed. exitTracerNotified can only be true if exitState is
// TaskExitZombie or TaskExitDead.
//
// exitTracerNotified is protected by the TaskSet mutex.
pub exitTracerNotified: bool,
// exitTracerAcked is true if exitTracerNotified is true and either the
// task's tracer has acknowledged the exit notification, or the exit path
// has determined that no such notification is needed.
//
// exitTracerAcked is protected by the TaskSet mutex.
pub exitTracerAcked: bool,
// exitParentNotified is true if the exit path has either signaled the
// task's parent to indicate the exit, or determined that no such signal is
// needed. exitParentNotified can only be true if exitState is
// TaskExitZombie or TaskExitDead.
//
// exitParentNotified is protected by the TaskSet mutex.
pub exitParentNotified: bool,
// exitParentAcked is true if exitParentNotified is true and either the
// task's parent has acknowledged the exit notification, or the exit path
// has determined that no such acknowledgment is needed.
//
// exitParentAcked is protected by the TaskSet mutex.
pub exitParentAcked: bool,
// startTime is the real time at which the task started. It is set when
// a Task is created or invokes execve(2).
//
// startTime is protected by mu.
pub startTime: Time,
// containerID has no equivalent in Linux; it's used by runsc to track all
// tasks that belong to a given containers since cgroups aren't implemented.
// It's inherited by the children, is immutable, and may be empty.
//
// NOTE: cgroups can be used to track this when implemented.
pub containerID: String,
pub ioUsage: IO,
pub robust_list_head: u64,
}
impl ThreadInternal {
pub fn IsChrooted(&self) -> bool {
let realRoot = self.k.RootDir();
let root = self.fsc.RootDirectory();
return root != realRoot;
}
pub fn SetRet(&mut self, ret: u64) {
self.SysCallReturn = Some(ret)
}
}
#[derive(Default)]
pub struct ThreadWeak {
pub uid: UniqueID,
pub data: Weak<Mutex<ThreadInternal>>,
}
impl ThreadWeak {
pub fn Upgrade(&self) -> Option<Thread> {
let t = match self.data.upgrade() {
None => return None,
Some(t) => t,
};
return Some(Thread {
uid: self.uid,
data: t,
})
}
}
//#[derive(Default)]
pub struct Thread {
pub uid: UniqueID,
pub data: Arc<Mutex<ThreadInternal>>,
}
impl Clone for Thread {
fn clone(&self) -> Self {
return Self {
uid: self.Uid(),
data: self.data.clone(),
}
}
}
impl Deref for Thread {
type Target = Arc<Mutex<ThreadInternal>>;
fn deref(&self) -> &Arc<Mutex<ThreadInternal>> {
&self.data
}
}
impl Ord for Thread {
fn cmp(&self, other: &Self) -> Ordering {
self.Uid().cmp(&other.Uid())
}
}
impl PartialOrd for Thread {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl PartialEq for Thread {
fn eq(&self, other: &Self) -> bool {
return self.Uid() == other.Uid()
}
}
impl Eq for Thread {}
impl Thread {
// debug api
pub fn IDs(&self) -> (i32, i32) {
let tg = self.ThreadGroup();
let pidns = tg.PIDNamespace();
return (pidns.IDOfThreadGroup(&tg), pidns.IDOfTask(&self))
}
pub fn MountNamespace(&self) -> MountNs {
return GetKernel().mounts.read().clone().unwrap();
}
pub fn RefCount(&self) -> usize {
return Arc::strong_count(&self.data);
}
pub fn Creds(&self) -> Credentials {
return self.lock().creds.clone();
}
pub fn UTSNamespace(&self) -> UTSNamespace {
return self.lock().utsns.clone();
}
pub fn MemoryManager(&self) -> MemoryManager {
return self.lock().memoryMgr.clone();
}
pub fn Downgrade(&self) -> ThreadWeak {
return ThreadWeak {
uid: self.uid,
data: Arc::downgrade(&self.data),
}
}
pub fn Kernel(&self) -> Kernel {
return self.lock().k.clone();
}
pub fn Uid(&self) -> UniqueID {
return self.uid
}
pub fn ThreadGroup(&self) -> ThreadGroup {
return self.lock().tg.clone();
}
pub fn PIDNamespace(&self) -> PIDNamespace {
let tg = self.lock().tg.clone();
return tg.lock().pidns.clone();
}
pub fn TaskSet(&self) -> TaskSet {
let pidns = self.PIDNamespace();
let owner = pidns.lock().owner.clone();
return owner;
}
pub fn Parent(&self) -> Option<Thread> {
let taskSet = self.TaskSet();
let _r = taskSet.ReadLock();
match &self.lock().parent {
None => None,
Some(ref p) => Some(p.clone()),
}
}
pub fn ThreadID(&self) -> ThreadID {
let ns = self.PIDNamespace();
return ns.IDOfTask(self)
}
pub fn StartTime(&self) -> Time {
return self.lock().startTime;
}
pub fn ContainerID(&self) -> String {
return self.lock().containerID.to_string();
}
} |
let mut token_map = HashMap::new();
for elem in &_tokvec {
let one_tok: Vec<&str> = elem.split(",").collect();
token_map.insert(one_tok[0], one_tok[1]);
println!("{:?}", token_map);
} |
// This file is part of linux-epoll. It is subject to the license terms in the COPYRIGHT file found in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/linux-epoll/master/COPYRIGHT. No part of linux-epoll, including this file, may be copied, modified, propagated, or distributed except according to the terms contained in the COPYRIGHT file.
// Copyright © 2019 The developers of linux-epoll. See the COPYRIGHT file in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/linux-epoll/master/COPYRIGHT.
/// An error in TLS handling.
///
/// All are irrecoverable.
#[derive(Debug)]
pub enum TlsInputOutputError
{
/// Error occurred whilst processing newly received TLS packets (messages).
ProcessNewPackets(TLSError),
/// End-of-file occurred whilst handshaking.
EndOfFileWhilstHandshaking,
/// When reading from a socket, a CloseNotify fatal alart was received.
BufferReadCloseNotifyAlertReceived,
}
impl Display for TlsInputOutputError
{
#[inline(always)]
fn fmt(&self, f: &mut Formatter) -> fmt::Result
{
Debug::fmt(self, f)
}
}
impl error::Error for TlsInputOutputError
{
#[inline(always)]
fn source(&self) -> Option<&(error::Error + 'static)>
{
use self::TlsInputOutputError::*;
match self
{
&ProcessNewPackets(ref error) => Some(error),
&EndOfFileWhilstHandshaking => None,
&BufferReadCloseNotifyAlertReceived => None,
}
}
}
|
#[doc = r"Register block"]
#[repr(C)]
pub struct RegisterBlock {
#[doc = "0x00 - control register"]
pub cr: CR,
_reserved1: [u8; 4usize],
#[doc = "0x08 - device configuration register"]
pub dcr1: DCR1,
#[doc = "0x0c - device configuration register 2"]
pub dcr2: DCR2,
#[doc = "0x10 - device configuration register 3"]
pub dcr3: DCR3,
#[doc = "0x14 - DCR4"]
pub dcr4: DCR4,
_reserved5: [u8; 8usize],
#[doc = "0x20 - status register"]
pub sr: SR,
#[doc = "0x24 - flag clear register"]
pub fcr: FCR,
_reserved7: [u8; 24usize],
#[doc = "0x40 - data length register"]
pub dlr: DLR,
_reserved8: [u8; 4usize],
#[doc = "0x48 - address register"]
pub ar: AR,
_reserved9: [u8; 4usize],
#[doc = "0x50 - data register"]
pub dr: DR,
_reserved10: [u8; 44usize],
#[doc = "0x80 - polling status mask register"]
pub psmkr: PSMKR,
_reserved11: [u8; 4usize],
#[doc = "0x88 - polling status match register"]
pub psmar: PSMAR,
_reserved12: [u8; 4usize],
#[doc = "0x90 - polling interval register"]
pub pir: PIR,
_reserved13: [u8; 108usize],
#[doc = "0x100 - communication configuration register"]
pub ccr: CCR,
_reserved14: [u8; 4usize],
#[doc = "0x108 - timing configuration register"]
pub tcr: TCR,
_reserved15: [u8; 4usize],
#[doc = "0x110 - instruction register"]
pub ir: IR,
_reserved16: [u8; 12usize],
#[doc = "0x120 - alternate bytes register"]
pub abr: ABR,
_reserved17: [u8; 12usize],
#[doc = "0x130 - low-power timeout register"]
pub lptr: LPTR,
_reserved18: [u8; 12usize],
#[doc = "0x140 - write communication configuration register"]
pub wpccr: WPCCR,
_reserved19: [u8; 4usize],
#[doc = "0x148 - write timing configuration register"]
pub wptcr: WPTCR,
_reserved20: [u8; 4usize],
#[doc = "0x150 - write instruction register"]
pub wpir: WPIR,
_reserved21: [u8; 12usize],
#[doc = "0x160 - write alternate bytes register"]
pub wpabr: WPABR,
_reserved22: [u8; 28usize],
#[doc = "0x180 - WCCR"]
pub wccr: WCCR,
_reserved23: [u8; 4usize],
#[doc = "0x188 - WTCR"]
pub wtcr: WTCR,
_reserved24: [u8; 4usize],
#[doc = "0x190 - WIR"]
pub wir: WIR,
_reserved25: [u8; 12usize],
#[doc = "0x1a0 - WABR"]
pub wabr: WABR,
_reserved26: [u8; 92usize],
#[doc = "0x200 - HyperBusTM latency configuration register"]
pub hlcr: HLCR,
}
#[doc = "control register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cr](cr) module"]
pub type CR = crate::Reg<u32, _CR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CR;
#[doc = "`read()` method returns [cr::R](cr::R) reader structure"]
impl crate::Readable for CR {}
#[doc = "`write(|w| ..)` method takes [cr::W](cr::W) writer structure"]
impl crate::Writable for CR {}
#[doc = "control register"]
pub mod cr;
#[doc = "device configuration register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dcr1](dcr1) module"]
pub type DCR1 = crate::Reg<u32, _DCR1>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _DCR1;
#[doc = "`read()` method returns [dcr1::R](dcr1::R) reader structure"]
impl crate::Readable for DCR1 {}
#[doc = "`write(|w| ..)` method takes [dcr1::W](dcr1::W) writer structure"]
impl crate::Writable for DCR1 {}
#[doc = "device configuration register"]
pub mod dcr1;
#[doc = "device configuration register 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dcr2](dcr2) module"]
pub type DCR2 = crate::Reg<u32, _DCR2>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _DCR2;
#[doc = "`read()` method returns [dcr2::R](dcr2::R) reader structure"]
impl crate::Readable for DCR2 {}
#[doc = "`write(|w| ..)` method takes [dcr2::W](dcr2::W) writer structure"]
impl crate::Writable for DCR2 {}
#[doc = "device configuration register 2"]
pub mod dcr2;
#[doc = "device configuration register 3\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dcr3](dcr3) module"]
pub type DCR3 = crate::Reg<u32, _DCR3>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _DCR3;
#[doc = "`read()` method returns [dcr3::R](dcr3::R) reader structure"]
impl crate::Readable for DCR3 {}
#[doc = "`write(|w| ..)` method takes [dcr3::W](dcr3::W) writer structure"]
impl crate::Writable for DCR3 {}
#[doc = "device configuration register 3"]
pub mod dcr3;
#[doc = "DCR4\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dcr4](dcr4) module"]
pub type DCR4 = crate::Reg<u32, _DCR4>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _DCR4;
#[doc = "`read()` method returns [dcr4::R](dcr4::R) reader structure"]
impl crate::Readable for DCR4 {}
#[doc = "`write(|w| ..)` method takes [dcr4::W](dcr4::W) writer structure"]
impl crate::Writable for DCR4 {}
#[doc = "DCR4"]
pub mod dcr4;
#[doc = "status register\n\nThis register you can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [sr](sr) module"]
pub type SR = crate::Reg<u32, _SR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _SR;
#[doc = "`write(|w| ..)` method takes [sr::W](sr::W) writer structure"]
impl crate::Writable for SR {}
#[doc = "status register"]
pub mod sr;
#[doc = "flag clear register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [fcr](fcr) module"]
pub type FCR = crate::Reg<u32, _FCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _FCR;
#[doc = "`read()` method returns [fcr::R](fcr::R) reader structure"]
impl crate::Readable for FCR {}
#[doc = "`write(|w| ..)` method takes [fcr::W](fcr::W) writer structure"]
impl crate::Writable for FCR {}
#[doc = "flag clear register"]
pub mod fcr;
#[doc = "data length register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dlr](dlr) module"]
pub type DLR = crate::Reg<u32, _DLR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _DLR;
#[doc = "`read()` method returns [dlr::R](dlr::R) reader structure"]
impl crate::Readable for DLR {}
#[doc = "`write(|w| ..)` method takes [dlr::W](dlr::W) writer structure"]
impl crate::Writable for DLR {}
#[doc = "data length register"]
pub mod dlr;
#[doc = "address register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ar](ar) module"]
pub type AR = crate::Reg<u32, _AR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AR;
#[doc = "`read()` method returns [ar::R](ar::R) reader structure"]
impl crate::Readable for AR {}
#[doc = "`write(|w| ..)` method takes [ar::W](ar::W) writer structure"]
impl crate::Writable for AR {}
#[doc = "address register"]
pub mod ar;
#[doc = "data register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dr](dr) module"]
pub type DR = crate::Reg<u32, _DR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _DR;
#[doc = "`read()` method returns [dr::R](dr::R) reader structure"]
impl crate::Readable for DR {}
#[doc = "`write(|w| ..)` method takes [dr::W](dr::W) writer structure"]
impl crate::Writable for DR {}
#[doc = "data register"]
pub mod dr;
#[doc = "polling status mask register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [psmkr](psmkr) module"]
pub type PSMKR = crate::Reg<u32, _PSMKR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _PSMKR;
#[doc = "`read()` method returns [psmkr::R](psmkr::R) reader structure"]
impl crate::Readable for PSMKR {}
#[doc = "`write(|w| ..)` method takes [psmkr::W](psmkr::W) writer structure"]
impl crate::Writable for PSMKR {}
#[doc = "polling status mask register"]
pub mod psmkr;
#[doc = "polling status match register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [psmar](psmar) module"]
pub type PSMAR = crate::Reg<u32, _PSMAR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _PSMAR;
#[doc = "`read()` method returns [psmar::R](psmar::R) reader structure"]
impl crate::Readable for PSMAR {}
#[doc = "`write(|w| ..)` method takes [psmar::W](psmar::W) writer structure"]
impl crate::Writable for PSMAR {}
#[doc = "polling status match register"]
pub mod psmar;
#[doc = "polling interval register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [pir](pir) module"]
pub type PIR = crate::Reg<u32, _PIR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _PIR;
#[doc = "`read()` method returns [pir::R](pir::R) reader structure"]
impl crate::Readable for PIR {}
#[doc = "`write(|w| ..)` method takes [pir::W](pir::W) writer structure"]
impl crate::Writable for PIR {}
#[doc = "polling interval register"]
pub mod pir;
#[doc = "communication configuration register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ccr](ccr) module"]
pub type CCR = crate::Reg<u32, _CCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CCR;
#[doc = "`read()` method returns [ccr::R](ccr::R) reader structure"]
impl crate::Readable for CCR {}
#[doc = "`write(|w| ..)` method takes [ccr::W](ccr::W) writer structure"]
impl crate::Writable for CCR {}
#[doc = "communication configuration register"]
pub mod ccr;
#[doc = "timing configuration register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tcr](tcr) module"]
pub type TCR = crate::Reg<u32, _TCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TCR;
#[doc = "`read()` method returns [tcr::R](tcr::R) reader structure"]
impl crate::Readable for TCR {}
#[doc = "`write(|w| ..)` method takes [tcr::W](tcr::W) writer structure"]
impl crate::Writable for TCR {}
#[doc = "timing configuration register"]
pub mod tcr;
#[doc = "instruction register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ir](ir) module"]
pub type IR = crate::Reg<u32, _IR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _IR;
#[doc = "`read()` method returns [ir::R](ir::R) reader structure"]
impl crate::Readable for IR {}
#[doc = "`write(|w| ..)` method takes [ir::W](ir::W) writer structure"]
impl crate::Writable for IR {}
#[doc = "instruction register"]
pub mod ir;
#[doc = "alternate bytes register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [abr](abr) module"]
pub type ABR = crate::Reg<u32, _ABR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _ABR;
#[doc = "`read()` method returns [abr::R](abr::R) reader structure"]
impl crate::Readable for ABR {}
#[doc = "`write(|w| ..)` method takes [abr::W](abr::W) writer structure"]
impl crate::Writable for ABR {}
#[doc = "alternate bytes register"]
pub mod abr;
#[doc = "low-power timeout register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [lptr](lptr) module"]
pub type LPTR = crate::Reg<u32, _LPTR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _LPTR;
#[doc = "`read()` method returns [lptr::R](lptr::R) reader structure"]
impl crate::Readable for LPTR {}
#[doc = "`write(|w| ..)` method takes [lptr::W](lptr::W) writer structure"]
impl crate::Writable for LPTR {}
#[doc = "low-power timeout register"]
pub mod lptr;
#[doc = "write communication configuration register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [wpccr](wpccr) module"]
pub type WPCCR = crate::Reg<u32, _WPCCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _WPCCR;
#[doc = "`read()` method returns [wpccr::R](wpccr::R) reader structure"]
impl crate::Readable for WPCCR {}
#[doc = "`write(|w| ..)` method takes [wpccr::W](wpccr::W) writer structure"]
impl crate::Writable for WPCCR {}
#[doc = "write communication configuration register"]
pub mod wpccr;
#[doc = "write timing configuration register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [wptcr](wptcr) module"]
pub type WPTCR = crate::Reg<u32, _WPTCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _WPTCR;
#[doc = "`read()` method returns [wptcr::R](wptcr::R) reader structure"]
impl crate::Readable for WPTCR {}
#[doc = "`write(|w| ..)` method takes [wptcr::W](wptcr::W) writer structure"]
impl crate::Writable for WPTCR {}
#[doc = "write timing configuration register"]
pub mod wptcr;
#[doc = "write instruction register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [wpir](wpir) module"]
pub type WPIR = crate::Reg<u32, _WPIR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _WPIR;
#[doc = "`read()` method returns [wpir::R](wpir::R) reader structure"]
impl crate::Readable for WPIR {}
#[doc = "`write(|w| ..)` method takes [wpir::W](wpir::W) writer structure"]
impl crate::Writable for WPIR {}
#[doc = "write instruction register"]
pub mod wpir;
#[doc = "write alternate bytes register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [wpabr](wpabr) module"]
pub type WPABR = crate::Reg<u32, _WPABR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _WPABR;
#[doc = "`read()` method returns [wpabr::R](wpabr::R) reader structure"]
impl crate::Readable for WPABR {}
#[doc = "`write(|w| ..)` method takes [wpabr::W](wpabr::W) writer structure"]
impl crate::Writable for WPABR {}
#[doc = "write alternate bytes register"]
pub mod wpabr;
#[doc = "WCCR\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [wccr](wccr) module"]
pub type WCCR = crate::Reg<u32, _WCCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _WCCR;
#[doc = "`read()` method returns [wccr::R](wccr::R) reader structure"]
impl crate::Readable for WCCR {}
#[doc = "`write(|w| ..)` method takes [wccr::W](wccr::W) writer structure"]
impl crate::Writable for WCCR {}
#[doc = "WCCR"]
pub mod wccr;
#[doc = "WTCR\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [wtcr](wtcr) module"]
pub type WTCR = crate::Reg<u32, _WTCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _WTCR;
#[doc = "`read()` method returns [wtcr::R](wtcr::R) reader structure"]
impl crate::Readable for WTCR {}
#[doc = "`write(|w| ..)` method takes [wtcr::W](wtcr::W) writer structure"]
impl crate::Writable for WTCR {}
#[doc = "WTCR"]
pub mod wtcr;
#[doc = "WIR\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [wir](wir) module"]
pub type WIR = crate::Reg<u32, _WIR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _WIR;
#[doc = "`read()` method returns [wir::R](wir::R) reader structure"]
impl crate::Readable for WIR {}
#[doc = "`write(|w| ..)` method takes [wir::W](wir::W) writer structure"]
impl crate::Writable for WIR {}
#[doc = "WIR"]
pub mod wir;
#[doc = "WABR\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [wabr](wabr) module"]
pub type WABR = crate::Reg<u32, _WABR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _WABR;
#[doc = "`read()` method returns [wabr::R](wabr::R) reader structure"]
impl crate::Readable for WABR {}
#[doc = "`write(|w| ..)` method takes [wabr::W](wabr::W) writer structure"]
impl crate::Writable for WABR {}
#[doc = "WABR"]
pub mod wabr;
#[doc = "HyperBusTM latency configuration register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [hlcr](hlcr) module"]
pub type HLCR = crate::Reg<u32, _HLCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _HLCR;
#[doc = "`read()` method returns [hlcr::R](hlcr::R) reader structure"]
impl crate::Readable for HLCR {}
#[doc = "`write(|w| ..)` method takes [hlcr::W](hlcr::W) writer structure"]
impl crate::Writable for HLCR {}
#[doc = "HyperBusTM latency configuration register"]
pub mod hlcr;
|
//! [](https://github.com/SOF3/willow/actions?query=workflow%3ACI)
//! [](https://crates.io/crates/willow)
//! [](https://crates.io/crates/willow)
//! [](https://docs.rs/willow)
//! [](https://github.com/SOF3/willow)
//! [](https://github.com/SOF3/willow)
//!
//! Willow is a library for using the WebGL API in WebAssembly projects.
//! It generates type-safe wrappers for WebAssembly programs using a macro syntax.
#![warn(missing_docs)]
use std::marker::PhantomData;
use std::mem;
use std::ops::{Bound, RangeBounds};
pub use willow_codegen::Program;
pub use anyhow::{self, Error, Result};
#[doc(hidden)]
pub use field_offset::offset_of;
#[doc(hidden)]
pub use log;
#[doc(hidden)]
pub use paste::paste;
#[doc(hidden)]
pub use web_sys::{
WebGlBuffer, WebGlProgram, WebGlRenderingContext, WebGlShader, WebGlUniformLocation,
};
mod index;
pub use index::*;
mod types;
pub use types::*;
mod program;
pub use program::*;
mod traits;
pub use traits::*;
/// A wrapper for a WebGL rendering context.
pub struct Context {
/// The raw WebGlRenderingContext object.
pub native: WebGlRenderingContext,
/// Ratio of width/height
aspect: f32,
}
impl Context {
/// Creates a context on the canvas element.
pub fn from_canvas(canvas: web_sys::Element, aspect_fix: AspectFix) -> Result<Self> {
use anyhow::Context;
use wasm_bindgen::JsCast;
let canvas = canvas
.dyn_into::<web_sys::HtmlCanvasElement>()
.ok()
.context("The element is not a <canvas>")?;
let aspect = canvas.client_width() as f32 / canvas.client_height() as f32;
match aspect_fix {
AspectFix::None => (),
AspectFix::FromWidth => canvas.set_height((canvas.width() as f32 / aspect) as u32),
AspectFix::FromHeight => canvas.set_width((canvas.height() as f32 * aspect) as u32),
}
Ok(Self {
native: canvas
.get_context("webgl")
.ok()
.flatten()
.context("Could not initialize WebGL context")?
.dyn_into()
.ok()
.context("WebGL context has an incorrect type")?,
aspect,
})
}
/// Aspect ratio of the canvas.
pub fn aspect(&self) -> f32 {
// TODO update upon resize
self.aspect
}
/// Clears the color, depth and stencil buffers.
pub fn clear(&self, clear: Clear) {
let mut mask = 0;
if let Some([r, g, b, a]) = clear.color {
mask |= WebGlRenderingContext::COLOR_BUFFER_BIT;
self.native.clear_color(r, g, b, a);
}
if let Some(depth) = clear.depth {
mask |= WebGlRenderingContext::DEPTH_BUFFER_BIT;
self.native.clear_depth(depth);
}
if let Some(stencil) = clear.stencil {
mask |= WebGlRenderingContext::STENCIL_BUFFER_BIT;
self.native.clear_stencil(stencil);
}
self.native.clear(mask);
}
}
/// Policy for correcting canvas size.
///
/// This corrects the canvas based on the rendered aspect ratio and the number of pixels in the
/// canvas along a certain axis.
#[derive(Debug, Clone, Copy)]
pub enum AspectFix {
/// Do not provide any correction
None,
/// Correct height based on canvas width and rendered aspect ratio
FromWidth,
/// Correct width based on canvas height and rendered aspect ratio
FromHeight,
}
/// Parameters for [`Context::clear`][Context::clear].
#[derive(Debug, Clone, Copy, Default)]
pub struct Clear {
/// The RGBA values (in the range `[0, 1]`) to reset to.
pub color: Option<[f32; 4]>,
/// The depth value (in the range `[0, 1]`) to reset to.
pub depth: Option<f32>,
/// The stencil value to reset to.
pub stencil: Option<i32>,
}
/// This macro allows efficient batch creation of programs by compiling and linking in parallel.
///
/// Example:
/// ```ignore
/// let (foo, bar, qux) = create_programs![context => Foo, Bar, Qux];
/// ```
///
/// This is more efficient than
/// ```ignore
/// let foo = Foo::create(context);
/// let bar = Bar::create(context);
/// let qux = Qux::create(context);
/// ```
#[macro_export]
macro_rules! create_programs {
($context:expr => $($ty:ty),* $(,)?) => {
{
$crate::paste! {
$(
#[allow(non_snake_case)]
let [<var_ $ty>] = $ty::create_internally(&$context);
)*;
$(
[<var_ $ty>].compile_shaders(&$context);
)*
$(
[<var_ $ty>].link_shaders(&$context);
)*
($(
[<var_ $ty>],
)*)
}
}
}
}
/// Wraps a WebGL buffer.
pub struct Buffer<T: AttrStruct> {
#[doc(hidden)]
pub buf: WebGlBuffer,
count: usize, // number of elements
_ph: PhantomData<*const T>,
}
impl<T: AttrStruct> Buffer<T> {
/// Allocates a WebGL buffer with the contents in `slice`.
pub fn from_slice(context: &Context, slice: &[T], usage: BufferDataUsage) -> Self {
let gl = &context.native;
let buf = gl.create_buffer().expect("Failed to create WebGL buffer");
gl.bind_buffer(WebGlRenderingContext::ARRAY_BUFFER, Some(&buf));
let bytes = unsafe {
std::slice::from_raw_parts(
slice.as_ptr() as *const u8,
slice.len() * mem::size_of::<T>(),
)
};
gl.buffer_data_with_u8_array(WebGlRenderingContext::ARRAY_BUFFER, bytes, usage.to_const());
Self {
buf,
count: slice.len(),
_ph: PhantomData,
}
}
/// Binds the buffer to a specified attribute.
pub fn bind_to_attr(&self, context: &Context, attr_index: u32, field_index: usize) {
context.native.vertex_attrib_pointer_with_i32(
attr_index,
T::field_num_comps(field_index) as i32, // component count
T::field_type(field_index), // type
T::field_normalized(field_index), // normalized
mem::size_of::<T>() as i32, // stride
T::field_offset(field_index) as i32, // offset
);
}
}
/// The `usage` parameter passed to `bufferData`.
///
/// Corresponds to the [`usage` parameter in `bufferData`][mdn].
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/bufferData#parameters
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BufferDataUsage {
/// The contents are intended to be specified once by the application, and used many times as the source for WebGL drawing and image specification commands.
StaticDraw,
/// The contents are intended to be respecified repeatedly by the application, and used many times as the source for WebGL drawing and image specification commands.
DynamicDraw,
/// The contents are intended to be specified once by the application, and used at most a few times as the source for WebGL drawing and image specification commands.
StreamDraw,
}
impl BufferDataUsage {
fn to_const(self) -> u32 {
match self {
Self::StaticDraw => WebGlRenderingContext::STATIC_DRAW,
Self::DynamicDraw => WebGlRenderingContext::DYNAMIC_DRAW,
Self::StreamDraw => WebGlRenderingContext::STREAM_DRAW,
}
}
}
/// The type of rendering primitive.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RenderPrimitiveType {
/// Draws a single dot.
Points,
/// Draws a straight line to the next vertex.
LineStrip,
/// Draws a straight line to the next vertex, and connects the last vertex back to the first.
LineLoop,
/// Draws a line between a pair of vertices.
Lines,
/// <https://en.wikipedia.org/wiki/Triangle_strip>
TriangleStrip,
/// <https://en.wikipedia.org/wiki/Triangle_fan>
TriangleFan,
/// Draws a triangle for a group of three vertices.
Triangles,
}
impl RenderPrimitiveType {
fn to_const(self) -> u32 {
match self {
Self::Points => WebGlRenderingContext::POINTS,
Self::LineStrip => WebGlRenderingContext::LINE_STRIP,
Self::LineLoop => WebGlRenderingContext::LINE_LOOP,
Self::Lines => WebGlRenderingContext::LINES,
Self::TriangleStrip => WebGlRenderingContext::TRIANGLE_STRIP,
Self::TriangleFan => WebGlRenderingContext::TRIANGLE_FAN,
Self::Triangles => WebGlRenderingContext::TRIANGLES,
}
}
}
fn resolve_range(items: impl RangeBounds<usize>, len: usize) -> (i32, i32) {
let start = match items.start_bound() {
Bound::Included(&x) => x as i32,
Bound::Excluded(&x) => x as i32 - 1,
Bound::Unbounded => 0,
};
let end = match items.end_bound() {
Bound::Included(&x) => x as i32 + 1,
Bound::Excluded(&x) => x as i32,
Bound::Unbounded => len as i32,
};
// assert!(end <= len as i32, "items range exceeds buffer size");
(start, end)
}
|
use quickcheck::TestResult;
use rand::{thread_rng, Rng};
use super::*;
use bat::bat_tests::create_mock_provided_bat;
use bat::SuperBat;
use map;
use map::map_tests::gen_rand_valid_path_of_len;
use pit::BottomlessPit;
use player::player_tests::create_mock_directed_player;
use player::Action;
use wumpus::Wumpus;
pub fn new_game_from(p: Player, s: State) -> Game {
let wumpus = Rc::new(Wumpus::new(s.wumpus));
let hazzards: Vec<Rc<dyn Hazzard>> = vec![
wumpus.clone(),
Rc::new(BottomlessPit { room: s.pit1 }),
Rc::new(BottomlessPit { room: s.pit2 }),
Rc::new(SuperBat::new(s.bat1)),
Rc::new(SuperBat::new(s.bat2)),
];
Game {
player: box p,
wumpus,
pit1_room: s.pit1,
pit2_room: s.pit2,
bat1_room: s.bat1,
bat2_room: s.bat2,
hazzards,
is_cheating: false
}
}
/// player moves into bat room, gets snatched back into the bat room, then
/// snatched to pit room.
#[test]
fn player_can_get_multi_snatched_into_pit() {
let player_room = 1;
let bat1_room = 2;
let bat2_room = 20;
let pit1_room = 3;
let pit2_room = 19;
let wumpus_room = 18;
let player = box create_mock_directed_player(player_room, vec![Action::Move(bat1_room)]);
let wumpus = Rc::new(Wumpus::new(wumpus_room));
let hazzards: Vec<Rc<dyn Hazzard>> = vec![
Rc::new(BottomlessPit { room: pit1_room }),
Rc::new(BottomlessPit { room: pit2_room }),
Rc::new(create_mock_provided_bat(
bat1_room,
vec![bat1_room, pit1_room]
)),
Rc::new(SuperBat::new(bat2_room)),
];
let mut game = Game {
player,
wumpus,
pit1_room,
pit2_room,
bat1_room,
bat2_room,
hazzards,
is_cheating: false
};
assert_eq!(RunResult::KilledByPit, game.run());
}
/// loop up to the max where we can shoot through up to 5 rooms in line and
/// still miss the Wumpus by one.
#[test]
fn can_miss_by_one() {
let max = map::NUM_OF_ROOMS - MAX_TRAVERSABLE;
for room_num in 1..max {
perform_trial(4, &|| {
// room count includes the player's room plus the number of rooms for the
// crooked arrow to traverse. [2, 6]
let room_count = thread_rng().gen_range(2, MAX_TRAVERSABLE + 2);
let rooms: Vec<_> = (room_num..(room_num + room_count)).collect();
let wumpus = room_num + room_count;
let shoot_result = traverse(&rooms, &get_inital_state(rooms[0], wumpus));
assert_eq!(
ShootResult::Miss,
shoot_result,
"rooms: {:?} wumpus: {}",
rooms,
wumpus
);
});
}
}
/// loop up to the max where we can shoot through up to 5 rooms in line and hit
/// the Wumpus.
#[test]
fn can_hit() {
let max = map::NUM_OF_ROOMS - MAX_TRAVERSABLE;
for room_num in 1..max {
perform_trial(4, &|| {
let room_count = thread_rng().gen_range(2, MAX_TRAVERSABLE + 2);
let rooms: Vec<_> = (room_num..(room_num + room_count)).collect();
let wumpus = rooms[rooms.len() - 1];
let shoot_result = traverse(&rooms, &get_inital_state(rooms[0], wumpus));
assert_eq!(ShootResult::Hit, shoot_result);
});
}
}
#[quickcheck]
fn invalid_first_room_causes_random_traversal(room_to_shoot: RoomNum) -> TestResult {
let player = 1;
if !is_adj(player, room_to_shoot) {
let wumpus = 20;
let rooms = [player, room_to_shoot];
// cannot shoot from a room not adjacent to the player.
let shoot_result = traverse(&rooms, &get_inital_state(player, wumpus));
TestResult::from_bool(ShootResult::Remaining(2, player) == shoot_result)
} else {
TestResult::discard()
}
}
#[test]
fn disjoint_room_causes_random_traversal() {
perform_trial(10, &|| {
// get rand number from [1, 5] and leave room for the last room to be disjoint.
let max = MAX_TRAVERSABLE + 1; // player room + 5 traversable rooms we can shoot.
let room_count = thread_rng().gen_range(1, max);
let mut paths = gen_rand_valid_path_of_len(room_count);
assert_eq!(room_count, paths.len(), "must gen paths of the given len.");
let last = paths[paths.len() - 1];
let disjoint_room = get_rand_room_disjoint_from(last);
paths.push(disjoint_room);
let wumpus = 21; // off the map so we don't hit the Wumpus.
let shoot_result = traverse(&paths, &get_inital_state(paths[0], wumpus));
let last_valid = paths[paths.len() - 2];
println!("{:?}", paths);
assert_eq!(
ShootResult::Remaining(2, last_valid),
shoot_result,
"paths: {:?}",
&paths
);
});
}
#[test]
fn player_can_suicide() {
let rooms = [1, 2, 3, 4, 5, 1];
let player = 1;
let wumpus = 20;
let shoot_result = traverse(&rooms, &get_inital_state(player, wumpus));
assert_eq!(ShootResult::Suicide, shoot_result);
}
fn get_rand_room_disjoint_from(room: RoomNum) -> RoomNum {
loop {
let r = map::rand_room();
if !map::is_adj(r, room) {
return r;
}
}
}
fn get_inital_state(player: RoomNum, wumpus: RoomNum) -> State {
State {
player,
wumpus,
arrow_count: 5,
..Default::default()
}
}
fn perform_trial(trial_count: u32, trial: &dyn Fn()) {
(0..trial_count).for_each(|_| trial());
}
|
use std::error::Error;
use std::fs;
type MyResult = Result<(), Box<Error>>;
fn main() -> MyResult
{
Ok(())
} |
#[doc = "Reader of register IM"]
pub type R = crate::R<u32, super::IM>;
#[doc = "Writer for register IM"]
pub type W = crate::W<u32, super::IM>;
#[doc = "Register IM `reset()`'s with value 0"]
impl crate::ResetValue for super::IM {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `ERRIM`"]
pub type ERRIM_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `ERRIM`"]
pub struct ERRIM_W<'a> {
w: &'a mut W,
}
impl<'a> ERRIM_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "Reader of field `RDIM`"]
pub type RDIM_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RDIM`"]
pub struct RDIM_W<'a> {
w: &'a mut W,
}
impl<'a> RDIM_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `WRIM`"]
pub type WRIM_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WRIM`"]
pub struct WRIM_W<'a> {
w: &'a mut W,
}
impl<'a> WRIM_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `DMARDIM`"]
pub type DMARDIM_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `DMARDIM`"]
pub struct DMARDIM_W<'a> {
w: &'a mut W,
}
impl<'a> DMARDIM_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `DMAWRIM`"]
pub type DMAWRIM_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `DMAWRIM`"]
pub struct DMAWRIM_W<'a> {
w: &'a mut W,
}
impl<'a> DMAWRIM_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
impl R {
#[doc = "Bit 0 - Error Interrupt Mask"]
#[inline(always)]
pub fn errim(&self) -> ERRIM_R {
ERRIM_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - Read FIFO Full Interrupt Mask"]
#[inline(always)]
pub fn rdim(&self) -> RDIM_R {
RDIM_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - Write FIFO Empty Interrupt Mask"]
#[inline(always)]
pub fn wrim(&self) -> WRIM_R {
WRIM_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - Read uDMA Interrupt Mask"]
#[inline(always)]
pub fn dmardim(&self) -> DMARDIM_R {
DMARDIM_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - Write uDMA Interrupt Mask"]
#[inline(always)]
pub fn dmawrim(&self) -> DMAWRIM_R {
DMAWRIM_R::new(((self.bits >> 4) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - Error Interrupt Mask"]
#[inline(always)]
pub fn errim(&mut self) -> ERRIM_W {
ERRIM_W { w: self }
}
#[doc = "Bit 1 - Read FIFO Full Interrupt Mask"]
#[inline(always)]
pub fn rdim(&mut self) -> RDIM_W {
RDIM_W { w: self }
}
#[doc = "Bit 2 - Write FIFO Empty Interrupt Mask"]
#[inline(always)]
pub fn wrim(&mut self) -> WRIM_W {
WRIM_W { w: self }
}
#[doc = "Bit 3 - Read uDMA Interrupt Mask"]
#[inline(always)]
pub fn dmardim(&mut self) -> DMARDIM_W {
DMARDIM_W { w: self }
}
#[doc = "Bit 4 - Write uDMA Interrupt Mask"]
#[inline(always)]
pub fn dmawrim(&mut self) -> DMAWRIM_W {
DMAWRIM_W { w: self }
}
}
|
// Smallest String With A Given Numeric Value
// https://leetcode.com/explore/challenge/card/january-leetcoding-challenge-2021/582/week-4-january-22nd-january-28th/3619/
pub struct Solution;
// First solution
#[cfg(disable)]
impl Solution {
pub fn get_smallest_string(n: i32, k: i32) -> String {
let n = n as usize;
let k = k as usize;
let num_of_z = (k - n) / 25;
let inter_add = (k - n) % 25;
let num_of_a = n - num_of_z - (inter_add != 0) as usize;
let mut res = String::with_capacity(n);
for _ in 0..num_of_a {
res.push('a');
}
if inter_add != 0 {
res.push(('a' as u8 + inter_add as u8) as char);
}
for _ in 0..num_of_z {
res.push('z');
}
res
}
}
impl Solution {
pub fn get_smallest_string(n: i32, k: i32) -> String {
let mut bytes = vec![0u8; n as _];
let mut needed = k - n;
for c in bytes.iter_mut().rev() {
let over = needed.min(25);
*c = b'a' + over as u8;
needed -= over;
}
unsafe { String::from_utf8_unchecked(bytes) }
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test0a() {
assert_eq!(&Solution::get_smallest_string(1, 1), "a");
}
#[test]
fn test0z() {
assert_eq!(&Solution::get_smallest_string(1, 26), "z");
}
#[test]
fn test0az() {
assert_eq!(&Solution::get_smallest_string(2, 27), "az");
}
#[test]
fn example1() {
assert_eq!(&Solution::get_smallest_string(3, 27), "aay");
}
#[test]
fn example2() {
assert_eq!(&Solution::get_smallest_string(5, 73), "aaszz");
}
}
|
use yew::prelude::*;
// use yew_router::components::RouterAnchor;
// use crate::app::Route;
pub struct ApplicationHome {}
pub enum Msg {}
impl Component for ApplicationHome {
type Message = Msg;
type Properties = ();
fn create(_: Self::Properties, _: ComponentLink<Self>) -> Self {
ApplicationHome {}
}
fn update(&mut self, _msg: Self::Message) -> ShouldRender {
true
}
fn change(&mut self, _: Self::Properties) -> ShouldRender {
false
}
fn view(&self) -> Html {
// type Anchor = RouterAnchor<Route>;
html! {
<>
<div
class="col py-3"
>
<div>
<div
class="mx-auto pt-5 pb-5 px-4"
style="max-width: 1048px;"
>
<div
class="mb-5"
>
<div
class="d-flex flex-row mb-3"
>
<div
class="flex-fill fs-3 fw-bold"
>
{"Applications"}
</div>
<div>
<button
type="button"
class="btn btn-primary d-flex align-items-center"
data-bs-toggle="modal"
data-bs-target="#exampleModal"
>
<i
class="bi bi-plus me-2"
style="margin-left: -5px;"
>
</i>
<span>{"Create Application"}</span>
</button>
</div>
</div>
<p>{"Setup a application to use for Authentication."}</p>
</div>
// <!-- LIST -->
<div>
<div
class="d-flex border-bottom border-1 list-hover"
>
<div
class="p-3 d-flex"
style="width: 40%;"
>
<div
style="flex: 0 0 auto; width: 40px; height: 40px; background-color: #eff0f2;"
class="d-flex justify-content-center align-items-center rounded me-3"
>
<img
src="https://cdn.auth0.com/manhattan/versions/1.3226.0/assets/non_interactive.svg" style=" color: transparent;
width: 100%;
height: 100%;
object-fit: cover;
text-align: center;
text-indent: 10000px;"
/>
</div>
<div
class="d-grid"
style="min-width: 40px;"
>
<a
class="fw-bold mb-0"
style=" white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
text-decoration: none;"
href="#">
{"API Explorer Application"}
</a>
<p
class="mb-0 text-muted"
style=" white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;"
>
{"Machine to Machine"}
</p>
</div>
</div>
<div
class="p-3 d-flex flex-fill align-items-center text-muted"
>
<span
style="font-size: 14px; margin-right: 8px; white-space: nowrap;"
>
{"Client ID:"}
</span>
<div
class="rounded"
style=" background-color: #eff0f2;
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
padding: 2px 6px;
font-family: 'Roboto Mono', monospace;"
>
{"AunM1dD5rf3p6xALjnssbrVWSiYiFBcy"}
</div>
<i
class="bi bi-files ms-1"
>
</i>
</div>
<div
class="p-3 d-flex align-items-center dropdown"
>
<button
type="button"
style="flex: 0 0 auto; width: 30px; height: 30px;"
class="btn d-flex justify-content-center align-items-center rounded border" role="button"
id="dropdownMenuButton1"
data-bs-toggle="dropdown"
aria-expanded="false"
>
<i
class="bi bi-three-dots"
>
</i>
</button>
<ul
class="dropdown-menu"
aria-labelledby="dropdownMenuButton1"
>
<li>
<a
class="dropdown-item fs-7"
href="#"
>
{"Quickstart"}
</a>
</li>
<li>
<a
class="dropdown-item fs-7"
href="#"
>
{"Settings"}
</a>
</li>
<li>
<a
class="dropdown-item fs-7"
href="#"
>
{"API"}
</a>
</li>
</ul>
</div>
</div>
</div>
<div>
<div
class="d-flex border-bottom border-1 list-hover"
>
<div class="p-3 d-flex" style="width: 40%;">
<div style="flex: 0 0 auto; width: 40px; height: 40px; background-color: #eff0f2;"
class="d-flex justify-content-center align-items-center rounded me-3">
<img
src="https://cdn.auth0.com/manhattan/versions/1.3226.0/assets/non_interactive.svg" style=" color: transparent;
width: 100%;
height: 100%;
object-fit: cover;
text-align: center;
text-indent: 10000px;"/>
</div>
<div class="d-grid" style="min-width: 40px;">
<a class="fw-bold mb-0" style="
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
text-decoration: none;
" href="#">
{"Management API (Test Application)"}
</a>
<p class="mb-0 text-muted" style="
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
">
{"Machine to Machine"}
</p>
</div>
</div>
<div class="p-3 d-flex flex-fill align-items-center text-muted">
<span style="font-size: 14px; margin-right: 8px; white-space: nowrap;">
{"Client ID:"}
</span>
<div class="rounded" style="
background-color: #eff0f2;
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
padding: 2px 6px;
font-family: 'Roboto Mono', monospace;"
>
{"AunM1dD5rf3p6xALjnssbrVWSiYiFBcy"}
</div>
<i class="bi bi-files ms-1"></i>
</div>
<div class="p-3 d-flex align-items-center dropdown">
<button type="button" style="flex: 0 0 auto; width: 30px; height: 30px;"
class="btn d-flex justify-content-center align-items-center rounded border" role="button"
id="dropdownMenuButton1" data-bs-toggle="dropdown" aria-expanded="false">
<i class="bi bi-three-dots"></i>
</button>
<ul class="dropdown-menu" aria-labelledby="dropdownMenuButton1">
<li><a class="dropdown-item fs-7" href="#">{"Quickstart"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"Settings"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"API"}</a></li>
</ul>
</div>
</div>
</div>
<div>
<div class="d-flex border-bottom border-1 list-hover">
<div class="p-3 d-flex" style="width: 40%;">
<div style="flex: 0 0 auto; width: 40px; height: 40px; background-color: #eff0f2;"
class="d-flex justify-content-center align-items-center rounded me-3">
<img src="https://cdn.auth0.com/manhattan/versions/1.3226.0/assets/none.svg"
style=" color: transparent;
width: 100%;
height: 100%;
object-fit: cover;
text-align: center;
text-indent: 10000px;"/>
</div>
<div class="d-grid" style="min-width: 40px;">
<a class="fw-bold mb-0" style="
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
text-decoration: none;
" href="#">
{"Default App"}
</a>
<p class="mb-0 text-muted" style="
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
">
{"Generic"}
</p>
</div>
</div>
<div class="p-3 d-flex flex-fill align-items-center text-muted">
<span style="font-size: 14px; margin-right: 8px; white-space: nowrap;">
{"Client ID:"}
</span>
<div class="rounded" style="
background-color: #eff0f2;
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
padding: 2px 6px;
font-family: 'Roboto Mono', monospace;
">
{"AunM1dD5rf3p6xALjnssbrVWSiYiFBcy"}
</div>
<i class="bi bi-files ms-1"></i>
</div>
<div class="p-3 d-flex align-items-center dropdown">
<button type="button" style="flex: 0 0 auto; width: 30px; height: 30px;"
class="btn d-flex justify-content-center align-items-center rounded border" role="button"
id="dropdownMenuButton1" data-bs-toggle="dropdown" aria-expanded="false">
<i class="bi bi-three-dots"></i>
</button>
<ul class="dropdown-menu" aria-labelledby="dropdownMenuButton1">
<li><a class="dropdown-item fs-7" href="#">{"Quickstart"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"Settings"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"Addons"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"Connections"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"Organizations"}</a></li>
</ul>
</div>
</div>
</div>
<div>
<div class="d-flex border-bottom border-1 list-hover">
<div class="p-3 d-flex" style="width: 40%;">
<div style="flex: 0 0 auto; width: 40px; height: 40px; background-color: #eff0f2;"
class="d-flex justify-content-center align-items-center rounded me-3">
<img src="https://cdn.auth0.com/manhattan/versions/1.3226.0/assets/spa.svg"
style=" color: transparent;
width: 100%;
height: 100%;
object-fit: cover;
text-align: center;
text-indent: 10000px;"/>
</div>
<div class="d-grid" style="min-width: 40px;">
<a class="fw-bold mb-0" style="
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
text-decoration: none;
" href="#">
{"My App"}
</a>
<p class="mb-0 text-muted" style="
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
">
{"Single Page Application"}
</p>
</div>
</div>
<div class="p-3 d-flex flex-fill align-items-center text-muted">
<span style="font-size: 14px; margin-right: 8px; white-space: nowrap;">
{"Client ID:"}
</span>
<div class="rounded" style="
background-color: #eff0f2;
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
padding: 2px 6px;
font-family: 'Roboto Mono', monospace;
">
{"AunM1dD5rf3p6xALjnssbrVWSiYiFBcy"}
</div>
<i class="bi bi-files ms-1"></i>
</div>
<div class="p-3 d-flex align-items-center dropdown">
<button type="button" style="flex: 0 0 auto; width: 30px; height: 30px;"
class="btn d-flex justify-content-center align-items-center rounded border" role="button"
id="dropdownMenuButton1" data-bs-toggle="dropdown" aria-expanded="false">
<i class="bi bi-three-dots"></i>
</button>
<ul class="dropdown-menu" aria-labelledby="dropdownMenuButton1">
<li><a class="dropdown-item fs-7" href="#">{"Quickstart"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"Settings"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"Addons"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"Connections"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"Organizations"}</a></li>
</ul>
</div>
</div>
</div>
<div>
<div class="d-flex border-bottom border-1 list-hover">
<div class="p-3 d-flex" style="width: 40%;">
<div style="flex: 0 0 auto; width: 40px; height: 40px; background-color: #eff0f2;"
class="d-flex justify-content-center align-items-center rounded me-3">
<img
src="https://cdn.auth0.com/manhattan/versions/1.3226.0/assets/non_interactive.svg" style=" color: transparent;
width: 100%;
height: 100%;
object-fit: cover;
text-align: center;
text-indent: 10000px;"/>
</div>
<div class="d-grid" style="min-width: 40px;">
<a class="fw-bold mb-0" style="
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
text-decoration: none;
" href="#">
{"Test (Test Application)"}
</a>
<p class="mb-0 text-muted" style="
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
">
{"Machine To Machine"}
</p>
</div>
</div>
<div class="p-3 d-flex flex-fill align-items-center text-muted">
<span style="font-size: 14px; margin-right: 8px; white-space: nowrap;">
{"Client ID:"}
</span>
<div class="rounded" style="
background-color: #eff0f2;
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
font-size: 14px;
padding: 2px 6px;
font-family: 'Roboto Mono', monospace;"
>
{"AunM1dD5rf3p6xALjnssbrVWSiYiFBcy"}
</div>
<i class="bi bi-files ms-1"></i>
</div>
<div class="p-3 d-flex align-items-center dropdown">
<button type="button" style="flex: 0 0 auto; width: 30px; height: 30px;"
class="btn d-flex justify-content-center align-items-center rounded border" role="button"
id="dropdownMenuButton1" data-bs-toggle="dropdown" aria-expanded="false">
<i class="bi bi-three-dots"></i>
</button>
<ul class="dropdown-menu" aria-labelledby="dropdownMenuButton1">
<li><a class="dropdown-item fs-7" href="#">{"Quickstart"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"Settings"}</a></li>
<li><a class="dropdown-item fs-7" href="#">{"API"}</a></li>
</ul>
</div>
</div>
</div>
// <!-- Modal -->
<div class="modal fade" id="exampleModal" tabindex="-1" aria-labelledby="exampleModalLabel" aria-hidden="true">
<div class="modal-dialog modal-dialog-scrollable">
<div class="modal-content">
<div class="modal-header">
<h5 class="modal-title" id="exampleModalLabel">{"Create Application"}</h5>
<button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
</div>
<div class="modal-body" style="font-size: 14px;">
<div class="mb-4">
<label for="basic-url" class="form-label fw-bold">{"Name"}</label>
<div class="input-group mb-2">
<input type="text" class="form-control" placeholder="My App" id="basic-url" aria-describedby="basic-addon3" />
</div>
<label class="form-label text-muted">{"This is your application name"}</label>
</div>
<div class="mb-4">
<label for="basic-url" class="form-label fw-bold">{"Application type"}</label>
<div class="input-group mb-2">
<input type="text" class="form-control" id="basic-url" aria-describedby="basic-addon3" />
</div>
<label class="form-label text-muted">{"Ex: Web Application"}</label>
</div>
</div>
<div class="modal-footer">
<button type="button" class="btn btn-secondary" data-bs-dismiss="modal">{"Cancel"}</button>
<button type="button" class="btn btn-primary">{"Create"}</button>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</>
}
}
}
|
use crate::song::hash::{HashMd5, HashSha256};
use std::collections::HashMap;
#[derive(Clone, Debug)]
pub struct Converter {
pub md5_to_sha256: HashMap<HashMd5, HashSha256>,
pub sha256_to_md5: HashMap<HashSha256, HashMd5>,
}
impl Converter {
pub fn new(
md5_to_sha256: HashMap<HashMd5, HashSha256>,
sha256_to_md5: HashMap<HashSha256, HashMd5>,
) -> Converter {
Converter {
md5_to_sha256,
sha256_to_md5,
}
}
pub fn get_md5(&self, sha256: &HashSha256) -> Option<HashMd5> {
self.sha256_to_md5.get(sha256).cloned()
}
pub fn get_sha256(&self, md5: &HashMd5) -> Option<HashSha256> {
self.md5_to_sha256.get(md5).cloned()
}
}
#[cfg(test)]
mod test {
use crate::song::hash::{HashMd5, HashSha256};
use crate::song::hash_converter::Converter;
use std::collections::HashMap;
#[test]
fn get() {
let mut builder = Builder::new();
let m1: HashMd5 = "m1".parse().unwrap();
let m2: HashMd5 = "m2".parse().unwrap();
let m3: HashMd5 = "m3".parse().unwrap();
let s1: HashSha256 = "s1".parse().unwrap();
let s2: HashSha256 = "s2".parse().unwrap();
let s3: HashSha256 = "s3".parse().unwrap();
builder.push(m1.clone(), s1.clone());
builder.push(m2.clone(), s2.clone());
let obj = Builder::build(builder);
assert_eq!(obj.get_md5(&s1), Some(m1.clone()));
assert_eq!(obj.get_sha256(&m1), Some(s1.clone()));
assert_eq!(obj.get_md5(&s3), None);
assert_eq!(obj.get_sha256(&m3), None);
}
struct Builder {
md5_to_sha256: HashMap<HashMd5, HashSha256>,
sha256_to_md5: HashMap<HashSha256, HashMd5>,
}
impl Builder {
pub fn new() -> Builder {
Builder {
md5_to_sha256: HashMap::new(),
sha256_to_md5: HashMap::new(),
}
}
fn push(&mut self, md5: HashMd5, sha256: HashSha256) {
self.sha256_to_md5.insert(sha256.clone(), md5.clone());
self.md5_to_sha256.insert(md5, sha256);
}
fn build(builder: Self) -> Converter {
Converter::new(builder.md5_to_sha256, builder.sha256_to_md5)
}
}
}
|
//! Internal result and error types used to build InfluxQL parsers
//!
use nom::error::{ErrorKind as NomErrorKind, ParseError as NomParseError};
use nom::Parser;
use std::borrow::Borrow;
use std::fmt::{Display, Formatter};
/// This trait must be implemented in order to use the [`map_fail`] and
/// [`expect`] functions for generating user-friendly error messages.
pub trait ParseError<'a>: NomParseError<&'a str> + Sized {
fn from_message(input: &'a str, message: &'static str) -> Self;
}
/// An internal error type used to build InfluxQL parsers.
#[derive(Debug, PartialEq, Eq)]
pub enum Error<I> {
Syntax { input: I, message: &'static str },
Nom(I, NomErrorKind),
}
impl<I: Display> Display for Error<I> {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::Syntax { input: _, message } => {
write!(f, "Syntax error: {message}")
}
Self::Nom(_, kind) => write!(f, "nom error: {kind:?}"),
}
}
}
impl<'a> ParseError<'a> for Error<&'a str> {
fn from_message(input: &'a str, message: &'static str) -> Self {
Self::Syntax { input, message }
}
}
/// Applies a function returning a [`ParseResult`] over the result of the `parser`.
/// If the parser returns an error, the result will be mapped to an unrecoverable
/// [`nom::Err::Failure`] with the specified `message` for additional context.
pub fn map_fail<'a, O1, O2, E: ParseError<'a>, E2, F, G>(
message: &'static str,
mut parser: F,
mut f: G,
) -> impl FnMut(&'a str) -> ParseResult<&'a str, O2, E>
where
F: Parser<&'a str, O1, E>,
G: FnMut(O1) -> Result<O2, E2>,
{
move |input| {
let (input, o1) = parser.parse(input)?;
match f(o1) {
Ok(o2) => Ok((input, o2)),
Err(_) => Err(nom::Err::Failure(E::from_message(input, message))),
}
}
}
/// Applies a function returning a [`ParseResult`] over the result of the `parser`.
/// If the parser returns an error, the result will be mapped to a recoverable
/// [`nom::Err::Error`] with the specified `message` for additional context.
pub fn map_error<'a, O1, O2, E: ParseError<'a>, E2, F, G>(
message: &'static str,
mut parser: F,
mut f: G,
) -> impl FnMut(&'a str) -> ParseResult<&'a str, O2, E>
where
F: Parser<&'a str, O1, E>,
G: FnMut(O1) -> Result<O2, E2>,
{
move |input| {
let (input, o1) = parser.parse(input)?;
match f(o1) {
Ok(o2) => Ok((input, o2)),
Err(_) => Err(nom::Err::Error(E::from_message(input, message))),
}
}
}
/// Transforms a [`nom::Err::Error`] to a [`nom::Err::Failure`] using `message` for additional
/// context.
pub fn expect<'a, E: ParseError<'a>, F, O>(
message: &'static str,
mut f: F,
) -> impl FnMut(&'a str) -> ParseResult<&'a str, O, E>
where
F: Parser<&'a str, O, E>,
{
move |i| match f.parse(i) {
Ok(o) => Ok(o),
Err(nom::Err::Incomplete(i)) => Err(nom::Err::Incomplete(i)),
Err(nom::Err::Error(_)) => Err(nom::Err::Failure(E::from_message(i, message))),
Err(nom::Err::Failure(e)) => Err(nom::Err::Failure(e)),
}
}
/// Returns the result of `f` if it satisfies `is_valid`; otherwise,
/// returns an error using the specified `message`.
pub fn verify<'a, O1, O2, E: ParseError<'a>, F, G>(
message: &'static str,
mut f: F,
is_valid: G,
) -> impl FnMut(&'a str) -> ParseResult<&'a str, O1, E>
where
F: Parser<&'a str, O1, E>,
G: Fn(&O2) -> bool,
O1: Borrow<O2>,
O2: ?Sized,
{
move |i: &str| {
let (remain, o) = f.parse(i)?;
if is_valid(o.borrow()) {
Ok((remain, o))
} else {
Err(nom::Err::Failure(E::from_message(i, message)))
}
}
}
impl<I> NomParseError<I> for Error<I> {
fn from_error_kind(input: I, kind: NomErrorKind) -> Self {
Self::Nom(input, kind)
}
fn append(_: I, _: NomErrorKind, other: Self) -> Self {
other
}
}
/// ParseResult is a type alias for [`nom::IResult`] used by nom combinator
/// functions for parsing InfluxQL.
pub(crate) type ParseResult<I, T, E = Error<I>> = nom::IResult<I, T, E>;
|
use crate::vectors::{VectorProperties::* ,Vector3::Vector3, Vector4::*};
use crate::matrices::{Matrix44::*};
use std::ops;
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct Quaternion {
x: f64,
y: f64,
z: f64,
w: f64
}
impl Default for Quaternion {
fn default() -> Quaternion {
Quaternion {
x: 0.0,
y: 0.0,
z: 0.0,
w: 1.0
}
}
}
impl Quaternion {
fn setIdentity(&mut self) {
self.x = 0.0;
self.y = 0.0;
self.z = 0.0;
self.w = 1.0;
}
fn length(&self) -> f64 {
(self.x*self.x + self.y*self.y + self.z*self.z + self.w*self.w).sqrt()
}
fn normalize(&mut self) {
let mag: f64 = self.length();
if mag == 0f64 {
return;
}
self.x /= mag;
self.y /= mag;
self.z /= mag;
self.w /= mag;
}
fn negate(&mut self) {
self.x = -self.x;
self.y = -self.y;
self.z = -self.z;
self.w = -self.w;
}
fn toMatrix(&self) -> Matrix44 {
let mut matrix: Matrix44 = Default::default();
let xy: f64 = self.x * self.y;
let xz: f64 = self.x * self.z;
let xw: f64 = self.x * self.w;
let yz: f64 = self.y * self.z;
let yw: f64 = self.y * self.w;
let zw: f64 = self.z * self.w;
matrix.m00 = 1.0 - 2.0 * (self.y*self.y + self.z*self.z);
matrix.m01 = 2.0 * (xy - zw);
matrix.m02 = 2.0 * (xz + yw);
matrix.m03 = 0.0;
matrix.m10 = 2.0 * (xy + zw);
matrix.m11 = 1.0 - 2.0 * (self.x*self.x + self.z*self.z);
matrix.m12 = 2.0 * (yz - xw);
matrix.m13 = 0.0;
matrix.m20 = 2.0 * (xz - yw);
matrix.m21 = 2.0 * (yz + xw);
matrix.m22 = 1.0 - 2.0 * (self.x*self.x + self.y*self.y);
matrix.m23 = 0.0;
matrix.m30 = 0.0;
matrix.m31 = 0.0;
matrix.m32 = 0.0;
matrix.m33 = 1.0;
return matrix;
}
fn setToAxisAngle(&mut self, axis: &Vector3, angle: f64) {
let mut rot: Matrix44 = Default::default();
rot.rotate(&axis, angle);
self.setMatrix(&rot);
self.normalize();
}
fn slerp(a: &Quaternion, b: &Quaternion, blend: f64) -> Quaternion {
let mut result: Quaternion = Default::default();
let dot = a.w *b.w + a.x*b.x + a.y*b.y + a.z*b.z;
let blendI = 1.0 - blend;
if dot < 0.0 {
result.w = blendI * a.w + blend * -b.w;
result.x = blendI * a.x + blend * -b.x;
result.y = blendI * a.y + blend * -b.y;
result.z = blendI * a.z + blend * -b.z;
} else {
result.w = blendI * a.w + blend * b.w;
result.x = blendI * a.x + blend * b.x;
result.y = blendI * a.y + blend * b.y;
result.z = blendI * a.z + blend * b.z;
}
result.normalize();
return result;
}
pub fn lookRotation(&mut self, f: &Vector3, u: &Vector3) {
// Copy (should work)
let mut forward: Vector3 = *f;
let mut up: Vector3 = *u;
forward.normalize();
up.normalize();
let right = Vector3::cross(&forward, &up);
let mut rot: Matrix44 = Default::default();
rot.m00 = right.x;
rot.m10 = right.y;
rot.m20 = right.z;
rot.m01 = up.x;
rot.m11 = up.y;
rot.m21 = up.z;
rot.m02 = forward.x;
rot.m12 = forward.y;
rot.m22 = forward.z;
self.setMatrix(&rot);
self.normalize();
}
fn setMatrix(&mut self, matrix: &Matrix44) {
let m00 = matrix.m00;
let m01 = matrix.m01;
let m02 = matrix.m02;
let m10 = matrix.m10;
let m11 = matrix.m11;
let m12 = matrix.m12;
let m20 = matrix.m20;
let m21 = matrix.m21;
let m22 = matrix.m22;
let mut s: f64;
let tr = m00 + m11 + m22;
if tr >= 0.0 {
s = (tr + 1.0).sqrt();
self.w = s * 0.5;
s = 0.5 / s;
self.x = (m21 - m12) * s;
self.y = (m02 - m20) * s;
self.z = (m10 - m01) * s;
} else {
let max: f64 = m00.max(m11).max(m22);
if max == m00 {
s = (m00 - (m11 + m22) + 1.0).sqrt();
self.x = s * 0.5;
s = 0.5 / s;
self.y = (m01 + m10) * s;
self.z = (m20 + m02) * s;
self.w = (m21 - m12) * s;
} else if max == m11 {
s = (m11 - (m22 + m00) + 1.0).sqrt();
self.y = s * 0.5;
s = 0.5 / s;
self.z = (m12 + m21) * s;
self.x = (m01 + m10) * s;
self.w = (m02 - m20) * s;
} else {
s = (m22 - (m00 + m11) + 1.0).sqrt();
self.z = s * 0.5;
s = 0.5 / s;
self.x = (m20 + m02) * s;
self.y = (m12 + m21) * s;
self.w = (m10 - m01) * s;
}
}
}
}
impl ops::Mul<Quaternion> for Quaternion {
type Output = Quaternion;
fn mul(self, rhs: Quaternion) -> Quaternion {
Quaternion {
x: self.x * rhs.w + self.w * rhs.x + self.y * rhs.z
- self.z * rhs.y,
y: self.y * rhs.w + self.w * rhs.y
+ self.z * rhs.x - self.x * rhs.z,
z: self.z * rhs.w
+ self.w * rhs.z + self.x * rhs.y - self.y * rhs.x,
w: self.w * rhs.w - self.x * rhs.x - self.y * rhs.y
- self.z * rhs.z
}
}
}
impl ops::Mul<Vector3> for Quaternion {
type Output = Vector3;
fn mul(self, rhs: Vector3) -> Vector3 {
let trans: Matrix44 = self.toMatrix();
let r: Vector4 = trans * Vector4{x: rhs.x, y: rhs.y, z: rhs.z, w: 0f64};
Vector3 {
x: r.x,
y: r.y,
z: r.z
}
}
}
impl ops::Mul<Vector4> for Quaternion {
type Output = Vector4;
fn mul(self, rhs: Vector4) -> Vector4 {
let trans: Matrix44 = self.toMatrix();
trans * rhs
}
}
impl ops::MulAssign<Quaternion> for Quaternion {
fn mul_assign(&mut self, rhs: Quaternion) {
self.x = self.x * rhs.w + self.w * rhs.x + self.y * rhs.z - self.z * rhs.y;
self.y = self.y * rhs.w + self.w * rhs.y + self.z * rhs.x - self.x * rhs.z;
self.z = self.z * rhs.w + self.w * rhs.z + self.x * rhs.y - self.y * rhs.x;
self.w = self.w * rhs.w - self.x * rhs.x - self.y * rhs.y - self.z * rhs.z;
}
} |
// Copyright 2019-2020 PolkaX. Licensed under MIT or Apache-2.0.
//! A CBOR implementation of `ipld format` in Rust.
#![deny(missing_docs)]
mod error;
mod node;
mod value;
pub use ipld_format::{FormatError, Link, Node, NodeStat, Resolver};
pub use self::error::{IpldCoreError, Result};
pub use self::node::IpldNode;
pub use self::value::IpldValue;
|
use std::collections::HashMap;
use order::{Order, OrderId, OrderStatus};
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct Portfolio {
active_orders: HashMap<OrderId, Order>,
closed_orders: HashMap<OrderId, Order>
}
impl Portfolio {
pub fn new() -> Portfolio {
Portfolio {
active_orders: HashMap::new(),
closed_orders: HashMap::new()
}
}
pub fn add_orders(&mut self, orders: Vec<Order>) {
for order in orders {
let mut property = match *order.status() {
OrderStatus::Filled(_) => &mut self.closed_orders,
OrderStatus::Cancelled(_) => &mut self.closed_orders,
_ => &mut self.active_orders
};
assert_eq!(property.insert(order.id().clone(), order), None);
}
}
pub fn update_orders(&mut self, order_updates: &HashMap<OrderId, OrderStatus>) {
for (updated_order_id, updated_order_status) in order_updates {
match *updated_order_status {
OrderStatus::Filled(_) => self.move_active_order_to_closed_orders(updated_order_id, updated_order_status.clone()),
OrderStatus::Cancelled(_) => self.move_active_order_to_closed_orders(updated_order_id, updated_order_status.clone()),
_ => ()
}
}
}
fn move_active_order_to_closed_orders(&mut self, order_id: &OrderId, order_status: OrderStatus) {
match self.active_orders.remove(order_id) {
Some(mut order) => {
order.set_status(order_status);
match *order.status() {
OrderStatus::Filled(_) => {
self.closed_orders.insert(order_id.clone(), order);
},
OrderStatus::Cancelled(_) => {
self.closed_orders.insert(order_id.clone(), order);
},
_ => ()
}
},
None => panic!("Order not found: {}", order_id)
};
}
pub fn active_orders(&self) -> &HashMap<OrderId, Order> {
&self.active_orders
}
pub fn closed_orders(&self) -> &HashMap<OrderId, Order> {
&self.closed_orders
}
}
#[cfg(test)]
mod test {
use super::*;
use direction::Direction;
use symbol::SymbolId;
use order::{OrderKind, OrderBuilder};
#[test]
fn add_order() {
let symbol_id = SymbolId::from("Symbol");
let order = OrderBuilder::unallocated(
OrderKind::MarketOrder, symbol_id.clone(), Direction::Long
).set_id(OrderId::from("test order")).build().unwrap();
let mut portfolio = Portfolio::new();
assert!(portfolio.active_orders().is_empty());
portfolio.add_orders(vec![order.clone()]);
assert_eq!(
portfolio.active_orders(),
&[(order.id().clone(), order)].iter().cloned().collect::<HashMap<OrderId, Order>>()
);
}
}
|
use super::super::commands::CommandResult;
use super::super::{LayoutTree, TreeError};
use super::super::core::Direction;
use super::super::core::container::{Container, ContainerType, Layout};
use petgraph::graph::NodeIndex;
use rustwlc::WlcView;
use uuid::Uuid;
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum FocusError {
/// Reached a container where we can keep climbing the tree no longer.
///
/// Usually this is a workspace, because it doesn't make sense to move a
/// container out of a workspace
ReachedLimit(NodeIndex),
/// Tried to focus on a container that was not a view.
NotAView(Uuid),
/// Tried to focus on a container (first one),
/// but that container was superseded by a fullscreen container (second one)
BlockedByFullscreen(Uuid, Uuid)
}
impl LayoutTree {
/// Focuses on the container by the uuid, if it points to a View.
/// Otherwise, an error is returned.
pub fn focus_on(&mut self, uuid: Uuid) -> CommandResult {
if let Some(fullscreen_id) = self.in_fullscreen_workspace(uuid)? {
if fullscreen_id != uuid {
return Err(TreeError::Focus(FocusError::BlockedByFullscreen(uuid, fullscreen_id)))
}
}
let node_ix = self.tree.lookup_id(uuid)
.ok_or(TreeError::NodeNotFound(uuid))?;
match self.tree[node_ix] {
Container::View { handle, .. } => {
handle.focus();
handle.bring_to_front();
self.active_container = Some(node_ix);
},
_ => return Err(TreeError::Focus(FocusError::NotAView(uuid)))
}
self.tree.set_ancestor_paths_active(node_ix);
let workspace_ix = self.tree.ancestor_of_type(node_ix,
ContainerType::Workspace)?;
for node_ix in self.tree.all_descendants_of(workspace_ix) {
match self.tree[node_ix] {
Container::View { floating, handle, .. } => {
if floating {
handle.bring_to_front();
}
},
_ => {}
}
}
if let Container::View { handle, floating, ..} = self.tree[node_ix] {
if floating {
handle.bring_to_front();
}
handle.focus();
}
Ok(())
}
/// Focus on the container relative to the active container.
///
/// If Horizontal, left and right will move within siblings.
/// If Vertical, up and down will move within siblings.
/// Other wise, it moves to the next sibling of the parent container.
///
/// If the edge of the children is hit, it does not wrap around,
/// but moves between ancestor siblings.
pub fn move_focus(&mut self, direction: Direction) -> CommandResult {
if let Some(prev_active_ix) = self.active_container {
let active_id = self.tree[prev_active_ix].get_id();
if let Some(fullscreen_id) = try!(self.in_fullscreen_workspace(active_id)) {
return Err(TreeError::Focus(
FocusError::BlockedByFullscreen(active_id, fullscreen_id)))
}
let new_active_ix = self.move_focus_recurse(prev_active_ix, direction)
.unwrap_or(prev_active_ix);
try!(self.set_active_node(new_active_ix));
match self.tree[self.active_container.unwrap()] {
Container::View { ref handle, .. } => handle.focus(),
_ => warn!("move_focus returned a non-view, cannot focus")
}
} else {
return Err(TreeError::NoActiveContainer)
}
self.validate();
Ok(())
}
fn move_focus_recurse(&mut self, node_ix: NodeIndex, direction: Direction)
-> Result<NodeIndex, TreeError> {
match self.tree[node_ix].get_type() {
ContainerType::View | ContainerType::Container => { /* continue */ },
_ => return Err(TreeError::UuidWrongType(self.tree[node_ix].get_id(),
vec!(ContainerType::View, ContainerType::Container)))
}
let parent_ix = self.tree.parent_of(node_ix)
.expect("Active ix had no parent");
match self.tree[parent_ix] {
Container::Container { layout, .. } => {
match (layout, direction) {
(Layout::Horizontal, Direction::Left) |
(Layout::Horizontal, Direction::Right) |
(Layout::Tabbed, Direction::Left) |
(Layout::Tabbed, Direction::Right) |
(Layout::Vertical, Direction::Up) |
(Layout::Vertical, Direction::Down) |
(Layout::Stacked, Direction::Up) |
(Layout::Stacked, Direction::Down) => {
let siblings = self.tree.children_of(parent_ix);
let cur_index = siblings.iter().position(|node| {
*node == node_ix
}).expect("Could not find self in parent");
let maybe_new_index = match direction {
Direction::Right | Direction::Down => {
cur_index.checked_add(1)
}
Direction::Left | Direction::Up => {
cur_index.checked_sub(1)
}
};
if maybe_new_index.is_some() &&
maybe_new_index.unwrap() < siblings.len() {
// There is a sibling to move to.
let new_index = maybe_new_index.unwrap();
let new_active_ix = siblings[new_index];
match self.tree[new_active_ix].get_type() {
ContainerType::Container => {
let path_ix = self.tree.follow_path(new_active_ix);
// If the path wasn't complete, find the first view and focus on that
let node_ix = try!(self.tree.descendant_of_type(path_ix, ContainerType::View)
.map_err(|err| TreeError::PetGraph(err)));
let parent_ix = try!(self.tree.parent_of(node_ix)
.map_err(|err| TreeError::PetGraph(err)));
match self.tree[node_ix].get_type() {
ContainerType::View | ContainerType::Container => {},
_ => panic!("Following path did not lead to a container or a view!")
}
trace!("Moving to different view {:?} in container {:?}",
self.tree[node_ix], self.tree[parent_ix]);
return Ok(node_ix);
},
ContainerType::View => {
trace!("Moving to other view {:?}", self.tree[new_active_ix]);
return Ok(new_active_ix)
},
_ => unreachable!()
};
}
},
_ => { /* We are moving out of siblings, recurse */ }
}
}
Container::Workspace { .. } => {
return Err(TreeError::Focus(FocusError::ReachedLimit(parent_ix)));
}
_ => unreachable!()
}
let parent_ix = self.tree.parent_of(node_ix)
.expect("Node had no parent");
return self.move_focus_recurse(parent_ix, direction);
}
/// Updates the current active container to be the next container or view
/// to focus on after the previous view/container was moved/removed.
///
/// A new view will tried to be set, starting with the children of the
/// parent node. If a view cannot be found there, it starts climbing the
/// tree until either a view is found or the workspace is (in which case
/// it set the active container to the root container of the workspace)
///
/// If there are siblings, the chosen node is the one with the lowest
/// active count.
///
/// If there is a fullscreen container in this workspace, that is focused on next,
/// with the active path updated accordingly.
pub fn focus_on_next_container(&mut self, mut parent_ix: NodeIndex) {
let last_ix = self.tree.active_path().last()
.expect("Active path did not lead anywhere").0;
let id = self.tree[last_ix].get_id();
match self.in_fullscreen_workspace(id) {
Ok(Some(fullscreen_id)) => {
self.set_active_container(fullscreen_id)
.unwrap_or_else(|err| {
error!("Could not set {:?} to be the active container, \
even though it's the fullscreen container! {:?}",
fullscreen_id, err);
error!("{:#?}", self);
panic!("Could not set the fullscreen container to be \
the active container!")
});
return;
},
_ => {}
}
match self.tree[last_ix] {
Container::View { handle, .. } => {
handle.focus();
self.set_active_container(id)
.expect("Could not focus on next container");
return
},
Container::Container { .. } => {
parent_ix = last_ix;
},
_ => {}
}
while self.tree.node_type(parent_ix)
.expect("Node not part of the tree") != ContainerType::Workspace {
if let Some(node_ix) = self.tree.lowest_active_view(parent_ix) {
match self.tree[node_ix] {
Container::View { .. } => {
trace!("Active container set to view at {:?}", node_ix);
let id = self.tree[node_ix].get_id();
self.set_active_container(id)
.expect("Could not set active container");
return;
},
_ => {}
}
}
parent_ix = self.tree.ancestor_of_type(parent_ix,
ContainerType::Container)
.unwrap_or_else(|_| {
self.tree.ancestor_of_type(parent_ix, ContainerType::Workspace)
.expect("Container was not part of a workspace")
});
}
// If this is reached, parent is workspace
let container_ix = self.tree.children_of(parent_ix).get(0).cloned();
if container_ix.is_none() {
trace!("There were no other containers to focus on, \
focusing on nothing in particular!");
return;
}
let container_ix = container_ix.unwrap();
let root_c_children = self.tree.grounded_children(container_ix);
if root_c_children.len() > 0 {
// Only searches first child of root container, can't be floating view.
let new_active_ix = self.tree.descendant_of_type(root_c_children[0],
ContainerType::View)
.unwrap_or(root_c_children[0]);
let id = self.tree[new_active_ix].get_id();
self.set_active_container(id)
.expect("Could not set active container");
match self.tree[new_active_ix] {
Container::View { ref handle, .. } => {
info!("Focusing on {:?}", handle);
handle.focus();
},
Container::Container { .. } => {
info!("No view found, focusing on nothing in workspace {:?}", parent_ix);
WlcView::root().focus();
}
_ => unreachable!()
};
return;
} else {
let floating_children = self.tree.floating_children(container_ix);
for child_ix in floating_children {
if let Ok(view_ix) = self.tree.descendant_of_type(child_ix,
ContainerType::View) {
match self.tree[view_ix] {
Container::View { handle, id, .. } => {
info!("Floating view found, focusing on {:#?}", handle);
handle.focus();
self.set_active_container(id)
.expect("Could not set active container");
return;
},
_ => unreachable!()
};
}
}
}
trace!("Active container set to container {:?}", container_ix);
let id = self.tree[container_ix].get_id();
self.set_active_container(id)
.expect("Could not set active container");
// Update focus to new container
self.get_active_container().map(|con| match *con {
Container::View { ref handle, .. } => handle.focus(),
Container::Container { .. } => WlcView::root().focus(),
_ => panic!("Active container not view or container!")
});
}
/// If the currently focused view is floating, then the non-floating at the end of
/// the path becomes the focused view. Otherwise, the first floating view becomes
/// the focused view.
///
/// If there is no currently focused view, does nothing.
pub fn toggle_floating_focus(&mut self) -> CommandResult {
let active_ix = try!(self.active_container.ok_or(TreeError::NoActiveContainer));
let id; let floating;
{
let container = &self.tree[active_ix];
id = container.get_id();
floating = container.floating();
}
if let Some(fullscreen_id) = try!(self.in_fullscreen_workspace(id)) {
return Err(TreeError::Focus(FocusError::BlockedByFullscreen(id, fullscreen_id)))
}
if floating {
let parent_ix = self.tree.parent_of(active_ix)?;
let new_ix = {
let children = self.tree.children_of_by_active(parent_ix);
if children.len() == 1 {
None
} else {
children.get(1).map(|ix| *ix)
}
};
match new_ix.map(|new_ix| (self.tree[new_ix].get_type(), new_ix)) {
None => Ok(()),
Some((ContainerType::View, new_ix)) |
Some((ContainerType::Container, new_ix)) => {
self.set_active_node(new_ix)?;
Ok(())
},
type_ => {
error!("Path lead to the wrong container, {:#?}\n{:#?}\n{:#?}",
active_ix, type_, self);
panic!("toggle_floating_focused: bad path");
}
}
} else {
// Current view is not floating, gotta focus on floating view
let root_c_ix = self.root_container_ix()
.expect("No root container ancestor of active container");
let floating_children = self.tree.floating_children(root_c_ix);
if floating_children.len() > 0 {
try!(self.set_active_node(floating_children[0]));
}
Ok(())
}
}
/// Sets all the nodes under and at the node index to the given
/// visibilty setting
pub fn set_container_visibility(&mut self, node_ix: NodeIndex, val: bool) {
match self.tree[node_ix].get_type() {
ContainerType::View => {
self.tree[node_ix].set_visibility(val);
},
_ => {
for child_ix in self.tree.children_of(node_ix) {
self.set_container_visibility(child_ix, val);
}
}
}
}
}
#[cfg(test)]
mod tests {
use super::super::super::core::tree::tests::basic_tree;
use rustwlc::*;
/// Tests the new algorithm, the one that i3 uses, to determine which
/// sibling to focus on when the active one is closed.
#[test]
fn test_sibling_focus_algorithm() {
let mut tree = basic_tree();
let fake_view = WlcView::root();
tree.switch_to_workspace("some_unique_workspace");
let view_1 = tree.add_view(fake_view).unwrap().get_id();
let view_2 = tree.add_view(fake_view).unwrap().get_id();
let view_3 = tree.add_view(fake_view).unwrap().get_id();
let view_4 = tree.add_view(fake_view).unwrap().get_id();
let view_5 = tree.add_view(fake_view).unwrap().get_id();
tree.focus_on(view_3).unwrap();
tree.focus_on(view_1).unwrap();
// should focus 1 -> 3 -> 5 -> 4 -> 2
// because this the "stack" of viewing them.
// NOTE that adding a view implicitly focuses and adds it to the "stack"
let views = vec![view_1, view_3, view_5, view_4, view_2];
for view in views {
let active_ix = tree.tree.lookup_id(view);
assert_eq!(tree.active_container, active_ix);
tree.remove_active().unwrap();
}
}
/// Tests that after sending a floating view to a new workspace,
/// there are no duplicate active numbers (and we can focus on that
/// workspace with no problem)
///
/// The expected behaviour is that we focus on the floating windows that
/// were sent over (e.g, the latest focused view from the user's perspective
/// is reflected even when sent to a different workspace).
#[test]
fn test_focus_on_floating_after_sending_to_workspace() {
let mut tree = basic_tree();
let fake_view = WlcView::root();
let target_workspace = "some_unique_workspace";
let source_workspace = "a different workspace";
tree.switch_to_workspace(target_workspace);
let _unused_tiled_view = tree.add_view(fake_view).unwrap().get_id();
tree.switch_to_workspace(source_workspace);
let floating_view_1 = tree.add_floating_view(fake_view, None).unwrap().get_id();
let floating_view_2 = tree.add_floating_view(fake_view, None).unwrap().get_id();
tree.focus_on(floating_view_2).unwrap();
assert_eq!(tree.tree.lookup_id(floating_view_2), tree.active_container);
// now send the view to the workspace with the tiled window.
tree.send_active_to_workspace(target_workspace);
tree.switch_to_workspace(target_workspace);
assert_eq!(tree.tree.lookup_id(floating_view_2), tree.active_container);
// and again with the other one
tree.switch_to_workspace(source_workspace);
tree.send_active_to_workspace(target_workspace);
tree.switch_to_workspace(target_workspace);
assert_eq!(tree.tree.lookup_id(floating_view_1), tree.active_container);
}
}
|
use embedded_hal::digital::v2::OutputPin;
pub struct Led<R, G, B> {
red: R,
green: G,
blue: B,
}
// Allow unused results until I decide on std/nostd
#[allow(unused_must_use)]
impl<R, G, B> Led<R, G, B>
where
R: OutputPin,
G: OutputPin,
B: OutputPin,
{
pub(crate) fn new(red: R, green: G, blue: B) -> Self {
Self { red, green, blue }
}
pub(crate) fn set(&mut self, color: Color) {
match color {
Color::Off => {
self.red.set_high();
self.green.set_high();
self.blue.set_high();
}
Color::Red => {
self.red.set_low();
self.green.set_high();
self.blue.set_high();
}
Color::Green => {
self.red.set_high();
self.green.set_low();
self.blue.set_high();
}
Color::Blue => {
self.red.set_high();
self.green.set_high();
self.blue.set_low();
}
Color::Cyan => {
self.red.set_high();
self.green.set_low();
self.blue.set_low();
}
Color::Magenta => {
self.red.set_low();
self.green.set_high();
self.blue.set_low();
}
Color::Yellow => {
self.red.set_low();
self.green.set_low();
self.blue.set_high();
}
Color::White => {
self.red.set_low();
self.green.set_low();
self.blue.set_low();
}
}
}
}
pub enum Color {
Off,
Red,
Green,
Blue,
Cyan,
Magenta,
Yellow,
White,
}
|
#![feature(proc_macro_hygiene, decl_macro, never_type)]
#[macro_use] extern crate lazy_static;
#[macro_use] extern crate rocket;
#[macro_use] extern crate serde_derive;
extern crate rocket_contrib;
use std::path::{Path, PathBuf};
use std::string::String;
use rocket::outcome::IntoOutcome;
use rocket::request::{self, Form, FlashMessage, FromRequest, Request};
use rocket::response::{NamedFile, Redirect, Flash};
use rocket::http::{Cookie, Cookies};
use rocket_contrib::templates::Template;
mod members;
mod club;
use members::Member;
use club::Club;
static LAYOUT: &str = "components/layout";
lazy_static! {
static ref CLUBINFO: Club = Club::open();
}
#[derive(Serialize)]
struct TemplateContext<T: ::serde::Serialize> {
title: String,
parent: &'static str,
clubinfo: &'static Club,
data: T,
is_member: bool,
}
impl<T: ::serde::Serialize> TemplateContext<T> {
fn new(title: String, data: T, is_member: bool) -> Self {
Self {
title,
parent: LAYOUT,
clubinfo: &CLUBINFO,
data,
is_member,
}
}
}
// Starting up the app start on the index page.
// This is public and just a club advert.
#[get("/", rank = 2)]
fn guest_home() -> Template {
Template::render("index", &TemplateContext::new( "Home".to_string(), (), false ))
}
#[get("/")]
fn member_home(member: MemberID) -> Template {
Template::render("index", &TemplateContext::new("Home".to_string(), member.0, true ))
}
// This is needed for pages to access static elements
#[get("/static/<file..>")]
fn files(file: PathBuf) -> Option<NamedFile> {
NamedFile::open(Path::new("static/").join(file)).ok()
}
#[derive(FromForm)]
struct SignIn {
member_email: String,
password: String,
}
#[derive(Debug, Serialize)]
struct MemberID(usize);
impl<'a, 'r> FromRequest<'a, 'r> for MemberID {
type Error = !;
fn from_request(request: &'a Request<'r>) -> request::Outcome<MemberID, !> {
request.cookies()
.get_private("member_id")
.and_then(|cookie| cookie.value().parse().ok())
.map(|id| MemberID(id))
.or_forward(())
}
}
// Accepts the sign in form
#[post("/signin", data = "<signin>")]
fn signin(mut cookies: Cookies, signin: Form<SignIn>) -> Result<Redirect, Flash<Redirect>> {
if members::authenticate_member(&signin.member_email, &signin.password) {
cookies.add_private(Cookie::new("member_id", 1.to_string()));
Ok(Redirect::to(uri!(member_home)))
} else {
Err(Flash::error(Redirect::to(uri!(signin_error)), "Invalid username/password."))
}
}
#[get("/signin")]
fn signin_member(_member: MemberID) -> Redirect {
//Template::render("signin", &TemplateContext::new("Sign in".to_string(), (), false))
Redirect::to(uri!(member_home))
}
#[get("/signin", rank = 2)]
fn signin_error(flash: Option<FlashMessage>) -> Template {
if let Some(ref msg) = flash {
Template::render("signin", &TemplateContext::new("Sign in".to_string(), msg.msg(), false))
}
else{
Template::render("signin", &TemplateContext::new("Sign in".to_string(), (), false))
}
}
#[get("/signout")]
fn signout(mut cookies: Cookies) -> Redirect {
cookies.remove_private(Cookie::named("member_id"));
Redirect::to(uri!(guest_home))
}
#[post("/apply", data = "<signin>")]
fn apply(signin: Form<SignIn>) {
let member = Member::new( &signin.member_email, &signin.password );
println!(
"Member ID: {}\nemail : {}\npasshash : {}",
member.id.to_string(),
member.email,
member.pass_hash
);
}
#[catch(404)]
fn not_found(req: &Request) -> Template {
let mut map = std::collections::HashMap::new();
map.insert("path", req.uri().path());
Template::render("error/404", &map)
}
fn main() {
rocket::ignite()
.mount(
"/",
routes![
guest_home,
member_home,
files,
signin,
signin_member,
signin_error,
signout,
apply,
])
.register(catchers![not_found])
.attach(Template::fairing())
.launch();
}
|
use crate::termwiztermtab;
use anyhow::bail;
use crossbeam::channel::{bounded, Receiver, Sender};
use promise::Promise;
use std::time::Duration;
use termwiz::cell::unicode_column_width;
use termwiz::lineedit::*;
use termwiz::surface::Change;
use termwiz::terminal::*;
#[derive(Default)]
struct PasswordPromptHost {
history: BasicHistory,
}
impl LineEditorHost for PasswordPromptHost {
fn history(&mut self) -> &mut dyn History {
&mut self.history
}
// Rewrite the input so that we can obscure the password
// characters when output to the terminal widget
fn highlight_line(&self, line: &str, cursor_position: usize) -> (Vec<OutputElement>, usize) {
let placeholder = "🔑";
let grapheme_count = unicode_column_width(line);
let mut output = vec![];
for _ in 0..grapheme_count {
output.push(OutputElement::Text(placeholder.to_string()));
}
(output, unicode_column_width(placeholder) * cursor_position)
}
}
pub enum UIRequest {
/// Display something
Output(Vec<Change>),
/// Request input
Input {
prompt: String,
echo: bool,
respond: Promise<String>,
},
Close,
}
struct ConnectionUIImpl {
term: termwiztermtab::TermWizTerminal,
rx: Receiver<UIRequest>,
}
impl ConnectionUIImpl {
fn run(&mut self) -> anyhow::Result<()> {
loop {
match self.rx.recv_timeout(Duration::from_millis(200)) {
Ok(UIRequest::Close) => break,
Ok(UIRequest::Output(changes)) => self.term.render(&changes)?,
Ok(UIRequest::Input {
prompt,
echo: true,
mut respond,
}) => {
respond.result(self.input_prompt(&prompt));
}
Ok(UIRequest::Input {
prompt,
echo: false,
mut respond,
}) => {
respond.result(self.password_prompt(&prompt));
}
Err(err) if err.is_timeout() => {}
Err(err) => bail!("recv_timeout: {}", err),
}
}
std::thread::sleep(Duration::new(2, 0));
Ok(())
}
fn password_prompt(&mut self, prompt: &str) -> anyhow::Result<String> {
let mut editor = LineEditor::new(&mut self.term);
editor.set_prompt(prompt);
let mut host = PasswordPromptHost::default();
if let Some(line) = editor.read_line(&mut host)? {
Ok(line)
} else {
bail!("password entry was cancelled");
}
}
fn input_prompt(&mut self, prompt: &str) -> anyhow::Result<String> {
let mut editor = LineEditor::new(&mut self.term);
editor.set_prompt(prompt);
let mut host = NopLineEditorHost::default();
if let Some(line) = editor.read_line(&mut host)? {
Ok(line)
} else {
bail!("prompt cancelled");
}
}
}
pub struct ConnectionUI {
tx: Sender<UIRequest>,
}
impl ConnectionUI {
pub fn new() -> Self {
let (tx, rx) = bounded(16);
promise::spawn::spawn_into_main_thread(termwiztermtab::run(70, 15, move |term| {
let mut ui = ConnectionUIImpl { term, rx };
ui.run()
}));
Self { tx }
}
pub fn title(&self, title: &str) {
self.output(vec![Change::Title(title.to_string())]);
}
pub fn output(&self, changes: Vec<Change>) {
self.tx
.send(UIRequest::Output(changes))
.expect("send to SShUI failed");
}
pub fn output_str(&self, s: &str) {
let s = s.replace("\n", "\r\n");
self.output(vec![Change::Text(s)]);
}
pub fn input(&self, prompt: &str) -> anyhow::Result<String> {
let mut promise = Promise::new();
let future = promise.get_future().unwrap();
self.tx
.send(UIRequest::Input {
prompt: prompt.replace("\n", "\r\n"),
echo: true,
respond: promise,
})
.expect("send to ConnectionUI failed");
future.wait()
}
pub fn password(&self, prompt: &str) -> anyhow::Result<String> {
let mut promise = Promise::new();
let future = promise.get_future().unwrap();
self.tx
.send(UIRequest::Input {
prompt: prompt.replace("\n", "\r\n"),
echo: false,
respond: promise,
})
.expect("send to ConnectionUI failed");
future.wait()
}
pub fn close(&self) {
self.tx
.send(UIRequest::Close)
.expect("send to ConnectionUI failed");
}
}
|
use std::fs;
use std::io::Read;
use rspirv::binary::Disassemble;
fn main() {
let matches = clap::App::new("rspirv-dis")
.version(env!("CARGO_PKG_VERSION"))
.about("SPIR-V binary module disassembler from the rspirv project")
.arg(clap::Arg::with_name("input").index(1).required(true))
.get_matches();
let input = matches.value_of("input").unwrap();
let mut f = fs::File::open(input).expect("cannot open file");
let mut buffer = Vec::new();
f.read_to_end(&mut buffer).expect("cannot read file");
match rspirv::dr::load_bytes(&buffer) {
Ok(module) => println!("{}", module.disassemble()),
Err(err) => println!("{}", err),
}
}
|
// ignore-compare-mode-nll
// revisions: base nll
// [nll]compile-flags: -Zborrowck=mir
// edition:2018
struct Xyz {
a: u64,
}
trait Foo {}
impl Xyz {
async fn do_sth<'a>(
&'a self, foo: &dyn Foo
) -> &dyn Foo
{
//[nll]~^ ERROR explicit lifetime required in the type of `foo` [E0621]
foo
//[base]~^ ERROR explicit lifetime required in the type of `foo` [E0621]
}
}
fn main() {}
|
pub mod pkce;
pub mod token;
pub mod user;
pub mod util;
|
pub mod apply;
pub mod exception;
pub mod fragment;
pub mod message;
mod module_function_arity;
pub mod node;
pub mod process;
pub mod scheduler;
pub mod string;
pub mod term;
#[cfg(test)]
pub mod testing;
pub mod time;
pub mod timeout;
pub use fragment::{HeapFragment, HeapFragmentAdapter};
pub use message::{Message, MessageData};
pub use module_function_arity::{Arity, ModuleFunctionArity};
pub use node::*;
pub use process::*;
/// Given a number of bytes `bytes`, returns the number of words
/// needed to hold that number of bytes, rounding up if necessary
#[inline]
pub fn to_word_size(bytes: usize) -> usize {
use core::mem;
use liblumen_core::alloc::utils::round_up_to_multiple_of;
round_up_to_multiple_of(bytes, mem::size_of::<usize>()) / mem::size_of::<usize>()
}
#[allow(unused)]
#[inline]
pub fn to_arch64_word_size(bytes: usize) -> usize {
use liblumen_core::alloc::utils::round_up_to_multiple_of;
round_up_to_multiple_of(bytes, 8) / 8
}
#[allow(unused)]
#[inline]
pub fn to_arch32_word_size(bytes: usize) -> usize {
use liblumen_core::alloc::utils::round_up_to_multiple_of;
round_up_to_multiple_of(bytes, 4) / 4
}
|
use super::{
builtins_iter, tuple::tuple_hash, PyInt, PyIntRef, PySlice, PyTupleRef, PyType, PyTypeRef,
};
use crate::{
atomic_func,
class::PyClassImpl,
common::hash::PyHash,
function::{ArgIndex, FuncArgs, OptionalArg, PyComparisonValue},
protocol::{PyIterReturn, PyMappingMethods, PySequenceMethods},
types::{
AsMapping, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
PyComparisonOp, Representable, SelfIter, Unconstructible,
},
AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
VirtualMachine,
};
use crossbeam_utils::atomic::AtomicCell;
use malachite_bigint::{BigInt, Sign};
use num_integer::Integer;
use num_traits::{One, Signed, ToPrimitive, Zero};
use once_cell::sync::Lazy;
use std::cmp::max;
// Search flag passed to iter_search
enum SearchType {
Count,
Contains,
Index,
}
// Note: might be a good idea to merge with _membership_iter_search or generalize (_sequence_iter_check?)
// and place in vm.rs for all sequences to be able to use it.
#[inline]
fn iter_search(
obj: PyObjectRef,
item: PyObjectRef,
flag: SearchType,
vm: &VirtualMachine,
) -> PyResult<usize> {
let mut count = 0;
let iter = obj.get_iter(vm)?;
for element in iter.iter_without_hint::<PyObjectRef>(vm)? {
if vm.bool_eq(&item, &*element?)? {
match flag {
SearchType::Index => return Ok(count),
SearchType::Contains => return Ok(1),
SearchType::Count => count += 1,
}
}
}
match flag {
SearchType::Count => Ok(count),
SearchType::Contains => Ok(0),
SearchType::Index => Err(vm.new_value_error(format!(
"{} not in range",
&item
.repr(vm)
.map(|v| v.as_str().to_owned())
.unwrap_or_else(|_| "value".to_owned())
))),
}
}
#[pyclass(module = false, name = "range")]
#[derive(Debug, Clone)]
pub struct PyRange {
pub start: PyIntRef,
pub stop: PyIntRef,
pub step: PyIntRef,
}
impl PyPayload for PyRange {
fn class(ctx: &Context) -> &'static Py<PyType> {
ctx.types.range_type
}
}
impl PyRange {
#[inline]
fn offset(&self, value: &BigInt) -> Option<BigInt> {
let start = self.start.as_bigint();
let stop = self.stop.as_bigint();
let step = self.step.as_bigint();
match step.sign() {
Sign::Plus if value >= start && value < stop => Some(value - start),
Sign::Minus if value <= self.start.as_bigint() && value > stop => Some(start - value),
_ => None,
}
}
#[inline]
pub fn index_of(&self, value: &BigInt) -> Option<BigInt> {
let step = self.step.as_bigint();
match self.offset(value) {
Some(ref offset) if offset.is_multiple_of(step) => Some((offset / step).abs()),
Some(_) | None => None,
}
}
#[inline]
pub fn is_empty(&self) -> bool {
self.compute_length().is_zero()
}
#[inline]
pub fn forward(&self) -> bool {
self.start.as_bigint() < self.stop.as_bigint()
}
#[inline]
pub fn get(&self, index: &BigInt) -> Option<BigInt> {
let start = self.start.as_bigint();
let step = self.step.as_bigint();
let stop = self.stop.as_bigint();
if self.is_empty() {
return None;
}
if index.is_negative() {
let length = self.compute_length();
let index: BigInt = &length + index;
if index.is_negative() {
return None;
}
Some(if step.is_one() {
start + index
} else {
start + step * index
})
} else {
let index = if step.is_one() {
start + index
} else {
start + step * index
};
if (step.is_positive() && stop > &index) || (step.is_negative() && stop < &index) {
Some(index)
} else {
None
}
}
}
#[inline]
fn compute_length(&self) -> BigInt {
let start = self.start.as_bigint();
let stop = self.stop.as_bigint();
let step = self.step.as_bigint();
match step.sign() {
Sign::Plus if start < stop => {
if step.is_one() {
stop - start
} else {
(stop - start - 1usize) / step + 1
}
}
Sign::Minus if start > stop => (start - stop - 1usize) / (-step) + 1,
Sign::Plus | Sign::Minus => BigInt::zero(),
Sign::NoSign => unreachable!(),
}
}
}
// pub fn get_value(obj: &PyObject) -> PyRange {
// obj.payload::<PyRange>().unwrap().clone()
// }
pub fn init(context: &Context) {
PyRange::extend_class(context, context.types.range_type);
PyLongRangeIterator::extend_class(context, context.types.long_range_iterator_type);
PyRangeIterator::extend_class(context, context.types.range_iterator_type);
}
#[pyclass(with(AsMapping, AsSequence, Hashable, Comparable, Iterable, Representable))]
impl PyRange {
fn new(cls: PyTypeRef, stop: ArgIndex, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
PyRange {
start: vm.ctx.new_pyref(0),
stop: stop.into(),
step: vm.ctx.new_pyref(1),
}
.into_ref_with_type(vm, cls)
}
fn new_from(
cls: PyTypeRef,
start: PyObjectRef,
stop: PyObjectRef,
step: OptionalArg<ArgIndex>,
vm: &VirtualMachine,
) -> PyResult<PyRef<Self>> {
let step = step.map_or_else(|| vm.ctx.new_int(1), |step| step.into());
if step.as_bigint().is_zero() {
return Err(vm.new_value_error("range() arg 3 must not be zero".to_owned()));
}
PyRange {
start: start.try_index(vm)?,
stop: stop.try_index(vm)?,
step,
}
.into_ref_with_type(vm, cls)
}
#[pygetset]
fn start(&self) -> PyIntRef {
self.start.clone()
}
#[pygetset]
fn stop(&self) -> PyIntRef {
self.stop.clone()
}
#[pygetset]
fn step(&self) -> PyIntRef {
self.step.clone()
}
#[pymethod(magic)]
fn reversed(&self, vm: &VirtualMachine) -> PyResult {
let start = self.start.as_bigint();
let step = self.step.as_bigint();
// Use CPython calculation for this:
let length = self.len();
let new_stop = start - step;
let start = &new_stop + length.clone() * step;
let step = -step;
Ok(
if let (Some(start), Some(step), Some(_)) =
(start.to_isize(), step.to_isize(), new_stop.to_isize())
{
PyRangeIterator {
index: AtomicCell::new(0),
start,
step,
// Cannot fail. If start, stop and step all successfully convert to isize, then result of zelf.len will
// always fit in a usize.
length: length.to_usize().unwrap_or(0),
}
.into_pyobject(vm)
} else {
PyLongRangeIterator {
index: AtomicCell::new(0),
start,
step,
length,
}
.into_pyobject(vm)
},
)
}
#[pymethod(magic)]
fn len(&self) -> BigInt {
self.compute_length()
}
#[pymethod(magic)]
fn bool(&self) -> bool {
!self.is_empty()
}
#[pymethod(magic)]
fn contains(&self, needle: PyObjectRef, vm: &VirtualMachine) -> bool {
// Only accept ints, not subclasses.
if let Some(int) = needle.payload_if_exact::<PyInt>(vm) {
match self.offset(int.as_bigint()) {
Some(ref offset) => offset.is_multiple_of(self.step.as_bigint()),
None => false,
}
} else {
iter_search(
self.clone().into_pyobject(vm),
needle,
SearchType::Contains,
vm,
)
.unwrap_or(0)
!= 0
}
}
#[pymethod(magic)]
fn reduce(&self, vm: &VirtualMachine) -> (PyTypeRef, PyTupleRef) {
let range_parameters: Vec<PyObjectRef> = [&self.start, &self.stop, &self.step]
.iter()
.map(|x| x.as_object().to_owned())
.collect();
let range_parameters_tuple = vm.ctx.new_tuple(range_parameters);
(vm.ctx.types.range_type.to_owned(), range_parameters_tuple)
}
#[pymethod]
fn index(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<BigInt> {
if let Ok(int) = needle.clone().downcast::<PyInt>() {
match self.index_of(int.as_bigint()) {
Some(idx) => Ok(idx),
None => Err(vm.new_value_error(format!("{int} is not in range"))),
}
} else {
// Fallback to iteration.
Ok(BigInt::from_bytes_be(
Sign::Plus,
&iter_search(
self.clone().into_pyobject(vm),
needle,
SearchType::Index,
vm,
)?
.to_be_bytes(),
))
}
}
#[pymethod]
fn count(&self, item: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
if let Ok(int) = item.clone().downcast::<PyInt>() {
if self.index_of(int.as_bigint()).is_some() {
Ok(1)
} else {
Ok(0)
}
} else {
// Dealing with classes who might compare equal with ints in their
// __eq__, slow search.
iter_search(self.clone().into_pyobject(vm), item, SearchType::Count, vm)
}
}
#[pymethod(magic)]
fn getitem(&self, subscript: PyObjectRef, vm: &VirtualMachine) -> PyResult {
match RangeIndex::try_from_object(vm, subscript)? {
RangeIndex::Slice(slice) => {
let (mut sub_start, mut sub_stop, mut sub_step) =
slice.inner_indices(&self.compute_length(), vm)?;
let range_step = &self.step;
let range_start = &self.start;
sub_step *= range_step.as_bigint();
sub_start = (sub_start * range_step.as_bigint()) + range_start.as_bigint();
sub_stop = (sub_stop * range_step.as_bigint()) + range_start.as_bigint();
Ok(PyRange {
start: vm.ctx.new_pyref(sub_start),
stop: vm.ctx.new_pyref(sub_stop),
step: vm.ctx.new_pyref(sub_step),
}
.into_ref(&vm.ctx)
.into())
}
RangeIndex::Int(index) => match self.get(index.as_bigint()) {
Some(value) => Ok(vm.ctx.new_int(value).into()),
None => Err(vm.new_index_error("range object index out of range".to_owned())),
},
}
}
#[pyslot]
fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
let range = if args.args.len() <= 1 {
let stop = args.bind(vm)?;
PyRange::new(cls, stop, vm)
} else {
let (start, stop, step) = args.bind(vm)?;
PyRange::new_from(cls, start, stop, step, vm)
}?;
Ok(range.into())
}
}
impl PyRange {
fn protocol_length(&self, vm: &VirtualMachine) -> PyResult<usize> {
PyInt::from(self.len())
.try_to_primitive::<isize>(vm)
.map(|x| x as usize)
}
}
impl AsMapping for PyRange {
fn as_mapping() -> &'static PyMappingMethods {
static AS_MAPPING: Lazy<PyMappingMethods> = Lazy::new(|| PyMappingMethods {
length: atomic_func!(
|mapping, vm| PyRange::mapping_downcast(mapping).protocol_length(vm)
),
subscript: atomic_func!(|mapping, needle, vm| {
PyRange::mapping_downcast(mapping).getitem(needle.to_owned(), vm)
}),
..PyMappingMethods::NOT_IMPLEMENTED
});
&AS_MAPPING
}
}
impl AsSequence for PyRange {
fn as_sequence() -> &'static PySequenceMethods {
static AS_SEQUENCE: Lazy<PySequenceMethods> = Lazy::new(|| PySequenceMethods {
length: atomic_func!(|seq, vm| PyRange::sequence_downcast(seq).protocol_length(vm)),
item: atomic_func!(|seq, i, vm| {
PyRange::sequence_downcast(seq)
.get(&i.into())
.map(|x| PyInt::from(x).into_ref(&vm.ctx).into())
.ok_or_else(|| vm.new_index_error("index out of range".to_owned()))
}),
contains: atomic_func!(|seq, needle, vm| {
Ok(PyRange::sequence_downcast(seq).contains(needle.to_owned(), vm))
}),
..PySequenceMethods::NOT_IMPLEMENTED
});
&AS_SEQUENCE
}
}
impl Hashable for PyRange {
fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
let length = zelf.compute_length();
let elements = if length.is_zero() {
[vm.ctx.new_int(length).into(), vm.ctx.none(), vm.ctx.none()]
} else if length.is_one() {
[
vm.ctx.new_int(length).into(),
zelf.start().into(),
vm.ctx.none(),
]
} else {
[
vm.ctx.new_int(length).into(),
zelf.start().into(),
zelf.step().into(),
]
};
tuple_hash(&elements, vm)
}
}
impl Comparable for PyRange {
fn cmp(
zelf: &Py<Self>,
other: &PyObject,
op: PyComparisonOp,
_vm: &VirtualMachine,
) -> PyResult<PyComparisonValue> {
op.eq_only(|| {
if zelf.is(other) {
return Ok(true.into());
}
let rhs = class_or_notimplemented!(Self, other);
let lhs_len = zelf.compute_length();
let eq = if lhs_len != rhs.compute_length() {
false
} else if lhs_len.is_zero() {
true
} else if zelf.start.as_bigint() != rhs.start.as_bigint() {
false
} else if lhs_len.is_one() {
true
} else {
zelf.step.as_bigint() == rhs.step.as_bigint()
};
Ok(eq.into())
})
}
}
impl Iterable for PyRange {
fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
let (start, stop, step, length) = (
zelf.start.as_bigint(),
zelf.stop.as_bigint(),
zelf.step.as_bigint(),
zelf.len(),
);
if let (Some(start), Some(step), Some(_), Some(_)) = (
start.to_isize(),
step.to_isize(),
stop.to_isize(),
(start + step).to_isize(),
) {
Ok(PyRangeIterator {
index: AtomicCell::new(0),
start,
step,
// Cannot fail. If start, stop and step all successfully convert to isize, then result of zelf.len will
// always fit in a usize.
length: length.to_usize().unwrap_or(0),
}
.into_pyobject(vm))
} else {
Ok(PyLongRangeIterator {
index: AtomicCell::new(0),
start: start.clone(),
step: step.clone(),
length,
}
.into_pyobject(vm))
}
}
}
impl Representable for PyRange {
#[inline]
fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
let repr = if zelf.step.as_bigint().is_one() {
format!("range({}, {})", zelf.start, zelf.stop)
} else {
format!("range({}, {}, {})", zelf.start, zelf.stop, zelf.step)
};
Ok(repr)
}
}
// Semantically, this is the same as the previous representation.
//
// Unfortunately, since AtomicCell requires a Copy type, no BigInt implementations can
// generally be used. As such, usize::MAX is the upper bound on number of elements (length)
// the range can contain in RustPython.
//
// This doesn't preclude the range from containing large values, since start and step
// can be BigInts, we can store any arbitrary range of values.
#[pyclass(module = false, name = "longrange_iterator")]
#[derive(Debug)]
pub struct PyLongRangeIterator {
index: AtomicCell<usize>,
start: BigInt,
step: BigInt,
length: BigInt,
}
impl PyPayload for PyLongRangeIterator {
fn class(ctx: &Context) -> &'static Py<PyType> {
ctx.types.long_range_iterator_type
}
}
#[pyclass(with(Constructor, IterNext, Iterable))]
impl PyLongRangeIterator {
#[pymethod(magic)]
fn length_hint(&self) -> BigInt {
let index = BigInt::from(self.index.load());
if index < self.length {
self.length.clone() - index
} else {
BigInt::zero()
}
}
#[pymethod(magic)]
fn setstate(&self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
self.index.store(range_state(&self.length, state, vm)?);
Ok(())
}
#[pymethod(magic)]
fn reduce(&self, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
range_iter_reduce(
self.start.clone(),
self.length.clone(),
self.step.clone(),
self.index.load(),
vm,
)
}
}
impl Unconstructible for PyLongRangeIterator {}
impl SelfIter for PyLongRangeIterator {}
impl IterNext for PyLongRangeIterator {
fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
// TODO: In pathological case (index == usize::MAX) this can wrap around
// (since fetch_add wraps). This would result in the iterator spinning again
// from the beginning.
let index = BigInt::from(zelf.index.fetch_add(1));
let r = if index < zelf.length {
let value = zelf.start.clone() + index * zelf.step.clone();
PyIterReturn::Return(vm.ctx.new_int(value).into())
} else {
PyIterReturn::StopIteration(None)
};
Ok(r)
}
}
// When start, stop, step are isize, we can use a faster more compact representation
// that only operates using isize to track values.
#[pyclass(module = false, name = "range_iterator")]
#[derive(Debug)]
pub struct PyRangeIterator {
index: AtomicCell<usize>,
start: isize,
step: isize,
length: usize,
}
impl PyPayload for PyRangeIterator {
fn class(ctx: &Context) -> &'static Py<PyType> {
ctx.types.range_iterator_type
}
}
#[pyclass(with(Constructor, IterNext, Iterable))]
impl PyRangeIterator {
#[pymethod(magic)]
fn length_hint(&self) -> usize {
let index = self.index.load();
if index < self.length {
self.length - index
} else {
0
}
}
#[pymethod(magic)]
fn setstate(&self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
self.index
.store(range_state(&BigInt::from(self.length), state, vm)?);
Ok(())
}
#[pymethod(magic)]
fn reduce(&self, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
range_iter_reduce(
BigInt::from(self.start),
BigInt::from(self.length),
BigInt::from(self.step),
self.index.load(),
vm,
)
}
}
impl Unconstructible for PyRangeIterator {}
impl SelfIter for PyRangeIterator {}
impl IterNext for PyRangeIterator {
fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
// TODO: In pathological case (index == usize::MAX) this can wrap around
// (since fetch_add wraps). This would result in the iterator spinning again
// from the beginning.
let index = zelf.index.fetch_add(1);
let r = if index < zelf.length {
let value = zelf.start + (index as isize) * zelf.step;
PyIterReturn::Return(vm.ctx.new_int(value).into())
} else {
PyIterReturn::StopIteration(None)
};
Ok(r)
}
}
fn range_iter_reduce(
start: BigInt,
length: BigInt,
step: BigInt,
index: usize,
vm: &VirtualMachine,
) -> PyResult<PyTupleRef> {
let iter = builtins_iter(vm).to_owned();
let stop = start.clone() + length * step.clone();
let range = PyRange {
start: PyInt::from(start).into_ref(&vm.ctx),
stop: PyInt::from(stop).into_ref(&vm.ctx),
step: PyInt::from(step).into_ref(&vm.ctx),
};
Ok(vm.new_tuple((iter, (range,), index)))
}
// Silently clips state (i.e index) in range [0, usize::MAX].
fn range_state(length: &BigInt, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
if let Some(i) = state.payload::<PyInt>() {
let mut index = i.as_bigint();
let max_usize = BigInt::from(usize::MAX);
if index > length {
index = max(length, &max_usize);
}
Ok(index.to_usize().unwrap_or(0))
} else {
Err(vm.new_type_error("an integer is required.".to_owned()))
}
}
pub enum RangeIndex {
Int(PyIntRef),
Slice(PyRef<PySlice>),
}
impl TryFromObject for RangeIndex {
fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
match_class!(match obj {
i @ PyInt => Ok(RangeIndex::Int(i)),
s @ PySlice => Ok(RangeIndex::Slice(s)),
obj => {
let val = obj.try_index(vm).map_err(|_| vm.new_type_error(format!(
"sequence indices be integers or slices or classes that override __index__ operator, not '{}'",
obj.class().name()
)))?;
Ok(RangeIndex::Int(val))
}
})
}
}
|
// Copyright 2022 Datafuse Labs.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use ahash::HashMap;
use common_exception::ErrorCode;
use common_exception::Result;
use crate::optimizer::rule::Rule;
use crate::optimizer::rule::TransformResult;
use crate::optimizer::RuleID;
use crate::optimizer::SExpr;
use crate::plans::AggregateFunction;
use crate::plans::AndExpr;
use crate::plans::BoundColumnRef;
use crate::plans::CastExpr;
use crate::plans::ComparisonExpr;
use crate::plans::Filter;
use crate::plans::FunctionCall;
use crate::plans::NotExpr;
use crate::plans::OrExpr;
use crate::plans::PatternPlan;
use crate::plans::RelOp;
use crate::plans::ScalarExpr;
use crate::plans::UnionAll;
use crate::plans::WindowFunc;
use crate::ColumnBinding;
use crate::IndexType;
use crate::Visibility;
// For a union query, it's not allowed to add `filter` after union
// Such as: `(select * from t1 union all select * from t2) where a > 1`, it's invalid.
// However, it's possible to have `filter` after `union` when involved `view`
// Such as: `create view v_t as (select * from t1 union all select * from t2)`.
// Then use the view with filter, `select * from v_t where a > 1`;
// So it'll be efficient to push down `filter` to `union`, reduce the size of data to pull from table.
pub struct RulePushDownFilterUnion {
id: RuleID,
pattern: SExpr,
}
impl RulePushDownFilterUnion {
pub fn new() -> Self {
Self {
id: RuleID::PushDownFilterUnion,
// Filter
// \
// UnionAll
// / \
// ... ...
pattern: SExpr::create_unary(
PatternPlan {
plan_type: RelOp::Filter,
}
.into(),
SExpr::create_binary(
PatternPlan {
plan_type: RelOp::UnionAll,
}
.into(),
SExpr::create_leaf(
PatternPlan {
plan_type: RelOp::Pattern,
}
.into(),
),
SExpr::create_leaf(
PatternPlan {
plan_type: RelOp::Pattern,
}
.into(),
),
),
),
}
}
}
impl Rule for RulePushDownFilterUnion {
fn id(&self) -> RuleID {
self.id
}
fn apply(&self, s_expr: &SExpr, state: &mut TransformResult) -> Result<()> {
let filter: Filter = s_expr.plan().clone().try_into()?;
let union_s_expr = s_expr.child(0)?;
let union: UnionAll = union_s_expr.plan().clone().try_into()?;
// Create a filter which matches union's right child.
let index_pairs: HashMap<IndexType, IndexType> =
union.pairs.iter().map(|pair| (pair.0, pair.1)).collect();
let new_predicates = filter
.predicates
.iter()
.map(|predicate| replace_column_binding(&index_pairs, predicate.clone()))
.collect::<Result<Vec<_>>>()?;
let right_filer = Filter {
predicates: new_predicates,
is_having: filter.is_having,
};
let mut union_left_child = union_s_expr.child(0)?.clone();
let mut union_right_child = union_s_expr.child(1)?.clone();
// Add filter to union children
union_left_child = SExpr::create_unary(filter.into(), union_left_child);
union_right_child = SExpr::create_unary(right_filer.into(), union_right_child);
let result = SExpr::create_binary(union.into(), union_left_child, union_right_child);
state.add_result(result);
Ok(())
}
fn pattern(&self) -> &SExpr {
&self.pattern
}
}
fn replace_column_binding(
index_pairs: &HashMap<IndexType, IndexType>,
scalar: ScalarExpr,
) -> Result<ScalarExpr> {
match scalar {
ScalarExpr::BoundColumnRef(column) => {
let index = column.column.index;
if index_pairs.contains_key(&index) {
let new_column = ColumnBinding {
database_name: None,
table_name: None,
column_name: column.column.column_name.clone(),
index: *index_pairs.get(&index).unwrap(),
data_type: column.column.data_type,
visibility: Visibility::Visible,
};
return Ok(ScalarExpr::BoundColumnRef(BoundColumnRef {
span: column.span,
column: new_column,
}));
}
Ok(ScalarExpr::BoundColumnRef(column))
}
ScalarExpr::BoundInternalColumnRef(_) => {
unreachable!()
}
constant_expr @ ScalarExpr::ConstantExpr(_) => Ok(constant_expr),
ScalarExpr::AndExpr(expr) => Ok(ScalarExpr::AndExpr(AndExpr {
left: Box::new(replace_column_binding(index_pairs, *expr.left)?),
right: Box::new(replace_column_binding(index_pairs, *expr.right)?),
})),
ScalarExpr::OrExpr(expr) => Ok(ScalarExpr::OrExpr(OrExpr {
left: Box::new(replace_column_binding(index_pairs, *expr.left)?),
right: Box::new(replace_column_binding(index_pairs, *expr.right)?),
})),
ScalarExpr::NotExpr(expr) => Ok(ScalarExpr::NotExpr(NotExpr {
argument: Box::new(replace_column_binding(index_pairs, *expr.argument)?),
})),
ScalarExpr::ComparisonExpr(expr) => Ok(ScalarExpr::ComparisonExpr(ComparisonExpr {
op: expr.op,
left: Box::new(replace_column_binding(index_pairs, *expr.left)?),
right: Box::new(replace_column_binding(index_pairs, *expr.right)?),
})),
ScalarExpr::WindowFunction(expr) => Ok(ScalarExpr::WindowFunction(WindowFunc {
agg_func: AggregateFunction {
display_name: expr.agg_func.display_name,
func_name: expr.agg_func.func_name,
distinct: expr.agg_func.distinct,
params: expr.agg_func.params,
args: expr
.agg_func
.args
.into_iter()
.map(|arg| replace_column_binding(index_pairs, arg))
.collect::<Result<Vec<_>>>()?,
return_type: expr.agg_func.return_type,
},
partition_by: expr.partition_by,
frame: expr.frame,
})),
ScalarExpr::AggregateFunction(expr) => {
Ok(ScalarExpr::AggregateFunction(AggregateFunction {
display_name: expr.display_name,
func_name: expr.func_name,
distinct: expr.distinct,
params: expr.params,
args: expr
.args
.into_iter()
.map(|arg| replace_column_binding(index_pairs, arg))
.collect::<Result<Vec<_>>>()?,
return_type: expr.return_type,
}))
}
ScalarExpr::FunctionCall(expr) => Ok(ScalarExpr::FunctionCall(FunctionCall {
span: expr.span,
func_name: expr.func_name,
params: expr.params,
arguments: expr
.arguments
.into_iter()
.map(|arg| replace_column_binding(index_pairs, arg))
.collect::<Result<Vec<_>>>()?,
})),
ScalarExpr::CastExpr(expr) => Ok(ScalarExpr::CastExpr(CastExpr {
span: expr.span,
is_try: expr.is_try,
argument: Box::new(replace_column_binding(index_pairs, *(expr.argument))?),
target_type: expr.target_type,
})),
ScalarExpr::SubqueryExpr(_) => Err(ErrorCode::Unimplemented(
"replace_column_binding: don't support subquery",
)),
}
}
|
use crate::builtins::Variable;
use crate::bytecode::{Get, Instr, Label, Reg};
use crate::common::{NumTy, Result, Stage};
use crate::compile::{self, Ty};
use crate::pushdown::FieldSet;
use crate::runtime::{self, Float, Int, Line, LineReader, Str, UniqueStr};
use crossbeam::scope;
use crossbeam_channel::bounded;
use hashbrown::HashMap;
use rand::{self, rngs::StdRng, Rng, SeedableRng};
use regex::bytes::Regex;
use std::cmp;
use std::mem;
type ClassicReader = runtime::splitter::regex::RegexSplitter<Box<dyn std::io::Read>>;
#[derive(Default)]
pub(crate) struct Storage<T> {
pub(crate) regs: Vec<T>,
pub(crate) stack: Vec<T>,
}
/// Core represents a subset of runtime structures that are relevant to both the bytecode
/// interpreter and the compiled runtimes.
pub(crate) struct Core<'a> {
pub vars: runtime::Variables<'a>,
pub regexes: runtime::RegexCache,
pub write_files: runtime::FileWrite,
pub rng: StdRng,
pub current_seed: u64,
pub slots: Slots,
}
impl<'a> Drop for Core<'a> {
fn drop(&mut self) {
if let Err(e) = self.write_files.shutdown() {
eprintln_ignore!("{}", e);
}
}
}
/// Slots are used for transmitting data across different "stages" of a parallel computation. In
/// order to send data to and from worker threads, we load and store them into dynamically-sized
/// "slots". These aren't normal registers, because slots store `Send` variants of the frawk
/// runtime types; making the value safe for sending between threads may involve performing a
/// deep copy.
#[derive(Default, Clone)]
pub(crate) struct Slots {
pub int: Vec<Int>,
pub float: Vec<Float>,
pub strs: Vec<UniqueStr<'static>>,
pub intint: Vec<HashMap<Int, Int>>,
pub intfloat: Vec<HashMap<Int, Float>>,
pub intstr: Vec<HashMap<Int, UniqueStr<'static>>>,
pub strint: Vec<HashMap<UniqueStr<'static>, Int>>,
pub strfloat: Vec<HashMap<UniqueStr<'static>, Float>>,
pub strstr: Vec<HashMap<UniqueStr<'static>, UniqueStr<'static>>>,
}
/// A Simple helper trait for implement aggregations for slot values and variables.
trait Agg {
fn agg(self, other: Self) -> Self;
}
impl Agg for Int {
fn agg(self, other: Int) -> Int {
self + other
}
}
impl Agg for Float {
fn agg(self, other: Float) -> Float {
self + other
}
}
impl<'a> Agg for UniqueStr<'a> {
fn agg(self, other: UniqueStr<'a>) -> UniqueStr<'a> {
// Strings are not aggregated explicitly.
if other.is_empty() {
self
} else {
other
}
}
}
impl<K: std::hash::Hash + Eq, V: Agg + Default> Agg for HashMap<K, V> {
fn agg(mut self, other: HashMap<K, V>) -> HashMap<K, V> {
for (k, v) in other {
let entry = self.entry(k).or_insert(Default::default());
let v2 = mem::replace(entry, Default::default());
*entry = v2.agg(v);
}
self
}
}
/// StageResult is a Send subset of Core that can be extracted for inter-stage aggregation in a
/// parallel script.
pub(crate) struct StageResult {
slots: Slots,
// TODO: put more variables in here? Most builtin variables are just going to be propagated
// from the initial thread.
nr: Int,
rc: i32,
}
impl Slots {
fn combine(&mut self, mut other: Slots) {
macro_rules! for_each_slot_pair {
($s1:ident, $s2:ident, $body:expr) => {
for_each_slot_pair!(
$s1, $s2, $body, int, float, strs, intint, intfloat, intstr, strint, strfloat,
strstr
);
};
($s1:ident, $s2:ident, $body:expr, $($fld:tt),*) => {$({
let $s1 = &mut self.$fld;
let $s2 = &mut other.$fld;
$body
});*};
}
for_each_slot_pair!(a, b, {
a.resize_with(std::cmp::max(a.len(), b.len()), Default::default);
for (a_elt, b_elt_v) in a.iter_mut().zip(b.drain(..)) {
let a_elt_v = mem::replace(a_elt, Default::default());
*a_elt = a_elt_v.agg(b_elt_v);
}
});
}
}
pub fn set_slot<T: Default>(vec: &mut Vec<T>, slot: usize, v: T) {
if slot < vec.len() {
vec[slot] = v;
return;
}
vec.resize_with(slot, Default::default);
vec.push(v)
}
pub fn combine_slot<T: Default>(vec: &mut Vec<T>, slot: usize, f: impl FnOnce(T) -> T) {
if slot < vec.len() {
let res = f(std::mem::replace(&mut vec[slot], Default::default()));
vec[slot] = res;
return;
}
vec.resize_with(slot, Default::default);
let res = f(Default::default());
vec.push(res)
}
impl<'a> Core<'a> {
pub fn shuttle(&self, pid: Int) -> impl FnOnce() -> Core<'a> + Send {
use crate::builtins::Variables;
let seed: u64 = rand::thread_rng().gen();
let fw = self.write_files.clone();
let fs: UniqueStr<'a> = self.vars.fs.clone().into();
let ofs: UniqueStr<'a> = self.vars.ofs.clone().into();
let rs: UniqueStr<'a> = self.vars.rs.clone().into();
let ors: UniqueStr<'a> = self.vars.ors.clone().into();
let filename: UniqueStr<'a> = self.vars.filename.clone().into();
let argv = self.vars.argv.shuttle();
let fi = self.vars.fi.shuttle();
let slots = self.slots.clone();
move || {
let vars = Variables {
fs: fs.into_str(),
ofs: ofs.into_str(),
ors: ors.into_str(),
rs: rs.into_str(),
filename: filename.into_str(),
pid,
nf: 0,
nr: 0,
fnr: 0,
rstart: 0,
rlength: 0,
argc: 0,
argv: argv.into(),
fi: fi.into(),
};
Core {
vars,
regexes: Default::default(),
write_files: fw,
rng: rand::rngs::StdRng::seed_from_u64(seed),
current_seed: seed,
slots,
}
}
}
pub fn new(ff: impl runtime::writers::FileFactory) -> Core<'a> {
let seed: u64 = rand::thread_rng().gen();
Core {
vars: Default::default(),
regexes: Default::default(),
write_files: runtime::FileWrite::new(ff),
rng: rand::rngs::StdRng::seed_from_u64(seed),
current_seed: seed,
slots: Default::default(),
}
}
pub fn extract_result(&mut self, rc: i32) -> StageResult {
StageResult {
slots: mem::replace(&mut self.slots, Default::default()),
nr: self.vars.nr,
rc,
}
}
pub fn combine(&mut self, StageResult { slots, nr, rc: _ }: StageResult) {
self.slots.combine(slots);
self.vars.nr = self.vars.nr.agg(nr);
}
pub fn reseed(&mut self, seed: u64) -> u64 /* old seed */ {
self.rng = StdRng::seed_from_u64(seed);
let old_seed = self.current_seed;
self.current_seed = seed;
old_seed
}
pub fn reseed_random(&mut self) -> u64 /* old seed */ {
self.reseed(rand::thread_rng().gen::<u64>())
}
pub fn match_regex(&mut self, s: &Str<'a>, pat: &Str<'a>) -> Result<Int> {
self.regexes.regex_match_loc(&mut self.vars, pat, s)
}
pub fn match_const_regex(&mut self, s: &Str<'a>, pat: &Regex) -> Result<Int> {
runtime::RegexCache::regex_const_match_loc(&mut self.vars, pat, s)
}
pub fn is_match_regex(&mut self, s: &Str<'a>, pat: &Str<'a>) -> Result<bool> {
self.regexes.is_regex_match(pat, s)
}
pub fn load_int(&mut self, slot: usize) -> Int {
self.slots.int[slot]
}
pub fn load_float(&mut self, slot: usize) -> Float {
self.slots.float[slot]
}
pub fn load_str(&mut self, slot: usize) -> Str<'a> {
mem::replace(&mut self.slots.strs[slot], Default::default())
.into_str()
.upcast()
}
pub fn load_intint(&mut self, slot: usize) -> runtime::IntMap<Int> {
mem::replace(&mut self.slots.intint[slot], Default::default()).into()
}
pub fn load_intfloat(&mut self, slot: usize) -> runtime::IntMap<Float> {
mem::replace(&mut self.slots.intfloat[slot], Default::default()).into()
}
pub fn load_intstr(&mut self, slot: usize) -> runtime::IntMap<Str<'a>> {
mem::replace(&mut self.slots.intstr[slot], Default::default())
.into_iter()
.map(|(k, v)| (k, v.into_str().upcast()))
.collect()
}
pub fn load_strint(&mut self, slot: usize) -> runtime::StrMap<'a, Int> {
mem::replace(&mut self.slots.strint[slot], Default::default())
.into_iter()
.map(|(k, v)| (k.into_str().upcast(), v))
.collect()
}
pub fn load_strfloat(&mut self, slot: usize) -> runtime::StrMap<'a, Float> {
mem::replace(&mut self.slots.strfloat[slot], Default::default())
.into_iter()
.map(|(k, v)| (k.into_str().upcast(), v))
.collect()
}
pub fn load_strstr(&mut self, slot: usize) -> runtime::StrMap<'a, Str<'a>> {
mem::replace(&mut self.slots.strstr[slot], Default::default())
.into_iter()
.map(|(k, v)| (k.into_str().upcast(), v.into_str().upcast()))
.collect()
}
pub fn store_int(&mut self, slot: usize, i: Int) {
set_slot(&mut self.slots.int, slot, i)
}
pub fn store_float(&mut self, slot: usize, f: Float) {
set_slot(&mut self.slots.float, slot, f)
}
pub fn store_str(&mut self, slot: usize, s: Str<'a>) {
set_slot(&mut self.slots.strs, slot, s.unmoor().into())
}
pub fn store_intint(&mut self, slot: usize, s: runtime::IntMap<Int>) {
set_slot(
&mut self.slots.intint,
slot,
s.iter(|i| i.map(|(k, v)| (*k, *v)).collect()),
)
}
pub fn store_intfloat(&mut self, slot: usize, s: runtime::IntMap<Float>) {
set_slot(
&mut self.slots.intfloat,
slot,
s.iter(|i| i.map(|(k, v)| (*k, *v)).collect()),
)
}
pub fn store_intstr(&mut self, slot: usize, s: runtime::IntMap<Str<'a>>) {
set_slot(
&mut self.slots.intstr,
slot,
s.iter(|i| i.map(|(k, v)| (*k, v.clone().unmoor().into())).collect()),
)
}
pub fn store_strint(&mut self, slot: usize, s: runtime::StrMap<'a, Int>) {
set_slot(
&mut self.slots.strint,
slot,
s.iter(|i| i.map(|(k, v)| (k.clone().unmoor().into(), *v)).collect()),
)
}
pub fn store_strfloat(&mut self, slot: usize, s: runtime::StrMap<'a, Float>) {
set_slot(
&mut self.slots.strfloat,
slot,
s.iter(|i| i.map(|(k, v)| (k.clone().unmoor().into(), *v)).collect()),
)
}
pub fn store_strstr(&mut self, slot: usize, s: runtime::StrMap<'a, Str<'a>>) {
set_slot(
&mut self.slots.strstr,
slot,
s.iter(|i| {
i.map(|(k, v)| (k.clone().unmoor().into(), v.clone().unmoor().into()))
.collect()
}),
)
}
}
macro_rules! map_regs {
($map_ty:expr, $map_reg:ident, $body:expr) => {{
let _placeholder_k = 0u32;
let _placeholder_v = 0u32;
map_regs!($map_ty, $map_reg, _placeholder_k, _placeholder_v, $body)
}};
($map_ty:expr, $map_reg:ident, $key_reg:ident, $val_reg:ident, $body:expr) => {{
let _placeholder_iter = 0u32;
map_regs!(
$map_ty,
$map_reg,
$key_reg,
$val_reg,
_placeholder_iter,
$body
)
}};
($map_ty:expr, $map_reg:ident, $key_reg:ident, $val_reg:ident, $iter_reg:ident, $body:expr) => {{
let map_ty = $map_ty;
match map_ty {
Ty::MapIntInt => {
let $map_reg: Reg<runtime::IntMap<Int>> = $map_reg.into();
let $key_reg: Reg<Int> = $key_reg.into();
let $val_reg: Reg<Int> = $val_reg.into();
let $iter_reg: Reg<runtime::Iter<Int>> = $iter_reg.into();
$body
}
Ty::MapIntFloat => {
let $map_reg: Reg<runtime::IntMap<Float>> = $map_reg.into();
let $key_reg: Reg<Int> = $key_reg.into();
let $val_reg: Reg<Float> = $val_reg.into();
let $iter_reg: Reg<runtime::Iter<Int>> = $iter_reg.into();
$body
}
Ty::MapIntStr => {
let $map_reg: Reg<runtime::IntMap<Str<'a>>> = $map_reg.into();
let $key_reg: Reg<Int> = $key_reg.into();
let $val_reg: Reg<Str<'a>> = $val_reg.into();
let $iter_reg: Reg<runtime::Iter<Int>> = $iter_reg.into();
$body
}
Ty::MapStrInt => {
let $map_reg: Reg<runtime::StrMap<'a, Int>> = $map_reg.into();
let $key_reg: Reg<Str<'a>> = $key_reg.into();
let $val_reg: Reg<Int> = $val_reg.into();
let $iter_reg: Reg<runtime::Iter<Str<'a>>> = $iter_reg.into();
$body
}
Ty::MapStrFloat => {
let $map_reg: Reg<runtime::StrMap<'a, Float>> = $map_reg.into();
let $key_reg: Reg<Str<'a>> = $key_reg.into();
let $val_reg: Reg<Float> = $val_reg.into();
let $iter_reg: Reg<runtime::Iter<Str<'a>>> = $iter_reg.into();
$body
}
Ty::MapStrStr => {
let $map_reg: Reg<runtime::StrMap<'a, Str<'a>>> = $map_reg.into();
let $key_reg: Reg<Str<'a>> = $key_reg.into();
let $val_reg: Reg<Str<'a>> = $val_reg.into();
let $iter_reg: Reg<runtime::Iter<Str<'a>>> = $iter_reg.into();
$body
}
Ty::Null | Ty::Int | Ty::Float | Ty::Str | Ty::IterInt | Ty::IterStr => panic!(
"attempting to perform map operations on non-map type: {:?}",
map_ty
),
}
}};
}
pub(crate) struct Interp<'a, LR: LineReader = ClassicReader> {
// index of `instrs` that contains "main"
main_func: Stage<usize>,
num_workers: usize,
instrs: Vec<Vec<Instr<'a>>>,
stack: Vec<(usize /*function*/, Label /*instr*/)>,
line: LR::Line,
read_files: runtime::FileRead<LR>,
core: Core<'a>,
// Core storage.
// TODO: should these be smallvec<[T; 32]>? We never add registers, so could we allocate one
// contiguous region ahead of time?
pub(crate) floats: Storage<Float>,
pub(crate) ints: Storage<Int>,
pub(crate) strs: Storage<Str<'a>>,
pub(crate) maps_int_float: Storage<runtime::IntMap<Float>>,
pub(crate) maps_int_int: Storage<runtime::IntMap<Int>>,
pub(crate) maps_int_str: Storage<runtime::IntMap<Str<'a>>>,
pub(crate) maps_str_float: Storage<runtime::StrMap<'a, Float>>,
pub(crate) maps_str_int: Storage<runtime::StrMap<'a, Int>>,
pub(crate) maps_str_str: Storage<runtime::StrMap<'a, Str<'a>>>,
pub(crate) iters_int: Storage<runtime::Iter<Int>>,
pub(crate) iters_str: Storage<runtime::Iter<Str<'a>>>,
}
fn default_of<T: Default>(n: usize) -> Storage<T> {
let mut regs = Vec::new();
regs.resize_with(n, Default::default);
Storage {
regs,
stack: Default::default(),
}
}
impl<'a, LR: LineReader> Interp<'a, LR> {
pub(crate) fn new(
instrs: Vec<Vec<Instr<'a>>>,
main_func: Stage<usize>,
num_workers: usize,
regs: impl Fn(compile::Ty) -> usize,
stdin: LR,
ff: impl runtime::writers::FileFactory,
used_fields: &FieldSet,
named_columns: Option<Vec<&[u8]>>,
) -> Self {
use compile::Ty::*;
Interp {
main_func,
num_workers,
instrs,
stack: Default::default(),
floats: default_of(regs(Float)),
ints: default_of(regs(Int)),
strs: default_of(regs(Str)),
core: Core::new(ff),
line: Default::default(),
read_files: runtime::FileRead::new(stdin, used_fields.clone(), named_columns),
maps_int_float: default_of(regs(MapIntFloat)),
maps_int_int: default_of(regs(MapIntInt)),
maps_int_str: default_of(regs(MapIntStr)),
maps_str_float: default_of(regs(MapStrFloat)),
maps_str_int: default_of(regs(MapStrInt)),
maps_str_str: default_of(regs(MapStrStr)),
iters_int: default_of(regs(IterInt)),
iters_str: default_of(regs(IterStr)),
}
}
pub(crate) fn instrs(&self) -> &Vec<Vec<Instr<'a>>> {
&self.instrs
}
fn format_arg(&self, (reg, ty): (NumTy, Ty)) -> Result<runtime::FormatArg<'a>> {
Ok(match ty {
Ty::Str => self.get(Reg::<Str<'a>>::from(reg)).clone().into(),
Ty::Int => self.get(Reg::<Int>::from(reg)).clone().into(),
Ty::Float => self.get(Reg::<Float>::from(reg)).clone().into(),
_ => return err!("non-scalar (s)printf argument type {:?}", ty),
})
}
fn reset_file_vars(&mut self) {
self.core.vars.fnr = 0;
self.core.vars.filename = self.read_files.stdin_filename().upcast();
}
pub(crate) fn run_parallel(&mut self) -> Result<i32> {
if self.num_workers <= 1 {
return self.run_serial();
}
let handles = self.read_files.try_resize(self.num_workers - 1);
if handles.len() == 0 {
return self.run_serial();
}
let (begin, middle, end) = match self.main_func {
Stage::Par {
begin,
main_loop,
end,
} => (begin, main_loop, end),
Stage::Main(_) => {
return err!("unexpected Main-only configuration for parallel execution")
}
};
let main_loop = if let Some(main_loop) = middle {
main_loop
} else {
return self.run_serial();
};
if let Some(off) = begin {
let rc = self.run_at(off)?;
if rc != 0 {
return Ok(rc);
}
}
if let Err(_) = self.core.write_files.flush_stdout() {
return Ok(1);
}
// For handling the worker portion, we want to transfer the current stdin progress to a
// worker thread, but to withold any progress on other files open for read. We'll swap
// these back in when we execute the `end` block, if there is one.
let mut old_read_files = mem::replace(&mut self.read_files.inputs, Default::default());
fn wrap_error<T, S>(r: std::result::Result<Result<T>, S>) -> Result<T> {
match r {
Ok(Ok(t)) => Ok(t),
Ok(Err(e)) => Err(e),
Err(_) => err!("error in executing worker thread"),
}
}
let scope_res = scope(|s| {
let (sender, receiver) = bounded(handles.len());
let float_size = self.floats.regs.len();
let ints_size = self.ints.regs.len();
let strs_size = self.strs.regs.len();
let maps_int_int_size = self.maps_int_int.regs.len();
let maps_int_float_size = self.maps_int_float.regs.len();
let maps_int_str_size = self.maps_int_str.regs.len();
let maps_str_int_size = self.maps_str_int.regs.len();
let maps_str_float_size = self.maps_str_float.regs.len();
let maps_str_str_size = self.maps_str_str.regs.len();
let iters_int_size = self.iters_int.regs.len();
let iters_str_size = self.iters_str.regs.len();
for (i, handle) in handles.into_iter().enumerate() {
let sender = sender.clone();
let core_shuttle = self.core.shuttle(i as Int + 2);
let instrs = self.instrs.clone();
s.spawn(move |_| {
if let Some(read_files) = handle() {
let mut interp = Interp {
main_func: Stage::Main(main_loop),
num_workers: 1,
instrs,
stack: Default::default(),
core: core_shuttle(),
line: Default::default(),
read_files,
floats: default_of(float_size),
ints: default_of(ints_size),
strs: default_of(strs_size),
maps_int_int: default_of(maps_int_int_size),
maps_int_float: default_of(maps_int_float_size),
maps_int_str: default_of(maps_int_str_size),
maps_str_int: default_of(maps_str_int_size),
maps_str_float: default_of(maps_str_float_size),
maps_str_str: default_of(maps_str_str_size),
iters_int: default_of(iters_int_size),
iters_str: default_of(iters_str_size),
};
let res = interp.run_at(main_loop);
// Ignore errors, as it means another thread executed with an error and we are
// exiting anyway.
let _ = match res {
Err(e) => sender.send(Err(e)),
Ok(rc) => sender.send(Ok(interp.core.extract_result(rc))),
};
}
});
}
mem::drop(sender);
self.core.vars.pid = 1;
let mut rc = self.run_at(main_loop)?;
self.core.vars.pid = 0;
while let Ok(res) = receiver.recv() {
let res = res?;
let sub_rc = res.rc;
self.core.combine(res);
if rc == 0 && sub_rc != 0 {
rc = sub_rc;
}
}
Ok(rc)
});
let rc = wrap_error(scope_res)?;
if rc != 0 {
return Ok(rc);
}
if let Some(end) = end {
mem::swap(&mut self.read_files.inputs, &mut old_read_files);
Ok(self.run_at(end)?)
} else {
Ok(0)
}
}
pub(crate) fn run_serial(&mut self) -> Result<i32> {
let offs: smallvec::SmallVec<[usize; 3]> = self.main_func.iter().cloned().collect();
for off in offs.into_iter() {
let rc = self.run_at(off)?;
if rc != 0 {
return Ok(rc);
}
}
Ok(0)
}
pub(crate) fn run(&mut self) -> Result<i32> {
match self.main_func {
Stage::Main(_) => self.run_serial(),
Stage::Par { .. } => self.run_parallel(),
}
}
pub(crate) fn run_at(&mut self, mut cur_fn: usize) -> Result<i32> {
use Instr::*;
let mut scratch: Vec<runtime::FormatArg> = Vec::new();
// We are only accessing one vector at a time here, but it's hard to convince the borrow
// checker of this fact, so we access the vectors through raw pointers.
let mut instrs = (&mut self.instrs[cur_fn]) as *mut Vec<Instr<'a>>;
let mut cur = 0;
'outer: loop {
cur = loop {
debug_assert!(cur < unsafe { (*instrs).len() });
use Variable::*;
match unsafe { (*instrs).get_unchecked(cur) } {
StoreConstStr(sr, s) => {
let sr = *sr;
*self.get_mut(sr) = s.clone_str()
}
StoreConstInt(ir, i) => {
let ir = *ir;
*self.get_mut(ir) = *i
}
StoreConstFloat(fr, f) => {
let fr = *fr;
*self.get_mut(fr) = *f
}
IntToStr(sr, ir) => {
let s = runtime::convert::<_, Str>(*self.get(*ir));
let sr = *sr;
*self.get_mut(sr) = s;
}
FloatToStr(sr, fr) => {
let s = runtime::convert::<_, Str>(*self.get(*fr));
let sr = *sr;
*self.get_mut(sr) = s;
}
StrToInt(ir, sr) => {
let i = runtime::convert::<_, Int>(self.get(*sr));
let ir = *ir;
*self.get_mut(ir) = i;
}
HexStrToInt(ir, sr) => {
let i = self.get(*sr).with_bytes(runtime::hextoi);
let ir = *ir;
*self.get_mut(ir) = i;
}
StrToFloat(fr, sr) => {
let f = runtime::convert::<_, Float>(self.get(*sr));
let fr = *fr;
*self.get_mut(fr) = f;
}
FloatToInt(ir, fr) => {
let i = runtime::convert::<_, Int>(*self.get(*fr));
let ir = *ir;
*self.get_mut(ir) = i;
}
IntToFloat(fr, ir) => {
let f = runtime::convert::<_, Float>(*self.get(*ir));
let fr = *fr;
*self.get_mut(fr) = f;
}
AddInt(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = l + r;
}
AddFloat(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = l + r;
}
MulInt(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = l * r;
}
MulFloat(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = l * r;
}
MinusInt(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = l - r;
}
MinusFloat(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = l - r;
}
ModInt(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = l % r;
}
ModFloat(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = l % r;
}
Div(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = l / r;
}
Pow(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = l.powf(r);
}
Not(res, ir) => {
let res = *res;
let i = *self.get(*ir);
*self.get_mut(res) = (i == 0) as Int;
}
NotStr(res, sr) => {
let res = *res;
let sr = *sr;
let is_empty = self.get(sr).with_bytes(|bs| bs.len() == 0);
*self.get_mut(res) = is_empty as Int;
}
NegInt(res, ir) => {
let res = *res;
let i = *self.get(*ir);
*self.get_mut(res) = -i;
}
NegFloat(res, fr) => {
let res = *res;
let f = *self.get(*fr);
*self.get_mut(res) = -f;
}
Float1(ff, dst, src) => {
let f = *index(&self.floats, src);
let dst = *dst;
*self.get_mut(dst) = ff.eval1(f);
}
Float2(ff, dst, x, y) => {
let fx = *index(&self.floats, x);
let fy = *index(&self.floats, y);
let dst = *dst;
*self.get_mut(dst) = ff.eval2(fx, fy);
}
Int1(bw, dst, src) => {
let i = *index(&self.ints, src);
let dst = *dst;
*self.get_mut(dst) = bw.eval1(i);
}
Int2(bw, dst, x, y) => {
let ix = *index(&self.ints, x);
let iy = *index(&self.ints, y);
let dst = *dst;
*self.get_mut(dst) = bw.eval2(ix, iy);
}
Rand(dst) => {
let res: f64 = self.core.rng.gen_range(0.0..=1.0);
*index_mut(&mut self.floats, dst) = res;
}
Srand(res, seed) => {
let old_seed = self.core.reseed(*index(&self.ints, seed) as u64);
*index_mut(&mut self.ints, res) = old_seed as Int;
}
ReseedRng(res) => {
*index_mut(&mut self.ints, res) = self.core.reseed_random() as Int;
}
StartsWithConst(res, s, bs) => {
let s_bytes = unsafe { &*index(&self.strs, s).get_bytes() };
*index_mut(&mut self.ints, res) =
(bs.len() <= s_bytes.len() && &s_bytes[..bs.len()] == &**bs) as Int;
}
Concat(res, l, r) => {
let res = *res;
let l = self.get(*l).clone();
let r = self.get(*r).clone();
*self.get_mut(res) = Str::concat(l, r);
}
Match(res, l, r) => {
*index_mut(&mut self.ints, res) = self
.core
.match_regex(index(&self.strs, l), index(&self.strs, r))?;
}
IsMatch(res, l, r) => {
*index_mut(&mut self.ints, res) = self
.core
.is_match_regex(index(&self.strs, l), index(&self.strs, r))?
as Int;
}
MatchConst(res, x, pat) => {
*index_mut(&mut self.ints, res) =
runtime::RegexCache::regex_const_match(&*pat, index(&self.strs, x))
as Int;
}
IsMatchConst(res, x, pat) => {
*index_mut(&mut self.ints, res) =
self.core.match_const_regex(index(&self.strs, x), &*pat)?;
}
SubstrIndex(res, s, t) => {
let res = *res;
let s = index(&self.strs, s);
let t = index(&self.strs, t);
*self.get_mut(res) = runtime::string_search::index_substr(t, s);
}
LenStr(res, s) => {
let res = *res;
let s = *s;
// TODO consider doing a with_str here or enforce elsewhere that strings
// cannot exceed u32::max.
let len = self.get(s).len();
*self.get_mut(res) = len as Int;
}
Sub(res, pat, s, in_s) => {
let (subbed, new) = {
let pat = index(&self.strs, pat);
let s = index(&self.strs, s);
let in_s = index(&self.strs, in_s);
self.core
.regexes
.with_regex(pat, |re| in_s.subst_first(re, s))?
};
*index_mut(&mut self.strs, in_s) = subbed;
*index_mut(&mut self.ints, res) = new as Int;
}
GSub(res, pat, s, in_s) => {
let (subbed, subs_made) = {
let pat = index(&self.strs, pat);
let s = index(&self.strs, s);
let in_s = index(&self.strs, in_s);
self.core
.regexes
.with_regex(pat, |re| in_s.subst_all(re, s))?
};
*index_mut(&mut self.strs, in_s) = subbed;
*index_mut(&mut self.ints, res) = subs_made;
}
EscapeCSV(res, s) => {
*index_mut(&mut self.strs, res) = {
let s = index(&self.strs, s);
runtime::escape_csv(s)
};
}
EscapeTSV(res, s) => {
*index_mut(&mut self.strs, res) = {
let s = index(&self.strs, s);
runtime::escape_tsv(s)
};
}
Substr(res, base, l, r) => {
let base = index(&self.strs, base);
let len = base.len();
let l = cmp::max(0, -1 + *index(&self.ints, l));
*index_mut(&mut self.strs, res) = if l as usize >= len {
Str::default()
} else {
let r = cmp::min(len as Int, l.saturating_add(*index(&self.ints, r)))
as usize;
base.slice(l as usize, r)
};
}
LTFloat(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = (l < r) as Int;
}
LTInt(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = (l < r) as Int;
}
LTStr(res, l, r) => {
let res = *res;
let l = self.get(*l);
let r = self.get(*r);
*self.get_mut(res) = l.with_bytes(|l| r.with_bytes(|r| l < r)) as Int;
}
GTFloat(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = (l > r) as Int;
}
GTInt(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = (l > r) as Int;
}
GTStr(res, l, r) => {
let res = *res;
let l = self.get(*l);
let r = self.get(*r);
*self.get_mut(res) = l.with_bytes(|l| r.with_bytes(|r| l > r)) as Int;
}
LTEFloat(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = (l <= r) as Int;
}
LTEInt(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = (l <= r) as Int;
}
LTEStr(res, l, r) => {
let res = *res;
let l = self.get(*l);
let r = self.get(*r);
*self.get_mut(res) = l.with_bytes(|l| r.with_bytes(|r| l <= r)) as Int;
}
GTEFloat(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = (l >= r) as Int;
}
GTEInt(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = (l >= r) as Int;
}
GTEStr(res, l, r) => {
let res = *res;
let l = self.get(*l);
let r = self.get(*r);
*self.get_mut(res) = l.with_bytes(|l| r.with_bytes(|r| l >= r)) as Int;
}
EQFloat(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = (l == r) as Int;
}
EQInt(res, l, r) => {
let res = *res;
let l = *self.get(*l);
let r = *self.get(*r);
*self.get_mut(res) = (l == r) as Int;
}
EQStr(res, l, r) => {
let res = *res;
let l = self.get(*l);
let r = self.get(*r);
*self.get_mut(res) = (l == r) as Int;
}
SetColumn(dst, src) => {
let col = *self.get(*dst);
let v = index(&self.strs, src);
self.line
.set_col(col, v, &self.core.vars.ofs, &mut self.core.regexes)?;
}
GetColumn(dst, src) => {
let col = *self.get(*src);
let dst = *dst;
let res = self.line.get_col(
col,
&self.core.vars.fs,
&self.core.vars.ofs,
&mut self.core.regexes,
)?;
*self.get_mut(dst) = res;
}
JoinCSV(dst, start, end) => {
let nf = self.line.nf(&self.core.vars.fs, &mut self.core.regexes)?;
*index_mut(&mut self.strs, dst) = {
let start = *index(&self.ints, start);
let end = *index(&self.ints, end);
self.line.join_cols(start, end, &",".into(), nf, |s| {
runtime::escape_csv(&s)
})?
};
}
JoinTSV(dst, start, end) => {
let nf = self.line.nf(&self.core.vars.fs, &mut self.core.regexes)?;
*index_mut(&mut self.strs, dst) = {
let start = *index(&self.ints, start);
let end = *index(&self.ints, end);
self.line.join_cols(start, end, &"\t".into(), nf, |s| {
runtime::escape_tsv(&s)
})?
};
}
JoinColumns(dst, start, end, sep) => {
let nf = self.line.nf(&self.core.vars.fs, &mut self.core.regexes)?;
*index_mut(&mut self.strs, dst) = {
let sep = index(&self.strs, sep);
let start = *index(&self.ints, start);
let end = *index(&self.ints, end);
self.line.join_cols(start, end, sep, nf, |s| s)?
};
}
ToUpperAscii(dst, src) => {
let res = index(&self.strs, src).to_upper_ascii();
*index_mut(&mut self.strs, dst) = res;
}
ToLowerAscii(dst, src) => {
let res = index(&self.strs, src).to_lower_ascii();
*index_mut(&mut self.strs, dst) = res;
}
SplitInt(flds, to_split, arr, pat) => {
// Index manually here to defeat the borrow checker.
let to_split = index(&self.strs, to_split);
let arr = index(&self.maps_int_str, arr);
let pat = index(&self.strs, pat);
self.core
.regexes
.split_regex_intmap(&pat, &to_split, &arr)?;
let res = arr.len() as Int;
let flds = *flds;
*self.get_mut(flds) = res;
}
SplitStr(flds, to_split, arr, pat) => {
// Very similar to above
let to_split = index(&self.strs, to_split);
let arr = index(&self.maps_str_str, arr);
let pat = index(&self.strs, pat);
self.core
.regexes
.split_regex_strmap(&pat, &to_split, &arr)?;
let res = arr.len() as Int;
let flds = *flds;
*self.get_mut(flds) = res;
}
Sprintf { dst, fmt, args } => {
debug_assert_eq!(scratch.len(), 0);
for a in args.iter() {
scratch.push(self.format_arg(*a)?);
}
use runtime::str_impl::DynamicBuf;
let fmt_str = index(&self.strs, fmt);
let mut buf = DynamicBuf::new(0);
fmt_str
.with_bytes(|bs| runtime::printf::printf(&mut buf, bs, &scratch[..]))?;
scratch.clear();
let res = unsafe { buf.into_str() };
let dst = *dst;
*self.get_mut(dst) = res;
}
PrintAll { output, args } => {
let mut scratch_strs =
smallvec::SmallVec::<[&Str; 4]>::with_capacity(args.len());
for a in args {
scratch_strs.push(index(&self.strs, a));
}
let res = if let Some((out_path_reg, fspec)) = output {
let out_path = index(&self.strs, out_path_reg);
self.core
.write_files
.write_all(&scratch_strs[..], Some((out_path, *fspec)))
} else {
self.core.write_files.write_all(&scratch_strs[..], None)
};
if res.is_err() {
return Ok(0);
}
}
Printf { output, fmt, args } => {
debug_assert_eq!(scratch.len(), 0);
for a in args.iter() {
scratch.push(self.format_arg(*a)?);
}
let fmt_str = index(&self.strs, fmt);
let res = if let Some((out_path_reg, fspec)) = output {
let out_path = index(&self.strs, out_path_reg);
self.core.write_files.printf(
Some((out_path, *fspec)),
fmt_str,
&scratch[..],
)
} else {
// print to stdout.
self.core.write_files.printf(None, fmt_str, &scratch[..])
};
if res.is_err() {
return Ok(0);
}
scratch.clear();
}
Close(file) => {
let file = index(&self.strs, file);
// NB this may create an unused entry in write_files. It would not be
// terribly difficult to optimize the close path to include an existence
// check first.
self.core.write_files.close(file)?;
self.read_files.close(file);
}
RunCmd(dst, cmd) => {
*index_mut(&mut self.ints, dst) =
index(&self.strs, cmd).with_bytes(runtime::run_command);
}
Exit(code) => return Ok(*index(&self.ints, code) as i32),
Lookup {
map_ty,
dst,
map,
key,
} => self.lookup(*map_ty, *dst, *map, *key),
Contains {
map_ty,
dst,
map,
key,
} => self.contains(*map_ty, *dst, *map, *key),
Delete { map_ty, map, key } => self.delete(*map_ty, *map, *key),
Clear { map_ty, map } => self.clear(*map_ty, *map),
Len { map_ty, map, dst } => self.len(*map_ty, *map, *dst),
Store {
map_ty,
map,
key,
val,
} => self.store_map(*map_ty, *map, *key, *val),
IncInt {
map_ty,
map,
key,
by,
dst,
} => self.inc_map_int(*map_ty, *map, *key, *by, *dst),
IncFloat {
map_ty,
map,
key,
by,
dst,
} => self.inc_map_float(*map_ty, *map, *key, *by, *dst),
LoadVarStr(dst, var) => {
let s = self.core.vars.load_str(*var)?;
let dst = *dst;
*self.get_mut(dst) = s;
}
StoreVarStr(var, src) => {
let src = *src;
let s = self.get(src).clone();
self.core.vars.store_str(*var, s)?;
}
LoadVarInt(dst, var) => {
// If someone explicitly sets NF to a different value, this means we will
// ignore it. I think that is fine.
if let NF = *var {
self.core.vars.nf =
self.line.nf(&self.core.vars.fs, &mut self.core.regexes)? as Int;
}
let i = self.core.vars.load_int(*var)?;
let dst = *dst;
*self.get_mut(dst) = i;
}
StoreVarInt(var, src) => {
let src = *src;
let s = *self.get(src);
self.core.vars.store_int(*var, s)?;
}
LoadVarIntMap(dst, var) => {
let arr = self.core.vars.load_intmap(*var)?;
let dst = *dst;
*self.get_mut(dst) = arr;
}
StoreVarIntMap(var, src) => {
let src = *src;
let s = self.get(src).clone();
self.core.vars.store_intmap(*var, s)?;
}
LoadVarStrMap(dst, var) => {
let arr = self.core.vars.load_strmap(*var)?;
let dst = *dst;
*self.get_mut(dst) = arr;
}
StoreVarStrMap(var, src) => {
let src = *src;
let s = self.get(src).clone();
self.core.vars.store_strmap(*var, s)?;
}
IterBegin { map_ty, map, dst } => self.iter_begin(*map_ty, *map, *dst),
IterHasNext { iter_ty, dst, iter } => self.iter_has_next(*iter_ty, *dst, *iter),
IterGetNext { iter_ty, dst, iter } => self.iter_get_next(*iter_ty, *dst, *iter),
LoadSlot { ty, dst, slot } => self.load_slot(*ty, *dst, *slot),
StoreSlot { ty, src, slot } => self.store_slot(*ty, *src, *slot),
Mov(ty, dst, src) => self.mov(*ty, *dst, *src),
AllocMap(ty, reg) => self.alloc_map(*ty, *reg),
// TODO add error logging for these errors perhaps?
ReadErr(dst, file, is_file) => {
let dst = *dst;
let file = index(&self.strs, file);
let res = if *is_file {
self.read_files.read_err(file)?
} else {
self.read_files.read_err_cmd(file)?
};
*self.get_mut(dst) = res;
}
NextLine(dst, file, is_file) => {
let dst = *dst;
let file = index(&self.strs, file);
match self.core.regexes.get_line(
file,
&self.core.vars.rs,
&mut self.read_files,
*is_file,
) {
Ok(l) => *self.get_mut(dst) = l,
Err(_) => *self.get_mut(dst) = "".into(),
};
}
ReadErrStdin(dst) => {
let dst = *dst;
let res = self.read_files.read_err_stdin();
*self.get_mut(dst) = res;
}
NextLineStdin(dst) => {
let dst = *dst;
let (changed, res) = self
.core
.regexes
.get_line_stdin(&self.core.vars.rs, &mut self.read_files)?;
if changed {
self.reset_file_vars();
}
*self.get_mut(dst) = res;
}
NextLineStdinFused() => {
let changed = self.core.regexes.get_line_stdin_reuse(
&self.core.vars.rs,
&mut self.read_files,
&mut self.line,
)?;
if changed {
self.reset_file_vars()
}
}
NextFile() => {
self.read_files.next_file()?;
self.reset_file_vars();
}
UpdateUsedFields() => {
let fi = &self.core.vars.fi;
self.read_files.update_named_columns(fi);
}
SetFI(key, val) => {
let key = *index(&self.ints, key);
let val = *index(&self.ints, val);
let col = self.line.get_col(
key,
&self.core.vars.fs,
&self.core.vars.ofs,
&mut self.core.regexes,
)?;
self.core.vars.fi.insert(col, val);
}
JmpIf(cond, lbl) => {
let cond = *cond;
if *self.get(cond) != 0 {
break lbl.0 as usize;
}
}
Jmp(lbl) => {
break lbl.0 as usize;
}
Push(ty, reg) => self.push_reg(*ty, *reg),
Pop(ty, reg) => self.pop_reg(*ty, *reg),
Call(func) => {
self.stack.push((cur_fn, Label(cur + 1)));
cur_fn = *func;
instrs = &mut self.instrs[*func];
break 0;
}
Ret => {
if let Some((func, Label(inst))) = self.stack.pop() {
cur_fn = func;
instrs = &mut self.instrs[func];
break inst as usize;
} else {
break 'outer Ok(0);
}
}
};
break cur + 1;
};
}
}
fn mov(&mut self, ty: Ty, dst: NumTy, src: NumTy) {
match ty {
Ty::Int => {
let src = *index(&self.ints, &src.into());
*index_mut(&mut self.ints, &dst.into()) = src;
}
Ty::Float => {
let src = *index(&self.floats, &src.into());
*index_mut(&mut self.floats, &dst.into()) = src;
}
Ty::Str => {
let src = index(&self.strs, &src.into()).clone();
*index_mut(&mut self.strs, &dst.into()) = src;
}
Ty::MapIntInt => {
let src = index(&self.maps_int_int, &src.into()).clone();
*index_mut(&mut self.maps_int_int, &dst.into()) = src;
}
Ty::MapIntFloat => {
let src = index(&self.maps_int_float, &src.into()).clone();
*index_mut(&mut self.maps_int_float, &dst.into()) = src;
}
Ty::MapIntStr => {
let src = index(&self.maps_int_str, &src.into()).clone();
*index_mut(&mut self.maps_int_str, &dst.into()) = src;
}
Ty::MapStrInt => {
let src = index(&self.maps_str_int, &src.into()).clone();
*index_mut(&mut self.maps_str_int, &dst.into()) = src;
}
Ty::MapStrFloat => {
let src = index(&self.maps_str_float, &src.into()).clone();
*index_mut(&mut self.maps_str_float, &dst.into()) = src;
}
Ty::MapStrStr => {
let src = index(&self.maps_str_str, &src.into()).clone();
*index_mut(&mut self.maps_str_str, &dst.into()) = src;
}
Ty::Null | Ty::IterInt | Ty::IterStr => {
panic!("invalid type for move operation: {:?}", ty)
}
}
}
fn alloc_map(&mut self, ty: Ty, reg: NumTy) {
map_regs!(ty, reg, *self.get_mut(reg) = Default::default())
}
fn lookup(&mut self, map_ty: Ty, dst: NumTy, map: NumTy, key: NumTy) {
map_regs!(map_ty, map, key, dst, {
let res = self.get(map).get(self.get(key));
*self.get_mut(dst) = res;
});
}
fn contains(&mut self, map_ty: Ty, dst: NumTy, map: NumTy, key: NumTy) {
let _v = 0u32;
let dst: Reg<Int> = dst.into();
map_regs!(map_ty, map, key, _v, {
let res = self.get(map).contains(self.get(key)) as Int;
*self.get_mut(dst) = res;
});
}
fn delete(&mut self, map_ty: Ty, map: NumTy, key: NumTy) {
let _v = 0u32;
map_regs!(map_ty, map, key, _v, {
self.get(map).delete(self.get(key))
});
}
fn clear(&mut self, map_ty: Ty, map: NumTy) {
map_regs!(map_ty, map, self.get(map).clear());
}
fn store_map(&mut self, map_ty: Ty, map: NumTy, key: NumTy, val: NumTy) {
map_regs!(map_ty, map, key, val, {
let k = self.get(key).clone();
let v = self.get(val).clone();
self.get(map).insert(k, v);
});
}
fn inc_map_int(&mut self, map_ty: Ty, map: NumTy, key: NumTy, by: Reg<Int>, dst: NumTy) {
map_regs!(map_ty, map, key, dst, {
let k = self.get(key);
let m = self.get(map);
let by = self.get(by).clone();
let res = m.inc_int(k, by);
*self.get_mut(dst) = res;
})
}
fn inc_map_float(&mut self, map_ty: Ty, map: NumTy, key: NumTy, by: Reg<Float>, dst: NumTy) {
map_regs!(map_ty, map, key, dst, {
let k = self.get(key);
let m = self.get(map);
let by = self.get(by).clone();
let res = m.inc_float(k, by);
*self.get_mut(dst) = res;
})
}
fn len(&mut self, map_ty: Ty, map: NumTy, dst: NumTy) {
let len = map_regs!(map_ty, map, self.get(map).len() as Int);
*index_mut(&mut self.ints, &dst.into()) = len;
}
fn iter_begin(&mut self, map_ty: Ty, map: NumTy, dst: NumTy) {
let _k = 0u32;
let _v = 0u32;
map_regs!(map_ty, map, _k, _v, dst, {
let iter = self.get(map).to_iter();
*self.get_mut(dst) = iter;
})
}
fn iter_has_next(&mut self, iter_ty: Ty, dst: NumTy, iter: NumTy) {
match iter_ty {
Ty::IterInt => {
let res = index(&self.iters_int, &iter.into()).has_next() as Int;
*index_mut(&mut self.ints, &dst.into()) = res;
}
Ty::IterStr => {
let res = index(&self.iters_str, &iter.into()).has_next() as Int;
*index_mut(&mut self.ints, &dst.into()) = res;
}
x => panic!("non-iterator type passed to has_next: {:?}", x),
}
}
fn iter_get_next(&mut self, iter_ty: Ty, dst: NumTy, iter: NumTy) {
match iter_ty {
Ty::IterInt => {
let res = unsafe { index(&self.iters_int, &iter.into()).get_next().clone() };
*index_mut(&mut self.ints, &dst.into()) = res;
}
Ty::IterStr => {
let res = unsafe { index(&self.iters_str, &iter.into()).get_next().clone() };
*index_mut(&mut self.strs, &dst.into()) = res;
}
x => panic!("non-iterator type passed to get_next: {:?}", x),
}
}
fn load_slot(&mut self, ty: Ty, dst: NumTy, slot: Int) {
let slot = slot as usize;
macro_rules! do_load {
($load_meth:tt, $reg_fld:tt) => {
*index_mut(&mut self.$reg_fld, &dst.into()) = self.core.$load_meth(slot)
};
}
match ty {
Ty::Int => do_load!(load_int, ints),
Ty::Float => do_load!(load_float, floats),
Ty::Str => do_load!(load_str, strs),
Ty::MapIntInt => do_load!(load_intint, maps_int_int),
Ty::MapIntFloat => do_load!(load_intfloat, maps_int_float),
Ty::MapIntStr => do_load!(load_intstr, maps_int_str),
Ty::MapStrInt => do_load!(load_strint, maps_str_int),
Ty::MapStrFloat => do_load!(load_strfloat, maps_str_float),
Ty::MapStrStr => do_load!(load_strstr, maps_str_str),
Ty::Null | Ty::IterInt | Ty::IterStr => {
panic!("unexpected operand type to slot operation: {:?}", ty)
}
}
}
fn store_slot(&mut self, ty: Ty, src: NumTy, slot: Int) {
let slot = slot as usize;
macro_rules! do_store {
($store_meth:tt, $reg_fld:tt) => {
self.core
.$store_meth(slot, index(&self.$reg_fld, &src.into()).clone())
};
}
match ty {
Ty::Int => do_store!(store_int, ints),
Ty::Float => do_store!(store_float, floats),
Ty::Str => do_store!(store_str, strs),
Ty::MapIntInt => do_store!(store_intint, maps_int_int),
Ty::MapIntFloat => do_store!(store_intfloat, maps_int_float),
Ty::MapIntStr => do_store!(store_intstr, maps_int_str),
Ty::MapStrInt => do_store!(store_strint, maps_str_int),
Ty::MapStrFloat => do_store!(store_strfloat, maps_str_float),
Ty::MapStrStr => do_store!(store_strstr, maps_str_str),
Ty::Null | Ty::IterInt | Ty::IterStr => panic!("unsupported slot type: {:?}", ty),
}
}
fn push_reg(&mut self, ty: Ty, src: NumTy) {
match ty {
Ty::Int => push(&mut self.ints, &src.into()),
Ty::Float => push(&mut self.floats, &src.into()),
Ty::Str => push(&mut self.strs, &src.into()),
Ty::MapIntInt => push(&mut self.maps_int_int, &src.into()),
Ty::MapIntFloat => push(&mut self.maps_int_float, &src.into()),
Ty::MapIntStr => push(&mut self.maps_int_str, &src.into()),
Ty::MapStrInt => push(&mut self.maps_str_int, &src.into()),
Ty::MapStrFloat => push(&mut self.maps_str_float, &src.into()),
Ty::MapStrStr => push(&mut self.maps_str_str, &src.into()),
Ty::Null | Ty::IterInt | Ty::IterStr => {
panic!("unsupported register type for push operation: {:?}", ty)
}
}
}
fn pop_reg(&mut self, ty: Ty, dst: NumTy) {
match ty {
Ty::Int => *index_mut(&mut self.ints, &dst.into()) = pop(&mut self.ints),
Ty::Float => *index_mut(&mut self.floats, &dst.into()) = pop(&mut self.floats),
Ty::Str => *index_mut(&mut self.strs, &dst.into()) = pop(&mut self.strs),
Ty::MapIntInt => {
*index_mut(&mut self.maps_int_int, &dst.into()) = pop(&mut self.maps_int_int)
}
Ty::MapIntFloat => {
*index_mut(&mut self.maps_int_float, &dst.into()) = pop(&mut self.maps_int_float)
}
Ty::MapIntStr => {
*index_mut(&mut self.maps_int_str, &dst.into()) = pop(&mut self.maps_int_str)
}
Ty::MapStrInt => {
*index_mut(&mut self.maps_str_int, &dst.into()) = pop(&mut self.maps_str_int)
}
Ty::MapStrFloat => {
*index_mut(&mut self.maps_str_float, &dst.into()) = pop(&mut self.maps_str_float)
}
Ty::MapStrStr => {
*index_mut(&mut self.maps_str_float, &dst.into()) = pop(&mut self.maps_str_float)
}
Ty::Null | Ty::IterInt | Ty::IterStr => {
panic!("unsupported register type for pop operation: {:?}", ty)
}
}
}
}
// TODO: Add a pass that does checking of indexes once.
// That could justify no checking during interpretation.
#[cfg(debug_assertions)]
const CHECKED: bool = true;
#[cfg(not(debug_assertions))]
const CHECKED: bool = false;
#[inline(always)]
pub(crate) fn index<'a, T>(Storage { regs, .. }: &'a Storage<T>, reg: &Reg<T>) -> &'a T {
if CHECKED {
®s[reg.index()]
} else {
debug_assert!(reg.index() < regs.len());
unsafe { regs.get_unchecked(reg.index()) }
}
}
#[inline(always)]
pub(crate) fn index_mut<'a, T>(
Storage { regs, .. }: &'a mut Storage<T>,
reg: &Reg<T>,
) -> &'a mut T {
if CHECKED {
&mut regs[reg.index()]
} else {
debug_assert!(reg.index() < regs.len());
unsafe { regs.get_unchecked_mut(reg.index()) }
}
}
pub(crate) fn push<'a, T: Clone>(s: &'a mut Storage<T>, reg: &Reg<T>) {
let v = index(s, reg).clone();
s.stack.push(v);
}
pub(crate) fn pop<'a, T: Clone>(s: &'a mut Storage<T>) -> T {
s.stack.pop().expect("pop must be called on nonempty stack")
}
// Used in benchmarking code.
#[cfg(test)]
impl<T: Default> Storage<T> {
#[cfg(feature = "unstable")]
fn reset(&mut self) {
self.stack.clear();
for i in self.regs.iter_mut() {
*i = Default::default();
}
}
}
#[cfg(test)]
impl<'a, LR: LineReader> Interp<'a, LR> {
#[cfg(feature = "unstable")]
pub(crate) fn reset(&mut self) {
self.stack = Default::default();
self.core.vars = Default::default();
self.line = Default::default();
self.core.regexes = Default::default();
self.floats.reset();
self.ints.reset();
self.strs.reset();
self.maps_int_int.reset();
self.maps_int_float.reset();
self.maps_int_str.reset();
self.maps_str_int.reset();
self.maps_str_float.reset();
self.maps_str_str.reset();
self.iters_int.reset();
self.iters_str.reset();
}
}
|
extern crate bootstrap_rs as bootstrap;
extern crate gl_util as gl;
extern crate parse_obj;
use bootstrap::window::*;
use gl::*;
use gl::context::Context;
use gl::shader::*;
use parse_obj::Obj;
static VERT_SOURCE: &'static str = r#"
#version 330 core
uniform mat4 model_transform;
layout(location = 0) in vec4 position;
layout(location = 1) in vec3 normal_in;
out vec3 normal;
void main() {
normal = normal_in;
gl_Position = model_transform * position;
}
"#;
static FRAG_SOURCE: &'static str = r#"
#version 330 core
uniform vec4 surface_color;
in vec3 normal;
out vec4 fragment_color;
void main() {
fragment_color = surface_color * vec4(normal, 1);
}
"#;
static MODEL_TRANSFORM: [f32; 16] = [
0.0, 0.0, -1.0, 0.0,
0.0, 1.0, 0.0, 0.0,
1.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 1.0];
fn main() {
// Load mesh file and normalize indices for OpenGL.
let obj = Obj::from_file("examples/epps_head.obj").unwrap();
// Gather vertex data so that OpenGL can use them.
let mut vertex_data = Vec::new();
// Iterate over each of the faces in the mesh.
for (positions, normals) in obj.position_indices().iter().zip(obj.normal_indices().iter()) {
// Iterate over each of the vertices in the face to combine the position and normal into
// a single vertex.
for (position_index, normal_index) in positions.iter().zip(normals.iter()) {
let position = obj.positions()[*position_index];
let normal = obj.normals()[*normal_index];
vertex_data.extend(&[position.0, position.1, position.2, position.3]);
vertex_data.extend(&[normal.0, normal.1, normal.2]);
}
}
// Create indices list.
let indices: Vec<u32> = (0..(obj.position_indices().len() * 3) as u32).collect();
// Create window and initialize OpenGL.
let mut window = Window::new("gl-util - wireframe example").unwrap();
let context = Context::from_window(&window).unwrap();
// Compile and link shaders into a shader program.
let vert_shader = Shader::new(&context, VERT_SOURCE, ShaderType::Vertex).unwrap();
let frag_shader = Shader::new(&context, FRAG_SOURCE, ShaderType::Fragment).unwrap();
let program = Program::new(&context, &[vert_shader, frag_shader]).unwrap();
let mut vertex_array = VertexArray::with_index_buffer(&context, &*vertex_data, &*indices);
vertex_array.set_attrib(
AttributeLocation::from_index(0),
AttribLayout { elements: 4, stride: 7, offset: 0 },
);
vertex_array.set_attrib(
AttributeLocation::from_index(1),
AttribLayout { elements: 3, stride: 7, offset: 4 },
);
let mut draw_builder = DrawBuilder::new(&context, &vertex_array, DrawMode::Triangles);
draw_builder
.program(&program)
.uniform("model_transform", GlMatrix {
data: &MODEL_TRANSFORM,
transpose: false,
})
.uniform("surface_color", (1.0, 0.0, 0.0, 1.0))
.depth_test(Comparison::Less)
.cull(Face::Back)
.winding(WindingOrder::Clockwise);
'outer: loop {
while let Some(message) = window.next_message() {
match message {
Message::Close => break 'outer,
_ => {},
}
}
context.clear();
draw_builder.draw();
context.swap_buffers();
}
}
|
#[macro_use]
extern crate websocat;
extern crate futures;
extern crate tokio_core;
extern crate tokio_stdin_stdout;
extern crate env_logger;
#[macro_use]
extern crate structopt;
use structopt::StructOpt;
use tokio_core::reactor::Core;
use websocat::{spec, Options, SpecifierClass, WebsocatConfiguration};
type Result<T> = std::result::Result<T, Box<std::error::Error>>;
#[derive(StructOpt, Debug)]
#[structopt(
after_help = "
Basic examples:
Connect stdin/stdout to a websocket:
websocat - ws://echo.websocket.org/
Listen websocket and redirect it to a TCP port:
websocat ws-l:127.0.0.1:8080 tcp:127.0.0.1:5678
See more examples with the --long-help option
Short list of specifiers (see --long-help):
ws:// wss:// - inetd: ws-listen: inetd-ws: tcp: tcp-l: ws-c:
autoreconnect: reuse: mirror: threadedstdio: clogged:
literal: literalreply: assert: udp-connect: open-async:
readfile: writefile: open-fd: unix-connect: unix-listen:
unix-dgram: abstract-connect: abstract-listen:
exec: sh-c:
"
)]
struct Opt {
/// First, listening/connecting specifier. See --long-help for info about specifiers.
s1: String,
/// Second, connecting specifier
s2: String,
#[structopt(
short = "u",
long = "unidirectional",
help = "Inhibit copying data from right specifier to left"
)]
unidirectional: bool,
#[structopt(
short = "U",
long = "unidirectional-reverse",
help = "Inhibit copying data from left specifier to right"
)]
unidirectional_reverse: bool,
#[structopt(
long = "exit-on-eof",
short = "E",
help = "Close a data transfer direction if the other one reached EOF"
)]
exit_on_eof: bool,
#[structopt(
short = "t", long = "text", help = "Send text WebSocket messages instead of binary"
)]
websocket_text_mode: bool,
#[structopt(long = "oneshot", help = "Serve only once. Not to be confused with -1 (--one-message)")]
oneshot: bool,
#[structopt(long = "long-help", help = "Show full help aboput specifiers and examples")]
longhelp: bool,
#[structopt(
long = "dump-spec",
help = "Instead of running, dump the specifiers representation to stdout"
)]
dumpspec: bool,
#[structopt(long = "protocol", help = "Specify Sec-WebSocket-Protocol: header")]
websocket_protocol: Option<String>,
#[structopt(long = "udp-oneshot", help = "udp-listen: replies only one packet per client")]
udp_oneshot_mode: bool,
#[structopt(long = "unlink", help = "Unlink listening UNIX socket before binding to it")]
unlink_unix_socket: bool,
#[structopt(
long = "exec-args",
raw(allow_hyphen_values = r#"true"#),
help = "Arguments for the `exec:` specifier. Must be the last option, everything after it gets into the exec args list."
)]
exec_args: Vec<String>,
#[structopt(
long = "ws-c-uri", help = "URI to use for ws-c: specifier", default_value = "ws://0.0.0.0/"
)]
ws_c_uri: String,
#[structopt(
long = "linemode-retain-newlines",
help = "In --line mode, don't chop off trailing \\n from messages"
)]
linemode_retain_newlines: bool,
#[structopt(
short = "-l", long = "--line", help = "Make each WebSocket message correspond to one line"
)]
linemode: bool,
#[structopt(long="origin",help="Add Origin HTTP header to websocket client request")]
origin: Option<String>,
#[structopt(
long="header",
short="H",
help="Add custom HTTP header to websocket client request. Separate header name and value with a colon and optionally a single space. Can be used multiple times.",
parse(try_from_str="interpret_custom_header"),
)]
custom_headers: Vec<(String,Vec<u8>)>,
#[structopt(long="websocket-version", help="Override the Sec-WebSocket-Version value")]
websocket_version: Option<String>,
#[structopt(long="no-close", short="n", help="Don't send Close message to websocket on EOF")]
websocket_dont_close: bool,
#[structopt(
short="1",
long="one-message",
help="Send and/or receive only one message. Use with --no-close and/or -u/-U.",
)]
one_message : bool,
// TODO: -v --quiet
}
// TODO: make it byte-oriented/OsStr?
fn interpret_custom_header(x:&str) -> Result<(String,Vec<u8>)> {
let colon = x.find(':');
let colon = if let Some(colon) = colon { colon } else {
Err("Argument to --header must contain `:` character")?
};
let hn = &x[0..colon];
let mut hv = &x[colon+1..];
if hv.chars().next() == Some(' ') {
hv = &x[colon+2..];
}
Ok((hn.to_owned(), hv.as_bytes().to_vec()))
}
fn longhelp() {
println!(
r#"(see also the usual --help message)
Positional arguments to websocat are generally called specifiers.
Specifiers are ways to obtain a connection from some string representation (i.e. address).
Specifiers may be argumentless (like `mirror:`), can accept an argument (which
may be some path or socket address, like `tcp:`), or can accept a subspecifier
(like `reuse:` or `autoreconnect:`).
Here is the full list of specifier classes in this WebSocat build:
"#
);
fn help1(sc: &SpecifierClass) {
let n = sc.get_name().replace("Class", "");
let prefixes = sc
.get_prefixes()
.iter()
.map(|x| format!("`{}`", x))
.collect::<Vec<_>>()
.join(", ");
println!("### {}\n\n* {}", n, prefixes);
let help =
sc
.help()
//.lines()
//.map(|x|format!(" {}",x))
//.collect::<Vec<_>>()
//.join("\n")
;
println!("{}\n", help);
}
macro_rules! my {
($x:expr) => {
help1(&$x);
};
}
list_of_all_specifier_classes!(my);
println!(
r#"
TODO:
sctp:
ssl:
Final example just for fun: wacky mode
websocat ws-c:ws-l:ws-c:- tcp:127.0.0.1:5678
Connect to a websocket using stdin/stdout as a transport,
then accept a websocket connection over the previous websocket used as a transport,
then connect to a websocket using previous step as a transport,
then forward resulting connection to the TCP port.
(Excercise to the reader: manage to make it actually connect to 5678).
"#
);
}
fn run() -> Result<()> {
if std::env::args().nth(1).unwrap_or_default() == "--long-help" {
longhelp();
return Ok(());
}
let cmd = Opt::from_args();
if cmd.longhelp {
longhelp();
return Ok(());
}
if false
// || cmd.oneshot
{
Err("This mode is not implemented")?
}
let opts = {
macro_rules! opts {
($($o:ident)*) => {
Options {
$($o : cmd.$o,)*
}
};
}
opts!(
websocket_text_mode
websocket_protocol
udp_oneshot_mode
unidirectional
unidirectional_reverse
exit_on_eof
oneshot
unlink_unix_socket
exec_args
ws_c_uri
linemode_retain_newlines
origin
custom_headers
websocket_version
websocket_dont_close
one_message
)
};
let s1 = spec(&cmd.s1)?;
let s2 = spec(&cmd.s2)?;
let mut websocat = WebsocatConfiguration { opts, s1, s2 };
if cmd.linemode {
use websocat::lints::AutoInstallLinemodeConcern::*;
websocat = match websocat.auto_install_linemode() {
Ok(x) => x,
Err((NoWebsocket,_)) => Err("No websocket usage is specified. Use line2msg: and msg2line: specifiers manually if needed.")?,
Err((MultipleWebsocket,_)) => Err("Multiple websocket usages are specified. Use line2msg: and msg2line: specifiers manually if needed.")?,
Err((AlreadyLine,_)) => Err("Can't auto-insert msg2line:/line2msg: if you have already manually specified some of them")?,
}
}
while let Some(concern) = websocat.get_concern() {
use websocat::lints::ConfigurationConcern::*;
if concern == StdinToStdout {
if cmd.dumpspec {
println!("cat mode");
return Ok(());
}
// Degenerate mode: just copy stdin to stdout and call it a day
::std::io::copy(&mut ::std::io::stdin(), &mut ::std::io::stdout())?;
return Ok(());
}
if concern == DegenerateMode {
if cmd.dumpspec {
println!("noop");
}
return Ok(());
}
if concern == StdioConflict {
Err("Too many usages of stdin/stdout")?;
}
if concern == NeedsStdioReuser {
eprintln!("Warning: replies on stdio get directed at random connected client");
websocat = websocat.auto_install_reuser();
continue;
}
if concern == NeedsStdioReuser2 {
websocat = websocat.auto_install_reuser();
continue;
}
if concern == MultipleReusers {
eprintln!("Specifier dump: {:?} {:?}", websocat.s1, websocat.s2);
Err("Multiple reusers is not allowed")?;
}
break;
}
if cmd.dumpspec {
println!("{:?}", websocat.s1);
println!("{:?}", websocat.s2);
println!("{:?}", websocat.opts);
return Ok(());
}
let mut core = Core::new()?;
let prog = websocat.serve(
core.handle(),
std::rc::Rc::new(|e| {
eprintln!("websocat: {}", e);
}),
);
core.run(prog).map_err(|()| "error running".to_string())?;
Ok(())
}
fn main() {
env_logger::init();
let r = run();
if let Err(e) = r {
eprintln!("websocat: {}", e);
::std::process::exit(1);
}
}
|
// Copied from hyperium/hyper-tls#62e3376/src/stream.rs
use bytes::{Buf, BufMut};
use futures::Poll;
use std::fmt;
use std::io::{self, Read, Write};
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_rustls::client::TlsStream;
/// A stream that might be protected with TLS.
pub enum MaybeHttpsStream<T> {
/// A stream over plain text.
Http(T),
/// A stream protected with TLS.
Https(TlsStream<T>),
}
impl<T: fmt::Debug> fmt::Debug for MaybeHttpsStream<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MaybeHttpsStream::Http(..) => f.pad("Http(..)"),
MaybeHttpsStream::Https(..) => f.pad("Https(..)"),
}
}
}
impl<T: AsyncRead + AsyncWrite> Read for MaybeHttpsStream<T> {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
match *self {
MaybeHttpsStream::Http(ref mut s) => s.read(buf),
MaybeHttpsStream::Https(ref mut s) => s.read(buf)
}
}
}
impl<T: AsyncRead + AsyncWrite> Write for MaybeHttpsStream<T> {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
match *self {
MaybeHttpsStream::Http(ref mut s) => s.write(buf),
MaybeHttpsStream::Https(ref mut s) => s.write(buf)
}
}
#[inline]
fn flush(&mut self) -> io::Result<()> {
match *self {
MaybeHttpsStream::Http(ref mut s) => s.flush(),
MaybeHttpsStream::Https(ref mut s) => s.flush()
}
}
}
impl<T: AsyncRead + AsyncWrite> AsyncRead for MaybeHttpsStream<T> {
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
match *self {
MaybeHttpsStream::Http(ref s) => s.prepare_uninitialized_buffer(buf),
MaybeHttpsStream::Https(ref s) => s.prepare_uninitialized_buffer(buf),
}
}
fn read_buf<B: BufMut>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
match *self {
MaybeHttpsStream::Http(ref mut s) => s.read_buf(buf),
MaybeHttpsStream::Https(ref mut s) => s.read_buf(buf),
}
}
}
impl<T: AsyncRead + AsyncWrite> AsyncWrite for MaybeHttpsStream<T> {
fn shutdown(&mut self) -> Poll<(), io::Error> {
match *self {
MaybeHttpsStream::Http(ref mut s) => s.shutdown(),
MaybeHttpsStream::Https(ref mut s) => s.shutdown(),
}
}
fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
match *self {
MaybeHttpsStream::Http(ref mut s) => s.write_buf(buf),
MaybeHttpsStream::Https(ref mut s) => s.write_buf(buf),
}
}
}
|
use common::movingai::Problem;
use criterion::{criterion_group, criterion_main, Criterion};
use pathfinding::expansion_policy::bitgrid::jps::{create_tmap, JpsExpansionPolicy};
use pathfinding::expansion_policy::bitgrid::no_corner_cutting::NoCornerCutting;
use pathfinding::expansion_policy::ExpansionPolicy;
use pathfinding::node_pool::GridPool;
use pathfinding::util::{grid_search, octile_heuristic, zero_heuristic, GridDomain};
use pathfinding::Owner;
mod common;
fn benchmark(c: &mut Criterion) {
common::walk("maps/bitgrid", &mut vec![], &mut |path, rope| {
if path.extension() != Some("scen".as_ref()) {
return;
}
let name = rope.join("/");
c.benchmark_group(name)
.bench_function("dijkstra", |b| {
let (map, problems) = common::movingai::load_scenario(path).unwrap();
let mut pool = GridPool::new(map.width(), map.height());
let mut ep = NoCornerCutting::new(&map);
b.iter(|| run(&mut pool, &problems, &mut ep, |_, _| zero_heuristic()));
})
.bench_function("astar", |b| {
let (map, problems) = common::movingai::load_scenario(path).unwrap();
let mut pool = GridPool::new(map.width(), map.height());
let mut ep = NoCornerCutting::new(&map);
b.iter(|| {
run(&mut pool, &problems, &mut ep, |_, goal| {
octile_heuristic(goal, 1.0)
})
});
})
.bench_function("jps", |b| {
let (map, problems) = common::movingai::load_scenario(path).unwrap();
let tmap = create_tmap(&map);
let mut pool = GridPool::new(map.width(), map.height());
let mut ep = JpsExpansionPolicy::new(&map, &tmap);
b.iter(|| {
run(&mut pool, &problems, &mut ep, |ep, goal| {
ep.set_goal(goal);
octile_heuristic(goal, 1.0)
})
});
});
})
}
fn run<E, H>(
pool: &mut GridPool,
problems: &[Problem],
ep: &mut E,
mut init: impl FnMut(&mut E, (i32, i32)) -> H,
) where
E: ExpansionPolicy<(i32, i32)> + GridDomain,
H: FnMut((i32, i32)) -> f64,
{
let mut owner = Owner::new();
for problem in problems {
let h = init(ep, problem.to);
grid_search(pool, &mut owner, ep, h, problem.from, problem.to);
}
}
criterion_group! {
name = bench;
config = Criterion::default();
targets = benchmark
}
criterion_main!(bench);
|
fn main() {
// functions experiments
my_function();
f2(42, "meaning of life");
fn local_function() {
println!("Can this work ?");
}
local_function();
// expressions experiments
let value = "Wednesday";
println!("value = {}", value);
let value = "Shadow";
println!("value = {}", value);
let value = concat!("Shadow", " ", "Moon");
println!("value = {}", value);
let value = concat!("Shadow", " ", concat!("Moon"));
println!("value = {}", value);
let value = format!("Shadow {}", "Moon");
println!("value = {}", value);
let value = 1;
let value = {
println!("one plus ?");
value + 1
};
println!("value = {:?}", value);
// BE CAREFUL
// works!
let x = {
let y = 5;
y + 5
};
println!("value = {}", x);
// doesn't work the same!
let x = {
let y = 5;
y + 5; // trailing ';' here changes this expression into a statement (no returned value !!!)
};
println!("value = {:?} // watch out !", x);
println!("one = {}", get_one());
println!("another = {}", get_another());
}
fn my_function() {
println!("Hello, nobody.");
}
fn f2(arg1: i32, arg2: &str) {
println!("Printing {} and {}", arg1, arg2);
}
fn get_one() -> i32 {
return 1
}
fn get_another() -> i32 {
1
}
|
#[doc = "Reader of register SSEMUX0"]
pub type R = crate::R<u32, super::SSEMUX0>;
#[doc = "Writer for register SSEMUX0"]
pub type W = crate::W<u32, super::SSEMUX0>;
#[doc = "Register SSEMUX0 `reset()`'s with value 0"]
impl crate::ResetValue for super::SSEMUX0 {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `EMUX0`"]
pub type EMUX0_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EMUX0`"]
pub struct EMUX0_W<'a> {
w: &'a mut W,
}
impl<'a> EMUX0_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "Reader of field `EMUX1`"]
pub type EMUX1_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EMUX1`"]
pub struct EMUX1_W<'a> {
w: &'a mut W,
}
impl<'a> EMUX1_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `EMUX2`"]
pub type EMUX2_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EMUX2`"]
pub struct EMUX2_W<'a> {
w: &'a mut W,
}
impl<'a> EMUX2_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Reader of field `EMUX3`"]
pub type EMUX3_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EMUX3`"]
pub struct EMUX3_W<'a> {
w: &'a mut W,
}
impl<'a> EMUX3_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
#[doc = "Reader of field `EMUX4`"]
pub type EMUX4_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EMUX4`"]
pub struct EMUX4_W<'a> {
w: &'a mut W,
}
impl<'a> EMUX4_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "Reader of field `EMUX5`"]
pub type EMUX5_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EMUX5`"]
pub struct EMUX5_W<'a> {
w: &'a mut W,
}
impl<'a> EMUX5_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
self.w
}
}
#[doc = "Reader of field `EMUX6`"]
pub type EMUX6_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EMUX6`"]
pub struct EMUX6_W<'a> {
w: &'a mut W,
}
impl<'a> EMUX6_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
self.w
}
}
#[doc = "Reader of field `EMUX7`"]
pub type EMUX7_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EMUX7`"]
pub struct EMUX7_W<'a> {
w: &'a mut W,
}
impl<'a> EMUX7_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 28)) | (((value as u32) & 0x01) << 28);
self.w
}
}
impl R {
#[doc = "Bit 0 - 1st Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux0(&self) -> EMUX0_R {
EMUX0_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 4 - 2th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux1(&self) -> EMUX1_R {
EMUX1_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 8 - 3rd Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux2(&self) -> EMUX2_R {
EMUX2_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 12 - 4th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux3(&self) -> EMUX3_R {
EMUX3_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 16 - 5th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux4(&self) -> EMUX4_R {
EMUX4_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 20 - 6th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux5(&self) -> EMUX5_R {
EMUX5_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bit 24 - 7th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux6(&self) -> EMUX6_R {
EMUX6_R::new(((self.bits >> 24) & 0x01) != 0)
}
#[doc = "Bit 28 - 8th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux7(&self) -> EMUX7_R {
EMUX7_R::new(((self.bits >> 28) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - 1st Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux0(&mut self) -> EMUX0_W {
EMUX0_W { w: self }
}
#[doc = "Bit 4 - 2th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux1(&mut self) -> EMUX1_W {
EMUX1_W { w: self }
}
#[doc = "Bit 8 - 3rd Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux2(&mut self) -> EMUX2_W {
EMUX2_W { w: self }
}
#[doc = "Bit 12 - 4th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux3(&mut self) -> EMUX3_W {
EMUX3_W { w: self }
}
#[doc = "Bit 16 - 5th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux4(&mut self) -> EMUX4_W {
EMUX4_W { w: self }
}
#[doc = "Bit 20 - 6th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux5(&mut self) -> EMUX5_W {
EMUX5_W { w: self }
}
#[doc = "Bit 24 - 7th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux6(&mut self) -> EMUX6_W {
EMUX6_W { w: self }
}
#[doc = "Bit 28 - 8th Sample Input Select (Upper Bit)"]
#[inline(always)]
pub fn emux7(&mut self) -> EMUX7_W {
EMUX7_W { w: self }
}
}
|
#![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
pub struct DEVPROP_FILTER_EXPRESSION {
pub Operator: DEVPROP_OPERATOR,
pub Property: super::Properties::DEVPROPERTY,
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl DEVPROP_FILTER_EXPRESSION {}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::default::Default for DEVPROP_FILTER_EXPRESSION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::fmt::Debug for DEVPROP_FILTER_EXPRESSION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEVPROP_FILTER_EXPRESSION").field("Operator", &self.Operator).field("Property", &self.Property).finish()
}
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::cmp::PartialEq for DEVPROP_FILTER_EXPRESSION {
fn eq(&self, other: &Self) -> bool {
self.Operator == other.Operator && self.Property == other.Property
}
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::cmp::Eq for DEVPROP_FILTER_EXPRESSION {}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
unsafe impl ::windows::core::Abi for DEVPROP_FILTER_EXPRESSION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DEVPROP_OPERATOR(pub u32);
pub const DEVPROP_OPERATOR_MODIFIER_NOT: DEVPROP_OPERATOR = DEVPROP_OPERATOR(65536u32);
pub const DEVPROP_OPERATOR_MODIFIER_IGNORE_CASE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(131072u32);
pub const DEVPROP_OPERATOR_NONE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(0u32);
pub const DEVPROP_OPERATOR_EXISTS: DEVPROP_OPERATOR = DEVPROP_OPERATOR(1u32);
pub const DEVPROP_OPERATOR_NOT_EXISTS: DEVPROP_OPERATOR = DEVPROP_OPERATOR(65537u32);
pub const DEVPROP_OPERATOR_EQUALS: DEVPROP_OPERATOR = DEVPROP_OPERATOR(2u32);
pub const DEVPROP_OPERATOR_NOT_EQUALS: DEVPROP_OPERATOR = DEVPROP_OPERATOR(65538u32);
pub const DEVPROP_OPERATOR_GREATER_THAN: DEVPROP_OPERATOR = DEVPROP_OPERATOR(3u32);
pub const DEVPROP_OPERATOR_LESS_THAN: DEVPROP_OPERATOR = DEVPROP_OPERATOR(4u32);
pub const DEVPROP_OPERATOR_GREATER_THAN_EQUALS: DEVPROP_OPERATOR = DEVPROP_OPERATOR(5u32);
pub const DEVPROP_OPERATOR_LESS_THAN_EQUALS: DEVPROP_OPERATOR = DEVPROP_OPERATOR(6u32);
pub const DEVPROP_OPERATOR_EQUALS_IGNORE_CASE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(131074u32);
pub const DEVPROP_OPERATOR_NOT_EQUALS_IGNORE_CASE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(196610u32);
pub const DEVPROP_OPERATOR_BITWISE_AND: DEVPROP_OPERATOR = DEVPROP_OPERATOR(7u32);
pub const DEVPROP_OPERATOR_BITWISE_OR: DEVPROP_OPERATOR = DEVPROP_OPERATOR(8u32);
pub const DEVPROP_OPERATOR_BEGINS_WITH: DEVPROP_OPERATOR = DEVPROP_OPERATOR(9u32);
pub const DEVPROP_OPERATOR_ENDS_WITH: DEVPROP_OPERATOR = DEVPROP_OPERATOR(10u32);
pub const DEVPROP_OPERATOR_CONTAINS: DEVPROP_OPERATOR = DEVPROP_OPERATOR(11u32);
pub const DEVPROP_OPERATOR_BEGINS_WITH_IGNORE_CASE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(131081u32);
pub const DEVPROP_OPERATOR_ENDS_WITH_IGNORE_CASE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(131082u32);
pub const DEVPROP_OPERATOR_CONTAINS_IGNORE_CASE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(131083u32);
pub const DEVPROP_OPERATOR_LIST_CONTAINS: DEVPROP_OPERATOR = DEVPROP_OPERATOR(4096u32);
pub const DEVPROP_OPERATOR_LIST_ELEMENT_BEGINS_WITH: DEVPROP_OPERATOR = DEVPROP_OPERATOR(8192u32);
pub const DEVPROP_OPERATOR_LIST_ELEMENT_ENDS_WITH: DEVPROP_OPERATOR = DEVPROP_OPERATOR(12288u32);
pub const DEVPROP_OPERATOR_LIST_ELEMENT_CONTAINS: DEVPROP_OPERATOR = DEVPROP_OPERATOR(16384u32);
pub const DEVPROP_OPERATOR_LIST_CONTAINS_IGNORE_CASE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(135168u32);
pub const DEVPROP_OPERATOR_LIST_ELEMENT_BEGINS_WITH_IGNORE_CASE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(139264u32);
pub const DEVPROP_OPERATOR_LIST_ELEMENT_ENDS_WITH_IGNORE_CASE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(143360u32);
pub const DEVPROP_OPERATOR_LIST_ELEMENT_CONTAINS_IGNORE_CASE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(147456u32);
pub const DEVPROP_OPERATOR_AND_OPEN: DEVPROP_OPERATOR = DEVPROP_OPERATOR(1048576u32);
pub const DEVPROP_OPERATOR_AND_CLOSE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(2097152u32);
pub const DEVPROP_OPERATOR_OR_OPEN: DEVPROP_OPERATOR = DEVPROP_OPERATOR(3145728u32);
pub const DEVPROP_OPERATOR_OR_CLOSE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(4194304u32);
pub const DEVPROP_OPERATOR_NOT_OPEN: DEVPROP_OPERATOR = DEVPROP_OPERATOR(5242880u32);
pub const DEVPROP_OPERATOR_NOT_CLOSE: DEVPROP_OPERATOR = DEVPROP_OPERATOR(6291456u32);
pub const DEVPROP_OPERATOR_ARRAY_CONTAINS: DEVPROP_OPERATOR = DEVPROP_OPERATOR(268435456u32);
pub const DEVPROP_OPERATOR_MASK_EVAL: DEVPROP_OPERATOR = DEVPROP_OPERATOR(4095u32);
pub const DEVPROP_OPERATOR_MASK_LIST: DEVPROP_OPERATOR = DEVPROP_OPERATOR(61440u32);
pub const DEVPROP_OPERATOR_MASK_MODIFIER: DEVPROP_OPERATOR = DEVPROP_OPERATOR(983040u32);
pub const DEVPROP_OPERATOR_MASK_NOT_LOGICAL: DEVPROP_OPERATOR = DEVPROP_OPERATOR(4027580415u32);
pub const DEVPROP_OPERATOR_MASK_LOGICAL: DEVPROP_OPERATOR = DEVPROP_OPERATOR(267386880u32);
pub const DEVPROP_OPERATOR_MASK_ARRAY: DEVPROP_OPERATOR = DEVPROP_OPERATOR(4026531840u32);
impl ::core::convert::From<u32> for DEVPROP_OPERATOR {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DEVPROP_OPERATOR {
type Abi = Self;
}
impl ::core::ops::BitOr for DEVPROP_OPERATOR {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for DEVPROP_OPERATOR {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for DEVPROP_OPERATOR {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for DEVPROP_OPERATOR {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for DEVPROP_OPERATOR {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
pub struct DEV_OBJECT {
pub ObjectType: DEV_OBJECT_TYPE,
pub pszObjectId: super::super::Foundation::PWSTR,
pub cPropertyCount: u32,
pub pProperties: *mut super::Properties::DEVPROPERTY,
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl DEV_OBJECT {}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::default::Default for DEV_OBJECT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::fmt::Debug for DEV_OBJECT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEV_OBJECT").field("ObjectType", &self.ObjectType).field("pszObjectId", &self.pszObjectId).field("cPropertyCount", &self.cPropertyCount).field("pProperties", &self.pProperties).finish()
}
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::cmp::PartialEq for DEV_OBJECT {
fn eq(&self, other: &Self) -> bool {
self.ObjectType == other.ObjectType && self.pszObjectId == other.pszObjectId && self.cPropertyCount == other.cPropertyCount && self.pProperties == other.pProperties
}
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::cmp::Eq for DEV_OBJECT {}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
unsafe impl ::windows::core::Abi for DEV_OBJECT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DEV_OBJECT_TYPE(pub i32);
pub const DevObjectTypeUnknown: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(0i32);
pub const DevObjectTypeDeviceInterface: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(1i32);
pub const DevObjectTypeDeviceContainer: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(2i32);
pub const DevObjectTypeDevice: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(3i32);
pub const DevObjectTypeDeviceInterfaceClass: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(4i32);
pub const DevObjectTypeAEP: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(5i32);
pub const DevObjectTypeAEPContainer: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(6i32);
pub const DevObjectTypeDeviceInstallerClass: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(7i32);
pub const DevObjectTypeDeviceInterfaceDisplay: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(8i32);
pub const DevObjectTypeDeviceContainerDisplay: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(9i32);
pub const DevObjectTypeAEPService: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(10i32);
pub const DevObjectTypeDevicePanel: DEV_OBJECT_TYPE = DEV_OBJECT_TYPE(11i32);
impl ::core::convert::From<i32> for DEV_OBJECT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DEV_OBJECT_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DEV_QUERY_FLAGS(pub i32);
pub const DevQueryFlagNone: DEV_QUERY_FLAGS = DEV_QUERY_FLAGS(0i32);
pub const DevQueryFlagUpdateResults: DEV_QUERY_FLAGS = DEV_QUERY_FLAGS(1i32);
pub const DevQueryFlagAllProperties: DEV_QUERY_FLAGS = DEV_QUERY_FLAGS(2i32);
pub const DevQueryFlagLocalize: DEV_QUERY_FLAGS = DEV_QUERY_FLAGS(4i32);
pub const DevQueryFlagAsyncClose: DEV_QUERY_FLAGS = DEV_QUERY_FLAGS(8i32);
impl ::core::convert::From<i32> for DEV_QUERY_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DEV_QUERY_FLAGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Devices_Properties")]
pub struct DEV_QUERY_PARAMETER {
pub Key: super::Properties::DEVPROPKEY,
pub Type: u32,
pub BufferSize: u32,
pub Buffer: *mut ::core::ffi::c_void,
}
#[cfg(feature = "Win32_Devices_Properties")]
impl DEV_QUERY_PARAMETER {}
#[cfg(feature = "Win32_Devices_Properties")]
impl ::core::default::Default for DEV_QUERY_PARAMETER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Devices_Properties")]
impl ::core::fmt::Debug for DEV_QUERY_PARAMETER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEV_QUERY_PARAMETER").field("Key", &self.Key).field("Type", &self.Type).field("BufferSize", &self.BufferSize).field("Buffer", &self.Buffer).finish()
}
}
#[cfg(feature = "Win32_Devices_Properties")]
impl ::core::cmp::PartialEq for DEV_QUERY_PARAMETER {
fn eq(&self, other: &Self) -> bool {
self.Key == other.Key && self.Type == other.Type && self.BufferSize == other.BufferSize && self.Buffer == other.Buffer
}
}
#[cfg(feature = "Win32_Devices_Properties")]
impl ::core::cmp::Eq for DEV_QUERY_PARAMETER {}
#[cfg(feature = "Win32_Devices_Properties")]
unsafe impl ::windows::core::Abi for DEV_QUERY_PARAMETER {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DEV_QUERY_RESULT_ACTION(pub i32);
pub const DevQueryResultStateChange: DEV_QUERY_RESULT_ACTION = DEV_QUERY_RESULT_ACTION(0i32);
pub const DevQueryResultAdd: DEV_QUERY_RESULT_ACTION = DEV_QUERY_RESULT_ACTION(1i32);
pub const DevQueryResultUpdate: DEV_QUERY_RESULT_ACTION = DEV_QUERY_RESULT_ACTION(2i32);
pub const DevQueryResultRemove: DEV_QUERY_RESULT_ACTION = DEV_QUERY_RESULT_ACTION(3i32);
impl ::core::convert::From<i32> for DEV_QUERY_RESULT_ACTION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DEV_QUERY_RESULT_ACTION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
pub struct DEV_QUERY_RESULT_ACTION_DATA {
pub Action: DEV_QUERY_RESULT_ACTION,
pub Data: DEV_QUERY_RESULT_ACTION_DATA_0,
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl DEV_QUERY_RESULT_ACTION_DATA {}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::default::Default for DEV_QUERY_RESULT_ACTION_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::cmp::PartialEq for DEV_QUERY_RESULT_ACTION_DATA {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::cmp::Eq for DEV_QUERY_RESULT_ACTION_DATA {}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
unsafe impl ::windows::core::Abi for DEV_QUERY_RESULT_ACTION_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
pub union DEV_QUERY_RESULT_ACTION_DATA_0 {
pub State: DEV_QUERY_STATE,
pub DeviceObject: DEV_OBJECT,
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl DEV_QUERY_RESULT_ACTION_DATA_0 {}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::default::Default for DEV_QUERY_RESULT_ACTION_DATA_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::cmp::PartialEq for DEV_QUERY_RESULT_ACTION_DATA_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
impl ::core::cmp::Eq for DEV_QUERY_RESULT_ACTION_DATA_0 {}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
unsafe impl ::windows::core::Abi for DEV_QUERY_RESULT_ACTION_DATA_0 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DEV_QUERY_STATE(pub i32);
pub const DevQueryStateInitialized: DEV_QUERY_STATE = DEV_QUERY_STATE(0i32);
pub const DevQueryStateEnumCompleted: DEV_QUERY_STATE = DEV_QUERY_STATE(1i32);
pub const DevQueryStateAborted: DEV_QUERY_STATE = DEV_QUERY_STATE(2i32);
pub const DevQueryStateClosed: DEV_QUERY_STATE = DEV_QUERY_STATE(3i32);
impl ::core::convert::From<i32> for DEV_QUERY_STATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DEV_QUERY_STATE {
type Abi = Self;
}
#[inline]
pub unsafe fn DevCloseObjectQuery(hdevquery: *const HDEVQUERY__) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevCloseObjectQuery(hdevquery: *const HDEVQUERY__);
}
::core::mem::transmute(DevCloseObjectQuery(::core::mem::transmute(hdevquery)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevCreateObjectQuery(objecttype: DEV_OBJECT_TYPE, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, pcallback: ::core::option::Option<PDEV_QUERY_RESULT_CALLBACK>, pcontext: *const ::core::ffi::c_void) -> ::windows::core::Result<*mut HDEVQUERY__> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevCreateObjectQuery(objecttype: DEV_OBJECT_TYPE, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, pcallback: ::windows::core::RawPtr, pcontext: *const ::core::ffi::c_void, phdevquery: *mut *mut HDEVQUERY__) -> ::windows::core::HRESULT;
}
let mut result__: <*mut HDEVQUERY__ as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
DevCreateObjectQuery(
::core::mem::transmute(objecttype),
::core::mem::transmute(queryflags),
::core::mem::transmute(crequestedproperties),
::core::mem::transmute(prequestedproperties),
::core::mem::transmute(cfilterexpressioncount),
::core::mem::transmute(pfilter),
::core::mem::transmute(pcallback),
::core::mem::transmute(pcontext),
&mut result__,
)
.from_abi::<*mut HDEVQUERY__>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevCreateObjectQueryEx(objecttype: DEV_OBJECT_TYPE, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, cextendedparametercount: u32, pextendedparameters: *const DEV_QUERY_PARAMETER, pcallback: ::core::option::Option<PDEV_QUERY_RESULT_CALLBACK>, pcontext: *const ::core::ffi::c_void) -> ::windows::core::Result<*mut HDEVQUERY__> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevCreateObjectQueryEx(objecttype: DEV_OBJECT_TYPE, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, cextendedparametercount: u32, pextendedparameters: *const DEV_QUERY_PARAMETER, pcallback: ::windows::core::RawPtr, pcontext: *const ::core::ffi::c_void, phdevquery: *mut *mut HDEVQUERY__) -> ::windows::core::HRESULT;
}
let mut result__: <*mut HDEVQUERY__ as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
DevCreateObjectQueryEx(
::core::mem::transmute(objecttype),
::core::mem::transmute(queryflags),
::core::mem::transmute(crequestedproperties),
::core::mem::transmute(prequestedproperties),
::core::mem::transmute(cfilterexpressioncount),
::core::mem::transmute(pfilter),
::core::mem::transmute(cextendedparametercount),
::core::mem::transmute(pextendedparameters),
::core::mem::transmute(pcallback),
::core::mem::transmute(pcontext),
&mut result__,
)
.from_abi::<*mut HDEVQUERY__>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevCreateObjectQueryFromId<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(objecttype: DEV_OBJECT_TYPE, pszobjectid: Param1, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, pcallback: ::core::option::Option<PDEV_QUERY_RESULT_CALLBACK>, pcontext: *const ::core::ffi::c_void) -> ::windows::core::Result<*mut HDEVQUERY__> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevCreateObjectQueryFromId(objecttype: DEV_OBJECT_TYPE, pszobjectid: super::super::Foundation::PWSTR, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, pcallback: ::windows::core::RawPtr, pcontext: *const ::core::ffi::c_void, phdevquery: *mut *mut HDEVQUERY__) -> ::windows::core::HRESULT;
}
let mut result__: <*mut HDEVQUERY__ as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
DevCreateObjectQueryFromId(
::core::mem::transmute(objecttype),
pszobjectid.into_param().abi(),
::core::mem::transmute(queryflags),
::core::mem::transmute(crequestedproperties),
::core::mem::transmute(prequestedproperties),
::core::mem::transmute(cfilterexpressioncount),
::core::mem::transmute(pfilter),
::core::mem::transmute(pcallback),
::core::mem::transmute(pcontext),
&mut result__,
)
.from_abi::<*mut HDEVQUERY__>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevCreateObjectQueryFromIdEx<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(
objecttype: DEV_OBJECT_TYPE,
pszobjectid: Param1,
queryflags: u32,
crequestedproperties: u32,
prequestedproperties: *const super::Properties::DEVPROPCOMPKEY,
cfilterexpressioncount: u32,
pfilter: *const DEVPROP_FILTER_EXPRESSION,
cextendedparametercount: u32,
pextendedparameters: *const DEV_QUERY_PARAMETER,
pcallback: ::core::option::Option<PDEV_QUERY_RESULT_CALLBACK>,
pcontext: *const ::core::ffi::c_void,
) -> ::windows::core::Result<*mut HDEVQUERY__> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevCreateObjectQueryFromIdEx(
objecttype: DEV_OBJECT_TYPE,
pszobjectid: super::super::Foundation::PWSTR,
queryflags: u32,
crequestedproperties: u32,
prequestedproperties: *const super::Properties::DEVPROPCOMPKEY,
cfilterexpressioncount: u32,
pfilter: *const DEVPROP_FILTER_EXPRESSION,
cextendedparametercount: u32,
pextendedparameters: *const DEV_QUERY_PARAMETER,
pcallback: ::windows::core::RawPtr,
pcontext: *const ::core::ffi::c_void,
phdevquery: *mut *mut HDEVQUERY__,
) -> ::windows::core::HRESULT;
}
let mut result__: <*mut HDEVQUERY__ as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
DevCreateObjectQueryFromIdEx(
::core::mem::transmute(objecttype),
pszobjectid.into_param().abi(),
::core::mem::transmute(queryflags),
::core::mem::transmute(crequestedproperties),
::core::mem::transmute(prequestedproperties),
::core::mem::transmute(cfilterexpressioncount),
::core::mem::transmute(pfilter),
::core::mem::transmute(cextendedparametercount),
::core::mem::transmute(pextendedparameters),
::core::mem::transmute(pcallback),
::core::mem::transmute(pcontext),
&mut result__,
)
.from_abi::<*mut HDEVQUERY__>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevCreateObjectQueryFromIds<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(objecttype: DEV_OBJECT_TYPE, pszzobjectids: Param1, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, pcallback: ::core::option::Option<PDEV_QUERY_RESULT_CALLBACK>, pcontext: *const ::core::ffi::c_void) -> ::windows::core::Result<*mut HDEVQUERY__> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevCreateObjectQueryFromIds(objecttype: DEV_OBJECT_TYPE, pszzobjectids: super::super::Foundation::PWSTR, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, pcallback: ::windows::core::RawPtr, pcontext: *const ::core::ffi::c_void, phdevquery: *mut *mut HDEVQUERY__) -> ::windows::core::HRESULT;
}
let mut result__: <*mut HDEVQUERY__ as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
DevCreateObjectQueryFromIds(
::core::mem::transmute(objecttype),
pszzobjectids.into_param().abi(),
::core::mem::transmute(queryflags),
::core::mem::transmute(crequestedproperties),
::core::mem::transmute(prequestedproperties),
::core::mem::transmute(cfilterexpressioncount),
::core::mem::transmute(pfilter),
::core::mem::transmute(pcallback),
::core::mem::transmute(pcontext),
&mut result__,
)
.from_abi::<*mut HDEVQUERY__>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevCreateObjectQueryFromIdsEx<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(
objecttype: DEV_OBJECT_TYPE,
pszzobjectids: Param1,
queryflags: u32,
crequestedproperties: u32,
prequestedproperties: *const super::Properties::DEVPROPCOMPKEY,
cfilterexpressioncount: u32,
pfilter: *const DEVPROP_FILTER_EXPRESSION,
cextendedparametercount: u32,
pextendedparameters: *const DEV_QUERY_PARAMETER,
pcallback: ::core::option::Option<PDEV_QUERY_RESULT_CALLBACK>,
pcontext: *const ::core::ffi::c_void,
) -> ::windows::core::Result<*mut HDEVQUERY__> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevCreateObjectQueryFromIdsEx(
objecttype: DEV_OBJECT_TYPE,
pszzobjectids: super::super::Foundation::PWSTR,
queryflags: u32,
crequestedproperties: u32,
prequestedproperties: *const super::Properties::DEVPROPCOMPKEY,
cfilterexpressioncount: u32,
pfilter: *const DEVPROP_FILTER_EXPRESSION,
cextendedparametercount: u32,
pextendedparameters: *const DEV_QUERY_PARAMETER,
pcallback: ::windows::core::RawPtr,
pcontext: *const ::core::ffi::c_void,
phdevquery: *mut *mut HDEVQUERY__,
) -> ::windows::core::HRESULT;
}
let mut result__: <*mut HDEVQUERY__ as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
DevCreateObjectQueryFromIdsEx(
::core::mem::transmute(objecttype),
pszzobjectids.into_param().abi(),
::core::mem::transmute(queryflags),
::core::mem::transmute(crequestedproperties),
::core::mem::transmute(prequestedproperties),
::core::mem::transmute(cfilterexpressioncount),
::core::mem::transmute(pfilter),
::core::mem::transmute(cextendedparametercount),
::core::mem::transmute(pextendedparameters),
::core::mem::transmute(pcallback),
::core::mem::transmute(pcontext),
&mut result__,
)
.from_abi::<*mut HDEVQUERY__>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevFindProperty<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(pkey: *const super::Properties::DEVPROPKEY, store: super::Properties::DEVPROPSTORE, pszlocalename: Param2, cproperties: u32, pproperties: *const super::Properties::DEVPROPERTY) -> *mut super::Properties::DEVPROPERTY {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevFindProperty(pkey: *const super::Properties::DEVPROPKEY, store: super::Properties::DEVPROPSTORE, pszlocalename: super::super::Foundation::PWSTR, cproperties: u32, pproperties: *const super::Properties::DEVPROPERTY) -> *mut super::Properties::DEVPROPERTY;
}
::core::mem::transmute(DevFindProperty(::core::mem::transmute(pkey), ::core::mem::transmute(store), pszlocalename.into_param().abi(), ::core::mem::transmute(cproperties), ::core::mem::transmute(pproperties)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevFreeObjectProperties(cpropertycount: u32, pproperties: *const super::Properties::DEVPROPERTY) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevFreeObjectProperties(cpropertycount: u32, pproperties: *const super::Properties::DEVPROPERTY);
}
::core::mem::transmute(DevFreeObjectProperties(::core::mem::transmute(cpropertycount), ::core::mem::transmute(pproperties)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevFreeObjects(cobjectcount: u32, pobjects: *const DEV_OBJECT) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevFreeObjects(cobjectcount: u32, pobjects: *const DEV_OBJECT);
}
::core::mem::transmute(DevFreeObjects(::core::mem::transmute(cobjectcount), ::core::mem::transmute(pobjects)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevGetObjectProperties<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(objecttype: DEV_OBJECT_TYPE, pszobjectid: Param1, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, pcpropertycount: *mut u32, ppproperties: *mut *mut super::Properties::DEVPROPERTY) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevGetObjectProperties(objecttype: DEV_OBJECT_TYPE, pszobjectid: super::super::Foundation::PWSTR, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, pcpropertycount: *mut u32, ppproperties: *mut *mut super::Properties::DEVPROPERTY) -> ::windows::core::HRESULT;
}
DevGetObjectProperties(::core::mem::transmute(objecttype), pszobjectid.into_param().abi(), ::core::mem::transmute(queryflags), ::core::mem::transmute(crequestedproperties), ::core::mem::transmute(prequestedproperties), ::core::mem::transmute(pcpropertycount), ::core::mem::transmute(ppproperties)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevGetObjectPropertiesEx<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(objecttype: DEV_OBJECT_TYPE, pszobjectid: Param1, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cextendedparametercount: u32, pextendedparameters: *const DEV_QUERY_PARAMETER, pcpropertycount: *mut u32, ppproperties: *mut *mut super::Properties::DEVPROPERTY) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevGetObjectPropertiesEx(objecttype: DEV_OBJECT_TYPE, pszobjectid: super::super::Foundation::PWSTR, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cextendedparametercount: u32, pextendedparameters: *const DEV_QUERY_PARAMETER, pcpropertycount: *mut u32, ppproperties: *mut *mut super::Properties::DEVPROPERTY) -> ::windows::core::HRESULT;
}
DevGetObjectPropertiesEx(
::core::mem::transmute(objecttype),
pszobjectid.into_param().abi(),
::core::mem::transmute(queryflags),
::core::mem::transmute(crequestedproperties),
::core::mem::transmute(prequestedproperties),
::core::mem::transmute(cextendedparametercount),
::core::mem::transmute(pextendedparameters),
::core::mem::transmute(pcpropertycount),
::core::mem::transmute(ppproperties),
)
.ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevGetObjects(objecttype: DEV_OBJECT_TYPE, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, pcobjectcount: *mut u32, ppobjects: *mut *mut DEV_OBJECT) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevGetObjects(objecttype: DEV_OBJECT_TYPE, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, pcobjectcount: *mut u32, ppobjects: *mut *mut DEV_OBJECT) -> ::windows::core::HRESULT;
}
DevGetObjects(
::core::mem::transmute(objecttype),
::core::mem::transmute(queryflags),
::core::mem::transmute(crequestedproperties),
::core::mem::transmute(prequestedproperties),
::core::mem::transmute(cfilterexpressioncount),
::core::mem::transmute(pfilter),
::core::mem::transmute(pcobjectcount),
::core::mem::transmute(ppobjects),
)
.ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
#[inline]
pub unsafe fn DevGetObjectsEx(objecttype: DEV_OBJECT_TYPE, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, cextendedparametercount: u32, pextendedparameters: *const DEV_QUERY_PARAMETER, pcobjectcount: *mut u32, ppobjects: *mut *mut DEV_OBJECT) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DevGetObjectsEx(objecttype: DEV_OBJECT_TYPE, queryflags: u32, crequestedproperties: u32, prequestedproperties: *const super::Properties::DEVPROPCOMPKEY, cfilterexpressioncount: u32, pfilter: *const DEVPROP_FILTER_EXPRESSION, cextendedparametercount: u32, pextendedparameters: *const DEV_QUERY_PARAMETER, pcobjectcount: *mut u32, ppobjects: *mut *mut DEV_OBJECT) -> ::windows::core::HRESULT;
}
DevGetObjectsEx(
::core::mem::transmute(objecttype),
::core::mem::transmute(queryflags),
::core::mem::transmute(crequestedproperties),
::core::mem::transmute(prequestedproperties),
::core::mem::transmute(cfilterexpressioncount),
::core::mem::transmute(pfilter),
::core::mem::transmute(cextendedparametercount),
::core::mem::transmute(pextendedparameters),
::core::mem::transmute(pcobjectcount),
::core::mem::transmute(ppobjects),
)
.ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct HDEVQUERY__ {
pub unused: i32,
}
impl HDEVQUERY__ {}
impl ::core::default::Default for HDEVQUERY__ {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for HDEVQUERY__ {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("HDEVQUERY__").field("unused", &self.unused).finish()
}
}
impl ::core::cmp::PartialEq for HDEVQUERY__ {
fn eq(&self, other: &Self) -> bool {
self.unused == other.unused
}
}
impl ::core::cmp::Eq for HDEVQUERY__ {}
unsafe impl ::windows::core::Abi for HDEVQUERY__ {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_Foundation"))]
pub type PDEV_QUERY_RESULT_CALLBACK = unsafe extern "system" fn(hdevquery: *const HDEVQUERY__, pcontext: *const ::core::ffi::c_void, pactiondata: *const DEV_QUERY_RESULT_ACTION_DATA);
|
use http::HeaderValue;
use pathfinder_common::AllowedOrigins;
use tower_http::cors::{AllowOrigin, CorsLayer};
pub fn with_allowed_origins(allowed_origins: AllowedOrigins) -> CorsLayer {
let allowed_origins = match allowed_origins {
AllowedOrigins::Any => AllowOrigin::any(),
AllowedOrigins::List(x) => AllowOrigin::list(x.into_iter().map(|s| {
HeaderValue::from_maybe_shared(s.into_bytes())
.expect("passed type is 'shared' (i.e. owned byte buffer)")
})),
};
CorsLayer::new()
.allow_methods([hyper::Method::POST])
.allow_origin(allowed_origins)
.allow_headers([hyper::header::CONTENT_TYPE])
}
#[cfg(test)]
mod tests {
use crate::{context::RpcContext, RpcServer};
use http::HeaderValue;
#[tokio::test]
async fn preflight() {
for (allowed, expected, line) in [
// Successful
(Some("*"), Some("*"), line!()),
(Some("http://a.com"), Some("http://a.com"), line!()),
// Not on the list
(Some("http://b.com"), None, line!()),
// Disabled
(None, None, line!()),
] {
let context = RpcContext::for_tests();
let server = RpcServer::new("127.0.0.1:0".parse().unwrap(), context);
let server = match allowed {
Some(allowed) => server.with_cors(allowed.into()),
None => server,
};
let (_server_handle, address) = server.run().await.unwrap();
let resp = reqwest::Client::new()
.request(reqwest::Method::OPTIONS, format!("http://{address}"))
.header("Access-Control-Request-Headers", "content-type")
.header("Access-Control-Request-Method", "POST")
.header("Origin", "http://a.com")
.body("")
.send()
.await
.unwrap();
let h = resp.headers();
assert_eq!(
h.get("access-control-allow-headers"),
allowed.and(Some(&HeaderValue::from_static("content-type"))),
"line: {line}"
);
assert_eq!(
h.get("access-control-allow-methods"),
allowed.and(Some(&HeaderValue::from_static("POST"))),
"line: {line}"
);
assert_eq!(
h.get("access-control-allow-origin"),
expected.map(HeaderValue::from_static).as_ref(),
"line: {line}"
);
}
}
}
|
use crate::comments::response::CommentResponse;
use crate::error::reddit_error::RedditError;
use crate::error::reddit_error::RedditError::InvalidDataType;
use crate::message::response::Message;
use crate::responses::listing::Listing;
use crate::Error;
use serde::de::Error as DeError;
pub use serde::Deserialize;
use serde::Deserializer;
use std::fmt;
use std::fmt::{Debug, Display, Formatter};
use std::str::FromStr;
use crate::submission::response::SubmissionResponse;
use crate::subreddit::response::AboutSubreddit;
use crate::user::response::AboutUser;
pub mod listing;
/// A Generic Response from Reddit the type is pre determined by API
/// Data from Reddit usually follows this format
#[derive(Deserialize)]
pub struct GenericResponse<T: Debug> {
/// The kind value from Reddit
pub kind: RedditDataType,
/// The Data that Reddit has responded with
pub data: T,
}
impl<T: Debug> Debug for GenericResponse<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "[{}]. {:?}", self.kind, self.data)
}
}
/// An Enum To Represent the Different Types of Data Reddit will respond with
pub enum RedditDataType {
/// Type: `Listing`
Listing,
/// Type: `t1`
Comment,
/// Type: `t2`
Account,
/// Type: `t3`
Link,
/// Type: `t4`
Message,
/// Type: `t5`
Subreddit,
/// Type: `t6`
Award,
}
impl Display for RedditDataType {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
let data = match self {
RedditDataType::Comment => "t1",
RedditDataType::Account => "t2",
RedditDataType::Link => "t3",
RedditDataType::Message => "t4",
RedditDataType::Subreddit => "t5",
RedditDataType::Award => "t6",
RedditDataType::Listing => "Listing",
};
write!(f, "{}", data)
}
}
impl FromStr for RedditDataType {
type Err = RedditError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"t1" => Ok(RedditDataType::Comment),
"t2" => Ok(RedditDataType::Account),
"t3" => Ok(RedditDataType::Link),
"t4" => Ok(RedditDataType::Message),
"t5" => Ok(RedditDataType::Subreddit),
"t6" => Ok(RedditDataType::Message),
"Listing" => Ok(RedditDataType::Listing),
data => Err(InvalidDataType(data.to_string())),
}
}
}
impl<'de> Deserialize<'de> for RedditDataType {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
RedditDataType::from_str(s.as_str()).map_err(DeError::custom)
}
}
/// A RedditResponse the type is dynamically decided based on the kind data
/// This is primarily used in Listing that return different type of data
pub type RedditResponse = GenericResponse<RedditTypeResponse>;
impl From<RedditTypeResponse> for RedditResponse {
fn from(reddit_type: RedditTypeResponse) -> Self {
let kind = match reddit_type {
RedditTypeResponse::Comment(_) => RedditDataType::Comment,
RedditTypeResponse::Account(_) => RedditDataType::Account,
RedditTypeResponse::Link(_) => RedditDataType::Link,
RedditTypeResponse::Message(_) => RedditDataType::Message,
RedditTypeResponse::Subreddit(_) => RedditDataType::Subreddit,
RedditTypeResponse::Award => RedditDataType::Award,
RedditTypeResponse::Listing(_) => RedditDataType::Listing,
};
RedditResponse {
kind,
data: reddit_type,
}
}
}
impl<'de> Deserialize<'de> for RedditResponse {
fn deserialize<D>(deserializer: D) -> Result<RedditResponse, D::Error>
where
D: Deserializer<'de>,
{
let value: serde_json::Value = serde::Deserialize::deserialize(deserializer).unwrap();
if let Some(kind) = value["kind"].as_str() {
return match kind {
"t1" => Ok(RedditResponse::from(RedditTypeResponse::Comment(
serde_json::from_value(value["data"].clone()).unwrap(),
))),
"t2" => Ok(RedditResponse::from(RedditTypeResponse::Account(
serde_json::from_value(value["data"].clone()).unwrap(),
))),
"t3" => Ok(RedditResponse::from(RedditTypeResponse::Link(
serde_json::from_value(value["data"].clone()).unwrap(),
))),
"t4" => Ok(RedditResponse::from(RedditTypeResponse::Message(
serde_json::from_value(value["data"].clone()).unwrap(),
))),
"t5" => Ok(RedditResponse::from(RedditTypeResponse::Subreddit(
serde_json::from_value(value["data"].clone()).unwrap(),
))),
"Listing" => Ok(RedditResponse::from(RedditTypeResponse::Listing(
serde_json::from_value(value["data"].clone()).unwrap(),
))),
//"t6" => { Ok(GenericResponse::new(RedditType::Comment(serde_json::from_str(value["data"].as_str().unwrap()).unwrap()))) }
_ => Err(DeError::custom("Invalid Reddit Kind")),
};
}
Err(DeError::custom("Some how we are missing a kind tag"))
}
}
/// FullNames are the {t1,t2,t3,t4,t5,t6}_{id} you see within Reddit API all the time
pub struct FullName {
pub reddit_type: RedditDataType,
pub id: String,
}
impl<'de> Deserialize<'de> for FullName {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
FullName::from_str(s.as_str()).map_err(serde::de::Error::custom)
}
}
impl FromStr for FullName {
type Err = crate::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let split = s.split('_').collect::<Vec<&str>>();
if split.len() != 2 {
// Yes, it is always a good time to make a monty python joke.
return Err(Error::from("Then shalt thou count to two, no more, no less. Two shall be the number thou shalt count, and the number of the counting shall be two."));
}
return Ok(FullName {
reddit_type: RedditDataType::from_str(split.first().unwrap())?,
id: split.get(1).unwrap().to_string(),
});
}
}
impl Display for FullName {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
write!(f, "{}_{}", self.reddit_type, self.id)
}
}
impl Debug for FullName {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "{}_{}", self.reddit_type, self.id)
}
}
/// Reddit Type Response Enum
pub enum RedditTypeResponse {
/// The Listing Type
Listing(Listing<RedditResponse>),
/// Comment Response
Comment(CommentResponse),
/// About User Response
Account(AboutUser),
/// Submission Type
Link(SubmissionResponse),
/// Message Response
/// Boxed for Memory Safety
Message(Box<Message>),
/// About SubReddit Response
/// Boxed for Memory Safety
Subreddit(Box<AboutSubreddit>),
/// TODO
Award,
}
impl Debug for RedditTypeResponse {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
RedditTypeResponse::Listing(data) => {
write!(f, "{:?}", data)
}
RedditTypeResponse::Comment(data) => {
write!(f, "{:?}", data)
}
RedditTypeResponse::Account(data) => {
write!(f, "{:?}", data)
}
RedditTypeResponse::Link(data) => {
write!(f, "{:?}", data)
}
RedditTypeResponse::Message(data) => {
write!(f, "{:?}", data)
}
RedditTypeResponse::Subreddit(data) => {
write!(f, "{:?}", data)
}
RedditTypeResponse::Award => {
write!(f, "AWARD!")
}
}
}
}
|
use std::cmp::{max, PartialEq};
use std::mem;
use std::mem::MaybeUninit;
use std::ops::{Index, IndexMut};
use serde::{Deserialize, Serialize};
use super::Row;
use crate::index::Line;
/// Maximum number of buffered lines outside of the grid for performance optimization.
const MAX_CACHE_SIZE: usize = 1_000;
/// A ring buffer for optimizing indexing and rotation.
///
/// The [`Storage::rotate`] and [`Storage::rotate_down`] functions are fast modular additions on
/// the internal [`zero`] field. As compared with [`slice::rotate_left`] which must rearrange items
/// in memory.
///
/// As a consequence, both [`Index`] and [`IndexMut`] are reimplemented for this type to account
/// for the zeroth element not always being at the start of the allocation.
///
/// Because certain [`Vec`] operations are no longer valid on this type, no [`Deref`]
/// implementation is provided. Anything from [`Vec`] that should be exposed must be done so
/// manually.
///
/// [`slice::rotate_left`]: https://doc.rust-lang.org/std/primitive.slice.html#method.rotate_left
/// [`Deref`]: std::ops::Deref
/// [`zero`]: #structfield.zero
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct Storage<T> {
inner: Vec<Row<T>>,
/// Starting point for the storage of rows.
///
/// This value represents the starting line offset within the ring buffer. The value of this
/// offset may be larger than the `len` itself, and will wrap around to the start to form the
/// ring buffer. It represents the bottommost line of the terminal.
zero: usize,
/// Number of visible lines.
visible_lines: usize,
/// Total number of lines currently active in the terminal (scrollback + visible)
///
/// Shrinking this length allows reducing the number of lines in the scrollback buffer without
/// having to truncate the raw `inner` buffer.
/// As long as `len` is bigger than `inner`, it is also possible to grow the scrollback buffer
/// without any additional insertions.
len: usize,
}
impl<T: PartialEq> PartialEq for Storage<T> {
fn eq(&self, other: &Self) -> bool {
// Both storage buffers need to be truncated and zeroed.
assert_eq!(self.zero, 0);
assert_eq!(other.zero, 0);
self.inner == other.inner && self.len == other.len
}
}
impl<T> Storage<T> {
#[inline]
pub fn with_capacity(visible_lines: usize, columns: usize) -> Storage<T>
where
T: Clone + Default,
{
// Initialize visible lines; the scrollback buffer is initialized dynamically.
let mut inner = Vec::with_capacity(visible_lines);
inner.resize_with(visible_lines, || Row::new(columns));
Storage { inner, zero: 0, visible_lines, len: visible_lines }
}
/// Increase the number of lines in the buffer.
#[inline]
pub fn grow_visible_lines(&mut self, next: usize)
where
T: Clone + Default,
{
// Number of lines the buffer needs to grow.
let growage = next - self.visible_lines;
let columns = self[Line(0)].len();
self.initialize(growage, columns);
// Update visible lines.
self.visible_lines = next;
}
/// Decrease the number of lines in the buffer.
#[inline]
pub fn shrink_visible_lines(&mut self, next: usize) {
// Shrink the size without removing any lines.
let shrinkage = self.visible_lines - next;
self.shrink_lines(shrinkage);
// Update visible lines.
self.visible_lines = next;
}
/// Shrink the number of lines in the buffer.
#[inline]
pub fn shrink_lines(&mut self, shrinkage: usize) {
self.len -= shrinkage;
// Free memory.
if self.inner.len() > self.len + MAX_CACHE_SIZE {
self.truncate();
}
}
/// Truncate the invisible elements from the raw buffer.
#[inline]
pub fn truncate(&mut self) {
self.rezero();
self.inner.truncate(self.len);
}
/// Dynamically grow the storage buffer at runtime.
#[inline]
pub fn initialize(&mut self, additional_rows: usize, columns: usize)
where
T: Clone + Default,
{
if self.len + additional_rows > self.inner.len() {
self.rezero();
let realloc_size = self.inner.len() + max(additional_rows, MAX_CACHE_SIZE);
self.inner.resize_with(realloc_size, || Row::new(columns));
}
self.len += additional_rows;
}
#[inline]
pub fn len(&self) -> usize {
self.len
}
/// Swap implementation for Row<T>.
///
/// Exploits the known size of Row<T> to produce a slightly more efficient
/// swap than going through slice::swap.
///
/// The default implementation from swap generates 8 movups and 4 movaps
/// instructions. This implementation achieves the swap in only 8 movups
/// instructions.
pub fn swap(&mut self, a: Line, b: Line) {
debug_assert_eq!(mem::size_of::<Row<T>>(), mem::size_of::<usize>() * 4);
let a = self.compute_index(a);
let b = self.compute_index(b);
unsafe {
// Cast to a qword array to opt out of copy restrictions and avoid
// drop hazards. Byte array is no good here since for whatever
// reason LLVM won't optimized it.
let a_ptr = self.inner.as_mut_ptr().add(a) as *mut MaybeUninit<usize>;
let b_ptr = self.inner.as_mut_ptr().add(b) as *mut MaybeUninit<usize>;
// Copy 1 qword at a time.
//
// The optimizer unrolls this loop and vectorizes it.
let mut tmp: MaybeUninit<usize>;
for i in 0..4 {
tmp = *a_ptr.offset(i);
*a_ptr.offset(i) = *b_ptr.offset(i);
*b_ptr.offset(i) = tmp;
}
}
}
/// Rotate the grid, moving all lines up/down in history.
#[inline]
pub fn rotate(&mut self, count: isize) {
debug_assert!(count.unsigned_abs() <= self.inner.len());
let len = self.inner.len();
self.zero = (self.zero as isize + count + len as isize) as usize % len;
}
/// Rotate all existing lines down in history.
///
/// This is a faster, specialized version of [`rotate_left`].
///
/// [`rotate_left`]: https://doc.rust-lang.org/std/vec/struct.Vec.html#method.rotate_left
#[inline]
pub fn rotate_down(&mut self, count: usize) {
self.zero = (self.zero + count) % self.inner.len();
}
/// Update the raw storage buffer.
#[inline]
pub fn replace_inner(&mut self, vec: Vec<Row<T>>) {
self.len = vec.len();
self.inner = vec;
self.zero = 0;
}
/// Remove all rows from storage.
#[inline]
pub fn take_all(&mut self) -> Vec<Row<T>> {
self.truncate();
let mut buffer = Vec::new();
mem::swap(&mut buffer, &mut self.inner);
self.len = 0;
buffer
}
/// Compute actual index in underlying storage given the requested index.
#[inline]
fn compute_index(&self, requested: Line) -> usize {
debug_assert!(requested.0 < self.visible_lines as i32);
let positive = -(requested - self.visible_lines).0 as usize - 1;
debug_assert!(positive < self.len);
let zeroed = self.zero + positive;
// Use if/else instead of remainder here to improve performance.
//
// Requires `zeroed` to be smaller than `self.inner.len() * 2`,
// but both `self.zero` and `requested` are always smaller than `self.inner.len()`.
if zeroed >= self.inner.len() {
zeroed - self.inner.len()
} else {
zeroed
}
}
/// Rotate the ringbuffer to reset `self.zero` back to index `0`.
#[inline]
fn rezero(&mut self) {
if self.zero == 0 {
return;
}
self.inner.rotate_left(self.zero);
self.zero = 0;
}
}
impl<T> Index<Line> for Storage<T> {
type Output = Row<T>;
#[inline]
fn index(&self, index: Line) -> &Self::Output {
let index = self.compute_index(index);
&self.inner[index]
}
}
impl<T> IndexMut<Line> for Storage<T> {
#[inline]
fn index_mut(&mut self, index: Line) -> &mut Self::Output {
let index = self.compute_index(index);
&mut self.inner[index]
}
}
#[cfg(test)]
mod tests {
use crate::grid::row::Row;
use crate::grid::storage::{Storage, MAX_CACHE_SIZE};
use crate::grid::GridCell;
use crate::index::{Column, Line};
use crate::term::cell::Flags;
impl GridCell for char {
fn is_empty(&self) -> bool {
*self == ' ' || *self == '\t'
}
fn reset(&mut self, template: &Self) {
*self = *template;
}
fn flags(&self) -> &Flags {
unimplemented!();
}
fn flags_mut(&mut self) -> &mut Flags {
unimplemented!();
}
}
#[test]
fn with_capacity() {
let storage = Storage::<char>::with_capacity(3, 1);
assert_eq!(storage.inner.len(), 3);
assert_eq!(storage.len, 3);
assert_eq!(storage.zero, 0);
assert_eq!(storage.visible_lines, 3);
}
#[test]
fn indexing() {
let mut storage = Storage::<char>::with_capacity(3, 1);
storage[Line(0)] = filled_row('0');
storage[Line(1)] = filled_row('1');
storage[Line(2)] = filled_row('2');
storage.zero += 1;
assert_eq!(storage[Line(0)], filled_row('2'));
assert_eq!(storage[Line(1)], filled_row('0'));
assert_eq!(storage[Line(2)], filled_row('1'));
}
#[test]
#[should_panic]
#[cfg(debug_assertions)]
fn indexing_above_inner_len() {
let storage = Storage::<char>::with_capacity(1, 1);
let _ = &storage[Line(-1)];
}
#[test]
fn rotate() {
let mut storage = Storage::<char>::with_capacity(3, 1);
storage.rotate(2);
assert_eq!(storage.zero, 2);
storage.shrink_lines(2);
assert_eq!(storage.len, 1);
assert_eq!(storage.inner.len(), 3);
assert_eq!(storage.zero, 2);
}
/// Grow the buffer one line at the end of the buffer.
///
/// Before:
/// 0: 0 <- Zero
/// 1: 1
/// 2: -
/// After:
/// 0: 0 <- Zero
/// 1: 1
/// 2: -
/// 3: \0
/// ...
/// MAX_CACHE_SIZE: \0
#[test]
fn grow_after_zero() {
// Setup storage area.
let mut storage: Storage<char> = Storage {
inner: vec![filled_row('0'), filled_row('1'), filled_row('-')],
zero: 0,
visible_lines: 3,
len: 3,
};
// Grow buffer.
storage.grow_visible_lines(4);
// Make sure the result is correct.
let mut expected = Storage {
inner: vec![filled_row('0'), filled_row('1'), filled_row('-')],
zero: 0,
visible_lines: 4,
len: 4,
};
expected.inner.append(&mut vec![filled_row('\0'); MAX_CACHE_SIZE]);
assert_eq!(storage.visible_lines, expected.visible_lines);
assert_eq!(storage.inner, expected.inner);
assert_eq!(storage.zero, expected.zero);
assert_eq!(storage.len, expected.len);
}
/// Grow the buffer one line at the start of the buffer.
///
/// Before:
/// 0: -
/// 1: 0 <- Zero
/// 2: 1
/// After:
/// 0: 0 <- Zero
/// 1: 1
/// 2: -
/// 3: \0
/// ...
/// MAX_CACHE_SIZE: \0
#[test]
fn grow_before_zero() {
// Setup storage area.
let mut storage: Storage<char> = Storage {
inner: vec![filled_row('-'), filled_row('0'), filled_row('1')],
zero: 1,
visible_lines: 3,
len: 3,
};
// Grow buffer.
storage.grow_visible_lines(4);
// Make sure the result is correct.
let mut expected = Storage {
inner: vec![filled_row('0'), filled_row('1'), filled_row('-')],
zero: 0,
visible_lines: 4,
len: 4,
};
expected.inner.append(&mut vec![filled_row('\0'); MAX_CACHE_SIZE]);
assert_eq!(storage.visible_lines, expected.visible_lines);
assert_eq!(storage.inner, expected.inner);
assert_eq!(storage.zero, expected.zero);
assert_eq!(storage.len, expected.len);
}
/// Shrink the buffer one line at the start of the buffer.
///
/// Before:
/// 0: 2
/// 1: 0 <- Zero
/// 2: 1
/// After:
/// 0: 2 <- Hidden
/// 0: 0 <- Zero
/// 1: 1
#[test]
fn shrink_before_zero() {
// Setup storage area.
let mut storage: Storage<char> = Storage {
inner: vec![filled_row('2'), filled_row('0'), filled_row('1')],
zero: 1,
visible_lines: 3,
len: 3,
};
// Shrink buffer.
storage.shrink_visible_lines(2);
// Make sure the result is correct.
let expected = Storage {
inner: vec![filled_row('2'), filled_row('0'), filled_row('1')],
zero: 1,
visible_lines: 2,
len: 2,
};
assert_eq!(storage.visible_lines, expected.visible_lines);
assert_eq!(storage.inner, expected.inner);
assert_eq!(storage.zero, expected.zero);
assert_eq!(storage.len, expected.len);
}
/// Shrink the buffer one line at the end of the buffer.
///
/// Before:
/// 0: 0 <- Zero
/// 1: 1
/// 2: 2
/// After:
/// 0: 0 <- Zero
/// 1: 1
/// 2: 2 <- Hidden
#[test]
fn shrink_after_zero() {
// Setup storage area.
let mut storage: Storage<char> = Storage {
inner: vec![filled_row('0'), filled_row('1'), filled_row('2')],
zero: 0,
visible_lines: 3,
len: 3,
};
// Shrink buffer.
storage.shrink_visible_lines(2);
// Make sure the result is correct.
let expected = Storage {
inner: vec![filled_row('0'), filled_row('1'), filled_row('2')],
zero: 0,
visible_lines: 2,
len: 2,
};
assert_eq!(storage.visible_lines, expected.visible_lines);
assert_eq!(storage.inner, expected.inner);
assert_eq!(storage.zero, expected.zero);
assert_eq!(storage.len, expected.len);
}
/// Shrink the buffer at the start and end of the buffer.
///
/// Before:
/// 0: 4
/// 1: 5
/// 2: 0 <- Zero
/// 3: 1
/// 4: 2
/// 5: 3
/// After:
/// 0: 4 <- Hidden
/// 1: 5 <- Hidden
/// 2: 0 <- Zero
/// 3: 1
/// 4: 2 <- Hidden
/// 5: 3 <- Hidden
#[test]
fn shrink_before_and_after_zero() {
// Setup storage area.
let mut storage: Storage<char> = Storage {
inner: vec![
filled_row('4'),
filled_row('5'),
filled_row('0'),
filled_row('1'),
filled_row('2'),
filled_row('3'),
],
zero: 2,
visible_lines: 6,
len: 6,
};
// Shrink buffer.
storage.shrink_visible_lines(2);
// Make sure the result is correct.
let expected = Storage {
inner: vec![
filled_row('4'),
filled_row('5'),
filled_row('0'),
filled_row('1'),
filled_row('2'),
filled_row('3'),
],
zero: 2,
visible_lines: 2,
len: 2,
};
assert_eq!(storage.visible_lines, expected.visible_lines);
assert_eq!(storage.inner, expected.inner);
assert_eq!(storage.zero, expected.zero);
assert_eq!(storage.len, expected.len);
}
/// Check that when truncating all hidden lines are removed from the raw buffer.
///
/// Before:
/// 0: 4 <- Hidden
/// 1: 5 <- Hidden
/// 2: 0 <- Zero
/// 3: 1
/// 4: 2 <- Hidden
/// 5: 3 <- Hidden
/// After:
/// 0: 0 <- Zero
/// 1: 1
#[test]
fn truncate_invisible_lines() {
// Setup storage area.
let mut storage: Storage<char> = Storage {
inner: vec![
filled_row('4'),
filled_row('5'),
filled_row('0'),
filled_row('1'),
filled_row('2'),
filled_row('3'),
],
zero: 2,
visible_lines: 1,
len: 2,
};
// Truncate buffer.
storage.truncate();
// Make sure the result is correct.
let expected = Storage {
inner: vec![filled_row('0'), filled_row('1')],
zero: 0,
visible_lines: 1,
len: 2,
};
assert_eq!(storage.visible_lines, expected.visible_lines);
assert_eq!(storage.inner, expected.inner);
assert_eq!(storage.zero, expected.zero);
assert_eq!(storage.len, expected.len);
}
/// Truncate buffer only at the beginning.
///
/// Before:
/// 0: 1
/// 1: 2 <- Hidden
/// 2: 0 <- Zero
/// After:
/// 0: 1
/// 0: 0 <- Zero
#[test]
fn truncate_invisible_lines_beginning() {
// Setup storage area.
let mut storage: Storage<char> = Storage {
inner: vec![filled_row('1'), filled_row('2'), filled_row('0')],
zero: 2,
visible_lines: 1,
len: 2,
};
// Truncate buffer.
storage.truncate();
// Make sure the result is correct.
let expected = Storage {
inner: vec![filled_row('0'), filled_row('1')],
zero: 0,
visible_lines: 1,
len: 2,
};
assert_eq!(storage.visible_lines, expected.visible_lines);
assert_eq!(storage.inner, expected.inner);
assert_eq!(storage.zero, expected.zero);
assert_eq!(storage.len, expected.len);
}
/// First shrink the buffer and then grow it again.
///
/// Before:
/// 0: 4
/// 1: 5
/// 2: 0 <- Zero
/// 3: 1
/// 4: 2
/// 5: 3
/// After Shrinking:
/// 0: 4 <- Hidden
/// 1: 5 <- Hidden
/// 2: 0 <- Zero
/// 3: 1
/// 4: 2
/// 5: 3 <- Hidden
/// After Growing:
/// 0: 4
/// 1: 5
/// 2: -
/// 3: 0 <- Zero
/// 4: 1
/// 5: 2
/// 6: 3
#[test]
fn shrink_then_grow() {
// Setup storage area.
let mut storage: Storage<char> = Storage {
inner: vec![
filled_row('4'),
filled_row('5'),
filled_row('0'),
filled_row('1'),
filled_row('2'),
filled_row('3'),
],
zero: 2,
visible_lines: 0,
len: 6,
};
// Shrink buffer.
storage.shrink_lines(3);
// Make sure the result after shrinking is correct.
let shrinking_expected = Storage {
inner: vec![
filled_row('4'),
filled_row('5'),
filled_row('0'),
filled_row('1'),
filled_row('2'),
filled_row('3'),
],
zero: 2,
visible_lines: 0,
len: 3,
};
assert_eq!(storage.inner, shrinking_expected.inner);
assert_eq!(storage.zero, shrinking_expected.zero);
assert_eq!(storage.len, shrinking_expected.len);
// Grow buffer.
storage.initialize(1, 1);
// Make sure the previously freed elements are reused.
let growing_expected = Storage {
inner: vec![
filled_row('4'),
filled_row('5'),
filled_row('0'),
filled_row('1'),
filled_row('2'),
filled_row('3'),
],
zero: 2,
visible_lines: 0,
len: 4,
};
assert_eq!(storage.inner, growing_expected.inner);
assert_eq!(storage.zero, growing_expected.zero);
assert_eq!(storage.len, growing_expected.len);
}
#[test]
fn initialize() {
// Setup storage area.
let mut storage: Storage<char> = Storage {
inner: vec![
filled_row('4'),
filled_row('5'),
filled_row('0'),
filled_row('1'),
filled_row('2'),
filled_row('3'),
],
zero: 2,
visible_lines: 0,
len: 6,
};
// Initialize additional lines.
let init_size = 3;
storage.initialize(init_size, 1);
// Generate expected grid.
let mut expected_inner = vec![
filled_row('0'),
filled_row('1'),
filled_row('2'),
filled_row('3'),
filled_row('4'),
filled_row('5'),
];
let expected_init_size = std::cmp::max(init_size, MAX_CACHE_SIZE);
expected_inner.append(&mut vec![filled_row('\0'); expected_init_size]);
let expected_storage = Storage { inner: expected_inner, zero: 0, visible_lines: 0, len: 9 };
assert_eq!(storage.len, expected_storage.len);
assert_eq!(storage.zero, expected_storage.zero);
assert_eq!(storage.inner, expected_storage.inner);
}
#[test]
fn rotate_wrap_zero() {
let mut storage: Storage<char> = Storage {
inner: vec![filled_row('-'), filled_row('-'), filled_row('-')],
zero: 2,
visible_lines: 0,
len: 3,
};
storage.rotate(2);
assert!(storage.zero < storage.inner.len());
}
fn filled_row(content: char) -> Row<char> {
let mut row = Row::new(1);
row[Column(0)] = content;
row
}
}
|
//mod talk;
mod talk;
use talk::*;
fn main(){
println!("Hello Wolrd");
talking();
}
|
use crate::result::{Error, Result};
use bincode::{deserialize, serialize};
use serde::de::DeserializeOwned;
use serde::Serialize;
use std::borrow::Borrow;
use std::collections::HashMap;
use std::marker::PhantomData;
use std::path::Path;
use std::sync::Arc;
pub mod columns {
#[derive(Debug)]
/// SlotMeta Column
pub struct SlotMeta;
#[derive(Debug)]
/// Orphans Column
pub struct Orphans;
#[derive(Debug)]
/// Erasure Column
pub struct Coding;
#[derive(Debug)]
/// Data Column
pub struct Data;
#[derive(Debug)]
/// The erasure meta column
pub struct ErasureMeta;
#[derive(Debug)]
/// The root column
pub struct Root;
}
pub trait Backend: Sized + Send + Sync {
type Key: ?Sized + ToOwned<Owned = Self::OwnedKey>;
type OwnedKey: Borrow<Self::Key>;
type ColumnFamily: Clone;
type Cursor: DbCursor<Self>;
type Iter: Iterator<Item = (Box<Self::Key>, Box<[u8]>)>;
type WriteBatch: IWriteBatch<Self>;
type Error: Into<Error>;
fn open(path: &Path) -> Result<Self>;
fn columns(&self) -> Vec<&'static str>;
fn destroy(path: &Path) -> Result<()>;
fn cf_handle(&self, cf: &str) -> Self::ColumnFamily;
fn get_cf(&self, cf: Self::ColumnFamily, key: &Self::Key) -> Result<Option<Vec<u8>>>;
fn put_cf(&self, cf: Self::ColumnFamily, key: &Self::Key, value: &[u8]) -> Result<()>;
fn delete_cf(&self, cf: Self::ColumnFamily, key: &Self::Key) -> Result<()>;
fn iterator_cf(&self, cf: Self::ColumnFamily, from: Option<&Self::Key>) -> Result<Self::Iter>;
fn raw_iterator_cf(&self, cf: Self::ColumnFamily) -> Result<Self::Cursor>;
fn write(&self, batch: Self::WriteBatch) -> Result<()>;
fn batch(&self) -> Result<Self::WriteBatch>;
}
pub trait Column<B>
where
B: Backend,
{
const NAME: &'static str;
type Index;
fn key(index: Self::Index) -> B::OwnedKey;
fn index(key: &B::Key) -> Self::Index;
}
pub trait DbCursor<B>
where
B: Backend,
{
fn valid(&self) -> bool;
fn seek(&mut self, key: &B::Key);
fn seek_to_first(&mut self);
fn next(&mut self);
fn key(&self) -> Option<B::OwnedKey>;
fn value(&self) -> Option<Vec<u8>>;
}
pub trait IWriteBatch<B>
where
B: Backend,
{
fn put_cf(&mut self, cf: B::ColumnFamily, key: &B::Key, value: &[u8]) -> Result<()>;
fn delete_cf(&mut self, cf: B::ColumnFamily, key: &B::Key) -> Result<()>;
}
pub trait TypedColumn<B>: Column<B>
where
B: Backend,
{
type Type: Serialize + DeserializeOwned;
}
#[derive(Debug, Clone)]
pub struct Database<B>
where
B: Backend,
{
backend: Arc<B>,
}
#[derive(Debug, Clone)]
pub struct BatchProcessor<B>
where
B: Backend,
{
backend: Arc<B>,
}
#[derive(Debug, Clone)]
pub struct Cursor<B, C>
where
B: Backend,
C: Column<B>,
{
db_cursor: B::Cursor,
column: PhantomData<C>,
backend: PhantomData<B>,
}
#[derive(Debug, Clone)]
pub struct LedgerColumn<B, C>
where
B: Backend,
C: Column<B>,
{
backend: Arc<B>,
column: PhantomData<C>,
}
#[derive(Debug)]
pub struct WriteBatch<B>
where
B: Backend,
{
write_batch: B::WriteBatch,
backend: PhantomData<B>,
map: HashMap<&'static str, B::ColumnFamily>,
}
impl<B> Database<B>
where
B: Backend,
{
pub fn open(path: &Path) -> Result<Self> {
let backend = Arc::new(B::open(path)?);
Ok(Database { backend })
}
pub fn destroy(path: &Path) -> Result<()> {
B::destroy(path)?;
Ok(())
}
pub fn get_bytes<C>(&self, key: C::Index) -> Result<Option<Vec<u8>>>
where
C: Column<B>,
{
self.backend
.get_cf(self.cf_handle::<C>(), C::key(key).borrow())
}
pub fn put_bytes<C>(&self, key: C::Index, data: &[u8]) -> Result<()>
where
C: Column<B>,
{
self.backend
.put_cf(self.cf_handle::<C>(), C::key(key).borrow(), data)
}
pub fn delete<C>(&self, key: C::Index) -> Result<()>
where
C: Column<B>,
{
self.backend
.delete_cf(self.cf_handle::<C>(), C::key(key).borrow())
}
pub fn get<C>(&self, key: C::Index) -> Result<Option<C::Type>>
where
C: TypedColumn<B>,
{
if let Some(serialized_value) = self
.backend
.get_cf(self.cf_handle::<C>(), C::key(key).borrow())?
{
let value = deserialize(&serialized_value)?;
Ok(Some(value))
} else {
Ok(None)
}
}
pub fn put<C>(&self, key: C::Index, value: &C::Type) -> Result<()>
where
C: TypedColumn<B>,
{
let serialized_value = serialize(value)?;
self.backend.put_cf(
self.cf_handle::<C>(),
C::key(key).borrow(),
&serialized_value,
)
}
pub fn cursor<C>(&self) -> Result<Cursor<B, C>>
where
C: Column<B>,
{
let db_cursor = self.backend.raw_iterator_cf(self.cf_handle::<C>())?;
Ok(Cursor {
db_cursor,
column: PhantomData,
backend: PhantomData,
})
}
pub fn iter<C>(
&self,
start_from: Option<C::Index>,
) -> Result<impl Iterator<Item = (C::Index, Box<[u8]>)>>
where
C: Column<B>,
{
let iter = {
if let Some(index) = start_from {
let key = C::key(index);
self.backend
.iterator_cf(self.cf_handle::<C>(), Some(key.borrow()))?
} else {
self.backend.iterator_cf(self.cf_handle::<C>(), None)?
}
};
Ok(iter.map(|(key, value)| (C::index(&key), value)))
}
#[inline]
pub fn cf_handle<C>(&self) -> B::ColumnFamily
where
C: Column<B>,
{
self.backend.cf_handle(C::NAME).clone()
}
pub fn column<C>(&self) -> LedgerColumn<B, C>
where
C: Column<B>,
{
LedgerColumn {
backend: Arc::clone(&self.backend),
column: PhantomData,
}
}
// Note this returns an object that can be used to directly write to multiple column families.
// This circumvents the synchronization around APIs that in Blocktree that use
// blocktree.batch_processor, so this API should only be used if the caller is sure they
// are writing to data in columns that will not be corrupted by any simultaneous blocktree
// operations.
pub unsafe fn batch_processor(&self) -> BatchProcessor<B> {
BatchProcessor {
backend: Arc::clone(&self.backend),
}
}
}
impl<B> BatchProcessor<B>
where
B: Backend,
{
pub fn batch(&mut self) -> Result<WriteBatch<B>> {
let db_write_batch = self.backend.batch()?;
let map = self
.backend
.columns()
.into_iter()
.map(|desc| (desc, self.backend.cf_handle(desc)))
.collect();
Ok(WriteBatch {
write_batch: db_write_batch,
backend: PhantomData,
map,
})
}
pub fn write(&mut self, batch: WriteBatch<B>) -> Result<()> {
self.backend.write(batch.write_batch)
}
}
impl<B, C> Cursor<B, C>
where
B: Backend,
C: Column<B>,
{
pub fn valid(&self) -> bool {
self.db_cursor.valid()
}
pub fn seek(&mut self, key: C::Index) {
self.db_cursor.seek(C::key(key).borrow());
}
pub fn seek_to_first(&mut self) {
self.db_cursor.seek_to_first();
}
pub fn next(&mut self) {
self.db_cursor.next();
}
pub fn key(&self) -> Option<C::Index> {
if let Some(key) = self.db_cursor.key() {
Some(C::index(key.borrow()))
} else {
None
}
}
pub fn value_bytes(&self) -> Option<Vec<u8>> {
self.db_cursor.value()
}
}
impl<B, C> Cursor<B, C>
where
B: Backend,
C: TypedColumn<B>,
{
pub fn value(&self) -> Option<C::Type> {
if let Some(bytes) = self.db_cursor.value() {
let value = deserialize(&bytes).ok()?;
Some(value)
} else {
None
}
}
}
impl<B, C> LedgerColumn<B, C>
where
B: Backend,
C: Column<B>,
{
pub fn get_bytes(&self, key: C::Index) -> Result<Option<Vec<u8>>> {
self.backend.get_cf(self.handle(), C::key(key).borrow())
}
pub fn cursor(&self) -> Result<Cursor<B, C>> {
let db_cursor = self.backend.raw_iterator_cf(self.handle())?;
Ok(Cursor {
db_cursor,
column: PhantomData,
backend: PhantomData,
})
}
pub fn iter(
&self,
start_from: Option<C::Index>,
) -> Result<impl Iterator<Item = (C::Index, Box<[u8]>)>> {
let iter = {
if let Some(index) = start_from {
let key = C::key(index);
self.backend
.iterator_cf(self.handle(), Some(key.borrow()))?
} else {
self.backend.iterator_cf(self.handle(), None)?
}
};
Ok(iter.map(|(key, value)| (C::index(&key), value)))
}
#[inline]
pub fn handle(&self) -> B::ColumnFamily {
self.backend.cf_handle(C::NAME).clone()
}
pub fn is_empty(&self) -> Result<bool> {
let mut cursor = self.cursor()?;
cursor.seek_to_first();
Ok(!cursor.valid())
}
pub fn put_bytes(&self, key: C::Index, value: &[u8]) -> Result<()> {
self.backend
.put_cf(self.handle(), C::key(key).borrow(), value)
}
pub fn delete(&self, key: C::Index) -> Result<()> {
self.backend.delete_cf(self.handle(), C::key(key).borrow())
}
}
impl<B, C> LedgerColumn<B, C>
where
B: Backend,
C: TypedColumn<B>,
{
pub fn get(&self, key: C::Index) -> Result<Option<C::Type>> {
if let Some(serialized_value) = self.backend.get_cf(self.handle(), C::key(key).borrow())? {
let value = deserialize(&serialized_value)?;
Ok(Some(value))
} else {
Ok(None)
}
}
pub fn put(&self, key: C::Index, value: &C::Type) -> Result<()> {
let serialized_value = serialize(value)?;
self.backend
.put_cf(self.handle(), C::key(key).borrow(), &serialized_value)
}
}
impl<B> WriteBatch<B>
where
B: Backend,
{
pub fn put_bytes<C: Column<B>>(&mut self, key: C::Index, bytes: &[u8]) -> Result<()> {
self.write_batch
.put_cf(self.get_cf::<C>(), C::key(key).borrow(), bytes)
}
pub fn delete<C: Column<B>>(&mut self, key: C::Index) -> Result<()> {
self.write_batch
.delete_cf(self.get_cf::<C>(), C::key(key).borrow())
}
pub fn put<C: TypedColumn<B>>(&mut self, key: C::Index, value: &C::Type) -> Result<()> {
let serialized_value = serialize(&value)?;
self.write_batch
.put_cf(self.get_cf::<C>(), C::key(key).borrow(), &serialized_value)
}
#[inline]
fn get_cf<C: Column<B>>(&self) -> B::ColumnFamily {
self.map[C::NAME].clone()
}
}
|
//! This module implements much of printf in awk.
//!
//! We lean heavily on ryu and the std::fmt machinery; as such, most of the work is parsing
//! awk-style format strings and translating them to individual calls to write!.
//!
//! TODO: Originally, frawk enforced that all Strs contained valid UTF-8. We have since allowed
//! strings to contain arbitrary byte sequences, but this module will eagerly replace invalid UTF8
//! byte sequences with REPLACEMENT CHARACTER using String's from_utf8_lossy function. This means
//! that users hoping to output raw bytes using `printf` (as may be necessary, given that print
//! appends a newline) may find some bytes replaced inadvertently. We could solve this by adding a
//! new print function that does not append a newline.
use crate::common::Result;
use crate::runtime::{convert, strtoi, Float, Int, Str};
use std::convert::TryFrom;
use std::fmt;
use std::io::Write;
use std::str;
type SmallVec<T> = smallvec::SmallVec<[T; 32]>;
#[derive(Default)]
struct StackWriter(pub SmallVec<u8>);
impl StackWriter {
pub fn len(&self) -> usize {
self.0.len()
}
}
impl Write for StackWriter {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.0.extend_from_slice(buf);
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
struct DisplayBytes<'a>(&'a [u8]);
impl<'a> fmt::Display for DisplayBytes<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt::Display::fmt(&*std::string::String::from_utf8_lossy(self.0), fmt)
}
}
#[derive(Clone, Debug)]
pub(crate) enum FormatArg<'a> {
S(Str<'a>),
F(Float),
I(Int),
}
impl<'a> From<Str<'a>> for FormatArg<'a> {
fn from(s: Str<'a>) -> FormatArg<'a> {
FormatArg::S(s)
}
}
impl<'a> From<&'a str> for FormatArg<'a> {
fn from(s: &'a str) -> FormatArg<'a> {
FormatArg::S(s.into())
}
}
impl<'a> From<&'a [u8]> for FormatArg<'a> {
fn from(bs: &'a [u8]) -> FormatArg<'a> {
FormatArg::S(bs.into())
}
}
impl<'a> From<Int> for FormatArg<'a> {
fn from(i: Int) -> FormatArg<'a> {
FormatArg::I(i)
}
}
impl<'a> From<Float> for FormatArg<'a> {
fn from(f: Float) -> FormatArg<'a> {
FormatArg::F(f)
}
}
impl<'a> FormatArg<'a> {
fn to_float(&self) -> f64 {
use FormatArg::*;
match self {
S(s) => convert::<_, f64>(s),
F(f) => *f,
I(i) => convert::<_, f64>(*i),
}
}
fn to_int(&self) -> i64 {
use FormatArg::*;
match self {
S(s) => convert::<_, i64>(s),
F(f) => convert::<_, i64>(*f),
I(i) => *i,
}
}
fn with_bytes<R>(&self, f: impl FnOnce(&[u8]) -> R) -> R {
use FormatArg::*;
let s: Str<'a> = match self {
S(s) => s.clone(),
F(f) => convert::<_, Str>(*f),
I(i) => convert::<_, Str>(*i),
};
s.with_bytes(f)
}
}
#[derive(Copy, Clone, Debug)]
struct FormatSpec {
// leading '-' ? -- left justification.
minus: bool,
// number to the left of '.', if any
leading_zeros: bool,
// padding
lnum: usize,
// maximum string width, or floating point precision.
rnum: usize,
// format specifier: e.g. c, d, s, x.
spec: u8,
}
impl Default for FormatSpec {
fn default() -> FormatSpec {
FormatSpec {
minus: false,
leading_zeros: false,
lnum: 0,
rnum: usize::max_value(),
spec: b'z', /* invalid */
}
}
}
fn is_spec(c: u8) -> bool {
match c {
b'f' | b'c' | b'd' | b'e' | b'g' | b'o' | b's' | b'x' => true,
_ => false,
}
}
fn process_spec(mut w: impl Write, fspec: &mut FormatSpec, arg: &FormatArg) -> Result<()> {
macro_rules! match_for_spec {
($s:expr, $arg:expr) => {
match (
fspec.minus,
fspec.leading_zeros,
fspec.lnum,
fspec.rnum == usize::max_value(),
) {
(true, true, lnum, true) => write!(w, concat!("{:0<l$", $s, "}"), $arg, l = lnum),
(true, false, lnum, true) => write!(w, concat!("{:<l$", $s, "}"), $arg, l = lnum),
(true, true, lnum, false) => write!(
w,
concat!("{:0<l$.r$", $s, "}"),
$arg,
l = lnum,
r = fspec.rnum
),
(true, false, lnum, false) => write!(
w,
concat!("{:<l$.r$", $s, "}"),
$arg,
l = lnum,
r = fspec.rnum
),
(false, true, lnum, true) => write!(w, concat!("{:0>l$", $s, "}"), $arg, l = lnum),
(false, false, lnum, true) => write!(w, concat!("{:>l$", $s, "}"), $arg, l = lnum),
(false, true, lnum, false) => write!(
w,
concat!("{:0>l$.r$", $s, "}"),
$arg,
l = lnum,
r = fspec.rnum
),
(false, false, lnum, false) => write!(
w,
concat!("{:>l$.r$", $s, "}"),
$arg,
l = lnum,
r = fspec.rnum
),
}
};
}
let res = match fspec.spec {
b'f' => {
if !fspec.leading_zeros && fspec.lnum == 0 && fspec.rnum == usize::max_value() {
// Fast path: use Ryu, which today is more efficient than the standard library.
// NB Ryu prints some things a bit differently than most awk implementations.
// `write!(w, "{}", arg.to_float())` is a bit closer.
let mut buf = ryu::Buffer::new();
write!(w, "{}", buf.format(arg.to_float()))
} else {
match_for_spec!("", arg.to_float())
}
}
b'e' => match_for_spec!("e", arg.to_float()),
b'g' => {
let mut buf = StackWriter::default();
// %g means "pick the shorter of standard and scientific notation". We do the obvious
// thing of computing both and writing out the smaller one.
fspec.spec = b'f';
process_spec(&mut buf, fspec, arg)?;
let l1 = buf.len();
fspec.spec = b'e';
process_spec(&mut buf, fspec, arg)?;
let l2 = buf.len() - l1;
let bytes = if l1 < l2 {
&buf.0[0..l1]
} else {
&buf.0[l1..(l1 + l2)]
};
return write_bytes(&mut w, bytes);
}
b'd' => match_for_spec!("", arg.to_int()),
b'o' => match_for_spec!("o", arg.to_int()),
b'x' => match_for_spec!("x", arg.to_int()),
b'c' => {
// First, see if we have something ascii/UTF8 here
match char::try_from(arg.to_int() as u32) {
Ok(ch) => match_for_spec!("", ch),
// TODO: Unclear what we should do here, write out the raw bytes? write out the
// character code? Awk may just write the raw bytes out, but it's hard to say
// (different behavior across implementations)
_ => match_for_spec!("", "?"),
}
}
b's' => arg.with_bytes(|bs| match_for_spec!("", DisplayBytes(bs))),
x => return err!("unsupported format specifier: {}", x),
};
wrap_result(res)
}
fn wrap_result<T>(r: std::result::Result<T, impl fmt::Display>) -> Result<()> {
match r {
Ok(_) => Ok(()),
Err(e) => err!("formatter: {}", e),
}
}
fn write_bytes(mut w: impl Write, bs: &[u8]) -> Result<()> {
wrap_result(w.write(bs))
}
pub(crate) fn printf(mut w: impl Write, spec: &[u8], mut args: &[FormatArg]) -> Result<()> {
#[derive(Copy, Clone)]
enum State {
// Byte index of start of string
Raw(usize),
// Byte index of percent sign
Format(usize),
}
use State::*;
let mut iter = spec.iter().cloned().enumerate();
macro_rules! next_state {
($e:expr) => {
match $e {
Some((_, b'%')) => Format(0),
Some(_) => Raw(0),
None => return Ok(()),
}
};
}
let mut state = next_state!(iter.next());
let default = FormatArg::S(Default::default());
let mut next_arg = || {
if args.len() == 0 {
&default
} else {
let res = &args[0];
args = &args[1..];
res
}
};
let mut buf = SmallVec::new();
'outer: loop {
match state {
Raw(start) => {
while let Some((ix, ch)) = iter.next() {
if ch == b'%' {
write_bytes(&mut w, &spec[start..ix])?;
state = Format(ix);
continue 'outer;
}
}
write_bytes(&mut w, &spec[start..])?;
break 'outer;
}
Format(start) => {
let mut fs = FormatSpec::default();
#[derive(Copy, Clone)]
enum Stage {
Begin,
Lnum,
Rnum,
}
use Stage::*;
let mut stage = Begin;
let mut next = iter.next();
// AWK is, as usual, rather permissive when it comes to invalid format specifiers:
// If something is formatted incorrectly, it is simply treated like a normal
// string. We implement by checking for error conditions and `break`ing out of the
// inner loop, which will change state to Raw(start).
while let Some((ix, ch)) = next {
if !ch.is_ascii() {
// We cast characters to bytes in what follows.
break;
}
match (ch, stage) {
(b'%', Begin) => {
fs.spec = b'%';
process_spec(&mut w, &mut fs, next_arg())?;
state = Raw(ix + 1);
continue 'outer;
}
(ch, _) if is_spec(ch) => {
fs.spec = ch as u8;
process_spec(&mut w, &mut fs, next_arg())?;
state = Raw(ix + 1);
continue 'outer;
}
(b'-', Begin) => {
stage = Lnum;
fs.minus = true;
}
(b'-', _) | (b'%', _) => break,
(ch, Lnum) | (ch, Begin) => {
if fs.lnum != 0 {
break;
}
buf.clear();
if ch == b'0' {
fs.leading_zeros = true;
} else if ch == b'.' {
stage = Rnum;
continue;
} else {
buf.push(ch);
};
next = None;
while let Some((ix, ch)) = iter.next() {
if !matches!(ch, b'0'..=b'9') {
next = Some((ix, ch));
break;
}
buf.push(ch);
}
let num = strtoi(&buf[..]);
if num < 0 {
break;
}
fs.lnum = num as usize;
stage = Rnum;
continue;
}
(ch, Rnum) => {
if fs.rnum != usize::max_value() {
break;
}
if ch != b'.' {
break;
}
buf.clear();
next = None;
while let Some((ix, ch)) = iter.next() {
if !matches!(ch, b'0'..=b'9') {
next = Some((ix, ch));
break;
}
buf.push(ch);
}
let num = strtoi(&buf[..]);
if num < 0 {
break;
}
fs.rnum = num as usize;
continue;
}
};
next = iter.next();
}
// We do not have a complete format specifier, and we have exhausted the string.
// Just print it out.
state = Raw(start);
continue 'outer;
}
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
macro_rules! sprintf {
($fmt:expr $(, $e:expr)*) => {{
let mut v = Vec::<u8>::new();
let w = Cursor::new(&mut v);
printf(w, $fmt, &[$( $e.into() ),*]).expect("printf failure");
String::from_utf8(v).expect("printf should produce valid utf8")
}}
}
#[test]
fn basic_printf() {
use FormatArg::*;
let mut v = Vec::<u8>::new();
let w = Cursor::new(&mut v);
// We don't use the macro here to test the truncation semantics here.
printf(
w,
b"Hi %s, to my %d friends %f percent of the time: %g!",
&[S("there".into()), F(2.5), I(1), F(1.25369E23)],
)
.expect("printf failed");
let s = str::from_utf8(&v[..]).unwrap();
assert_eq!(
s,
"Hi there, to my 2 friends 1.0 percent of the time: 1.25369e23!"
);
let s2 = sprintf!(b"%e %d ~~ %s", 12535, 3, "hi");
assert_eq!(s2.as_str(), "1.2535e4 3 ~~ hi");
}
#[test]
fn truncation_padding() {
let s1 = sprintf!(b"%06o |%-10.3s|", 98, "February");
assert_eq!(s1.as_str(), "000142 |Feb |");
let s2 = sprintf!(b"|%-10.");
assert_eq!(s2.as_str(), "|%-10.");
}
#[test]
fn float_rounding() {
let s1 = sprintf!(b"%02.2f", 2.375);
assert_eq!(s1.as_str(), "2.38");
let s2 = sprintf!(b"%.2f", 2.375);
assert_eq!(s2.as_str(), "2.38");
}
}
|
use super::doc_base::*;
use super::var_doc;
use super::vardoc_gen::*;
use pine::ast::syntax_type::*;
use pine::libs::{declare_vars, VarResult};
use pine::types::PineRef;
use std::collections::BTreeMap;
use std::rc::Rc;
#[derive(Debug, PartialEq)]
struct NameInfo {
name: String,
var_type: VarType,
signatures: Vec<String>,
}
impl NameInfo {
pub fn new(name: String, var_type: VarType, signatures: Vec<String>) -> NameInfo {
NameInfo {
name,
var_type,
signatures,
}
}
pub fn simple_var(name: String, sig: &'static str) -> NameInfo {
NameInfo {
name: name,
var_type: VarType::Variable,
signatures: vec![String::from(sig)],
}
}
pub fn simple_var2(name: String, sig: String) -> NameInfo {
NameInfo {
name: name,
var_type: VarType::Variable,
signatures: vec![sig],
}
}
pub fn func_vars(name: String, sigs: Vec<String>) -> NameInfo {
NameInfo {
name: name,
var_type: VarType::Function,
signatures: sigs,
}
}
}
fn format_func_type<'a>(name: String, t: FunctionType<'a>) -> String {
let func_sig = t
.signature
.0
.iter()
.map(|v| {
format_var_type(String::from(v.0), v.1.clone())
.iter()
.map(|m| format!("{}: {}", m.name, m.signatures[0]))
.collect::<Vec<_>>()
})
.flatten()
.collect::<Vec<_>>()
.join(", ");
let ret = &format_var_type(String::from(""), t.signature.1)[0].signatures[0];
format!("{}({}) -> {}", name, func_sig, ret)
}
fn format_func_types<'a>(name: String, t: Rc<FunctionTypes<'a>>) -> Vec<String> {
t.0.iter()
.map(|t| format_func_type(name.clone(), t.clone()))
.collect()
}
fn format_obj_type<'a>(name: String, obj: Rc<BTreeMap<&'a str, SyntaxType<'a>>>) -> Vec<NameInfo> {
obj.iter()
.map(|(n, t)| format_var_type([name.clone(), String::from(*n)].join("."), t.clone()))
.flatten()
.collect()
}
fn format_func<'a>(name: String, func: Rc<FunctionTypes<'a>>) -> Vec<NameInfo> {
vec![NameInfo::func_vars(
name.clone(),
format_func_types(name.clone(), func),
)]
}
fn format_var_type<'a>(name: String, t: SyntaxType<'a>) -> Vec<NameInfo> {
match t {
SyntaxType::Void => vec![NameInfo::simple_var(name, "void")],
SyntaxType::Simple(SimpleSyntaxType::Int) => vec![NameInfo::simple_var(name, "int")],
SyntaxType::Simple(SimpleSyntaxType::Float) => vec![NameInfo::simple_var(name, "float")],
SyntaxType::Simple(SimpleSyntaxType::Bool) => vec![NameInfo::simple_var(name, "bool")],
SyntaxType::Simple(SimpleSyntaxType::Na) => vec![NameInfo::simple_var(name, "na")],
SyntaxType::Simple(SimpleSyntaxType::Color) => vec![NameInfo::simple_var(name, "color")],
SyntaxType::Simple(SimpleSyntaxType::String) => vec![NameInfo::simple_var(name, "string")],
SyntaxType::Series(SimpleSyntaxType::Int) => {
vec![NameInfo::simple_var(name, "series(int)")]
}
SyntaxType::Series(SimpleSyntaxType::Float) => {
vec![NameInfo::simple_var(name, "series(float)")]
}
SyntaxType::Series(SimpleSyntaxType::Bool) => {
vec![NameInfo::simple_var(name, "series(bool)")]
}
SyntaxType::Series(SimpleSyntaxType::Na) => vec![NameInfo::simple_var(name, "series(na)")],
SyntaxType::Series(SimpleSyntaxType::Color) => {
vec![NameInfo::simple_var(name, "series(color)")]
}
SyntaxType::Series(SimpleSyntaxType::String) => {
vec![NameInfo::simple_var(name, "series(string)")]
}
SyntaxType::List(sub_t) => vec![NameInfo::simple_var2(
name,
format!(
"list({})",
format_var_type(String::from(""), SyntaxType::Simple(sub_t))
.into_iter()
.map(|d| d.signatures)
.flatten()
.collect::<Vec<_>>()
.join(",")
),
)],
SyntaxType::Tuple(types) => {
let v: Vec<String> = types
.iter()
.map(|t| format_var_type(String::from(""), t.clone()))
.flatten()
.map(|d| d.signatures)
.flatten()
.collect();
vec![NameInfo::simple_var2(name, format!("[{}]", v.join(", ")))]
}
SyntaxType::ObjectClass(t) => vec![NameInfo::simple_var2(name, String::from(t))],
SyntaxType::Val(t) => format_var_type(name, *t),
SyntaxType::Object(obj) => format_obj_type(name, obj),
SyntaxType::Function(func) => format_func(name, func),
SyntaxType::ObjectFunction(obj, func) => {
let v1 = format_obj_type(name.clone(), obj);
let v2 = format_func(name.clone(), func);
vec![v1, v2].into_iter().flatten().collect::<Vec<_>>()
}
SyntaxType::ValFunction(val, func) => {
let v1 = format_var_type(name.clone(), (*val).clone());
let v2 = format_func(name.clone(), func);
vec![v1, v2].into_iter().flatten().collect::<Vec<_>>()
}
SyntaxType::ValObjectFunction(val, obj, func) => {
let v1 = format_var_type(name.clone(), (*val).clone());
let v2 = format_obj_type(name.clone(), obj);
let v3 = format_func(name.clone(), func);
vec![v1, v2, v3].into_iter().flatten().collect::<Vec<_>>()
}
SyntaxType::UserFunction(_) => unreachable!(),
SyntaxType::DynamicExpr(t) => format_var_type(name, (*t).clone()),
SyntaxType::Any => unreachable!(),
}
}
#[derive(Debug, PartialEq)]
pub struct LibVarParser {
pub variables: BTreeMap<String, String>,
pub functions: BTreeMap<String, String>,
pub brief_vars: BTreeMap<String, String>,
pub brief_funcs: BTreeMap<String, String>,
}
fn inner_vars<'a>() -> Vec<VarResult<'a>> {
["close", "open", "high", "low"]
.iter()
.map(|name| {
VarResult::new(
PineRef::new(Some(0f64)),
SyntaxType::Series(SimpleSyntaxType::Float),
name,
)
})
.collect()
}
impl LibVarParser {
pub fn new() -> LibVarParser {
LibVarParser {
variables: BTreeMap::new(),
functions: BTreeMap::new(),
brief_vars: BTreeMap::new(),
brief_funcs: BTreeMap::new(),
}
}
pub fn parse_lib_vars(&mut self) {
let docs = var_doc::declare_vars();
vec![declare_vars(), inner_vars()]
.iter()
.flatten()
.for_each(|s| {
let name_infos = format_var_type(String::from(s.name), s.syntax_type.clone());
name_infos.into_iter().for_each(|s| {
let doc = docs
.iter()
.find(|m| m.name == s.name && m.var_type == s.var_type);
match s.var_type {
VarType::Variable => {
self.variables.insert(
s.name.clone(),
gen_var_doc(
s.name.clone(),
doc.clone(),
&s.signatures,
String::from("var"),
),
);
self.brief_vars.insert(
s.name.clone(),
gen_brief_var_doc(s.name.clone(), doc.clone(), &s.signatures),
);
}
VarType::Function => {
self.functions.insert(
s.name.clone(),
gen_var_doc(
s.name.clone(),
doc.clone(),
&s.signatures,
String::from("fun"),
),
);
self.brief_funcs.insert(
s.name.clone(),
gen_brief_var_doc(s.name.clone(), doc.clone(), &s.signatures),
);
}
}
})
// match s.syntax_type {}
});
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::rc::Rc;
#[test]
fn format_type_test() {
assert_eq!(
format_var_type(String::from("hello"), SyntaxType::int()),
vec![NameInfo::simple_var(String::from("hello"), "int")],
);
assert_eq!(
format_var_type(String::from("hello"), SyntaxType::int_series()),
vec![NameInfo::simple_var(String::from("hello"), "series(int)")],
);
assert_eq!(
format_var_type(
String::from("hello"),
SyntaxType::List(SimpleSyntaxType::Int)
),
vec![NameInfo::simple_var(String::from("hello"), "list(int)")]
);
assert_eq!(
format_var_type(
String::from("hello"),
SyntaxType::Tuple(Rc::new(vec![SyntaxType::int(), SyntaxType::float()]))
),
vec![NameInfo::simple_var(String::from("hello"), "[int, float]")]
);
let mut obj = BTreeMap::new();
let mut obj2 = BTreeMap::new();
obj.insert("e1", SyntaxType::int());
obj2.insert("se", SyntaxType::float());
obj.insert("e2", SyntaxType::Object(Rc::new(obj2)));
assert_eq!(
format_var_type(String::from("hello"), SyntaxType::Object(Rc::new(obj))),
vec![
NameInfo::simple_var(String::from("hello.e1"), "int"),
NameInfo::simple_var(String::from("hello.e2.se"), "float")
]
);
assert_eq!(
format_var_type(
String::from("hello"),
SyntaxType::Function(Rc::new(FunctionTypes(vec![
FunctionType::new((vec![("e1", SyntaxType::bool())], SyntaxType::int())),
FunctionType::new((vec![("e1", SyntaxType::int())], SyntaxType::int()))
])))
),
vec![NameInfo::func_vars(
String::from("hello"),
vec![
String::from("hello(e1: bool) -> int"),
String::from("hello(e1: int) -> int")
]
),]
);
}
}
|
#[allow(dead_code)]
/// Generic Error type for the server
pub struct GenericError
{
msg: String,
kind: ErrorKind
}
impl GenericError
{
/// Create a new GenericError from a message and an error kind
pub fn new(msg: String, kind: ErrorKind) -> Self
{
Self
{
msg,
kind
}
}
}
/// Types of errors required for the server process
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ErrorKind
{
ACIError,
EnvironmentError,
ConnectionError,
ParsingError
}
impl std::fmt::Display for GenericError
{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
{
write!(f, "{}", self.msg)
}
}
impl std::convert::From<aci::errors::ACIError> for GenericError
{
fn from(error: aci::errors::ACIError) -> Self
{
match error
{
aci::errors::ACIError::ClientError(error) =>
{
Self::from(error)
},
aci::errors::ACIError::ServerError(error) =>
{
Self::from(error)
}
}
}
}
impl std::convert::From<aci::errors::ACIClientError> for GenericError
{
fn from(error: aci::errors::ACIClientError) -> Self
{
Self::new(format!("{}", error), ErrorKind::ACIError)
}
}
impl std::convert::From<aci::errors::ACIServerError> for GenericError
{
fn from(error: aci::errors::ACIServerError) -> Self
{
Self::new(format!("{}", error), ErrorKind::ACIError)
}
}
/// Generic result type for wrapping results with GenericError
pub type GenericResult<T> = Result<T, GenericError>; |
use crate::{scene::Object, scene::Scene, Color, Vecf};
use image::{Pixel, Rgb, RgbImage};
use std::f32::consts::PI;
use vecmath::{
vec3_add, vec3_cross, vec3_dot, vec3_len, vec3_neg, vec3_normalized, vec3_scale, vec3_sub,
};
pub struct Ray {
pub direction: Vecf,
pub origin: Vecf,
}
impl Ray {
pub fn new(origin: Vecf, direction: Vecf) -> Ray {
let direction = vec3_normalized(direction);
Ray { origin, direction }
}
}
pub struct View {
image_width: u32,
image_height: u32,
cam_position: Vecf,
fov_rad: f32,
direction: Vecf,
max_depth: u32,
background: Color,
shadow_bias: f32,
}
impl View {
pub fn new(
image_width: u32,
image_height: u32,
cam_position: Vecf,
fov: f32,
direction: Vecf,
max_depth: u32,
background: Color,
shadow_bias: f32,
) -> View {
let fov_rad = (fov * PI) / 180.0;
let direction = vec3_normalized(direction);
View {
image_width,
image_height,
cam_position,
fov_rad,
direction,
max_depth,
background,
shadow_bias,
}
}
pub fn render(&self, scene: &Scene) -> RgbImage {
let mut img_buffer = RgbImage::new(self.image_width, self.image_height);
let img_height = self.image_height as f32;
let img_width = self.image_width as f32;
let cam_right = vec3_normalized(vec3_cross([0.0, 1.0, 0.0], self.direction));
let cam_up = vec3_normalized(vec3_cross(cam_right, self.direction));
let cam_half_width = (self.fov_rad / 2.0).tan() as f32;
let cam_half_height = cam_half_width * (img_height / img_width);
let pixel_width = cam_half_width * 2.0 / img_width;
let pixel_height = cam_half_height * 2.0 / img_height;
for x in 0..self.image_width {
for y in 0..self.image_height {
let vec_x_pixel = vec3_scale(cam_right, pixel_width * x as f32 - cam_half_width);
let vec_y_pixel = vec3_scale(cam_up, pixel_height * y as f32 - cam_half_height);
let vec_translate = vec3_add(vec_x_pixel, vec_y_pixel);
let mut ray = Ray::new(
self.cam_position,
vec3_normalized(vec3_add(self.direction, vec_translate)),
);
let mut pixel_color: [f32; 3] = [0.0; 3];
let mut depth = 0;
let mut reflection_coef = 1.0;
while depth < self.max_depth && reflection_coef > 0.0 {
if !self.color_trace(scene, &mut reflection_coef, &mut ray, &mut pixel_color) {
break;
}
depth += 1;
}
let mut color = [0; 3];
for c in 0..color.len() {
color[c] = (pixel_color[c] * 255.0) as u8;
}
img_buffer.put_pixel(x, y, Rgb(color));
}
}
img_buffer
}
fn color_trace(
&self,
scene: &Scene,
reflection_coef: &mut f32,
ray: &mut Ray,
current_color: &mut [f32; 3],
) -> bool {
if let Some((hit_point, dist, hit_object)) = self.trace(scene, &ray) {
let object_color = hit_object.get_color().0;
let light = self.lambert_shade(scene, hit_object.as_ref(), hit_point);
*ray = hit_object.reflect_ray(ray, hit_point);
for i in 0..current_color.len() {
current_color[i] += (object_color[i] as f32 / 255.0)
* light
* hit_object.get_lambert()
* *reflection_coef;
}
*reflection_coef *= hit_object.get_specular();
true
} else {
false
}
}
fn trace(&self, scene: &Scene, ray: &Ray) -> Option<(Vecf, f32, Box<dyn Object>)> {
let mut min_dist = f32::INFINITY;
let mut closest_object: Option<(Vecf, f32, Box<dyn Object>)> = None;
for object in &scene.objects {
let (distance, hit_point) = object.intersect(&ray);
if distance < min_dist && distance > 0.0 {
min_dist = distance;
closest_object = Some((hit_point, min_dist, object.clone())); //OK??????
}
}
closest_object
}
fn all_intersects(&self, scene: &Scene, ray: &Ray) -> Vec<f32> {
let mut intersects = Vec::new();
for object in &scene.objects {
let (distance, hit_point) = object.intersect(&ray);
if distance > 0.0 && distance != f32::INFINITY {
intersects.push(distance);
}
}
intersects.sort_by(|a, b| a.partial_cmp(b).unwrap());
intersects
}
fn lambert_shade(&self, scene: &Scene, object: &dyn Object, point: Vecf) -> f32 {
let mut lambert_amount = 0.0;
for light in &scene.lights {
let dist_to_light = vec3_sub(light.position, point);
let dir_to_light = vec3_normalized(dist_to_light);
let dist_to_light = vec3_len(dist_to_light);
let shadow_point = vec3_add(point, vec3_scale(dir_to_light, self.shadow_bias));
let mut blocked = false;
for intersect in self.all_intersects(scene, &Ray::new(shadow_point, dir_to_light)) {
if intersect < dist_to_light {
blocked = true;
break;
}
}
if !blocked {
let contribution = vec3_dot(
dir_to_light,
object.normal_to(&Ray::new(point, vec3_neg(dir_to_light))),
);
if contribution > 0.0 {
lambert_amount +=
contribution * (light.intensity / (4.0 * PI * dist_to_light.powi(2)));
}
}
}
lambert_amount.min(1.0)
}
}
|
/// Construct a `ConstValue`.
#[macro_export]
macro_rules! value {
($($json:tt)+) => {
$crate::value_internal!($($json)+)
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! value_internal {
// Done with trailing comma.
(@array [$($elems:expr,)*]) => {
$crate::value_internal_vec![$($elems,)*]
};
// Done without trailing comma.
(@array [$($elems:expr),*]) => {
$crate::value_internal_vec![$($elems),*]
};
// Next element is `null`.
(@array [$($elems:expr,)*] null $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!(null)] $($rest)*)
};
// Next element is `true`.
(@array [$($elems:expr,)*] true $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!(true)] $($rest)*)
};
// Next element is `false`.
(@array [$($elems:expr,)*] false $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!(false)] $($rest)*)
};
// Next element is an array.
(@array [$($elems:expr,)*] [$($array:tt)*] $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!([$($array)*])] $($rest)*)
};
// Next element is a map.
(@array [$($elems:expr,)*] {$($map:tt)*} $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!({$($map)*})] $($rest)*)
};
// Next element is an expression followed by comma.
(@array [$($elems:expr,)*] $next:expr, $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!($next),] $($rest)*)
};
// Last element is an expression with no trailing comma.
(@array [$($elems:expr,)*] $last:expr) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!($last)])
};
// Comma after the most recent element.
(@array [$($elems:expr),*] , $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)*] $($rest)*)
};
// Unexpected token after most recent element.
(@array [$($elems:expr),*] $unexpected:tt $($rest:tt)*) => {
$crate::value_unexpected!($unexpected)
};
// Done.
(@object $object:ident () () ()) => {};
// Insert the current entry followed by trailing comma.
(@object $object:ident [$($key:tt)+] ($value:expr) , $($rest:tt)*) => {
let _ = $object.insert($crate::Name::new($($key)+), $value);
$crate::value_internal!(@object $object () ($($rest)*) ($($rest)*));
};
// Current entry followed by unexpected token.
(@object $object:ident [$($key:tt)+] ($value:expr) $unexpected:tt $($rest:tt)*) => {
$crate::value_unexpected!($unexpected);
};
// Insert the last entry without trailing comma.
(@object $object:ident [$($key:tt)+] ($value:expr)) => {
let _ = $object.insert($crate::Name::new($($key)+), $value);
};
// Next value is `null`.
(@object $object:ident ($($key:tt)+) (: null $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$($key)+] ($crate::value_internal!(null)) $($rest)*);
};
// Next value is `true`.
(@object $object:ident ($($key:tt)+) (: true $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$($key)+] ($crate::value_internal!(true)) $($rest)*);
};
// Next value is `false`.
(@object $object:ident ($($key:tt)+) (: false $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$($key)+] ($crate::value_internal!(false)) $($rest)*);
};
// Next value is an array.
(@object $object:ident ($($key:tt)+) (: [$($array:tt)*] $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$($key)+] ($crate::value_internal!([$($array)*])) $($rest)*);
};
// Next value is a map.
(@object $object:ident ($($key:tt)+) (: {$($map:tt)*} $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$($key)+] ($crate::value_internal!({$($map)*})) $($rest)*);
};
// Next value is an expression followed by comma.
(@object $object:ident ($($key:tt)+) (: $value:expr , $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$($key)+] ($crate::value_internal!($value)) , $($rest)*);
};
// Last value is an expression with no trailing comma.
(@object $object:ident ($($key:tt)+) (: $value:expr) $copy:tt) => {
$crate::value_internal!(@object $object [$($key)+] ($crate::value_internal!($value)));
};
// Missing value for last entry. Trigger a reasonable error message.
(@object $object:ident ($($key:tt)+) (:) $copy:tt) => {
// "unexpected end of macro invocation"
$crate::value_internal!();
};
// Missing colon and value for last entry. Trigger a reasonable error
// message.
(@object $object:ident ($($key:tt)+) () $copy:tt) => {
// "unexpected end of macro invocation"
$crate::value_internal!();
};
// Misplaced colon. Trigger a reasonable error message.
(@object $object:ident () (: $($rest:tt)*) ($colon:tt $($copy:tt)*)) => {
// Takes no arguments so "no rules expected the token `:`".
$crate::value_unexpected!($colon);
};
// Found a comma inside a key. Trigger a reasonable error message.
(@object $object:ident ($($key:tt)*) (, $($rest:tt)*) ($comma:tt $($copy:tt)*)) => {
// Takes no arguments so "no rules expected the token `,`".
$crate::value_unexpected!($comma);
};
// Key is fully parenthesized. This avoids clippy double_parens false
// positives because the parenthesization may be necessary here.
(@object $object:ident () (($key:expr) : $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object ($key) (: $($rest)*) (: $($rest)*));
};
// Refuse to absorb colon token into key expression.
(@object $object:ident ($($key:tt)*) (: $($unexpected:tt)+) $copy:tt) => {
$crate::value_expect_expr_comma!($($unexpected)+);
};
// Munch a token into the current key.
(@object $object:ident ($($key:tt)*) ($tt:tt $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object ($($key)* $tt) ($($rest)*) ($($rest)*));
};
//////////////////////////////////////////////////////////////////////////
// The main implementation.
//
// Must be invoked as: value_internal!($($json)+)
//////////////////////////////////////////////////////////////////////////
(null) => {
$crate::ConstValue::Null
};
(true) => {
$crate::ConstValue::Boolean(true)
};
(false) => {
$crate::ConstValue::Boolean(false)
};
([]) => {
$crate::ConstValue::List($crate::value_internal_vec![])
};
([ $($tt:tt)+ ]) => {
$crate::ConstValue::List($crate::value_internal!(@array [] $($tt)+))
};
({}) => {
$crate::ConstValue::Object(Default::default())
};
({ $($tt:tt)+ }) => {
$crate::ConstValue::Object({
let mut object = $crate::indexmap::IndexMap::new();
$crate::value_internal!(@object object () ($($tt)+) ($($tt)+));
object
})
};
// Any Serialize type: numbers, strings, struct literals, variables etc.
// Must be below every other rule.
($other:expr) => {
$crate::to_value(&$other).unwrap()
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! value_internal_vec {
($($content:tt)*) => {
vec![$($content)*]
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! value_unexpected {
() => {};
}
#[macro_export]
#[doc(hidden)]
macro_rules! value_expect_expr_comma {
($e:expr , $($tt:tt)*) => {};
}
#[cfg(test)]
mod tests {
use indexmap::IndexMap;
use crate::{ConstValue, Name};
#[test]
fn test_macro() {
assert_eq!(value!(1), ConstValue::Number(1.into()));
assert_eq!(value!(1 + 2), ConstValue::Number(3.into()));
assert_eq!(value!("abc"), ConstValue::String("abc".into()));
assert_eq!(value!(true), ConstValue::Boolean(true));
assert_eq!(
value!([1, 2, 3]),
ConstValue::List(
(1..=3)
.into_iter()
.map(|n| ConstValue::Number(n.into()))
.collect()
)
);
assert_eq!(
value!([1, 2, 3,]),
ConstValue::List(
(1..=3)
.into_iter()
.map(|n| ConstValue::Number(n.into()))
.collect()
)
);
assert_eq!(value!({"a": 10, "b": true}), {
let mut map = IndexMap::new();
map.insert(Name::new("a"), ConstValue::Number(10.into()));
map.insert(Name::new("b"), ConstValue::Boolean(true));
ConstValue::Object(map)
});
}
}
|
use std::cell::RefCell;
use std::fmt;
use std::rc::Rc;
use crate::function::Function;
use crate::value::Value;
pub struct ObjUpvalue {
pub is_open: bool,
pub stack_slot: usize,
pub value: RefCell<Value>,
}
pub struct ObjClosure {
pub function: Rc<Function>,
pub upvalues: Vec<Rc<RefCell<ObjUpvalue>>>,
}
impl ObjClosure {
pub fn new(function: &Rc<Function>, upvalues: Vec<Rc<RefCell<ObjUpvalue>>>) -> ObjClosure {
ObjClosure { function: Rc::clone(function), upvalues }
}
}
impl fmt::Display for ObjClosure {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.function)
}
}
pub enum ObjValue {
String(String),
Closure(Rc<ObjClosure>),
ObjUpvalue(ObjUpvalue),
}
impl ObjValue {
pub fn is_string(&self) -> bool {
match self {
ObjValue::String(_) => true,
_ => false,
}
}
pub fn as_str(&self) -> Option<&str> {
match self {
ObjValue::String(s) => Some(&s),
_ => None,
}
}
pub fn as_closure(&self) -> Option<&Rc<ObjClosure>> {
match self {
ObjValue::Closure(c) => Some(c),
_ => None,
}
}
}
impl PartialEq for ObjValue {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(ObjValue::String(rhs), ObjValue::String(lhs)) => rhs.eq(lhs),
(lhs, rhs) => std::ptr::eq(lhs, rhs),
}
}
}
impl fmt::Display for ObjValue {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
ObjValue::String(x) => write!(f, "{}", x),
ObjValue::Closure(x) => write!(f, "{}", x),
ObjValue::ObjUpvalue(_) => write!(f, "upvalue"),
}
}
}
pub struct Obj {
pub value: ObjValue,
}
impl Obj {
pub fn new(value: ObjValue) -> Obj {
Obj { value }
}
pub fn new_string(s: String) -> Obj {
let value = ObjValue::String(s);
Obj::new(value)
}
pub fn new_closure(function: &Rc<Function>, upvalues: Vec<Rc<RefCell<ObjUpvalue>>>) -> Obj {
let closure = ObjClosure::new(function, upvalues);
let closure = Rc::new(closure);
let value = ObjValue::Closure(closure);
Obj::new(value)
}
pub fn with_closure(closure: &Rc<ObjClosure>) -> Obj {
let closure = Rc::clone(closure);
let value = ObjValue::Closure(closure);
Obj::new(value)
}
pub fn is_string(&self) -> bool {
self.value.is_string()
}
pub fn as_str(&self) -> Option<&str> {
self.value.as_str()
}
pub fn as_closure(&self) -> Option<&Rc<ObjClosure>> {
self.value.as_closure()
}
}
impl PartialEq for Obj {
fn eq(&self, other: &Self) -> bool {
self.value.eq(&other.value)
}
}
impl fmt::Display for Obj {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.value)
}
}
|
mod config;
mod dns;
mod htp;
mod lws;
mod requests;
mod service;
mod tunnels;
mod udpx;
mod xport;
use fs2::FileExt;
//use futures::stream::Stream;
//se futures::Future;
use log::{error, info};
use service::Service;
use std::env;
use std::fs::OpenOptions;
use std::io::Write;
use std::process;
use tokio::runtime;
use tokio::signal::unix::{signal, SignalKind};
pub const PIDFILE: &'static str = "/var/run/lproxy-cv.pid";
pub const LOCKFILE: &'static str = "/var/run/lproxy-cv.lock";
pub const VERSION: &'static str = env!("CARGO_PKG_VERSION");
pub const ARCH: &'static str = std::env::consts::ARCH;
fn to_version_number(ver: &str) -> usize {
// split
let splits = ver.split(".");
let vec: Vec<&str> = splits.collect();
let mut u: usize = 0;
for s in vec.iter() {
let uu: usize = s.parse().unwrap();
u = (u << 8) | uu;
}
u
}
fn main() {
config::log_init().unwrap();
let args: Vec<String> = env::args().collect();
// println!("{:?}", args);
let mut uuid: String = String::default();
let mut hardcore_dns:String = String::default();
if args.len() > 1 {
let s = args.get(1).unwrap();
if s == "-v" {
println!("{}", VERSION);
std::process::exit(0);
} else if s == "-vn" {
println!("{}", to_version_number(VERSION));
std::process::exit(0);
} else if s == "-u" {
if args.len() > 2 {
let uuidstr = args.get(2).unwrap();
uuid = uuidstr.to_string();
}
}
if args.len() > 4 {
let s = args.get(3).unwrap();
if s == "-d" {
let dnsstr = args.get(4).unwrap();
hardcore_dns = dnsstr.to_string();
}
}
}
if uuid == "" {
println!("please specify the uuid with -u");
std::process::exit(1);
}
let lockfile = OpenOptions::new()
.write(true)
.truncate(true)
.create(true)
.open(LOCKFILE);
match lockfile {
Ok(ref lfile) => {
if let Err(e) = lfile.try_lock_exclusive() {
error!("lock pid file failed!:{}", e);
return;
}
}
Err(e) => {
error!("create lock file failed!:{}", e);
return;
}
}
let pidfile = OpenOptions::new()
.write(true)
.truncate(true)
.create(true)
.open(PIDFILE);
let pidfile_holder;
match pidfile {
Ok(mut pidf) => {
let pid = process::id();
let pid = &format!("{}", pid);
match pidf.write_all(pid.as_bytes()) {
Err(e) => {
error!("write pid file failed!:{}", e);
return;
}
_ => {
pidfile_holder = Some(pidf);
}
}
}
Err(e) => {
error!("create pid file failed:{}", e);
return;
}
}
info!(
"try to start lproxy-cv server, ver:{}, uuid: {}, arch:{}, hardcore_dns:{}",
VERSION, uuid, ARCH, hardcore_dns
);
let mut basic_rt = runtime::Builder::new()
.basic_scheduler()
.enable_all()
.build()
.unwrap();
// let handle = rt.handle();
let local = tokio::task::LocalSet::new();
let l = async move {
let s = Service::new(uuid, hardcore_dns);
s.borrow_mut().start(s.clone());
let mut ss = signal(SignalKind::user_defined1()).unwrap();
let sig = ss.recv().await;
println!("got signal {:?}", sig);
// Service::stop
s.borrow_mut().stop();
};
local.spawn_local(l);
basic_rt.block_on(local);
if pidfile_holder.is_some() {
match pidfile_holder.unwrap().set_len(0) {
_ => {}
}
}
}
|
use proconio::{input, marker::Chars};
use run_length::RunLength;
fn main() {
input! {
_n: usize,
s: Chars,
};
let rle = RunLength::new(s.iter()).collect::<Vec<_>>();
let mut x = 0;
for w in rle.windows(2) {
let (c1, l1) = w[0];
let (c2, l2) = w[1];
if c1 == &'o' {
x = x.max(l1);
} else {
assert_eq!(c2, &'o');
x = x.max(l2);
}
}
if x == 0 {
println!("-1");
} else {
println!("{}", x);
}
}
|
#[doc = "Reader of register MACHWF1R"]
pub type R = crate::R<u32, super::MACHWF1R>;
#[doc = "Reader of field `RXFIFOSIZE`"]
pub type RXFIFOSIZE_R = crate::R<u8, u8>;
#[doc = "Reader of field `TXFIFOSIZE`"]
pub type TXFIFOSIZE_R = crate::R<u8, u8>;
#[doc = "Reader of field `OSTEN`"]
pub type OSTEN_R = crate::R<bool, bool>;
#[doc = "Reader of field `PTOEN`"]
pub type PTOEN_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADVTHWORD`"]
pub type ADVTHWORD_R = crate::R<bool, bool>;
#[doc = "Reader of field `DCBEN`"]
pub type DCBEN_R = crate::R<bool, bool>;
#[doc = "Reader of field `SPHEN`"]
pub type SPHEN_R = crate::R<bool, bool>;
#[doc = "Reader of field `TSOEN`"]
pub type TSOEN_R = crate::R<bool, bool>;
#[doc = "Reader of field `DBGMEMA`"]
pub type DBGMEMA_R = crate::R<bool, bool>;
#[doc = "Reader of field `AVSEL`"]
pub type AVSEL_R = crate::R<bool, bool>;
#[doc = "Reader of field `HASHTBLSZ`"]
pub type HASHTBLSZ_R = crate::R<u8, u8>;
#[doc = "Reader of field `L3L4FNUM`"]
pub type L3L4FNUM_R = crate::R<u8, u8>;
impl R {
#[doc = "Bits 0:4 - RXFIFOSIZE"]
#[inline(always)]
pub fn rxfifosize(&self) -> RXFIFOSIZE_R {
RXFIFOSIZE_R::new((self.bits & 0x1f) as u8)
}
#[doc = "Bits 6:10 - TXFIFOSIZE"]
#[inline(always)]
pub fn txfifosize(&self) -> TXFIFOSIZE_R {
TXFIFOSIZE_R::new(((self.bits >> 6) & 0x1f) as u8)
}
#[doc = "Bit 11 - OSTEN"]
#[inline(always)]
pub fn osten(&self) -> OSTEN_R {
OSTEN_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 12 - PTOEN"]
#[inline(always)]
pub fn ptoen(&self) -> PTOEN_R {
PTOEN_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 13 - ADVTHWORD"]
#[inline(always)]
pub fn advthword(&self) -> ADVTHWORD_R {
ADVTHWORD_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 16 - DCBEN"]
#[inline(always)]
pub fn dcben(&self) -> DCBEN_R {
DCBEN_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - SPHEN"]
#[inline(always)]
pub fn sphen(&self) -> SPHEN_R {
SPHEN_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 18 - TSOEN"]
#[inline(always)]
pub fn tsoen(&self) -> TSOEN_R {
TSOEN_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 19 - DBGMEMA"]
#[inline(always)]
pub fn dbgmema(&self) -> DBGMEMA_R {
DBGMEMA_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 20 - AVSEL"]
#[inline(always)]
pub fn avsel(&self) -> AVSEL_R {
AVSEL_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bits 24:25 - HASHTBLSZ"]
#[inline(always)]
pub fn hashtblsz(&self) -> HASHTBLSZ_R {
HASHTBLSZ_R::new(((self.bits >> 24) & 0x03) as u8)
}
#[doc = "Bits 27:30 - L3L4FNUM"]
#[inline(always)]
pub fn l3l4fnum(&self) -> L3L4FNUM_R {
L3L4FNUM_R::new(((self.bits >> 27) & 0x0f) as u8)
}
}
|
// Copyright (c) 2021 Quark Container Authors / 2018 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use alloc::sync::Arc;
use spin::Mutex;
use alloc::collections::btree_map::BTreeMap;
use alloc::string::ToString;
use super::super::super::super::qlib::common::*;
use super::super::super::super::qlib::linux_def::*;
use super::super::super::super::qlib::device::*;
use super::super::super::super::qlib::auth::*;
use super::super::super::super::kernel::kernel::*;
use super::super::super::super::task::*;
use super::super::super::super::fs::fsutil::file::dynamic_dir_file_operations::*;
use super::super::super::super::fs::dentry::*;
use super::super::super::super::fs::mount::*;
use super::super::super::attr::*;
use super::super::super::file::*;
use super::super::super::flags::*;
use super::super::super::dirent::*;
use super::super::super::inode::*;
use super::super::super::ramfs::dir::*;
use super::super::super::super::threadmgr::pid_namespace::*;
use super::super::super::super::threadmgr::thread::*;
use super::super::proc::*;
use super::super::dir_proc::*;
use super::super::inode::*;
impl ProcNode {
pub fn NewSubTasksDir(&self, task: &Task, thread: &Thread, msrc: &Arc<Mutex<MountSource>>) -> Inode {
let contents = BTreeMap::new();
let subTasksNode = SubTasksNode {
thread: thread.clone(),
procNode: self.clone(),
};
let subTaskDir = DirNode {
dir: Dir::New(task, contents, &ROOT_OWNER, &FilePermissions::FromMode(FileMode(0o0555))),
data: subTasksNode
};
return NewProcInode(&Arc::new(subTaskDir), msrc, InodeType::SpecialDirectory, Some(thread.clone()))
}
}
// subtasks represents a /proc/TID/task directory.\
pub struct SubTasksNode {
pub thread: Thread,
pub procNode: ProcNode,
}
impl DirDataNode for SubTasksNode {
fn Lookup(&self, _d: &Dir, task: &Task, dir: &Inode, name: &str) -> Result<Dirent> {
let tid = match name.parse::<i32>() {
Err(_) => return Err(Error::SysError(SysErr::ENOENT)),
Ok(id) => id,
};
let pidns = self.procNode.lock().pidns.clone();
let thread = match pidns.TaskWithID(tid) {
None => return Err(Error::SysError(SysErr::ENOENT)),
Some(t) => t,
};
if thread.ThreadGroup() != self.thread.ThreadGroup() {
return Err(Error::SysError(SysErr::ENOENT))
}
let ms = dir.lock().MountSource.clone();
let td = self.procNode.NewTaskDir(task, &self.thread, &ms, false);
return Ok(Dirent::New(&td, name));
}
fn GetFile(&self, _d: &Dir, _task: &Task, _dir: &Inode, dirent: &Dirent, flags: FileFlags) -> Result<File> {
let pidns = self.procNode.lock().pidns.clone();
return Ok(File::New(dirent, &flags, NewSubTasksFile(&self.thread, &pidns)))
}
}
pub fn NewSubTasksFile(thread: &Thread, pidns: &PIDNamespace) -> DynamicDirFileOperations<SubTasksFileNode> {
let subTaskFile = SubTasksFileNode {
thread: thread.clone(),
pidns: pidns.clone(),
};
return DynamicDirFileOperations {
node: subTaskFile
}
}
pub struct SubTasksFileNode {
pub thread: Thread,
pub pidns: PIDNamespace,
}
impl DynamicDirFileNode for SubTasksFileNode {
fn ReadDir(&self, task: &Task, _f: &File, offset: i64, serializer: &mut DentrySerializer) -> Result<i64> {
let mut dirCtx = DirCtx {
Serializer: serializer,
DirCursor: "".to_string(),
};
if offset == 0 {
let kernel = GetKernel();
let root = kernel.RootDir();
let (dot, dotdot) = root.GetDotAttrs(&root);
dirCtx.DirEmit(task, &".".to_string(), &dot)?;
dirCtx.DirEmit(task, &"..".to_string(), &dotdot)?;
}
let tasks = self.thread.ThreadGroup().MemberIDs(&self.pidns);
let idx = match tasks.binary_search(&(offset as i32)) {
Ok(i) => i,
Err(i) => i
};
if idx == tasks.len() {
return Ok(offset);
}
let taskInts = &tasks[idx..];
let mut tid = 0;
for id in taskInts {
tid = *id;
let name = format!("{}", tid);
let attr = DentAttr::GenericDentAttr(InodeType::SpecialDirectory, &PROC_DEVICE);
dirCtx.DirEmit(task, &name, &attr)?;
}
return Ok(tid as i64 + 1)
}
}
|
use specs::prelude::*;
use std::marker::PhantomData;
use super::physics::Direction;
use super::command::{GameCommand, GameCommandQueue};
#[derive(Component)]
pub struct Legs; |
use core::fmt;
use serde::de::{self, Deserializer, Error, Unexpected};
use serde::ser::Serializer;
use serde::{Deserialize, Serialize};
use coruscant_nbt::Compression;
#[derive(Serialize, Debug)]
#[serde(rename = "Player")]
pub struct PlayerDat {
#[serde(rename = "DataVersion")]
data_version: i32,
#[serde(rename = "Dimension")]
dimension: Dimension,
#[serde(rename = "abilities")]
abilities: Abilities,
}
#[derive(Debug)]
pub enum Dimension {
Overworld,
Nether,
TheEnd,
}
impl Serialize for Dimension {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let number = match *self {
Dimension::Overworld => 0,
Dimension::Nether => -1,
Dimension::TheEnd => 1,
};
serializer.serialize_i32(number)
}
}
impl<'de> Deserialize<'de> for Dimension {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct Visitor;
impl<'de> de::Visitor<'de> for Visitor {
type Value = Dimension;
fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("an 32-bit integer 1, 0 or -1")
}
fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E>
where
E: de::Error,
{
match value {
0 => Ok(Dimension::Overworld),
-1 => Ok(Dimension::Nether),
1 => Ok(Dimension::TheEnd),
v => Err(Error::invalid_value(
Unexpected::Signed(v.into()),
&"1, 0 or -1",
)),
}
}
}
deserializer.deserialize_i32(Visitor)
}
}
#[derive(Serialize, Debug)]
pub struct Abilities {
#[serde(rename = "walkSpeed")]
walk_speed: f32,
#[serde(rename = "flySpeed")]
fly_speed: f32,
#[serde(rename = "mayfly")]
may_fly: bool,
#[serde(rename = "flying")]
flying: bool,
#[serde(rename = "invulnerable")]
invulnerable: bool,
#[serde(rename = "mayBuild")]
may_build: bool,
#[serde(rename = "instabuild")]
instant_build: bool,
}
#[derive(Serialize, Debug)]
pub struct ItemStructure {
#[serde(rename = "Count")]
count: i8,
#[serde(rename = "Slot")]
#[serde(skip_serializing_if = "Option::is_none")]
slot_id: Option<i8>,
#[serde(rename = "id")]
item_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
#[serde(default)]
#[serde(rename = "tag")]
item_tag: Option<ItemTag>,
}
#[derive(Serialize, Debug)]
pub enum ItemTag {}
fn main() -> coruscant_nbt::Result<()> {
let dat = PlayerDat {
data_version: 19133,
dimension: Dimension::Nether,
abilities: Abilities {
walk_speed: 0.1,
fly_speed: 0.05,
may_fly: false,
flying: false,
invulnerable: false,
may_build: true,
instant_build: false,
},
};
let s = coruscant_nbt::to_string_transcript(&dat)?;
println!("{}", s);
let v = coruscant_nbt::to_vec(&dat)?;
println!("{:?}", v);
let mut vec = Vec::with_capacity(128);
coruscant_nbt::to_gzip_writer(&mut vec, &dat, Compression::fast())?;
println!("{:?}", vec);
Ok(())
}
|
use std::collections::HashSet;
///
/// Check if a string only contains unique characters (i.e. every character
/// in the string occurs exactly once).
///
/// Time Complexity: `O(n)` (`n * O(1)` insertions)
/// Spacial Complexity: `O(n)` (worst case: all chars are unique)
///
/// # Examples
///
/// ```
/// use cracking_code_interview::arraystrings::uniquechars::only_unique_chars;
/// assert_eq!(only_unique_chars("donald"), false);
/// assert_eq!(only_unique_chars("raby"), true);
/// ```
pub fn only_unique_chars(s: &str) -> bool {
let mut found_chars = HashSet::new();
for c in s.chars() {
// returns false if character is already in the set
if !found_chars.insert(c) {
return false;
}
}
// If this point is reached, there was only one occurrence of each char in
// the string. Therefore, the string must only contain unique chars.
return true;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn empty_string() {
assert_eq!(only_unique_chars(""), true);
}
#[test]
fn single_char() {
assert_eq!(only_unique_chars("a"), true);
}
#[test]
fn two_chars_different() {
assert_eq!(only_unique_chars("ab"), true);
}
#[test]
fn two_chars_same() {
assert_eq!(only_unique_chars("aa"), false);
}
#[test]
fn many_chars_different() {
assert_eq!(only_unique_chars("abcdefghijkl"), true );
}
#[test]
fn many_chars_same() {
assert_eq!(only_unique_chars("aabaaa"), false);
}
}
|
use std::{
borrow::Cow, collections::HashMap as StdHashMap, fmt::Display, hash::Hash, str::FromStr,
};
use async_graphql_parser::{types::Field, Positioned};
use async_graphql_value::{from_value, to_value};
use hashbrown::HashMap;
use indexmap::IndexMap;
use serde::{de::DeserializeOwned, Serialize};
use crate::{
registry::Registry, ContextSelectionSet, InputType, InputValueError, InputValueResult, Name,
OutputType, ServerResult, Value,
};
impl<K, V> InputType for HashMap<K, V>
where
K: ToString + FromStr + Eq + Hash + Send + Sync,
K::Err: Display,
V: Serialize + DeserializeOwned + Send + Sync,
{
type RawValueType = Self;
fn type_name() -> Cow<'static, str> {
<StdHashMap<K, V> as InputType>::type_name()
}
fn create_type_info(registry: &mut Registry) -> String {
<StdHashMap<K, V> as InputType>::create_type_info(registry)
}
fn parse(value: Option<Value>) -> InputValueResult<Self> {
let value = value.unwrap_or_default();
match value {
Value::Object(map) => map
.into_iter()
.map(|(name, value)| {
Ok((
K::from_str(&name).map_err(|err| {
InputValueError::<Self>::custom(format!("object key: {}", err))
})?,
from_value(value).map_err(|err| format!("object value: {}", err))?,
))
})
.collect::<Result<_, _>>()
.map_err(InputValueError::propagate),
_ => Err(InputValueError::expected_type(value)),
}
}
fn to_value(&self) -> Value {
let mut map = IndexMap::new();
for (name, value) in self {
map.insert(
Name::new(name.to_string()),
to_value(value).unwrap_or_default(),
);
}
Value::Object(map)
}
fn as_raw_value(&self) -> Option<&Self::RawValueType> {
Some(self)
}
}
#[async_trait::async_trait]
impl<K, V> OutputType for HashMap<K, V>
where
K: ToString + Eq + Hash + Send + Sync,
V: Serialize + Send + Sync,
{
fn type_name() -> Cow<'static, str> {
<StdHashMap<K, V> as OutputType>::type_name()
}
fn create_type_info(registry: &mut Registry) -> String {
<StdHashMap<K, V> as OutputType>::create_type_info(registry)
}
async fn resolve(
&self,
_ctx: &ContextSelectionSet<'_>,
_field: &Positioned<Field>,
) -> ServerResult<Value> {
let mut map = IndexMap::new();
for (name, value) in self {
map.insert(
Name::new(name.to_string()),
to_value(value).unwrap_or_default(),
);
}
Ok(Value::Object(map))
}
}
|
use std::sync::Arc;
use smallvec::SmallVec;
use sourcerenderer_core::atomic_refcell::AtomicRefCell;
use sourcerenderer_core::graphics::{
Backend,
BufferInfo,
BufferUsage,
Device,
MemoryUsage,
};
/// We suballocate all mesh buffers from a large buffer
/// to be able use indirect rendering.
pub struct AssetBuffer<B: Backend> {
internal: Arc<AssetBufferInternal<B>>,
}
struct AssetBufferInternal<B: Backend> {
buffer: Arc<B::Buffer>,
free_ranges: AtomicRefCell<Vec<BufferRange>>,
reuse_ranges: AtomicRefCell<Vec<(BufferRange, u32)>>,
}
pub struct AssetBufferSlice<B: Backend> {
buffer: Arc<AssetBufferInternal<B>>,
range: BufferRange,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct BufferRange {
offset: u32,
aligned_offset: u32,
length: u32,
}
impl<B: Backend> AssetBuffer<B> {
pub const SIZE_BIG: u32 = 256 << 20;
pub const SIZE_SMALL: u32 = 64 << 20;
pub fn new(device: &Arc<B::Device>, size: u32, usage: BufferUsage) -> Self {
let buffer = device.create_buffer(
&BufferInfo {
size: size as usize,
usage: usage,
},
MemoryUsage::VRAM,
Some("AssetBuffer"),
);
let free_range = BufferRange {
offset: 0,
aligned_offset: 0,
length: size,
};
Self {
internal: Arc::new(AssetBufferInternal {
buffer,
free_ranges: AtomicRefCell::new(vec![free_range]),
reuse_ranges: AtomicRefCell::new(Vec::new()),
}),
}
}
pub fn get_slice(&self, length: usize, alignment: usize) -> AssetBufferSlice<B> {
let alignment = alignment as u32;
let mut free_ranges = self.internal.free_ranges.borrow_mut();
let mut remove_range: bool = false;
let mut used_range = Option::<(usize, u32)>::None;
for (index, range) in free_ranges.iter_mut().enumerate() {
let mut aligned_range = range.clone();
aligned_range.offset = ((aligned_range.offset + alignment - 1) / alignment) * alignment;
let alignment_diff = aligned_range.offset - range.offset;
aligned_range.length -= alignment_diff;
if aligned_range.length >= length as u32 {
used_range = Some((index, range.offset));
if range.length != length as u32 {
range.offset += length as u32 + alignment_diff;
range.length -= length as u32 + alignment_diff;
} else {
remove_range = true;
}
break;
}
}
let (index, offset) = used_range.expect("Could not find enough space in the AssetBuffer");
if remove_range {
free_ranges.remove(index);
}
AssetBufferSlice::<B> {
buffer: self.internal.clone(),
range: BufferRange {
offset,
aligned_offset: ((offset + alignment - 1) / alignment) * alignment,
length: length as u32,
},
}
}
pub fn bump_frame(&self, device: &Arc<B::Device>) {
let mut reuse_ranges = self.internal.reuse_ranges.borrow_mut();
for (range, frames) in reuse_ranges.iter_mut() {
*frames += 1;
if *frames > device.prerendered_frames() + 1 {
self.internal.reuse_range(&range);
}
}
reuse_ranges.retain(|(_r, frames)| *frames <= device.prerendered_frames() + 1);
}
pub fn buffer(&self) -> &Arc<B::Buffer> {
&self.internal.buffer
}
}
impl<B: Backend> AssetBufferInternal<B> {
pub fn queue_for_reuse(&self, range: &BufferRange) {
let mut reuse_ranges = self.reuse_ranges.borrow_mut();
reuse_ranges.push((range.clone(), 0));
}
pub fn reuse_range(&self, range: &BufferRange) {
let mut free_ranges = self.free_ranges.borrow_mut();
let mut indices_to_delete = SmallVec::<[u32; 16]>::new();
let mut range = range.clone();
for (index, entry) in free_ranges.iter().enumerate() {
if entry.offset == range.offset + range.length {
range.length += entry.length;
indices_to_delete.push(index as u32);
} else if entry.offset + entry.offset == range.offset {
range.offset -= entry.length;
indices_to_delete.push(index as u32);
}
}
let mut deleted_count = 0;
for index_to_delete in indices_to_delete {
free_ranges.remove(index_to_delete as usize - deleted_count);
deleted_count += 1;
}
free_ranges.push(range);
}
}
impl<B: Backend> AssetBufferSlice<B> {
pub fn buffer(&self) -> &Arc<B::Buffer> {
&self.buffer.buffer
}
pub fn offset(&self) -> u32 {
self.range.offset
}
pub fn size(&self) -> u32 {
self.range.length
}
}
impl<B: Backend> Drop for AssetBufferSlice<B> {
fn drop(&mut self) {
self.buffer.queue_for_reuse(&self.range);
}
}
|
extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, ItemStruct};
#[proc_macro_derive(Force)]
pub fn derive_force(input: TokenStream) -> TokenStream {
let item = parse_macro_input!(input as ItemStruct);
let struct_name = item.ident;
let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
let gen = quote! {
impl #impl_generics Force for #struct_name #ty_generics #where_clause {
fn apply(&self, points: &mut [Point], alpha: f32) {
for u in 0..points.len() {
self.apply_to_node(u, points, alpha);
}
}
}
};
gen.into()
}
|
// Search a 2D Matrix II
// https://leetcode.com/explore/challenge/card/february-leetcoding-challenge-2021/587/week-4-february-22nd-february-28th/3650/
pub struct Solution;
use std::cmp::Ordering::*;
#[cfg(disable)]
impl Solution {
pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
let m = matrix.len();
let n = matrix[0].len();
let mut i = m - 1;
let mut j = 0;
while j < n {
match matrix[i][j].cmp(&target) {
Equal => return true,
Greater if i > 0 => {
i -= 1;
}
_ => j += 1,
}
}
false
}
}
use std::ops::Range;
impl Solution {
pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
let m = matrix.len();
let n = matrix[0].len();
Self::search_block(&matrix, target, &(0..m), &(0..n))
}
fn search_block(
matrix: &Vec<Vec<i32>>,
target: i32,
ir: &Range<usize>,
jr: &Range<usize>,
) -> bool {
// `is_empty` doesn't work in Leetcode's version, the replacement could
// be: `if ir.start == ir.end || jr.start == jr.end`
if ir.is_empty() || jr.is_empty() {
return false;
}
let im = (ir.start + ir.end) / 2;
let jm = (jr.start + jr.end) / 2;
match matrix[im][jm].cmp(&target) {
Equal => true,
Less => {
Self::search_block(
matrix,
target,
&(ir.start..im + 1),
&(jm + 1..jr.end),
) || Self::search_block(matrix, target, &(im + 1..ir.end), jr)
}
Greater => {
Self::search_block(matrix, target, &(ir.start..im), jr)
|| Self::search_block(
matrix,
target,
&(im..ir.end),
&(jr.start..jm),
)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::matrix;
#[test]
fn example1() {
assert_eq!(
Solution::search_matrix(
matrix![
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30],
],
5,
),
true,
);
}
#[test]
fn example2() {
assert_eq!(
Solution::search_matrix(
matrix![
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30],
],
20,
),
false,
);
}
#[test]
fn test_big() {
let mut matrix = matrix![0_i32; 300; 300];
for i in 0..300 {
for j in 0..300 {
matrix[i][j] = (i + j) as i32;
}
}
assert_eq!(Solution::search_matrix(matrix, 500), true);
}
#[test]
fn fail1() {
assert_eq!(Solution::search_matrix(matrix![[-5]], -5), true);
}
#[test]
fn fail2() {
assert_eq!(Solution::search_matrix(matrix![[-5]], -10), false);
}
#[test]
fn fail3() {
assert_eq!(
Solution::search_matrix(
matrix![
[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
],
5
),
true,
);
}
}
|
use board::stones::stone::Stone;
struct GoSample {
x: Vec<Stone>,
y: Vec<f32>,
}
impl GoSample {
pub fn new(x: Vec<Stone>, y: Vec<f32>) -> Self {
GoSample {
x,
y
}
}
}
impl GoSample {} |
/*
* Open Service Cloud API
*
* Open Service Cloud API to manage different backend cloud services.
*
* The version of the OpenAPI document: 0.0.3
* Contact: wanghui71leon@gmail.com
* Generated by: https://openapi-generator.tech
*/
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct VpcResourceFragmentRoutes {
#[serde(rename = "destination", skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "nexthop", skip_serializing_if = "Option::is_none")]
pub nexthop: Option<String>,
}
impl VpcResourceFragmentRoutes {
pub fn new() -> VpcResourceFragmentRoutes {
VpcResourceFragmentRoutes {
destination: None,
nexthop: None,
}
}
}
|
use crate::NUMERICS;
use arrow::array::{Array, ArrayRef};
use arrow::compute::kernels::numeric::sub_wrapping;
use arrow::compute::shift;
use arrow::datatypes::DataType;
use datafusion::common::{Result, ScalarValue};
use datafusion::logical_expr::{PartitionEvaluator, Signature, TypeSignature, Volatility};
use once_cell::sync::Lazy;
use std::sync::Arc;
/// The name of the difference window function.
pub(super) const NAME: &str = "difference";
/// Valid signatures for the difference window function.
pub(super) static SIGNATURE: Lazy<Signature> = Lazy::new(|| {
Signature::one_of(
NUMERICS
.iter()
.map(|dt| TypeSignature::Exact(vec![dt.clone()]))
.collect(),
Volatility::Immutable,
)
});
/// Calculate the return type given the function signature.
pub(super) fn return_type(sig: &[DataType]) -> Result<Arc<DataType>> {
Ok(Arc::new(sig[0].clone()))
}
/// Create a new partition_evaluator_factory.
pub(super) fn partition_evaluator_factory() -> Result<Box<dyn PartitionEvaluator>> {
Ok(Box::new(DifferencePartitionEvaluator {}))
}
/// PartitionEvaluator which returns the difference between input values.
#[derive(Debug)]
struct DifferencePartitionEvaluator {}
impl PartitionEvaluator for DifferencePartitionEvaluator {
fn evaluate_all(&mut self, values: &[ArrayRef], _num_rows: usize) -> Result<Arc<dyn Array>> {
assert_eq!(values.len(), 1);
let array = Arc::clone(&values[0]);
if array.null_count() == 0 {
// If there are no gaps then use arrow kernels.
Ok(sub_wrapping(&array, &shift(&array, 1)?)?)
} else {
let mut idx: usize = 0;
let mut last: ScalarValue = array.data_type().try_into()?;
let mut difference: Vec<ScalarValue> = vec![];
while idx < array.len() {
last = ScalarValue::try_from_array(&array, idx)?;
difference.push(array.data_type().try_into()?);
idx += 1;
if !last.is_null() {
break;
}
}
while idx < array.len() {
let v = ScalarValue::try_from_array(&array, idx)?;
if v.is_null() {
difference.push(array.data_type().try_into()?);
} else {
difference.push(v.sub(last)?);
last = v;
}
idx += 1;
}
Ok(Arc::new(ScalarValue::iter_to_array(difference)?))
}
}
fn uses_window_frame(&self) -> bool {
false
}
fn include_rank(&self) -> bool {
false
}
}
|
use std::net::UdpSocket;
use std::io;
use std::net::SocketAddr;
use std::time;
use std::str;
use twinstick_logic::{BUFFER_SIZE, VERSION, FPS_60, FPS_120, DataType, GenericObject, TwinstickGame};
use chrono::Local;
pub extern crate serde_derive;
pub extern crate bincode;
pub use bincode::{deserialize, serialize};
use threadpool::ThreadPool;
mod threadpool;
fn log(msg: String) {
let date = Local::now();
println!("{}: {}", date.format("[%Y-%m-%d]%H:%M:%S"), msg);
}
pub struct Server {
udp: UdpSocket,
clients: Vec<SocketAddr>,
static_objects_sent: Vec<Option<u32>>,
client_last_connection: Vec<time::Instant>,
game: TwinstickGame,
}
impl Server {
pub fn new(ip: &str) -> Server {
log(format!("listening on udp port {}", ip));
let udp = UdpSocket::bind(ip).unwrap();
udp.set_nonblocking(true).unwrap();
Server {
udp,
clients: Vec::new(),
static_objects_sent: Vec::new(),
client_last_connection: Vec::new(),
game: TwinstickGame::new(),
}
}
pub fn game(&self) -> &TwinstickGame {
&self.game
}
pub fn update(&mut self, delta_time: f64) {
let (static_objects, enemies) = self.game.update_server(delta_time);
self.send_player_data_to_all_clients();
self.send_dynamic_objects_to_all_clients(self.game.enemies().clone());
for obj in static_objects {
self.send_data_to_all_clients(&DataType::StaticObject(obj.send_static_object()).serialise());
}
for i in 0..self.game().enemies().len() {
self.send_data_to_all_clients(&DataType::Enemy(self.game().enemies()[i].send_dyn_obj_update(), i).serialise());
}
for enemy in enemies {
self.send_data_to_all_clients(&DataType::AddEnemy(enemy.send_dyn_obj()).serialise());
}
}
pub fn add_player(&mut self, src_addr: SocketAddr) {
let index = self.clients.len();
self.clients.push(src_addr);
self.client_last_connection.push(time::Instant::now());
self.game.add_player();
self.send_data_to_all_clients(&DataType::AddPlayer(self.game.players()[index].clone().send_dyn_obj()).serialise());
self.send_data_to_client(src_addr, &DataType::PlayerNum(index).serialise());
}
pub fn remove_player(&mut self, index: usize) {
let src_addr = self.clients.remove(index);
log(format!("Removing client: {}", src_addr));
self.client_last_connection.remove(index);
self.game.remove_player(index);
self.static_objects_sent.remove(index);
self.send_data_to_all_clients(&DataType::RemovePlayer(index).serialise());
}
pub fn remove_player_from_addr(&mut self, src_addr: SocketAddr) {
match self.clients.binary_search(&src_addr) {
Ok(i) => {
self.remove_player(i);
},
Err(_e) => {
// println!("Error: {}", e);
// self.remove_all_players();
}
}
}
pub fn send_data_to_all_clients(&mut self, buffer: &[u8]) {
if self.clients.len() == 0 {
return;
}
for i in 0..self.clients.len() {
self.send_data_to_client(self.clients[i], buffer);
}
}
pub fn send_static_objects_to_client(&mut self, src_addr: SocketAddr) {
for j in 0..self.game.static_objects().len() {
let object = self.game.static_objects()[j].clone().send_static_object();
self.send_data_to_client(src_addr, &DataType::StaticObject(object).serialise());
}
}
pub fn send_dynamic_objects_to_all_clients(&mut self, dyn_objects: Vec<Box<dyn GenericObject>>) {
if self.clients.len() == 0 {
return;
}
for j in 0..dyn_objects.len() {
let object = dyn_objects[j].clone().send_dyn_obj_update();
self.send_data_to_all_clients(&DataType::Enemy(object, j).serialise());
}
}
pub fn send_static_objects_to_all_clients(&mut self) {
if self.clients.len() == 0 {
return;
}
for j in 0..self.game.static_objects().len() {
let object = self.game.static_objects()[j].clone().send_static_object();
self.send_data_to_all_clients(&DataType::StaticObject(object).serialise());
}
}
pub fn send_player_data_to_all_clients(&mut self) {
if self.clients.len() == 0 {
return;
}
for j in 0..self.game.players().len() {
self.send_data_to_all_clients(&DataType::Player(self.game.players()[j].clone().send_player_update(), j).serialise());
}
for i in 0..self.clients.len() {
self.send_data_to_client(self.clients[i], &DataType::PlayerNum(i).serialise());
}
}
pub fn send_data_to_client(&mut self, addr: SocketAddr, buffer: &[u8]) {
self.udp.send_to(&buffer, addr).unwrap();
}
pub fn send_static_objects(&mut self) {
for i in 0..self.static_objects_sent.len() {
let mut is_done = false;
if self.static_objects_sent[i].is_some() {
let objs_sent = self.static_objects_sent[i].unwrap();
if objs_sent < self.game.static_objects().len() as u32 {
self.send_data_to_client(self.clients[i], &DataType::StaticObject(self.game.static_objects()[objs_sent as usize].send_static_object()).serialise());
self.static_objects_sent[i] = Some(objs_sent+1);
} else {
self.static_objects_sent[i] = None;
}
}
}
/*
if let Some(objs_sent) = &mut self.static_objects_sent[i] {
if *objs_sent < self.game.static_objects().len() as u32 {
self.send_data_to_client(self.clients[i], &DataType::StaticObject(self.game.static_objects()[*objs_sent as usize].send_static_object()).serialise());
*objs_sent += 1;
} else {
is_done = true;
}
}
if is_done {
self.static_objects_sent[i] = None;
}
}*/
}
pub fn listen(&mut self) {
let mut buffer = [0; BUFFER_SIZE];
match self.udp.recv_from(&mut buffer) {
Ok((number_of_bytes, src_addr)) => {
let filled_buf = &mut buffer[..number_of_bytes];
if !self.clients.contains(&src_addr) {
match DataType::deserialise(filled_buf) {
Some(DataType::TryConnect(v)) => {
if v == VERSION {
self.send_data_to_client(src_addr, &DataType::ConfirmConnect(VERSION).serialise());
log(format!("New client connected: {}", src_addr));
for i in 0..self.clients.len() {
self.send_data_to_client(src_addr, &DataType::AddPlayer(self.game.players()[i].clone().send_dyn_obj()).serialise());
}
self.add_player(src_addr);
// self.send_static_objects_to_client(src_addr);
self.static_objects_sent.push(Some(0));
for j in 0..self.game.enemies().len() {
let object = self.game.enemies()[j].clone().send_dyn_obj();
self.send_data_to_client(src_addr, &DataType::AddEnemy(object).serialise());
}
} else {
self.send_data_to_client(src_addr, &DataType::Err(format!("Outdated version (Expected: {}, Actual: {})", VERSION, v)).serialise());
}
},
_ => {},
}
} else {
let mut client_id = 0;
match self.clients.binary_search(&src_addr) {
Ok(i) => {
self.client_last_connection[i] = time::Instant::now();
client_id = i;
},
_ => {}
}
match DataType::deserialise(filled_buf) {
Some(data_type) => {
match data_type {
DataType::PlayerRotation(rot, idx) => {
self.game.set_player_rotation(idx, rot);
},
DataType::Input(input) => {
self.game.add_input(client_id, input);
},
DataType::Exit => {
self.remove_player_from_addr(src_addr);
},
_ => {
},
}
},
None => {
}
}
}
},
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
// wait until network socket is ready, typically implemented
// via platform-specific APIs such as epoll or IOCP
//wait_for_fd();
for i in (0..(self.clients.len() as i32 - 1).max(0) as usize).rev() {
if self.client_last_connection[i].elapsed() > time::Duration::from_secs(5) {
self.remove_player(i);
}
}
},
Err(e) => panic!("encountered IO error: {}", e),
}
}
}
fn main() {
let mut server = Server::new("0.0.0.0:8008");
let mut delta_time: f64;
let mut last_time = time::Instant::now();
let mut tick = 0.0;
let mut tick_120 = 0.0;
loop {
delta_time = last_time.elapsed().subsec_nanos() as f64 / 1000000000.0 as f64;
last_time = time::Instant::now();
server.listen();
tick += delta_time;
tick_120 += delta_time;
if tick >= FPS_60 {
tick = 0.0;
server.update(FPS_60);
}
if tick_120 >= FPS_120 {
tick_120 = 0.0;
server.send_static_objects();
}
}
}
|
use std::any::Any;
use std::cmp;
use std::marker::PhantomData;
use std::ops::RangeInclusive;
use self::vec_mutation::{RevertVectorMutation, VectorMutation, VectorMutationRandomStep, VectorMutationStep};
use crate::mutators::mutations::{Mutation, RevertMutation};
use crate::subvalue_provider::EmptySubValueProvider;
use crate::{DefaultMutator, Mutator};
pub mod arbitrary;
pub mod copy_element;
pub mod crossover_insert_slice;
pub mod crossover_replace_element;
pub mod insert_element;
pub mod insert_many_elements;
pub mod mutate_element;
pub mod only_choose_length;
pub mod remove;
pub mod remove_and_insert_element;
pub mod swap_elements;
pub mod vec_mutation;
impl<T> DefaultMutator for Vec<T>
where
T: DefaultMutator + 'static,
{
type Mutator = VecMutator<T, T::Mutator>;
#[no_coverage]
fn default_mutator() -> Self::Mutator {
VecMutator::new(T::default_mutator(), 0..=usize::MAX)
}
}
#[derive(Clone)]
pub enum VecArbitraryStep {
InnerMutatorIsUnit { length_step: usize },
Normal { make_empty: bool },
}
pub struct VecMutatorCache<T, M>
where
T: 'static + Clone,
M: Mutator<T>,
{
pub inner: Vec<<M as Mutator<T>>::Cache>,
pub sum_cplx: f64,
pub random_mutation_step: VectorMutationRandomStep<T, M>,
}
impl<T, M> Clone for VecMutatorCache<T, M>
where
T: 'static + Clone,
M: Mutator<T>,
{
#[no_coverage]
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
sum_cplx: self.sum_cplx,
random_mutation_step: self.random_mutation_step.clone(),
}
}
}
pub struct VecMutator<T, M>
where
T: Clone + 'static,
M: Mutator<T>,
{
m: M,
len_range: RangeInclusive<usize>,
rng: fastrand::Rng,
mutations: VectorMutation,
inherent_complexity: bool,
_phantom: PhantomData<T>,
}
impl<T, M> VecMutator<T, M>
where
T: Clone + 'static,
M: Mutator<T>,
{
#[no_coverage]
pub fn new_without_inherent_complexity(m: M, len_range: RangeInclusive<usize>) -> Self {
Self {
m,
len_range,
rng: fastrand::Rng::new(),
mutations: VectorMutation::default(),
inherent_complexity: false,
_phantom: PhantomData,
}
}
#[no_coverage]
pub fn new(m: M, len_range: RangeInclusive<usize>) -> Self {
Self {
m,
len_range,
rng: fastrand::Rng::new(),
mutations: VectorMutation::default(),
inherent_complexity: true,
_phantom: PhantomData,
}
}
#[no_coverage]
fn complexity_from_inner(&self, cplx: f64, len: usize) -> f64 {
if self.inherent_complexity {
1.0 + if len == 0 || self.m.min_complexity() > 0.0 {
cplx
} else {
len as f64 + cplx
}
} else {
cplx
}
}
}
impl<T, M> Mutator<Vec<T>> for VecMutator<T, M>
where
T: Clone + 'static,
M: Mutator<T>,
{
#[doc(hidden)]
type Cache = VecMutatorCache<T, M>;
#[doc(hidden)]
type MutationStep = VectorMutationStep<T, M>;
#[doc(hidden)]
type ArbitraryStep = VecArbitraryStep;
#[doc(hidden)]
type UnmutateToken = RevertVectorMutation<T, M>;
#[doc(hidden)]
#[no_coverage]
fn initialize(&self) {
self.m.initialize();
}
#[doc(hidden)]
#[no_coverage]
fn default_arbitrary_step(&self) -> Self::ArbitraryStep {
if self.m.max_complexity() == 0.0 {
Self::ArbitraryStep::InnerMutatorIsUnit {
length_step: *self.len_range.start(),
}
} else {
Self::ArbitraryStep::Normal { make_empty: false }
}
}
#[doc(hidden)]
#[no_coverage]
fn is_valid(&self, value: &Vec<T>) -> bool {
if !self.len_range.contains(&value.len()) {
return false;
}
for v in value.iter() {
if !self.m.is_valid(v) {
return false;
}
}
true
}
#[doc(hidden)]
#[no_coverage]
fn validate_value(&self, value: &Vec<T>) -> Option<Self::Cache> {
if !self.len_range.contains(&value.len()) {
return None;
}
let inner_caches: Vec<_> = value
.iter()
.map(
#[no_coverage]
|x| self.m.validate_value(x),
)
.collect::<Option<_>>()?;
let cplxs = value
.iter()
.zip(inner_caches.iter())
.map(
#[no_coverage]
|(v, c)| self.m.complexity(v, c),
)
.collect::<Vec<_>>();
let sum_cplx = cplxs.iter().fold(
0.0,
#[no_coverage]
|sum_cplx, c| sum_cplx + c,
);
let random_mutation_step = self.mutations.default_random_step(self, value).unwrap();
let cache = VecMutatorCache {
inner: inner_caches,
sum_cplx,
random_mutation_step,
};
Some(cache)
}
#[doc(hidden)]
#[no_coverage]
fn default_mutation_step(&self, value: &Vec<T>, cache: &Self::Cache) -> Self::MutationStep {
self.mutations.default_step(self, value, cache).unwrap()
}
#[doc(hidden)]
#[no_coverage]
fn global_search_space_complexity(&self) -> f64 {
if self.m.global_search_space_complexity() == 0.0 {
super::size_to_cplxity(self.len_range.end() - self.len_range.start() + 1)
} else {
self.m.global_search_space_complexity() * ((self.len_range.end() - self.len_range.start()) as f64)
}
}
#[doc(hidden)]
#[no_coverage]
fn max_complexity(&self) -> f64 {
let max_len = *self.len_range.end();
self.complexity_from_inner((max_len as f64) * self.m.max_complexity(), max_len)
}
#[doc(hidden)]
#[no_coverage]
fn min_complexity(&self) -> f64 {
let min_len = *self.len_range.start();
let min_sum_cplx = if min_len == 0 {
0.0
} else {
(min_len as f64) * self.m.min_complexity()
};
self.complexity_from_inner(min_sum_cplx, min_len)
}
#[doc(hidden)]
#[no_coverage]
fn complexity(&self, value: &Vec<T>, cache: &Self::Cache) -> f64 {
self.complexity_from_inner(cache.sum_cplx, value.len())
}
#[doc(hidden)]
#[no_coverage]
fn ordered_arbitrary(&self, step: &mut Self::ArbitraryStep, max_cplx: f64) -> Option<(Vec<T>, f64)> {
if max_cplx < self.min_complexity() {
return None;
}
match step {
VecArbitraryStep::InnerMutatorIsUnit { length_step } => {
if self.len_range.contains(length_step) && (*length_step as f64) < max_cplx {
let mut result = Vec::with_capacity(*length_step);
for _ in 0..*length_step {
let (e, c) = self.m.random_arbitrary(1.0);
assert_eq!(c, 0.0);
result.push(e);
}
let cplx = self.complexity_from_inner(0.0, *length_step);
*length_step += 1;
Some((result, cplx))
} else {
None
}
}
VecArbitraryStep::Normal { make_empty } => {
if !*make_empty || max_cplx <= 1.0 {
*make_empty = true;
if self.len_range.contains(&0) {
Some((<_>::default(), self.complexity_from_inner(0.0, 0)))
} else {
Some(self.random_arbitrary(max_cplx))
}
} else {
Some(self.random_arbitrary(max_cplx))
}
}
}
}
#[doc(hidden)]
#[no_coverage]
fn random_arbitrary(&self, max_cplx: f64) -> (Vec<T>, f64) {
let min_cplx = self.min_complexity();
if max_cplx <= min_cplx || self.rng.u8(..) == 0 {
// return the least complex value possible
let mut v = Vec::with_capacity(*self.len_range.start());
let mut inner_cplx = 0.0;
for _ in 0..*self.len_range.start() {
let (el, el_cplx) = self.m.random_arbitrary(0.0);
v.push(el);
inner_cplx += el_cplx;
}
let cplx = self.complexity_from_inner(inner_cplx, v.len());
return (v, cplx);
}
let target_cplx = crate::mutators::gen_f64(&self.rng, min_cplx..max_cplx);
let len_range = self.choose_slice_length(target_cplx);
let upperbound_max_len = std::cmp::min(*len_range.end(), (max_cplx / self.m.min_complexity()).ceil() as usize);
let target_len = self.rng.usize(0..=upperbound_max_len);
let (v, inner_cplx) =
self.new_input_with_length_and_complexity(*self.len_range.start(), target_len, target_cplx);
let cplx = self.complexity_from_inner(inner_cplx, v.len());
(v, cplx)
}
#[doc(hidden)]
#[no_coverage]
fn ordered_mutate(
&self,
value: &mut Vec<T>,
cache: &mut Self::Cache,
step: &mut Self::MutationStep,
subvalue_provider: &dyn crate::SubValueProvider,
max_cplx: f64,
) -> Option<(Self::UnmutateToken, f64)> {
if max_cplx < self.min_complexity() {
return None;
}
let mutation = VectorMutation::from_step(self, value, cache, step, subvalue_provider, max_cplx)?;
Some(VectorMutation::apply(
mutation,
self,
value,
cache,
subvalue_provider,
max_cplx,
))
}
#[doc(hidden)]
#[no_coverage]
fn random_mutate(&self, value: &mut Vec<T>, cache: &mut Self::Cache, max_cplx: f64) -> (Self::UnmutateToken, f64) {
let mutation = VectorMutation::random(self, value, cache, &cache.random_mutation_step, max_cplx);
VectorMutation::apply(mutation, self, value, cache, &EmptySubValueProvider, max_cplx)
}
#[doc(hidden)]
#[no_coverage]
fn unmutate(&self, value: &mut Vec<T>, cache: &mut Self::Cache, t: Self::UnmutateToken) {
RevertVectorMutation::revert(t, self, value, cache)
}
#[doc(hidden)]
#[no_coverage]
fn visit_subvalues<'a>(&self, value: &'a Vec<T>, cache: &'a Self::Cache, visit: &mut dyn FnMut(&'a dyn Any, f64)) {
if !value.is_empty() {
for idx in 0..value.len() {
let cplx = self.m.complexity(&value[idx], &cache.inner[idx]);
visit(&value[idx], cplx);
}
for (el, el_cache) in value.iter().zip(cache.inner.iter()) {
self.m.visit_subvalues(el, el_cache, visit);
}
}
}
}
impl<T, M> VecMutator<T, M>
where
T: Clone + 'static,
M: Mutator<T>,
{
/**
Give an approximation for the range of lengths within which the target complexity can be reached.
*/
#[no_coverage]
fn choose_slice_length(&self, target_cplx: f64) -> RangeInclusive<usize> {
// The maximum length is the target complexity divided by the minimum complexity of each element
// But that does not take into account the part of the complexity of the vector that comes from its length.
// That complexity is given by 1.0 + crate::size_to_compelxity(len)
#[no_coverage]
fn length_for_elements_of_cplx(target_cplx: f64, cplx: f64) -> usize {
if cplx == 0.0 {
assert!(target_cplx.is_finite());
assert!(target_cplx >= 0.0);
// cplx is 0, so the length is the maximum complexity of the length component of the vector
target_cplx.round() as usize
} else if !cplx.is_finite() {
0
} else {
(target_cplx / cplx).trunc() as usize
}
}
let min_len = length_for_elements_of_cplx(target_cplx, self.m.max_complexity());
let max_len = length_for_elements_of_cplx(target_cplx, self.m.min_complexity());
let min_len = clamp(&self.len_range, min_len);
let max_len = clamp(&(min_len..=*self.len_range.end()), max_len);
min_len..=max_len
}
#[no_coverage]
fn new_input_with_length_and_complexity(
&self,
min_len: usize,
target_len: usize,
target_cplx: f64,
) -> (Vec<T>, f64) {
let mut v = Vec::with_capacity(target_len);
let mut sum_cplx = 0.0;
let mut remaining_cplx = target_cplx;
for i in 0..target_len {
let max_cplx_element = remaining_cplx / ((target_len - i) as f64);
let min_cplx_el = self.m.min_complexity();
if min_cplx_el >= max_cplx_element {
break;
}
let (x, x_cplx) = self.m.random_arbitrary(max_cplx_element);
sum_cplx += x_cplx;
v.push(x);
remaining_cplx -= x_cplx;
}
if v.len() < min_len {
// at this point it is smaller than it must be, so we add new, minimal, elements
let remaining = min_len - v.len();
for _ in 0..remaining {
let (x, x_cplx) = self.m.random_arbitrary(0.0);
v.push(x);
sum_cplx += x_cplx;
}
}
self.rng.shuffle(&mut v);
// let cplx = self.complexity_from_inner(sum_cplx, v.len());
(v, sum_cplx)
}
}
#[no_coverage]
fn clamp(range: &RangeInclusive<usize>, x: usize) -> usize {
cmp::min(cmp::max(*range.start(), x), *range.end())
}
|
import front.ast;
import front.ast.ann;
import front.ast.method;
import front.ast.ty;
import front.ast.mutability;
import front.ast.item;
import front.ast.block;
import front.ast.block_;
import front.ast.block_index_entry;
import front.ast.mod_index_entry;
import front.ast.obj_field;
import front.ast.decl;
import front.ast.arm;
import front.ast.stmt;
import front.ast.stmt_;
import front.ast.stmt_decl;
import front.ast.stmt_expr;
import front.ast.stmt_crate_directive;
import front.ast.decl_local;
import front.ast.decl_item;
import front.ast.ident;
import front.ast.def_id;
import front.ast.ann;
import front.ast.field;
import front.ast.expr;
import front.ast.expr_call;
import front.ast.expr_vec;
import front.ast.expr_tup;
import front.ast.expr_path;
import front.ast.expr_field;
import front.ast.expr_index;
import front.ast.expr_log;
import front.ast.expr_block;
import front.ast.expr_rec;
import front.ast.expr_if;
import front.ast.expr_binary;
import front.ast.expr_unary;
import front.ast.expr_assign;
import front.ast.expr_assign_op;
import front.ast.expr_while;
import front.ast.expr_do_while;
import front.ast.expr_alt;
import front.ast.expr_lit;
import front.ast.expr_ret;
import front.ast.expr_self_method;
import front.ast.expr_bind;
import front.ast.expr_spawn;
import front.ast.expr_ext;
import front.ast.expr_fail;
import front.ast.expr_break;
import front.ast.expr_cont;
import front.ast.expr_send;
import front.ast.expr_recv;
import front.ast.expr_put;
import front.ast.expr_port;
import front.ast.expr_chan;
import front.ast.expr_be;
import front.ast.expr_check_expr;
import front.ast.expr_cast;
import front.ast.expr_for;
import front.ast.expr_for_each;
import front.ast.path;
import front.ast.elt;
import front.ast.crate_directive;
import front.ast.fn_decl;
import front.ast._obj;
import front.ast.native_mod;
import front.ast.variant;
import front.ast.ty_param;
import front.ast.ty;
import front.ast.proto;
import front.ast.pat;
import front.ast.binop;
import front.ast.unop;
import front.ast.def;
import front.ast.lit;
import front.ast.init_op;
import front.ast.initializer;
import front.ast.local;
import front.ast._fn;
import front.ast.ann_none;
import front.ast.ann_type;
import front.ast._obj;
import front.ast._mod;
import front.ast.crate;
import front.ast.mod_index_entry;
import front.ast.mie_item;
import front.ast.item_fn;
import front.ast.item_obj;
import front.ast.def_local;
import middle.fold;
import middle.fold.respan;
import driver.session;
import util.common;
import util.common.span;
import util.common.spanned;
import util.common.new_str_hash;
import util.common.new_def_hash;
import util.common.uistr;
import util.common.elt_exprs;
import util.common.field_exprs;
import util.common.log_expr;
import util.common.log_stmt;
import util.common.log_block;
import util.typestate_ann;
import util.typestate_ann.ts_ann;
import util.typestate_ann.empty_pre_post;
import util.typestate_ann.empty_poststate;
import util.typestate_ann.true_precond;
import util.typestate_ann.true_postcond;
import util.typestate_ann.postcond;
import util.typestate_ann.precond;
import util.typestate_ann.poststate;
import util.typestate_ann.prestate;
import util.typestate_ann.pre_and_post;
import util.typestate_ann.get_pre;
import util.typestate_ann.get_post;
import util.typestate_ann.ann_precond;
import util.typestate_ann.ann_prestate;
import util.typestate_ann.set_precondition;
import util.typestate_ann.set_postcondition;
import util.typestate_ann.set_prestate;
import util.typestate_ann.set_poststate;
import util.typestate_ann.set_in_postcond;
import util.typestate_ann.set_in_poststate;
import util.typestate_ann.implies;
import util.typestate_ann.pre_and_post_state;
import util.typestate_ann.empty_states;
import util.typestate_ann.empty_prestate;
import util.typestate_ann.empty_ann;
import util.typestate_ann.extend_prestate;
import util.typestate_ann.extend_poststate;
import util.typestate_ann.intersect;
import util.typestate_ann.pp_clone;
import middle.ty;
import middle.ty.ann_to_type;
import middle.ty.arg;
import middle.ty.block_ty;
import middle.ty.expr_ty;
import middle.ty.ty_to_str;
import pretty.pprust.print_block;
import pretty.pprust.print_expr;
import pretty.pprust.print_decl;
import pretty.pp.mkstate;
import std.io.stdout;
import std.io.str_writer;
import std.io.string_writer;
import std._vec.map;
import std._vec;
import std._vec.len;
import std._vec.pop;
import std._vec.push;
import std._vec.slice;
import std._vec.unzip;
import std._vec.plus_option;
import std.option;
import std.option.t;
import std.option.some;
import std.option.none;
import std.option.from_maybe;
import std.option.maybe;
import std.option.is_none;
import std.option.get;
import std.map.hashmap;
import std.list;
import std.list.list;
import std.list.cons;
import std.list.nil;
import std.list.foldl;
import std.list.find;
import std._uint;
import std.bitv;
import std.util.fst;
import std.util.snd;
import util.typestate_ann;
import util.typestate_ann.difference;
import util.typestate_ann.union;
import util.typestate_ann.pps_len;
import util.typestate_ann.require_and_preserve;
/**** debugging junk ****/
fn log_bitv(fn_info enclosing, bitv.t v) {
auto s = "";
for each (@tup(def_id, tup(uint, ident)) p in enclosing.items()) {
if (bitv.get(v, p._1._0)) {
s += " " + p._1._1 + " ";
}
}
log(s);
}
fn log_cond(vec[uint] v) -> () {
auto res = "";
for (uint i in v) {
if (i == 0u) {
res += "0";
}
else {
res += "1";
}
}
log(res);
}
fn log_pp(&pre_and_post pp) -> () {
auto p1 = bitv.to_vec(pp.precondition);
auto p2 = bitv.to_vec(pp.postcondition);
log("pre:");
log_cond(p1);
log("post:");
log_cond(p2);
}
fn print_ident(&ident i) -> () {
log(" " + i + " ");
}
fn print_idents(vec[ident] idents) -> () {
if(len[ident](idents) == 0u) {
ret;
}
else {
log("an ident: " + pop[ident](idents));
print_idents(idents);
}
}
/**********************************************************************/
/* mapping from variable name (def_id is assumed to be for a local
variable in a given function) to bit number
(also remembers the ident for error-logging purposes) */
type var_info = tup(uint, ident);
type fn_info = std.map.hashmap[def_id, var_info];
/* mapping from function name to fn_info map */
type fn_info_map = std.map.hashmap[def_id, fn_info];
fn bit_num(def_id v, fn_info m) -> uint {
check (m.contains_key(v));
ret m.get(v)._0;
}
fn get_fn_info(fn_info_map fm, def_id did) -> fn_info {
check (fm.contains_key(did));
ret fm.get(did);
}
fn var_is_local(def_id v, fn_info m) -> bool {
ret (m.contains_key(v));
}
fn num_locals(fn_info m) -> uint {
ret m.size();
}
fn find_locals(_fn f) -> vec[tup(ident,def_id)] {
auto res = _vec.alloc[tup(ident,def_id)](0u);
for each (@tup(ident, block_index_entry) p
in f.body.node.index.items()) {
alt (p._1) {
case (ast.bie_local(?loc)) {
res += vec(tup(loc.ident,loc.id));
}
case (_) { }
}
}
ret res;
}
fn add_var(def_id v, ident nm, uint next, fn_info tbl) -> uint {
log(nm + " |-> " + util.common.uistr(next));
tbl.insert(v, tup(next,nm));
ret (next + 1u);
}
/* builds a table mapping each local var defined in f
to a bit number in the precondition/postcondition vectors */
fn mk_fn_info(_fn f) -> fn_info {
auto res = new_def_hash[var_info]();
let uint next = 0u;
let vec[ast.arg] f_args = f.decl.inputs;
for (ast.arg v in f_args) {
next = add_var(v.id, v.ident, next, res);
}
let vec[tup(ident,def_id)] locals = find_locals(f);
for (tup(ident,def_id) p in locals) {
next = add_var(p._1, p._0, next, res);
}
ret res;
}
/* extends mk_fn_info to a function item, side-effecting the map fi from
function IDs to fn_info maps */
fn mk_fn_info_item_fn(&fn_info_map fi, &span sp, ident i, &ast._fn f,
vec[ast.ty_param] ty_params, def_id id, ann a) -> @item {
fi.insert(id, mk_fn_info(f));
log(i + " has " + uistr(num_locals(mk_fn_info(f))) + " local vars");
ret @respan(sp, item_fn(i, f, ty_params, id, a));
}
/* extends mk_fn_info to an obj item, side-effecting the map fi from
function IDs to fn_info maps */
fn mk_fn_info_item_obj(&fn_info_map fi, &span sp, ident i, &ast._obj o,
vec[ast.ty_param] ty_params, ast.obj_def_ids odid, ann a) -> @item {
auto all_methods = _vec.clone[@method](o.methods);
plus_option[@method](all_methods, o.dtor);
for (@method m in all_methods) {
/* FIXME: also need to pass in fields so we can say
they're initialized? */
fi.insert(m.node.id, mk_fn_info(m.node.meth));
log(m.node.ident + " has " +
uistr(num_locals(mk_fn_info(m.node.meth))) + " local vars");
}
ret @respan(sp, item_obj(i, o, ty_params, odid, a));
}
/* initializes the global fn_info_map (mapping each function ID, including
nested locally defined functions, onto a mapping from local variable name
to bit number) */
fn mk_f_to_fn_info(@ast.crate c) -> fn_info_map {
auto res = new_def_hash[fn_info]();
auto fld = fold.new_identity_fold[fn_info_map]();
fld = @rec(fold_item_fn = bind mk_fn_info_item_fn(_,_,_,_,_,_,_),
fold_item_obj = bind mk_fn_info_item_obj(_,_,_,_,_,_,_)
with *fld);
fold.fold_crate[fn_info_map](res, fld, c);
ret res;
}
/**** Helpers ****/
fn expr_ann(&expr e) -> ann {
alt(e.node) {
case (ast.expr_vec(_,_,?a)) {
ret a;
}
case (ast.expr_tup(_,?a)) {
ret a;
}
case (ast.expr_rec(_,_,?a)) {
ret a;
}
case (ast.expr_call(_,_,?a)) {
ret a;
}
case (ast.expr_bind(_,_,?a)) {
ret a;
}
case (ast.expr_binary(_,_,_,?a)) {
ret a;
}
case (ast.expr_unary(_,_,?a)) {
ret a;
}
case (ast.expr_lit(_,?a)) {
ret a;
}
case (ast.expr_cast(_,_,?a)) {
ret a;
}
case (ast.expr_if(_,_,_,?a)) {
ret a;
}
case (ast.expr_while(_,_,?a)) {
ret a;
}
case (ast.expr_for(_,_,_,?a)) {
ret a;
}
case (ast.expr_for_each(_,_,_,?a)) {
ret a;
}
case (ast.expr_do_while(_,_,?a)) {
ret a;
}
case (ast.expr_alt(_,_,?a)) {
ret a;
}
case (ast.expr_block(_,?a)) {
ret a;
}
case (ast.expr_assign(_,_,?a)) {
ret a;
}
case (ast.expr_assign_op(_,_,_,?a)) {
ret a;
}
case (ast.expr_send(_,_,?a)) {
ret a;
}
case (ast.expr_recv(_,_,?a)) {
ret a;
}
case (ast.expr_field(_,_,?a)) {
ret a;
}
case (ast.expr_index(_,_,?a)) {
ret a;
}
case (ast.expr_path(_,_,?a)) {
ret a;
}
case (ast.expr_ext(_,_,_,_,?a)) {
ret a;
}
case (ast.expr_fail(?a)) {
ret a;
}
case (ast.expr_ret(_,?a)) {
ret a;
}
case (ast.expr_put(_,?a)) {
ret a;
}
case (ast.expr_be(_,?a)) {
ret a;
}
case (ast.expr_log(_,_,?a)) {
ret a;
}
case (ast.expr_check_expr(_,?a)) {
ret a;
}
case (ast.expr_port(?a)) {
ret a;
}
case (ast.expr_chan(_,?a)) {
ret a;
}
}
}
fn ann_to_ts_ann(ann a, uint nv) -> ts_ann {
alt (a) {
case (ann_none) { ret empty_ann(nv); }
case (ann_type(_,_,?t)) {
alt (t) {
/* Kind of inconsistent. empty_ann()s everywhere
or an option of a ts_ann? */
case (none[@ts_ann]) { ret empty_ann(nv); }
case (some[@ts_ann](?t)) { ret *t; }
}
}
}
}
fn ann_to_ts_ann_fail(ann a) -> option.t[@ts_ann] {
alt (a) {
case (ann_none) {
log("ann_to_ts_ann_fail: didn't expect ann_none here");
fail;
}
case (ann_type(_,_,?t)) {
ret t;
}
}
}
fn ann_to_ts_ann_fail_more(ann a) -> @ts_ann {
alt (a) {
case (ann_none) {
log("ann_to_ts_ann_fail: didn't expect ann_none here");
fail;
}
case (ann_type(_,_,?t)) {
check (! is_none[@ts_ann](t));
ret get[@ts_ann](t);
}
}
}
fn ann_to_poststate(ann a) -> poststate {
ret (ann_to_ts_ann_fail_more(a)).states.poststate;
}
fn stmt_to_ann(&stmt s) -> option.t[@ts_ann] {
alt (s.node) {
case (stmt_decl(_,?a)) {
ret ann_to_ts_ann_fail(a);
}
case (stmt_expr(_,?a)) {
ret ann_to_ts_ann_fail(a);
}
case (stmt_crate_directive(_)) {
ret none[@ts_ann];
}
}
}
/* fails if e has no annotation */
fn expr_states(&expr e) -> pre_and_post_state {
alt (expr_ann(e)) {
case (ann_none) {
log_err "expr_pp: the impossible happened (no annotation)";
fail;
}
case (ann_type(_, _, ?maybe_pp)) {
alt (maybe_pp) {
case (none[@ts_ann]) {
log_err "expr_pp: the impossible happened (no pre/post)";
fail;
}
case (some[@ts_ann](?p)) {
ret p.states;
}
}
}
}
}
/* fails if e has no annotation */
fn expr_pp(&expr e) -> pre_and_post {
alt (expr_ann(e)) {
case (ann_none) {
log_err "expr_pp: the impossible happened (no annotation)";
fail;
}
case (ann_type(_, _, ?maybe_pp)) {
alt (maybe_pp) {
case (none[@ts_ann]) {
log_err "expr_pp: the impossible happened (no pre/post)";
fail;
}
case (some[@ts_ann](?p)) {
ret p.conditions;
}
}
}
}
}
fn stmt_pp(&stmt s) -> pre_and_post {
alt (stmt_to_ann(s)) {
case (none[@ts_ann]) {
log "stmt_pp: the impossible happened (no annotation)";
fail;
}
case (some[@ts_ann](?p)) {
ret p.conditions;
}
}
}
/* fails if b has no annotation */
/* FIXME: factor out code in the following two functions (block_ts_ann) */
fn block_pp(&block b) -> pre_and_post {
alt (b.node.a) {
case (ann_none) {
log_err "block_pp: the impossible happened (no ann)";
fail;
}
case (ann_type(_,_,?t)) {
alt (t) {
case (none[@ts_ann]) {
log_err "block_pp: the impossible happened (no ty)";
fail;
}
case (some[@ts_ann](?ts)) {
ret ts.conditions;
}
}
}
}
}
fn block_states(&block b) -> pre_and_post_state {
alt (b.node.a) {
case (ann_none) {
log_err "block_pp: the impossible happened (no ann)";
fail;
}
case (ann_type(_,_,?t)) {
alt (t) {
case (none[@ts_ann]) {
log_err "block_states: the impossible happened (no ty)";
fail;
}
case (some[@ts_ann](?ts)) {
ret ts.states;
}
}
}
}
}
fn stmt_states(&stmt s, uint nv) -> pre_and_post_state {
alt (stmt_to_ann(s)) {
case (none[@ts_ann]) {
ret empty_states(nv);
}
case (some[@ts_ann](?a)) {
ret a.states;
}
}
}
fn expr_precond(&expr e) -> precond {
ret (expr_pp(e)).precondition;
}
fn expr_postcond(&expr e) -> postcond {
ret (expr_pp(e)).postcondition;
}
fn expr_prestate(&expr e) -> prestate {
ret (expr_states(e)).prestate;
}
fn expr_poststate(&expr e) -> poststate {
ret (expr_states(e)).poststate;
}
/*
fn stmt_precond(&stmt s) -> precond {
ret (stmt_pp(s)).precondition;
}
fn stmt_postcond(&stmt s) -> postcond {
ret (stmt_pp(s)).postcondition;
}
*/
fn states_to_poststate(&pre_and_post_state ss) -> poststate {
ret ss.poststate;
}
/*
fn stmt_prestate(&stmt s) -> prestate {
ret (stmt_states(s)).prestate;
}
*/
fn stmt_poststate(&stmt s, uint nv) -> poststate {
ret (stmt_states(s, nv)).poststate;
}
fn block_postcond(&block b) -> postcond {
ret (block_pp(b)).postcondition;
}
fn block_poststate(&block b) -> poststate {
ret (block_states(b)).poststate;
}
/* returns a new annotation where the pre_and_post is p */
fn with_pp(ann a, pre_and_post p) -> ann {
alt (a) {
case (ann_none) {
log("with_pp: the impossible happened");
fail; /* shouldn't happen b/c code is typechecked */
}
case (ann_type(?t, ?ps, _)) {
ret (ann_type(t, ps,
some[@ts_ann]
(@rec(conditions=p,
states=empty_states(pps_len(p))))));
}
}
}
// Given a list of pres and posts for exprs e0 ... en,
// return the precondition for evaluating each expr in order.
// So, if e0's post is {x} and e1's pre is {x, y, z}, the entire
// precondition shouldn't include x.
fn seq_preconds(uint num_vars, vec[pre_and_post] pps) -> precond {
let uint sz = len[pre_and_post](pps);
if (sz >= 1u) {
auto first = pps.(0);
check (pps_len(first) == num_vars);
let precond rest = seq_preconds(num_vars,
slice[pre_and_post](pps, 1u, sz));
difference(rest, first.postcondition);
union(first.precondition, rest);
ret first.precondition;
}
else {
ret true_precond(num_vars);
}
}
/* works on either postconds or preconds
should probably rethink the whole type synonym situation */
fn union_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
auto sz = _vec.len[postcond](rest);
if (sz > 0u) {
auto other = rest.(0);
union(first, other);
union_postconds_go(first, slice[postcond](rest, 1u, len[postcond](rest)));
}
ret first;
}
fn union_postconds(&vec[postcond] pcs) -> postcond {
check (len[postcond](pcs) > 0u);
ret union_postconds_go(bitv.clone(pcs.(0)), pcs);
}
/* Gee, maybe we could use foldl or something */
fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
auto sz = _vec.len[postcond](rest);
if (sz > 0u) {
auto other = rest.(0);
intersect(first, other);
intersect_postconds_go(first, slice[postcond](rest, 1u,
len[postcond](rest)));
}
ret first;
}
fn intersect_postconds(&vec[postcond] pcs) -> postcond {
check (len[postcond](pcs) > 0u);
ret intersect_postconds_go(bitv.clone(pcs.(0)), pcs);
}
/******* AST-traversing code ********/
fn find_pre_post_mod(&_mod m) -> _mod {
log("implement find_pre_post_mod!");
fail;
}
fn find_pre_post_state_mod(&_mod m) -> bool {
log("implement find_pre_post_state_mod!");
fail;
}
fn find_pre_post_native_mod(&native_mod m) -> native_mod {
log("implement find_pre_post_native_mod");
fail;
}
fn find_pre_post_state_native_mod(&native_mod m) -> bool {
log("implement find_pre_post_state_native_mod!");
fail;
}
fn find_pre_post_obj(&fn_info_map fm, _obj o) -> () {
fn do_a_method(fn_info_map fm, &@method m) -> () {
check(fm.contains_key(m.node.id));
find_pre_post_fn(fm, fm.get(m.node.id), m.node.meth);
}
auto f = bind do_a_method(fm,_);
_vec.map[@method, ()](f, o.methods);
option.map[@method, ()](f, o.dtor);
}
fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool {
fn do_a_method(fn_info_map fm, &@method m) -> bool {
check(fm.contains_key(m.node.id));
ret find_pre_post_state_fn(fm, fm.get(m.node.id), m.node.meth);
}
auto f = bind do_a_method(fm,_);
auto flags = _vec.map[@method, bool](f, o.methods);
auto changed = _vec.or(flags);
changed = changed || maybe[@method, bool](false, f, o.dtor);
ret changed;
}
fn find_pre_post_item(fn_info_map fm, fn_info enclosing, &item i) -> () {
alt (i.node) {
case (ast.item_const(?id, ?t, ?e, ?di, ?a)) {
find_pre_post_expr(fm, enclosing, *e);
}
case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
check (fm.contains_key(di));
find_pre_post_fn(fm, fm.get(di), f);
}
case (ast.item_mod(?id, ?m, ?di)) {
find_pre_post_mod(m);
}
case (ast.item_native_mod(?id, ?nm, ?di)) {
find_pre_post_native_mod(nm);
}
case (ast.item_ty(_,_,_,_,_)) {
ret;
}
case (ast.item_tag(_,_,_,_,_)) {
ret;
}
case (ast.item_obj(?id, ?o, ?ps, ?di, ?a)) {
find_pre_post_obj(fm, o);
}
}
}
/* Finds the pre and postcondition for each expr in <args>;
sets the precondition in a to be the result of combining
the preconditions for <args>, and the postcondition in a to
be the union of all postconditions for <args> */
fn find_pre_post_exprs(&fn_info_map fm, &fn_info enclosing,
&vec[@expr] args, ann a) {
fn do_one(fn_info_map fm, fn_info enclosing,
&@expr e) -> () {
find_pre_post_expr(fm, enclosing, *e);
}
auto f = bind do_one(fm, enclosing, _);
_vec.map[@expr, ()](f, args);
fn get_pp(&@expr e) -> pre_and_post {
ret expr_pp(*e);
}
auto g = get_pp;
auto pps = _vec.map[@expr, pre_and_post](g, args);
auto h = get_post;
set_pre_and_post(a,
rec(precondition=seq_preconds(num_locals(enclosing), pps),
postcondition=union_postconds
(_vec.map[pre_and_post, postcond](h, pps))));
}
/* Fills in annotations as a side effect. Does not rebuild the expr */
fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
auto num_local_vars = num_locals(enclosing);
fn do_rand_(fn_info_map fm, fn_info enclosing, &@expr e) -> () {
find_pre_post_expr(fm, enclosing, *e);
}
fn pp_one(&@expr e) -> pre_and_post {
be expr_pp(*e);
}
/* log("find_pre_post_expr (num_locals =" +
uistr(num_local_vars) + "):");
log_expr(e);
*/
alt(e.node) {
case(expr_call(?operator, ?operands, ?a)) {
auto args = _vec.clone[@expr](operands);
_vec.push[@expr](args, operator);
find_pre_post_exprs(fm, enclosing, args, a);
}
case(expr_path(?p, ?maybe_def, ?a)) {
auto df;
alt (maybe_def) {
case (none[def])
{ log("expr_path should have a def"); fail; }
case (some[def](?d)) { df = d; }
}
auto res = empty_pre_post(num_local_vars);
alt (df) {
case (def_local(?d_id)) {
auto i = bit_num(d_id, enclosing);
require_and_preserve(i, res);
}
case (_) { /* nothing to check */ }
}
// Otherwise, variable is global, so it must be initialized
set_pre_and_post(a, res);
}
case(expr_log(_, ?arg, ?a)) {
find_pre_post_expr(fm, enclosing, *arg);
set_pre_and_post(a, expr_pp(*arg));
}
case (expr_block(?b, ?a)) {
find_pre_post_block(fm, enclosing, b);
set_pre_and_post(a, block_pp(b));
}
case (expr_rec(?fields,?maybe_base,?a)) {
auto es = field_exprs(fields);
_vec.plus_option[@expr](es, maybe_base);
find_pre_post_exprs(fm, enclosing, es, a);
}
case (expr_assign(?lhs, ?rhs, ?a)) {
alt (lhs.node) {
case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) {
find_pre_post_expr(fm, enclosing, *rhs);
set_pre_and_post(a, expr_pp(*rhs));
gen(enclosing, a, d_id);
}
case (_) {
// doesn't check that lhs is an lval, but
// that's probably ok
find_pre_post_exprs(fm, enclosing, vec(lhs, rhs), a);
}
}
}
case (expr_lit(_,?a)) {
set_pre_and_post(a, empty_pre_post(num_local_vars));
}
case (expr_ret(?maybe_val, ?a)) {
alt (maybe_val) {
case (none[@expr]) {
set_pre_and_post(a, empty_pre_post(num_local_vars));
}
case (some[@expr](?ret_val)) {
find_pre_post_expr(fm, enclosing, *ret_val);
let pre_and_post pp =
rec(precondition=expr_precond(*ret_val),
postcondition=empty_poststate(num_local_vars));
set_pre_and_post(a, pp);
}
}
}
case (expr_if(?antec, ?conseq, ?maybe_alt, ?a)) {
find_pre_post_expr(fm, enclosing, *antec);
find_pre_post_block(fm, enclosing, conseq);
alt (maybe_alt) {
case (none[@expr]) {
auto precond_res = seq_preconds(num_local_vars,
vec(expr_pp(*antec),
block_pp(conseq)));
set_pre_and_post(a, rec(precondition=precond_res,
postcondition=
expr_poststate(*antec)));
}
case (some[@expr](?altern)) {
find_pre_post_expr(fm, enclosing, *altern);
auto precond_true_case =
seq_preconds(num_local_vars,
vec(expr_pp(*antec), block_pp(conseq)));
auto postcond_true_case = union_postconds
(vec(expr_postcond(*antec), block_postcond(conseq)));
auto precond_false_case = seq_preconds
(num_local_vars,
vec(expr_pp(*antec), expr_pp(*altern)));
auto postcond_false_case = union_postconds
(vec(expr_postcond(*antec), expr_postcond(*altern)));
auto precond_res = union_postconds(vec(precond_true_case,
precond_false_case));
auto postcond_res = intersect_postconds
(vec(postcond_true_case, postcond_false_case));
set_pre_and_post(a, rec(precondition=precond_res,
postcondition=postcond_res));
}
}
}
case (expr_binary(?bop,?l,?r,?a)) {
/* *unless* bop is lazy (e.g. and, or)?
FIXME */
find_pre_post_exprs(fm, enclosing, vec(l, r), a);
}
case (expr_unary(_,?operand,?a)) {
find_pre_post_expr(fm, enclosing, *operand);
set_pre_and_post(a, expr_pp(*operand));
}
case (expr_while(?test, ?body, ?a)) {
find_pre_post_expr(fm, enclosing, *test);
find_pre_post_block(fm, enclosing, body);
set_pre_and_post(a,
rec(precondition=
seq_preconds(num_local_vars,
vec(expr_pp(*test),
block_pp(body))),
postcondition=
intersect_postconds(vec(expr_postcond(*test),
block_postcond(body)))));
}
case (expr_index(?e, ?sub, ?a)) {
find_pre_post_exprs(fm, enclosing, vec(e, sub), a);
}
case (expr_alt(?e, ?alts, ?a)) {
find_pre_post_expr(fm, enclosing, *e);
fn do_an_alt(fn_info_map fm, fn_info enc, &arm an_alt)
-> pre_and_post {
find_pre_post_block(fm, enc, an_alt.block);
ret block_pp(an_alt.block);
}
auto f = bind do_an_alt(fm, enclosing, _);
auto alt_pps = _vec.map[arm, pre_and_post](f, alts);
fn combine_pp(pre_and_post antec,
uint num_local_vars, &pre_and_post pp,
&pre_and_post next) -> pre_and_post {
union(pp.precondition, seq_preconds(num_local_vars,
vec(antec, next)));
intersect(pp.postcondition, next.postcondition);
ret pp;
}
auto e_pp1 = expr_pp(*e);
auto e_pp = pp_clone(e_pp1);
auto g = bind combine_pp(e_pp, num_local_vars, _, _);
set_pre_and_post(a, _vec.foldl[pre_and_post, pre_and_post]
(g, e_pp, alt_pps));
}
case (expr_field(?operator, _, ?a)) {
find_pre_post_expr(fm, enclosing, *operator);
set_pre_and_post(a, expr_pp(*operator));
}
case (expr_fail(?a)) {
set_pre_and_post(a,
rec(precondition=empty_prestate(num_local_vars),
postcondition=true_postcond(num_local_vars)));
}
case(_) {
log("this sort of expr isn't implemented!");
log_expr(e);
fail;
}
}
}
fn gen(&fn_info enclosing, &ann a, def_id id) -> bool {
check(enclosing.contains_key(id));
let uint i = (enclosing.get(id))._0;
ret set_in_postcond(i, (ann_to_ts_ann_fail_more(a)).conditions);
}
fn gen_poststate(&fn_info enclosing, &ann a, def_id id) -> bool {
check(enclosing.contains_key(id));
let uint i = (enclosing.get(id))._0;
ret set_in_poststate(i, (ann_to_ts_ann_fail_more(a)).states);
}
fn find_pre_post_stmt(fn_info_map fm, &fn_info enclosing, &ast.stmt s)
-> () {
auto num_local_vars = num_locals(enclosing);
alt(s.node) {
case(ast.stmt_decl(?adecl, ?a)) {
alt(adecl.node) {
case(ast.decl_local(?alocal)) {
alt(alocal.init) {
case(some[ast.initializer](?an_init)) {
find_pre_post_expr(fm, enclosing, *an_init.expr);
auto rhs_pp = expr_pp(*an_init.expr);
set_pre_and_post(alocal.ann, rhs_pp);
/* Inherit ann from initializer, and add var being
initialized to the postcondition */
set_pre_and_post(a, rhs_pp);
gen(enclosing, a, alocal.id);
}
case(none[ast.initializer]) {
auto pp = empty_pre_post(num_local_vars);
set_pre_and_post(alocal.ann, pp);
set_pre_and_post(a, pp);
}
}
}
case(decl_item(?anitem)) {
auto pp = empty_pre_post(num_local_vars);
set_pre_and_post(a, pp);
find_pre_post_item(fm, enclosing, *anitem);
}
}
}
case(stmt_expr(?e,?a)) {
find_pre_post_expr(fm, enclosing, *e);
set_pre_and_post(a, expr_pp(*e));
}
}
}
fn find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b)
-> () {
fn do_one_(fn_info_map fm, fn_info i, &@stmt s) -> () {
find_pre_post_stmt(fm, i, *s);
}
auto do_one = bind do_one_(fm, enclosing, _);
_vec.map[@stmt, ()](do_one, b.node.stmts);
fn do_inner_(fn_info_map fm, fn_info i, &@expr e) -> () {
find_pre_post_expr(fm, i, *e);
}
auto do_inner = bind do_inner_(fm, enclosing, _);
option.map[@expr, ()](do_inner, b.node.expr);
let vec[pre_and_post] pps = vec();
fn get_pp_stmt(&@stmt s) -> pre_and_post {
ret stmt_pp(*s);
}
auto f = get_pp_stmt;
pps += _vec.map[@stmt, pre_and_post](f, b.node.stmts);
fn get_pp_expr(&@expr e) -> pre_and_post {
ret expr_pp(*e);
}
auto g = get_pp_expr;
plus_option[pre_and_post](pps,
option.map[@expr, pre_and_post](g, b.node.expr));
auto block_precond = seq_preconds(num_locals(enclosing), pps);
auto h = get_post;
auto postconds = _vec.map[pre_and_post, postcond](h, pps);
/* A block may be empty, so this next line ensures that the postconds
vector is non-empty. */
_vec.push[postcond](postconds, block_precond);
auto block_postcond = union_postconds(postconds);
set_pre_and_post(b.node.a, rec(precondition=block_precond,
postcondition=block_postcond));
}
fn find_pre_post_fn(&fn_info_map fm, &fn_info fi, &_fn f) -> () {
find_pre_post_block(fm, fi, f.body);
}
fn check_item_fn(&fn_info_map fm, &span sp, ident i, &ast._fn f,
vec[ast.ty_param] ty_params, def_id id, ann a) -> @item {
check (fm.contains_key(id));
find_pre_post_fn(fm, fm.get(id), f);
ret @respan(sp, ast.item_fn(i, f, ty_params, id, a));
}
fn find_pre_post_state_item(fn_info_map fm, fn_info enclosing, @item i)
-> bool {
alt (i.node) {
case (ast.item_const(?id, ?t, ?e, ?di, ?a)) {
ret find_pre_post_state_expr(fm, enclosing,
empty_prestate(num_locals(enclosing)), e);
}
case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
check (fm.contains_key(di));
ret find_pre_post_state_fn(fm, fm.get(di), f);
}
case (ast.item_mod(?id, ?m, ?di)) {
ret find_pre_post_state_mod(m);
}
case (ast.item_native_mod(?id, ?nm, ?di)) {
ret find_pre_post_state_native_mod(nm);
}
case (ast.item_ty(_,_,_,_,_)) {
ret false;
}
case (ast.item_tag(_,_,_,_,_)) {
ret false;
}
case (ast.item_obj(?id, ?o, ?ps, ?di, ?a)) {
ret find_pre_post_state_obj(fm, o);
}
}
}
fn set_prestate_ann(ann a, prestate pre) -> bool {
alt (a) {
case (ann_type(_,_,?ts_a)) {
check (! is_none[@ts_ann](ts_a));
ret set_prestate(*get[@ts_ann](ts_a), pre);
}
case (ann_none) {
log("set_prestate_ann: expected an ann_type here");
fail;
}
}
}
fn extend_prestate_ann(ann a, prestate pre) -> bool {
alt (a) {
case (ann_type(_,_,?ts_a)) {
check (! is_none[@ts_ann](ts_a));
ret extend_prestate((*get[@ts_ann](ts_a)).states.prestate, pre);
}
case (ann_none) {
log("set_prestate_ann: expected an ann_type here");
fail;
}
}
}
fn set_poststate_ann(ann a, poststate post) -> bool {
alt (a) {
case (ann_type(_,_,?ts_a)) {
check (! is_none[@ts_ann](ts_a));
ret set_poststate(*get[@ts_ann](ts_a), post);
}
case (ann_none) {
log("set_poststate_ann: expected an ann_type here");
fail;
}
}
}
fn extend_poststate_ann(ann a, poststate post) -> bool {
alt (a) {
case (ann_type(_,_,?ts_a)) {
check (! is_none[@ts_ann](ts_a));
ret extend_poststate((*get[@ts_ann](ts_a)).states.poststate, post);
}
case (ann_none) {
log("set_poststate_ann: expected an ann_type here");
fail;
}
}
}
fn set_pre_and_post(&ann a, pre_and_post pp) -> () {
alt (a) {
case (ann_type(_,_,?ts_a)) {
check (! is_none[@ts_ann](ts_a));
auto t = *get[@ts_ann](ts_a);
/* log("set_pre_and_post, old =");
log_pp(t.conditions);
log("new =");
log_pp(pp);
*/
set_precondition(t, pp.precondition);
set_postcondition(t, pp.postcondition);
}
case (ann_none) {
log("set_pre_and_post: expected an ann_type here");
fail;
}
}
}
fn seq_states(&fn_info_map fm, &fn_info enclosing,
prestate pres, vec[@expr] exprs) -> tup(bool, poststate) {
auto changed = false;
auto post = pres;
for (@expr e in exprs) {
changed = find_pre_post_state_expr(fm, enclosing, post, e) || changed;
post = expr_poststate(*e);
}
ret tup(changed, post);
}
fn find_pre_post_state_exprs(&fn_info_map fm,
&fn_info enclosing,
&prestate pres,
&ann a, &vec[@expr] es) -> bool {
auto res = seq_states(fm, enclosing, pres, es);
auto changed = res._0;
changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, res._1) || changed;
ret changed;
}
fn pure_exp(&ann a, &prestate p) -> bool {
auto changed = false;
changed = extend_prestate_ann(a, p) || changed;
changed = extend_poststate_ann(a, p) || changed;
ret changed;
}
fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
&prestate pres, &@expr e) -> bool {
auto changed = false;
auto num_local_vars = num_locals(enclosing);
alt (e.node) {
case (expr_vec(?elts, _, ?a)) {
be find_pre_post_state_exprs(fm, enclosing, pres, a, elts);
}
case (expr_tup(?elts, ?a)) {
be find_pre_post_state_exprs(fm, enclosing, pres, a, elt_exprs(elts));
}
case (expr_call(?operator, ?operands, ?a)) {
/* do the prestate for the rator */
changed = find_pre_post_state_expr(fm, enclosing, pres, operator)
|| changed;
/* rands go left-to-right */
ret(find_pre_post_state_exprs(fm, enclosing,
expr_poststate(*operator), a, operands)
|| changed);
}
case (expr_path(_,_,?a)) {
ret pure_exp(a, pres);
}
case (expr_log(_,?e,?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e);
changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
ret changed;
}
case (expr_lit(?l,?a)) {
ret pure_exp(a, pres);
}
case (expr_block(?b,?a)) {
changed = find_pre_post_state_block(fm, enclosing, pres, b)
|| changed;
changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, block_poststate(b)) || changed;
ret changed;
}
case (expr_rec(?fields,?maybe_base,?a)) {
changed = find_pre_post_state_exprs(fm, enclosing, pres, a,
field_exprs(fields)) || changed;
alt (maybe_base) {
case (none[@expr]) { /* do nothing */ }
case (some[@expr](?base)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, base)
|| changed;
changed = extend_poststate_ann(a, expr_poststate(*base))
|| changed;
}
}
ret changed;
}
case (expr_assign(?lhs, ?rhs, ?a)) {
extend_prestate_ann(a, pres);
alt (lhs.node) {
case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) {
// assignment to local var
changed = pure_exp(a_lhs, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, rhs)
|| changed;
changed = extend_poststate_ann(a, expr_poststate(*rhs))
|| changed;
changed = gen_poststate(enclosing, a, d_id) || changed;
}
case (_) {
// assignment to something that must already have been init'd
changed = find_pre_post_state_expr(fm, enclosing, pres, lhs)
|| changed;
changed = find_pre_post_state_expr(fm, enclosing,
expr_poststate(*lhs), rhs) || changed;
changed = extend_poststate_ann(a, expr_poststate(*rhs))
|| changed;
}
}
ret changed;
}
case (expr_ret(?maybe_ret_val, ?a)) {
changed = extend_prestate_ann(a, pres) || changed;
set_poststate_ann(a, empty_poststate(num_local_vars));
alt(maybe_ret_val) {
case (none[@expr]) { /* do nothing */ }
case (some[@expr](?ret_val)) {
changed = find_pre_post_state_expr(fm, enclosing,
pres, ret_val) || changed;
}
}
ret changed;
}
case (expr_if(?antec, ?conseq, ?maybe_alt, ?a)) {
changed = extend_prestate_ann(a, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, antec)
|| changed;
changed = find_pre_post_state_block(fm, enclosing,
expr_poststate(*antec), conseq) || changed;
alt (maybe_alt) {
case (none[@expr]) {
changed = extend_poststate_ann(a, expr_poststate(*antec))
|| changed;
}
case (some[@expr](?altern)) {
changed = find_pre_post_state_expr(fm, enclosing,
expr_poststate(*antec), altern) || changed;
auto poststate_res = intersect_postconds
(vec(block_poststate(conseq), expr_poststate(*altern)));
changed = extend_poststate_ann(a, poststate_res) || changed;
}
}
ret changed;
}
case (expr_binary(?bop, ?l, ?r, ?a)) {
/* FIXME: what if bop is lazy? */
changed = extend_prestate_ann(a, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, l)
|| changed;
changed = find_pre_post_state_expr(fm,
enclosing, expr_poststate(*l), r) || changed;
changed = extend_poststate_ann(a, expr_poststate(*r)) || changed;
ret changed;
}
case (expr_while(?test, ?body, ?a)) {
changed = extend_prestate_ann(a, pres) || changed;
/* to handle general predicates, we need to pass in
pres `intersect` (poststate(a))
like: auto test_pres = intersect_postconds(pres, expr_postcond(a));
However, this doesn't work right now because we would be passing
in an all-zero prestate initially
FIXME
maybe need a "don't know" state in addition to 0 or 1?
*/
changed = find_pre_post_state_expr(fm, enclosing, pres, test)
|| changed;
changed = find_pre_post_state_block(fm,
enclosing, expr_poststate(*test), body) || changed;
changed = extend_poststate_ann(a,
intersect_postconds(vec(expr_poststate(*test),
block_poststate(body)))) || changed;
ret changed;
}
case (expr_index(?e, ?sub, ?a)) {
changed = extend_prestate_ann(a, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
changed = find_pre_post_state_expr(fm, enclosing,
expr_poststate(*e), sub) || changed;
changed = extend_poststate_ann(a, expr_poststate(*sub));
ret changed;
}
case (expr_alt(?e, ?alts, ?a)) {
changed = extend_prestate_ann(a, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
auto e_post = expr_poststate(*e);
auto a_post = ann_to_poststate(a);
for (arm an_alt in alts) {
changed = find_pre_post_state_block(fm, enclosing, e_post,
an_alt.block) || changed;
changed = intersect(a_post, block_poststate(an_alt.block))
|| changed;
}
ret changed;
}
case (expr_field(?e,_,?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e);
changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
ret changed;
}
case (expr_unary(_,?operand,?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, operand)
|| changed;
changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, expr_poststate(*operand))
|| changed;
ret changed;
}
case (expr_fail(?a)) {
changed = extend_prestate_ann(a, pres) || changed;
changed = set_poststate_ann(a, true_postcond(num_local_vars))
|| changed;
ret changed;
}
case (_) {
log("find_pre_post_state_expr: implement this case!");
fail;
}
}
}
fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing,
&prestate pres, @stmt s) -> bool {
auto changed = false;
auto stmt_ann_ = stmt_to_ann(*s);
check (!is_none[@ts_ann](stmt_ann_));
auto stmt_ann = *(get[@ts_ann](stmt_ann_));
/*
log("*At beginning: stmt = ");
log_stmt(*s);
log("*prestate = ");
log(bitv.to_str(stmt_ann.states.prestate));
log("*poststate =");
log(bitv.to_str(stmt_ann.states.poststate));
log("*changed =");
log(changed);
*/
alt (s.node) {
case (stmt_decl(?adecl, ?a)) {
alt (adecl.node) {
case (ast.decl_local(?alocal)) {
alt (alocal.init) {
case (some[ast.initializer](?an_init)) {
changed = find_pre_post_state_expr
(fm, enclosing, pres, an_init.expr) || changed;
changed = extend_poststate(stmt_ann.states.poststate,
expr_poststate(*an_init.expr))
|| changed;
changed = gen_poststate(enclosing, a, alocal.id) || changed;
/*
log("Summary: stmt = ");
log_stmt(*s);
log("prestate = ");
log(bitv.to_str(stmt_ann.states.prestate));
log_bitv(enclosing, stmt_ann.states.prestate);
log("poststate =");
log_bitv(enclosing, stmt_ann.states.poststate);
log("changed =");
log(changed);
*/
ret changed;
}
case (none[ast.initializer]) {
changed = extend_prestate(stmt_ann.states.prestate, pres)
|| changed;
changed = extend_poststate(stmt_ann.states.poststate, pres)
|| changed;
ret changed;
}
}
}
case (ast.decl_item(?an_item)) {
be find_pre_post_state_item(fm, enclosing, an_item);
}
}
}
case (stmt_expr(?e, _)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
changed = extend_prestate(stmt_ann.states.prestate, expr_prestate(*e))
|| changed;
changed = extend_poststate(stmt_ann.states.poststate,
expr_poststate(*e)) || changed;
/*
log("Summary: stmt = ");
log_stmt(*s);
log("prestate = ");
log(bitv.to_str(stmt_ann.states.prestate));
log_bitv(enclosing, stmt_ann.states.prestate);
log("poststate =");
log_bitv(enclosing, stmt_ann.states.poststate);
log("changed =");
log(changed);
*/
ret changed;
}
case (_) { ret false; }
}
}
/* Updates the pre- and post-states of statements in the block,
returns a boolean flag saying whether any pre- or poststates changed */
fn find_pre_post_state_block(&fn_info_map fm, &fn_info enclosing,
&prestate pres0, block b)
-> bool {
auto changed = false;
auto num_local_vars = num_locals(enclosing);
/* First, set the pre-states and post-states for every expression */
auto pres = pres0;
/* Iterate over each stmt. The new prestate is <pres>. The poststate
consist of improving <pres> with whatever variables this stmt initializes.
Then <pres> becomes the new poststate. */
for (@stmt s in b.node.stmts) {
changed = find_pre_post_state_stmt(fm, enclosing, pres, s) || changed;
pres = stmt_poststate(*s, num_local_vars);
}
auto post = pres;
alt (b.node.expr) {
case (none[@expr]) {}
case (some[@expr](?e)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
post = expr_poststate(*e);
}
}
set_prestate_ann(b.node.a, pres0);
set_poststate_ann(b.node.a, post);
ret changed;
}
fn find_pre_post_state_fn(&fn_info_map f_info, &fn_info fi, &ast._fn f)
-> bool {
/* FIXME: where do we set args as being initialized?
What about for methods? */
auto num_local_vars = num_locals(fi);
ret find_pre_post_state_block(f_info, fi,
empty_prestate(num_local_vars), f.body);
}
fn fixed_point_states(fn_info_map fm, fn_info f_info,
fn (&fn_info_map, &fn_info, &ast._fn) -> bool f,
&ast._fn start) -> () {
auto changed = f(fm, f_info, start);
if (changed) {
ret fixed_point_states(fm, f_info, f, start);
}
else {
// we're done!
ret;
}
}
fn check_states_expr(fn_info enclosing, &expr e) -> () {
let precond prec = expr_precond(e);
let prestate pres = expr_prestate(e);
if (!implies(pres, prec)) {
log("check_states_expr: unsatisfied precondition for ");
log_expr(e);
log("Precondition: ");
log_bitv(enclosing, prec);
log("Prestate: ");
log_bitv(enclosing, pres);
fail;
}
}
fn check_states_stmt(fn_info enclosing, &stmt s) -> () {
alt (stmt_to_ann(s)) {
case (none[@ts_ann]) {
ret;
}
case (some[@ts_ann](?a)) {
let precond prec = ann_precond(*a);
let prestate pres = ann_prestate(*a);
/*
log("check_states_stmt:");
log_stmt(s);
log("prec = ");
log_bitv(enclosing, prec);
log("pres = ");
log_bitv(enclosing, pres);
*/
if (!implies(pres, prec)) {
log("check_states_stmt: unsatisfied precondition for ");
log_stmt(s);
log("Precondition: ");
log_bitv(enclosing, prec);
log("Prestate: ");
log_bitv(enclosing, pres);
fail;
}
}
}
}
fn check_states_against_conditions(fn_info enclosing, &ast._fn f) -> () {
fn do_one_(fn_info i, &@stmt s) -> () {
check_states_stmt(i, *s);
}
auto do_one = bind do_one_(enclosing, _);
_vec.map[@stmt, ()](do_one, f.body.node.stmts);
fn do_inner_(fn_info i, &@expr e) -> () {
check_states_expr(i, *e);
}
auto do_inner = bind do_inner_(enclosing, _);
option.map[@expr, ()](do_inner, f.body.node.expr);
}
fn check_fn_states(&fn_info_map f_info_map, &fn_info f_info, &ast._fn f)
-> () {
/* Compute the pre- and post-states for this function */
auto g = find_pre_post_state_fn;
fixed_point_states(f_info_map, f_info, g, f);
/* Now compare each expr's pre-state to its precondition
and post-state to its postcondition */
check_states_against_conditions(f_info, f);
}
fn check_item_fn_state(&fn_info_map f_info_map, &span sp, ident i,
&ast._fn f, vec[ast.ty_param] ty_params, def_id id,
ann a) -> @item {
/* Look up the var-to-bit-num map for this function */
check(f_info_map.contains_key(id));
auto f_info = f_info_map.get(id);
check_fn_states(f_info_map, f_info, f);
/* Rebuild the same function */
ret @respan(sp, ast.item_fn(i, f, ty_params, id, a));
}
fn check_method_states(&fn_info_map f_info_map, @method m) -> () {
check (f_info_map.contains_key(m.node.id));
auto f_info = f_info_map.get(m.node.id);
check_fn_states(f_info_map, f_info, m.node.meth);
}
fn check_obj_state(&fn_info_map f_info_map, vec[obj_field] fields,
vec[@method] methods, option.t[@method] dtor) -> ast._obj {
fn one(fn_info_map fm, &@method m) -> () {
ret check_method_states(fm, m);
}
auto f = bind one(f_info_map,_);
_vec.map[@method, ()](f, methods);
option.map[@method, ()](f, dtor);
ret rec(fields=fields, methods=methods, dtor=dtor);
}
fn init_ann(&fn_info fi, ann a) -> ann {
alt (a) {
case (ann_none) {
log("init_ann: shouldn't see ann_none");
fail;
}
case (ann_type(?t,?ps,_)) {
ret ann_type(t, ps, some[@ts_ann](@empty_ann(num_locals(fi))));
}
}
}
fn init_blank_ann(&() ignore, ann a) -> ann {
alt (a) {
case (ann_none) {
log("init_ann: shouldn't see ann_none");
fail;
}
case (ann_type(?t,?ps,_)) {
ret ann_type(t, ps, some[@ts_ann](@empty_ann(0u)));
}
}
}
fn init_block(&fn_info fi, &span sp, &block_ b) -> block {
log("init_block:");
log_block(respan(sp, b));
alt(b.a) {
case (ann_none) {
log("init_ann: shouldn't see ann_none");
fail;
}
case (ann_type(?t,?ps,_)) {
auto fld0 = fold.new_identity_fold[fn_info]();
fld0 = @rec(fold_ann = bind init_ann(_,_) with *fld0);
ret fold.fold_block[fn_info](fi, fld0, respan(sp, b));
}
}
}
fn item_fn_anns(&fn_info_map fm, &span sp, ident i, &ast._fn f,
vec[ast.ty_param] ty_params, def_id id, ann a) -> @item {
check(fm.contains_key(id));
auto f_info = fm.get(id);
log(i + " has " + uistr(num_locals(f_info)) + " local vars");
auto fld0 = fold.new_identity_fold[fn_info]();
fld0 = @rec(fold_ann = bind init_ann(_,_)
// fold_block = bind init_block(_,_,_)
with *fld0);
ret fold.fold_item[fn_info]
(f_info, fld0, @respan(sp, item_fn(i, f, ty_params, id, a)));
}
/* This is painstakingly written as an explicit recursion b/c the
standard ast.fold doesn't traverse in the correct order:
consider
fn foo() {
fn bar() {
auto x = 5;
log(x);
}
}
With fold, first bar() would be processed and its subexps would
correctly be annotated with length-1 bit vectors.
But then, the process would be repeated with (fn bar()...) as
a subexp of foo, which has 0 local variables -- so then
the body of bar() would be incorrectly annotated with length-0 bit
vectors. */
fn annotate_exprs(&fn_info_map fm, &vec[@expr] es) -> vec[@expr] {
fn one(fn_info_map fm, &@expr e) -> @expr {
ret annotate_expr(fm, e);
}
auto f = bind one(fm,_);
ret _vec.map[@expr, @expr](f, es);
}
fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] {
fn one(fn_info_map fm, &elt e) -> elt {
ret rec(mut=e.mut,
expr=annotate_expr(fm, e.expr));
}
auto f = bind one(fm,_);
ret _vec.map[elt, elt](f, es);
}
fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] {
fn one(fn_info_map fm, &field f) -> field {
ret rec(mut=f.mut,
ident=f.ident,
expr=annotate_expr(fm, f.expr));
}
auto f = bind one(fm,_);
ret _vec.map[field, field](f, fs);
}
fn annotate_option_exp(&fn_info_map fm, &option.t[@expr] o)
-> option.t[@expr] {
fn one(fn_info_map fm, &@expr e) -> @expr {
ret annotate_expr(fm, e);
}
auto f = bind one(fm,_);
ret option.map[@expr, @expr](f, o);
}
fn annotate_option_exprs(&fn_info_map fm, &vec[option.t[@expr]] es)
-> vec[option.t[@expr]] {
fn one(fn_info_map fm, &option.t[@expr] o) -> option.t[@expr] {
ret annotate_option_exp(fm, o);
}
auto f = bind one(fm,_);
ret _vec.map[option.t[@expr], option.t[@expr]](f, es);
}
fn annotate_decl(&fn_info_map fm, &@decl d) -> @decl {
auto d1 = d.node;
alt (d.node) {
case (decl_local(?l)) {
alt(l.init) {
case (some[initializer](?init)) {
let option.t[initializer] an_i =
some[initializer]
(rec(expr=annotate_expr(fm, init.expr)
with init));
let @local new_l = @rec(init=an_i with *l);
d1 = decl_local(new_l);
}
case (_) { /* do nothing */ }
}
}
case (decl_item(?item)) {
d1 = decl_item(annotate_item(fm, item));
}
}
ret @respan(d.span, d1);
}
fn annotate_alts(&fn_info_map fm, &vec[arm] alts) -> vec[arm] {
fn one(fn_info_map fm, &arm a) -> arm {
ret rec(pat=a.pat,
block=annotate_block(fm, a.block),
index=a.index);
}
auto f = bind one(fm,_);
ret _vec.map[arm, arm](f, alts);
}
fn annotate_expr(&fn_info_map fm, &@expr e) -> @expr {
auto e1 = e.node;
alt (e.node) {
case (expr_vec(?es, ?m, ?a)) {
e1 = expr_vec(annotate_exprs(fm, es), m, a);
}
case (expr_tup(?es, ?a)) {
e1 = expr_tup(annotate_elts(fm, es), a);
}
case (expr_rec(?fs, ?maybe_e, ?a)) {
e1 = expr_rec(annotate_fields(fm, fs),
annotate_option_exp(fm, maybe_e), a);
}
case (expr_call(?e, ?es, ?a)) {
e1 = expr_call(annotate_expr(fm, e),
annotate_exprs(fm, es), a);
}
case (expr_self_method(_,_)) {
// no change
}
case (expr_bind(?e, ?maybe_es, ?a)) {
e1 = expr_bind(annotate_expr(fm, e),
annotate_option_exprs(fm, maybe_es),
a);
}
case (expr_spawn(?s, ?maybe_s, ?e, ?es, ?a)) {
e1 = expr_spawn(s, maybe_s, annotate_expr(fm, e),
annotate_exprs(fm, es), a);
}
case (expr_binary(?bop, ?w, ?x, ?a)) {
e1 = expr_binary(bop, annotate_expr(fm, w),
annotate_expr(fm, x), a);
}
case (expr_unary(?uop, ?w, ?a)) {
e1 = expr_unary(uop, annotate_expr(fm, w), a);
}
case (expr_lit(_,_)) {
/* no change */
}
case (expr_cast(?e,?t,?a)) {
e1 = expr_cast(annotate_expr(fm, e), t, a);
}
case (expr_if(?e, ?b, ?maybe_e, ?a)) {
e1 = expr_if(annotate_expr(fm, e),
annotate_block(fm, b),
annotate_option_exp(fm, maybe_e), a);
}
case (expr_while(?e, ?b, ?a)) {
e1 = expr_while(annotate_expr(fm, e),
annotate_block(fm, b), a);
}
case (expr_for(?d, ?e, ?b, ?a)) {
e1 = expr_for(annotate_decl(fm, d),
annotate_expr(fm, e),
annotate_block(fm, b), a);
}
case (expr_for_each(?d, ?e, ?b, ?a)) {
e1 = expr_for_each(annotate_decl(fm, d),
annotate_expr(fm, e),
annotate_block(fm, b), a);
}
case (expr_do_while(?b, ?e, ?a)) {
e1 = expr_do_while(annotate_block(fm, b),
annotate_expr(fm, e), a);
}
case (expr_alt(?e, ?alts, ?a)) {
e1 = expr_alt(annotate_expr(fm, e),
annotate_alts(fm, alts), a);
}
case (expr_block(?b, ?a)) {
e1 = expr_block(annotate_block(fm, b), a);
}
case (expr_assign(?l, ?r, ?a)) {
e1 = expr_assign(annotate_expr(fm, l), annotate_expr(fm, r), a);
}
case (expr_assign_op(?bop, ?l, ?r, ?a)) {
e1 = expr_assign_op(bop,
annotate_expr(fm, l), annotate_expr(fm, r), a);
}
case (expr_send(?l, ?r, ?a)) {
e1 = expr_send(annotate_expr(fm, l),
annotate_expr(fm, r), a);
}
case (expr_recv(?l, ?r, ?a)) {
e1 = expr_recv(annotate_expr(fm, l),
annotate_expr(fm, r), a);
}
case (expr_field(?e, ?i, ?a)) {
e1 = expr_field(annotate_expr(fm, e),
i, a);
}
case (expr_index(?e, ?sub, ?a)) {
e1 = expr_index(annotate_expr(fm, e),
annotate_expr(fm, sub), a);
}
case (expr_path(_,_,_)) {
/* no change */
}
case (expr_ext(?p, ?es, ?e_opt, ?e, ?a)) {
e1 = expr_ext(p, annotate_exprs(fm, es),
annotate_option_exp(fm, e_opt),
annotate_expr(fm, e), a);
}
/* no change, next 3 cases */
case (expr_fail(_)) { }
case (expr_break(_)) { }
case (expr_cont(_)) { }
case (expr_ret(?maybe_e, ?a)) {
e1 = expr_ret(annotate_option_exp(fm, maybe_e), a);
}
case (expr_put(?maybe_e, ?a)) {
e1 = expr_put(annotate_option_exp(fm, maybe_e), a);
}
case (expr_be(?e, ?a)) {
e1 = expr_be(annotate_expr(fm, e), a);
}
case (expr_log(?n, ?e, ?a)) {
e1 = expr_log(n, annotate_expr(fm, e), a);
}
case (expr_check_expr(?e, ?a)) {
e1 = expr_check_expr(annotate_expr(fm, e), a);
}
case (expr_port(_)) { /* no change */ }
case (expr_chan(?e, ?a)) {
e1 = expr_chan(annotate_expr(fm, e), a);
}
}
ret @respan(e.span, e1);
}
fn annotate_stmt(&fn_info_map fm, &@stmt s) -> @stmt {
alt (s.node) {
case (stmt_decl(?d, ?a)) {
ret @respan(s.span, stmt_decl(annotate_decl(fm, d), a));
}
case (stmt_expr(?e, ?a)) {
ret @respan(s.span, stmt_expr(annotate_expr(fm, e), a));
}
}
}
fn annotate_block(&fn_info_map fm, &block b) -> block {
let vec[@stmt] new_stmts = vec();
auto new_index = new_str_hash[block_index_entry]();
for (@stmt s in b.node.stmts) {
auto new_s = annotate_stmt(fm, s);
_vec.push[@stmt](new_stmts, new_s);
ast.index_stmt(new_index, new_s);
}
fn ann_e(fn_info_map fm, &@expr e) -> @expr {
ret annotate_expr(fm, e);
}
auto f = bind ann_e(fm,_);
auto new_e = option.map[@expr, @expr](f, b.node.expr);
ret respan(b.span,
rec(stmts=new_stmts, expr=new_e, index=new_index with b.node));
}
fn annotate_fn(&fn_info_map fm, &ast._fn f) -> ast._fn {
// subexps have *already* been annotated based on
// f's number-of-locals
ret rec(body=annotate_block(fm, f.body) with f);
}
fn annotate_mod(&fn_info_map fm, &ast._mod m) -> ast._mod {
let vec[@item] new_items = vec();
auto new_index = new_str_hash[mod_index_entry]();
for (@item i in m.items) {
auto new_i = annotate_item(fm, i);
_vec.push[@item](new_items, new_i);
ast.index_item(new_index, new_i);
}
ret rec(items=new_items, index=new_index with m);
}
fn annotate_native_mod(&fn_info_map fm, &ast.native_mod m)
-> ast.native_mod {
log("implement annotate_native_mod!");
fail;
}
fn annotate_method(&fn_info_map fm, &@method m) -> @method {
auto f_info = get_fn_info(fm, m.node.id);
auto fld0 = fold.new_identity_fold[fn_info]();
fld0 = @rec(fold_ann = bind init_ann(_,_)
with *fld0);
auto outer = fold.fold_method[fn_info](f_info, fld0, m);
auto new_fn = annotate_fn(fm, outer.node.meth);
ret @respan(m.span,
rec(meth=new_fn with m.node));
}
fn annotate_obj(&fn_info_map fm, &ast._obj o) -> ast._obj {
fn one(fn_info_map fm, &@method m) -> @method {
ret annotate_method(fm, m);
}
auto f = bind one(fm,_);
auto new_methods = _vec.map[@method, @method](f, o.methods);
auto new_dtor = option.map[@method, @method](f, o.dtor);
ret rec(methods=new_methods, dtor=new_dtor with o);
}
// Only annotates the components of the item recursively.
fn annotate_item_inner(&fn_info_map fm, &@ast.item item) -> @ast.item {
alt (item.node) {
/* FIXME can't skip this case -- exprs contain blocks contain stmts,
which contain decls */
case (ast.item_const(_,_,_,_,_)) {
// this has already been annotated by annotate_item
ret item;
}
case (ast.item_fn(?ident, ?ff, ?tps, ?id, ?ann)) {
ret @respan(item.span,
ast.item_fn(ident, annotate_fn(fm, ff), tps, id, ann));
}
case (ast.item_mod(?ident, ?mm, ?id)) {
ret @respan(item.span,
ast.item_mod(ident, annotate_mod(fm, mm), id));
}
case (ast.item_native_mod(?ident, ?mm, ?id)) {
ret @respan(item.span,
ast.item_native_mod(ident,
annotate_native_mod(fm, mm), id));
}
case (ast.item_ty(_,_,_,_,_)) {
ret item;
}
case (ast.item_tag(_,_,_,_,_)) {
ret item;
}
case (ast.item_obj(?ident, ?ob, ?tps, ?odid, ?ann)) {
ret @respan(item.span,
ast.item_obj(ident, annotate_obj(fm, ob), tps, odid, ann));
}
}
}
fn annotate_item(&fn_info_map fm, &@ast.item item) -> @ast.item {
// Using a fold, recursively set all anns in this item
// to be blank.
// *Then*, call annotate_item recursively to do the right
// thing for any nested items inside this one.
alt (item.node) {
case (ast.item_const(_,_,_,_,_)) {
auto fld0 = fold.new_identity_fold[()]();
fld0 = @rec(fold_ann = bind init_blank_ann(_,_)
with *fld0);
ret fold.fold_item[()]((), fld0, item);
}
case (ast.item_fn(?i,?ff,?tps,?id,?ann)) {
auto f_info = get_fn_info(fm, id);
auto fld0 = fold.new_identity_fold[fn_info]();
fld0 = @rec(fold_ann = bind init_ann(_,_)
with *fld0);
auto outer = fold.fold_item[fn_info](f_info, fld0, item);
// now recurse into any nested items
ret annotate_item_inner(fm, outer);
}
case (ast.item_mod(?i, ?mm, ?id)) {
auto fld0 = fold.new_identity_fold[()]();
fld0 = @rec(fold_ann = bind init_blank_ann(_,_)
with *fld0);
auto outer = fold.fold_item[()]((), fld0, item);
ret annotate_item_inner(fm, outer);
}
case (ast.item_ty(_,_,_,_,_)) {
ret item;
}
case (ast.item_tag(_,_,_,_,_)) {
ret item;
}
case (ast.item_obj(?i,?ob,?tps,?odid,?ann)) {
auto fld0 = fold.new_identity_fold[()]();
fld0 = @rec(fold_ann = bind init_blank_ann(_,_)
with *fld0);
auto outer = fold.fold_item[()]((), fld0, item);
ret annotate_item_inner(fm, outer);
}
}
}
fn annotate_module(&fn_info_map fm, &ast._mod module) -> ast._mod {
let vec[@item] new_items = vec();
auto new_index = new_str_hash[ast.mod_index_entry]();
for (@item i in module.items) {
auto new_item = annotate_item(fm, i);
_vec.push[@item](new_items, new_item);
ast.index_item(new_index, new_item);
}
ret rec(items = new_items, index = new_index with module);
}
fn annotate_crate(&fn_info_map fm, &@ast.crate crate) -> @ast.crate {
ret @respan(crate.span,
rec(module = annotate_module(fm, crate.node.module)
with crate.node));
}
fn check_crate(@ast.crate crate) -> @ast.crate {
/* Build the global map from function id to var-to-bit-num-map */
auto fm = mk_f_to_fn_info(crate);
/* Add a blank ts_ann to every statement (and expression) */
/*
auto fld0 = fold.new_identity_fold[fn_info_map]();
fld0 = @rec(fold_item_fn = bind item_fn_anns(_,_,_,_,_,_,_)
with *fld0);
*/
auto with_anns = annotate_crate(fm, crate);
/* Compute the pre and postcondition for every subexpression */
auto fld = fold.new_identity_fold[fn_info_map]();
fld = @rec(fold_item_fn = bind check_item_fn(_,_,_,_,_,_,_) with *fld);
auto with_pre_postconditions = fold.fold_crate[fn_info_map]
(fm, fld, with_anns);
auto fld1 = fold.new_identity_fold[fn_info_map]();
fld1 = @rec(fold_item_fn = bind check_item_fn_state(_,_,_,_,_,_,_),
fold_obj = bind check_obj_state(_,_,_,_)
with *fld1);
ret fold.fold_crate[fn_info_map](fm, fld1,
with_pre_postconditions);
}
//
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End:
//
|
#[doc = r"Register block"]
#[repr(C)]
pub struct RegisterBlock {
#[doc = "0x00 - FDCAN Core Release Register"]
pub crel: CREL,
#[doc = "0x04 - FDCAN Core Release Register"]
pub endn: ENDN,
_reserved2: [u8; 4usize],
#[doc = "0x0c - This register is only writable if bits CCCR.CCE and CCCR.INIT are set. The CAN bit time may be programed in the range of 4 to 25 time quanta. The CAN time quantum may be programmed in the range of 1 to 1024 FDCAN clock periods. tq = (DBRP + 1) FDCAN clock period. DTSEG1 is the sum of Prop_Seg and Phase_Seg1. DTSEG2 is Phase_Seg2. Therefore the length of the bit time is (programmed values) \\[DTSEG1 + DTSEG2 + 3\\]
tq or (functional values) \\[Sync_Seg + Prop_Seg + Phase_Seg1 + Phase_Seg2\\]
tq. The Information Processing Time (IPT) is zero, meaning the data for the next bit is available at the first clock edge after the sample point."]
pub dbtp: DBTP,
#[doc = "0x10 - Write access to the Test Register has to be enabled by setting bit CCCR\\[TEST\\]
to 1 . All Test Register functions are set to their reset values when bit CCCR\\[TEST\\]
is reset. Loop Back mode and software control of Tx pin FDCANx_TX are hardware test modes. Programming TX differently from 00 may disturb the message transfer on the CAN bus."]
pub test: TEST,
#[doc = "0x14 - The RAM Watchdog monitors the READY output of the Message RAM. A Message RAM access starts the Message RAM Watchdog Counter with the value configured by the RWD\\[WDC\\]
bits. The counter is reloaded with RWD\\[WDC\\]
bits when the Message RAM signals successful completion by activating its READY output. In case there is no response from the Message RAM until the counter has counted down to 0, the counter stops and interrupt flag IR\\[WDI\\]
bit is set. The RAM Watchdog Counter is clocked by the fdcan_pclk clock."]
pub rwd: RWD,
#[doc = "0x18 - For details about setting and resetting of single bits see Software initialization."]
pub cccr: CCCR,
#[doc = "0x1c - FDCAN_NBTP"]
pub nbtp: NBTP,
#[doc = "0x20 - FDCAN Timestamp Counter Configuration Register"]
pub tscc: TSCC,
#[doc = "0x24 - FDCAN Timestamp Counter Value Register"]
pub tscv: TSCV,
#[doc = "0x28 - FDCAN Timeout Counter Configuration Register"]
pub tocc: TOCC,
#[doc = "0x2c - FDCAN Timeout Counter Value Register"]
pub tocv: TOCV,
_reserved11: [u8; 16usize],
#[doc = "0x40 - FDCAN Error Counter Register"]
pub ecr: ECR,
#[doc = "0x44 - FDCAN Protocol Status Register"]
pub psr: PSR,
#[doc = "0x48 - FDCAN Transmitter Delay Compensation Register"]
pub tdcr: TDCR,
_reserved14: [u8; 4usize],
#[doc = "0x50 - The flags are set when one of the listed conditions is detected (edge-sensitive). The flags remain set until the Host clears them. A flag is cleared by writing a 1 to the corresponding bit position. Writing a 0 has no effect. A hard reset will clear the register. The configuration of IE controls whether an interrupt is generated. The configuration of ILS controls on which interrupt line an interrupt is signaled."]
pub ir: IR,
#[doc = "0x54 - The settings in the Interrupt Enable register determine which status changes in the Interrupt Register will be signaled on an interrupt line."]
pub ie: IE,
#[doc = "0x58 - The Interrupt Line Select register assigns an interrupt generated by a specific interrupt flag from the Interrupt Register to one of the two module interrupt lines. For interrupt generation the respective interrupt line has to be enabled via ILE\\[EINT0\\]
and ILE\\[EINT1\\]."]
pub ils: ILS,
#[doc = "0x5c - Each of the two interrupt lines to the CPU can be enabled/disabled separately by programming bits EINT0 and EINT1."]
pub ile: ILE,
_reserved18: [u8; 32usize],
#[doc = "0x80 - Global settings for Message ID filtering. The Global Filter Configuration controls the filter path for standard and extended messages as described in Figure706: Standard Message ID filter path and Figure707: Extended Message ID filter path."]
pub rxgfc: RXGFC,
#[doc = "0x84 - FDCAN Extended ID and Mask Register"]
pub xidam: XIDAM,
#[doc = "0x88 - This register is updated every time a Message ID filter element configured to generate a priority event match. This can be used to monitor the status of incoming high priority messages and to enable fast access to these messages."]
pub hpms: HPMS,
_reserved21: [u8; 4usize],
#[doc = "0x90 - FDCAN Rx FIFO 0 Status Register"]
pub rxf0s: RXF0S,
#[doc = "0x94 - CAN Rx FIFO 0 Acknowledge Register"]
pub rxf0a: RXF0A,
#[doc = "0x98 - FDCAN Rx FIFO 1 Status Register"]
pub rxf1s: RXF1S,
#[doc = "0x9c - FDCAN Rx FIFO 1 Acknowledge Register"]
pub rxf1a: RXF1A,
_reserved25: [u8; 32usize],
#[doc = "0xc0 - FDCAN Tx Buffer Configuration Register"]
pub txbc: TXBC,
#[doc = "0xc4 - The Tx FIFO/Queue status is related to the pending Tx requests listed in register TXBRP. Therefore the effect of Add/Cancellation requests may be delayed due to a running Tx scan (TXBRP not yet updated)."]
pub txfqs: TXFQS,
#[doc = "0xc8 - FDCAN Tx Buffer Request Pending Register"]
pub txbrp: TXBRP,
#[doc = "0xcc - FDCAN Tx Buffer Add Request Register"]
pub txbar: TXBAR,
#[doc = "0xd0 - FDCAN Tx Buffer Cancellation Request Register"]
pub txbcr: TXBCR,
#[doc = "0xd4 - FDCAN Tx Buffer Transmission Occurred Register"]
pub txbto: TXBTO,
#[doc = "0xd8 - FDCAN Tx Buffer Cancellation Finished Register"]
pub txbcf: TXBCF,
#[doc = "0xdc - FDCAN Tx Buffer Transmission Interrupt Enable Register"]
pub txbtie: TXBTIE,
#[doc = "0xe0 - FDCAN Tx Buffer Cancellation Finished Interrupt Enable Register"]
pub txbcie: TXBCIE,
#[doc = "0xe4 - FDCAN Tx Event FIFO Status Register"]
pub txefs: TXEFS,
#[doc = "0xe8 - FDCAN Tx Event FIFO Acknowledge Register"]
pub txefa: TXEFA,
_reserved36: [u8; 20usize],
#[doc = "0x100 - FDCAN CFG clock divider register"]
pub ckdiv: CKDIV,
}
#[doc = "FDCAN Core Release Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [crel](crel) module"]
pub type CREL = crate::Reg<u32, _CREL>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CREL;
#[doc = "`read()` method returns [crel::R](crel::R) reader structure"]
impl crate::Readable for CREL {}
#[doc = "FDCAN Core Release Register"]
pub mod crel;
#[doc = "FDCAN Core Release Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [endn](endn) module"]
pub type ENDN = crate::Reg<u32, _ENDN>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _ENDN;
#[doc = "`read()` method returns [endn::R](endn::R) reader structure"]
impl crate::Readable for ENDN {}
#[doc = "FDCAN Core Release Register"]
pub mod endn;
#[doc = "This register is only writable if bits CCCR.CCE and CCCR.INIT are set. The CAN bit time may be programed in the range of 4 to 25 time quanta. The CAN time quantum may be programmed in the range of 1 to 1024 FDCAN clock periods. tq = (DBRP + 1) FDCAN clock period. DTSEG1 is the sum of Prop_Seg and Phase_Seg1. DTSEG2 is Phase_Seg2. Therefore the length of the bit time is (programmed values) \\[DTSEG1 + DTSEG2 + 3\\]
tq or (functional values) \\[Sync_Seg + Prop_Seg + Phase_Seg1 + Phase_Seg2\\]
tq. The Information Processing Time (IPT) is zero, meaning the data for the next bit is available at the first clock edge after the sample point.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dbtp](dbtp) module"]
pub type DBTP = crate::Reg<u32, _DBTP>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _DBTP;
#[doc = "`read()` method returns [dbtp::R](dbtp::R) reader structure"]
impl crate::Readable for DBTP {}
#[doc = "`write(|w| ..)` method takes [dbtp::W](dbtp::W) writer structure"]
impl crate::Writable for DBTP {}
#[doc = "This register is only writable if bits CCCR.CCE and CCCR.INIT are set. The CAN bit time may be programed in the range of 4 to 25 time quanta. The CAN time quantum may be programmed in the range of 1 to 1024 FDCAN clock periods. tq = (DBRP + 1) FDCAN clock period. DTSEG1 is the sum of Prop_Seg and Phase_Seg1. DTSEG2 is Phase_Seg2. Therefore the length of the bit time is (programmed values) \\[DTSEG1 + DTSEG2 + 3\\]
tq or (functional values) \\[Sync_Seg + Prop_Seg + Phase_Seg1 + Phase_Seg2\\]
tq. The Information Processing Time (IPT) is zero, meaning the data for the next bit is available at the first clock edge after the sample point."]
pub mod dbtp;
#[doc = "Write access to the Test Register has to be enabled by setting bit CCCR\\[TEST\\]
to 1 . All Test Register functions are set to their reset values when bit CCCR\\[TEST\\]
is reset. Loop Back mode and software control of Tx pin FDCANx_TX are hardware test modes. Programming TX differently from 00 may disturb the message transfer on the CAN bus.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [test](test) module"]
pub type TEST = crate::Reg<u32, _TEST>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TEST;
#[doc = "`read()` method returns [test::R](test::R) reader structure"]
impl crate::Readable for TEST {}
#[doc = "`write(|w| ..)` method takes [test::W](test::W) writer structure"]
impl crate::Writable for TEST {}
#[doc = "Write access to the Test Register has to be enabled by setting bit CCCR\\[TEST\\]
to 1 . All Test Register functions are set to their reset values when bit CCCR\\[TEST\\]
is reset. Loop Back mode and software control of Tx pin FDCANx_TX are hardware test modes. Programming TX differently from 00 may disturb the message transfer on the CAN bus."]
pub mod test;
#[doc = "The RAM Watchdog monitors the READY output of the Message RAM. A Message RAM access starts the Message RAM Watchdog Counter with the value configured by the RWD\\[WDC\\]
bits. The counter is reloaded with RWD\\[WDC\\]
bits when the Message RAM signals successful completion by activating its READY output. In case there is no response from the Message RAM until the counter has counted down to 0, the counter stops and interrupt flag IR\\[WDI\\]
bit is set. The RAM Watchdog Counter is clocked by the fdcan_pclk clock.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rwd](rwd) module"]
pub type RWD = crate::Reg<u32, _RWD>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _RWD;
#[doc = "`read()` method returns [rwd::R](rwd::R) reader structure"]
impl crate::Readable for RWD {}
#[doc = "`write(|w| ..)` method takes [rwd::W](rwd::W) writer structure"]
impl crate::Writable for RWD {}
#[doc = "The RAM Watchdog monitors the READY output of the Message RAM. A Message RAM access starts the Message RAM Watchdog Counter with the value configured by the RWD\\[WDC\\]
bits. The counter is reloaded with RWD\\[WDC\\]
bits when the Message RAM signals successful completion by activating its READY output. In case there is no response from the Message RAM until the counter has counted down to 0, the counter stops and interrupt flag IR\\[WDI\\]
bit is set. The RAM Watchdog Counter is clocked by the fdcan_pclk clock."]
pub mod rwd;
#[doc = "For details about setting and resetting of single bits see Software initialization.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cccr](cccr) module"]
pub type CCCR = crate::Reg<u32, _CCCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CCCR;
#[doc = "`read()` method returns [cccr::R](cccr::R) reader structure"]
impl crate::Readable for CCCR {}
#[doc = "`write(|w| ..)` method takes [cccr::W](cccr::W) writer structure"]
impl crate::Writable for CCCR {}
#[doc = "For details about setting and resetting of single bits see Software initialization."]
pub mod cccr;
#[doc = "FDCAN_NBTP\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [nbtp](nbtp) module"]
pub type NBTP = crate::Reg<u32, _NBTP>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _NBTP;
#[doc = "`read()` method returns [nbtp::R](nbtp::R) reader structure"]
impl crate::Readable for NBTP {}
#[doc = "`write(|w| ..)` method takes [nbtp::W](nbtp::W) writer structure"]
impl crate::Writable for NBTP {}
#[doc = "FDCAN_NBTP"]
pub mod nbtp;
#[doc = "FDCAN Timestamp Counter Configuration Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tscc](tscc) module"]
pub type TSCC = crate::Reg<u32, _TSCC>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TSCC;
#[doc = "`read()` method returns [tscc::R](tscc::R) reader structure"]
impl crate::Readable for TSCC {}
#[doc = "`write(|w| ..)` method takes [tscc::W](tscc::W) writer structure"]
impl crate::Writable for TSCC {}
#[doc = "FDCAN Timestamp Counter Configuration Register"]
pub mod tscc;
#[doc = "FDCAN Timestamp Counter Value Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tscv](tscv) module"]
pub type TSCV = crate::Reg<u32, _TSCV>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TSCV;
#[doc = "`read()` method returns [tscv::R](tscv::R) reader structure"]
impl crate::Readable for TSCV {}
#[doc = "FDCAN Timestamp Counter Value Register"]
pub mod tscv;
#[doc = "FDCAN Timeout Counter Configuration Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tocc](tocc) module"]
pub type TOCC = crate::Reg<u32, _TOCC>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TOCC;
#[doc = "`read()` method returns [tocc::R](tocc::R) reader structure"]
impl crate::Readable for TOCC {}
#[doc = "`write(|w| ..)` method takes [tocc::W](tocc::W) writer structure"]
impl crate::Writable for TOCC {}
#[doc = "FDCAN Timeout Counter Configuration Register"]
pub mod tocc;
#[doc = "FDCAN Timeout Counter Value Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tocv](tocv) module"]
pub type TOCV = crate::Reg<u32, _TOCV>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TOCV;
#[doc = "`read()` method returns [tocv::R](tocv::R) reader structure"]
impl crate::Readable for TOCV {}
#[doc = "FDCAN Timeout Counter Value Register"]
pub mod tocv;
#[doc = "FDCAN Error Counter Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ecr](ecr) module"]
pub type ECR = crate::Reg<u32, _ECR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _ECR;
#[doc = "`read()` method returns [ecr::R](ecr::R) reader structure"]
impl crate::Readable for ECR {}
#[doc = "FDCAN Error Counter Register"]
pub mod ecr;
#[doc = "FDCAN Protocol Status Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [psr](psr) module"]
pub type PSR = crate::Reg<u32, _PSR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _PSR;
#[doc = "`read()` method returns [psr::R](psr::R) reader structure"]
impl crate::Readable for PSR {}
#[doc = "`write(|w| ..)` method takes [psr::W](psr::W) writer structure"]
impl crate::Writable for PSR {}
#[doc = "FDCAN Protocol Status Register"]
pub mod psr;
#[doc = "FDCAN Transmitter Delay Compensation Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tdcr](tdcr) module"]
pub type TDCR = crate::Reg<u32, _TDCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TDCR;
#[doc = "`read()` method returns [tdcr::R](tdcr::R) reader structure"]
impl crate::Readable for TDCR {}
#[doc = "`write(|w| ..)` method takes [tdcr::W](tdcr::W) writer structure"]
impl crate::Writable for TDCR {}
#[doc = "FDCAN Transmitter Delay Compensation Register"]
pub mod tdcr;
#[doc = "The flags are set when one of the listed conditions is detected (edge-sensitive). The flags remain set until the Host clears them. A flag is cleared by writing a 1 to the corresponding bit position. Writing a 0 has no effect. A hard reset will clear the register. The configuration of IE controls whether an interrupt is generated. The configuration of ILS controls on which interrupt line an interrupt is signaled.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ir](ir) module"]
pub type IR = crate::Reg<u32, _IR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _IR;
#[doc = "`read()` method returns [ir::R](ir::R) reader structure"]
impl crate::Readable for IR {}
#[doc = "`write(|w| ..)` method takes [ir::W](ir::W) writer structure"]
impl crate::Writable for IR {}
#[doc = "The flags are set when one of the listed conditions is detected (edge-sensitive). The flags remain set until the Host clears them. A flag is cleared by writing a 1 to the corresponding bit position. Writing a 0 has no effect. A hard reset will clear the register. The configuration of IE controls whether an interrupt is generated. The configuration of ILS controls on which interrupt line an interrupt is signaled."]
pub mod ir;
#[doc = "The settings in the Interrupt Enable register determine which status changes in the Interrupt Register will be signaled on an interrupt line.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ie](ie) module"]
pub type IE = crate::Reg<u32, _IE>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _IE;
#[doc = "`read()` method returns [ie::R](ie::R) reader structure"]
impl crate::Readable for IE {}
#[doc = "`write(|w| ..)` method takes [ie::W](ie::W) writer structure"]
impl crate::Writable for IE {}
#[doc = "The settings in the Interrupt Enable register determine which status changes in the Interrupt Register will be signaled on an interrupt line."]
pub mod ie;
#[doc = "The Interrupt Line Select register assigns an interrupt generated by a specific interrupt flag from the Interrupt Register to one of the two module interrupt lines. For interrupt generation the respective interrupt line has to be enabled via ILE\\[EINT0\\]
and ILE\\[EINT1\\].\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ils](ils) module"]
pub type ILS = crate::Reg<u32, _ILS>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _ILS;
#[doc = "`read()` method returns [ils::R](ils::R) reader structure"]
impl crate::Readable for ILS {}
#[doc = "`write(|w| ..)` method takes [ils::W](ils::W) writer structure"]
impl crate::Writable for ILS {}
#[doc = "The Interrupt Line Select register assigns an interrupt generated by a specific interrupt flag from the Interrupt Register to one of the two module interrupt lines. For interrupt generation the respective interrupt line has to be enabled via ILE\\[EINT0\\]
and ILE\\[EINT1\\]."]
pub mod ils;
#[doc = "Each of the two interrupt lines to the CPU can be enabled/disabled separately by programming bits EINT0 and EINT1.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ile](ile) module"]
pub type ILE = crate::Reg<u32, _ILE>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _ILE;
#[doc = "`read()` method returns [ile::R](ile::R) reader structure"]
impl crate::Readable for ILE {}
#[doc = "`write(|w| ..)` method takes [ile::W](ile::W) writer structure"]
impl crate::Writable for ILE {}
#[doc = "Each of the two interrupt lines to the CPU can be enabled/disabled separately by programming bits EINT0 and EINT1."]
pub mod ile;
#[doc = "Global settings for Message ID filtering. The Global Filter Configuration controls the filter path for standard and extended messages as described in Figure706: Standard Message ID filter path and Figure707: Extended Message ID filter path.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rxgfc](rxgfc) module"]
pub type RXGFC = crate::Reg<u32, _RXGFC>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _RXGFC;
#[doc = "`read()` method returns [rxgfc::R](rxgfc::R) reader structure"]
impl crate::Readable for RXGFC {}
#[doc = "`write(|w| ..)` method takes [rxgfc::W](rxgfc::W) writer structure"]
impl crate::Writable for RXGFC {}
#[doc = "Global settings for Message ID filtering. The Global Filter Configuration controls the filter path for standard and extended messages as described in Figure706: Standard Message ID filter path and Figure707: Extended Message ID filter path."]
pub mod rxgfc;
#[doc = "FDCAN Extended ID and Mask Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [xidam](xidam) module"]
pub type XIDAM = crate::Reg<u32, _XIDAM>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _XIDAM;
#[doc = "`read()` method returns [xidam::R](xidam::R) reader structure"]
impl crate::Readable for XIDAM {}
#[doc = "`write(|w| ..)` method takes [xidam::W](xidam::W) writer structure"]
impl crate::Writable for XIDAM {}
#[doc = "FDCAN Extended ID and Mask Register"]
pub mod xidam;
#[doc = "This register is updated every time a Message ID filter element configured to generate a priority event match. This can be used to monitor the status of incoming high priority messages and to enable fast access to these messages.\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [hpms](hpms) module"]
pub type HPMS = crate::Reg<u32, _HPMS>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _HPMS;
#[doc = "`read()` method returns [hpms::R](hpms::R) reader structure"]
impl crate::Readable for HPMS {}
#[doc = "This register is updated every time a Message ID filter element configured to generate a priority event match. This can be used to monitor the status of incoming high priority messages and to enable fast access to these messages."]
pub mod hpms;
#[doc = "FDCAN Rx FIFO 0 Status Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rxf0s](rxf0s) module"]
pub type RXF0S = crate::Reg<u32, _RXF0S>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _RXF0S;
#[doc = "`read()` method returns [rxf0s::R](rxf0s::R) reader structure"]
impl crate::Readable for RXF0S {}
#[doc = "`write(|w| ..)` method takes [rxf0s::W](rxf0s::W) writer structure"]
impl crate::Writable for RXF0S {}
#[doc = "FDCAN Rx FIFO 0 Status Register"]
pub mod rxf0s;
#[doc = "CAN Rx FIFO 0 Acknowledge Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rxf0a](rxf0a) module"]
pub type RXF0A = crate::Reg<u32, _RXF0A>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _RXF0A;
#[doc = "`read()` method returns [rxf0a::R](rxf0a::R) reader structure"]
impl crate::Readable for RXF0A {}
#[doc = "`write(|w| ..)` method takes [rxf0a::W](rxf0a::W) writer structure"]
impl crate::Writable for RXF0A {}
#[doc = "CAN Rx FIFO 0 Acknowledge Register"]
pub mod rxf0a;
#[doc = "FDCAN Rx FIFO 1 Status Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rxf1s](rxf1s) module"]
pub type RXF1S = crate::Reg<u32, _RXF1S>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _RXF1S;
#[doc = "`read()` method returns [rxf1s::R](rxf1s::R) reader structure"]
impl crate::Readable for RXF1S {}
#[doc = "FDCAN Rx FIFO 1 Status Register"]
pub mod rxf1s;
#[doc = "FDCAN Rx FIFO 1 Acknowledge Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rxf1a](rxf1a) module"]
pub type RXF1A = crate::Reg<u32, _RXF1A>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _RXF1A;
#[doc = "`read()` method returns [rxf1a::R](rxf1a::R) reader structure"]
impl crate::Readable for RXF1A {}
#[doc = "`write(|w| ..)` method takes [rxf1a::W](rxf1a::W) writer structure"]
impl crate::Writable for RXF1A {}
#[doc = "FDCAN Rx FIFO 1 Acknowledge Register"]
pub mod rxf1a;
#[doc = "FDCAN Tx Buffer Configuration Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txbc](txbc) module"]
pub type TXBC = crate::Reg<u32, _TXBC>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXBC;
#[doc = "`read()` method returns [txbc::R](txbc::R) reader structure"]
impl crate::Readable for TXBC {}
#[doc = "`write(|w| ..)` method takes [txbc::W](txbc::W) writer structure"]
impl crate::Writable for TXBC {}
#[doc = "FDCAN Tx Buffer Configuration Register"]
pub mod txbc;
#[doc = "The Tx FIFO/Queue status is related to the pending Tx requests listed in register TXBRP. Therefore the effect of Add/Cancellation requests may be delayed due to a running Tx scan (TXBRP not yet updated).\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txfqs](txfqs) module"]
pub type TXFQS = crate::Reg<u32, _TXFQS>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXFQS;
#[doc = "`read()` method returns [txfqs::R](txfqs::R) reader structure"]
impl crate::Readable for TXFQS {}
#[doc = "The Tx FIFO/Queue status is related to the pending Tx requests listed in register TXBRP. Therefore the effect of Add/Cancellation requests may be delayed due to a running Tx scan (TXBRP not yet updated)."]
pub mod txfqs;
#[doc = "FDCAN Tx Buffer Request Pending Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txbrp](txbrp) module"]
pub type TXBRP = crate::Reg<u32, _TXBRP>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXBRP;
#[doc = "`read()` method returns [txbrp::R](txbrp::R) reader structure"]
impl crate::Readable for TXBRP {}
#[doc = "FDCAN Tx Buffer Request Pending Register"]
pub mod txbrp;
#[doc = "FDCAN Tx Buffer Add Request Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txbar](txbar) module"]
pub type TXBAR = crate::Reg<u32, _TXBAR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXBAR;
#[doc = "`read()` method returns [txbar::R](txbar::R) reader structure"]
impl crate::Readable for TXBAR {}
#[doc = "`write(|w| ..)` method takes [txbar::W](txbar::W) writer structure"]
impl crate::Writable for TXBAR {}
#[doc = "FDCAN Tx Buffer Add Request Register"]
pub mod txbar;
#[doc = "FDCAN Tx Buffer Cancellation Request Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txbcr](txbcr) module"]
pub type TXBCR = crate::Reg<u32, _TXBCR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXBCR;
#[doc = "`read()` method returns [txbcr::R](txbcr::R) reader structure"]
impl crate::Readable for TXBCR {}
#[doc = "`write(|w| ..)` method takes [txbcr::W](txbcr::W) writer structure"]
impl crate::Writable for TXBCR {}
#[doc = "FDCAN Tx Buffer Cancellation Request Register"]
pub mod txbcr;
#[doc = "FDCAN Tx Buffer Transmission Occurred Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txbto](txbto) module"]
pub type TXBTO = crate::Reg<u32, _TXBTO>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXBTO;
#[doc = "`read()` method returns [txbto::R](txbto::R) reader structure"]
impl crate::Readable for TXBTO {}
#[doc = "FDCAN Tx Buffer Transmission Occurred Register"]
pub mod txbto;
#[doc = "FDCAN Tx Buffer Cancellation Finished Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txbcf](txbcf) module"]
pub type TXBCF = crate::Reg<u32, _TXBCF>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXBCF;
#[doc = "`read()` method returns [txbcf::R](txbcf::R) reader structure"]
impl crate::Readable for TXBCF {}
#[doc = "FDCAN Tx Buffer Cancellation Finished Register"]
pub mod txbcf;
#[doc = "FDCAN Tx Buffer Transmission Interrupt Enable Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txbtie](txbtie) module"]
pub type TXBTIE = crate::Reg<u32, _TXBTIE>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXBTIE;
#[doc = "`read()` method returns [txbtie::R](txbtie::R) reader structure"]
impl crate::Readable for TXBTIE {}
#[doc = "`write(|w| ..)` method takes [txbtie::W](txbtie::W) writer structure"]
impl crate::Writable for TXBTIE {}
#[doc = "FDCAN Tx Buffer Transmission Interrupt Enable Register"]
pub mod txbtie;
#[doc = "FDCAN Tx Buffer Cancellation Finished Interrupt Enable Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txbcie](txbcie) module"]
pub type TXBCIE = crate::Reg<u32, _TXBCIE>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXBCIE;
#[doc = "`read()` method returns [txbcie::R](txbcie::R) reader structure"]
impl crate::Readable for TXBCIE {}
#[doc = "`write(|w| ..)` method takes [txbcie::W](txbcie::W) writer structure"]
impl crate::Writable for TXBCIE {}
#[doc = "FDCAN Tx Buffer Cancellation Finished Interrupt Enable Register"]
pub mod txbcie;
#[doc = "FDCAN Tx Event FIFO Status Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txefs](txefs) module"]
pub type TXEFS = crate::Reg<u32, _TXEFS>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXEFS;
#[doc = "`read()` method returns [txefs::R](txefs::R) reader structure"]
impl crate::Readable for TXEFS {}
#[doc = "FDCAN Tx Event FIFO Status Register"]
pub mod txefs;
#[doc = "FDCAN Tx Event FIFO Acknowledge Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txefa](txefa) module"]
pub type TXEFA = crate::Reg<u32, _TXEFA>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _TXEFA;
#[doc = "`read()` method returns [txefa::R](txefa::R) reader structure"]
impl crate::Readable for TXEFA {}
#[doc = "`write(|w| ..)` method takes [txefa::W](txefa::W) writer structure"]
impl crate::Writable for TXEFA {}
#[doc = "FDCAN Tx Event FIFO Acknowledge Register"]
pub mod txefa;
#[doc = "FDCAN CFG clock divider register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ckdiv](ckdiv) module"]
pub type CKDIV = crate::Reg<u32, _CKDIV>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CKDIV;
#[doc = "`read()` method returns [ckdiv::R](ckdiv::R) reader structure"]
impl crate::Readable for CKDIV {}
#[doc = "`write(|w| ..)` method takes [ckdiv::W](ckdiv::W) writer structure"]
impl crate::Writable for CKDIV {}
#[doc = "FDCAN CFG clock divider register"]
pub mod ckdiv;
|
use crate::image::Color;
#[derive(Clone)]
pub struct Material {
pub color: Color,
pub ambient: f64,
pub diffuse: f64,
pub specular: f64,
pub shininess: f64,
pub reflection: f64
}
impl Material {
pub fn new(color: Color, ambient: f64, diffuse: f64, specular: f64, shininess: f64, reflection: f64) -> Material {
Material{color, ambient, diffuse, specular, shininess, reflection}
}
pub fn from_color(color: Color) -> Material {
Material{color, ambient: 0.1, diffuse: 0.9, specular: 0.9 , shininess: 200.0, reflection: 0.0}
}
}
|
//! Audio generators.
//!
//! This provides audio generators which implements the [Generator] trait.
//!
//! It is part of the [audio ecosystem] of crates.
//!
//! # Examples
//!
//! ```rust
//! use audio_generator::{Generator, Sine};
//!
//! let mut g = Sine::new(440.0, 44100.0);
//! assert_eq!(g.sample(), 0.0);
//! assert!(g.sample() > 0.0);
//! ```
//!
//! [audio ecosystem]: https://docs.rs/audio
mod generator;
pub use self::generator::Generator;
mod sine;
pub use self::sine::Sine;
|
use fonttools::font::Table;
use fonttools_cli::{open_font, read_args, save_font};
fn main() {
let matches = read_args(
"ttf-add-minimal-dsig",
"Adds a minimal DSIG table if one is not present",
);
let mut infont = open_font(&matches);
if !infont.tables.contains_key(b"DSIG") {
infont.tables.insert(
*b"DSIG",
Table::Unknown(vec![0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00]),
);
}
save_font(infont, &matches);
}
|
use proconio::input;
fn main() {
input! {
n: usize,
m: usize,
x: [i64; n],
cy: [(usize, i64); m],
};
let mut bonus = vec![0; n + 1];
for (c, y) in cy {
bonus[c] = y;
}
let mut dp = vec![-1; n + 1];
dp[0] = 0;
for x in x {
let mut nxt_dp = vec![-1; n + 1];
for j in 0..=n {
if dp[j] < 0 {
continue;
}
if j + 1 <= n {
nxt_dp[j + 1] = nxt_dp[j + 1].max(dp[j] + x + bonus[j + 1]);
}
nxt_dp[0] = nxt_dp[0].max(dp[j]);
}
dp = nxt_dp;
}
let ans = dp.iter().max().copied().unwrap();
assert!(ans >= 0);
println!("{}", ans);
}
|
mod vertex;
use ecs::{Entity, ECS};
use renderer::{RendererDevice, MeshFlags};
use std::path::Path;
use vertex::Vertex;
pub fn load(ecs: &mut ECS) {
let context = ecs.resources.get_mut::<RendererDevice>().unwrap();
ecs.add_entity(Entity::new().with(context.new_mesh(
&Path::new("shaders/color.glsl"),
vec![
Vertex::new(-0.5, 0.5, 0.5, 0.44, 0.77, 0.63),
Vertex::new(0.5, 0.5, 0.5, 0.82, 0.71, 0.18),
Vertex::new(-0.5, 0.5, 0.5, 0.35, 0.08, 0.5),
Vertex::new(-0.5, -0.5, 0.5, 0.32, 0.59, 0.89),
Vertex::new(0.5, -0.5, 0.5, 0.13, 0.72, 0.78),
Vertex::new(0.5, 0.5, 0.5, 0.81, 0.96, 0.38),
Vertex::new(0.5, -0.5, 0.5, 0.84, 0.34, 0.72),
Vertex::new(-0.5, -0.5, 0.5, 0.4, 0.88, 0.78),
Vertex::new(0.5, -0.5, -0.5, 0.65, 0.87, 0.03),
Vertex::new(0.5, 0.5, -0.5, 0.6, 0.82, 0.65),
Vertex::new(0.5, -0.5, -0.5, 0.27, 0.51, 0.81),
Vertex::new(-0.5, -0.5, -0.5, 0.09, 0.36, 0.19),
Vertex::new(-0.5, 0.5, -0.5, 0.57, 0.93, 0.65),
Vertex::new(0.5, 0.5, -0.5, 0.24, 0.22, 1.0),
Vertex::new(-0.5, 0.5, -0.5, 0.16, 0.79, 0.63),
Vertex::new(-0.5, -0.5, -0.5, 0.09, 0.62, 0.19),
Vertex::new(0.5, 0.5, -0.5, 0.41, 0.02, 0.74),
Vertex::new(0.5, 0.5, 0.5, 0.51, 0.12, 0.37),
Vertex::new(-0.5, -0.5, 0.5, 0.25, 0.2, 0.44),
Vertex::new(-0.5, -0.5, -0.5, 0.61, 0.55, 0.93),
Vertex::new(-0.5, 0.5, -0.5, 0.68, 0.8, 0.81),
Vertex::new(-0.5, 0.5, 0.5, 0.53, 0.27, 0.72),
Vertex::new(0.5, -0.5, -0.5, 0.12, 0.03, 0.15),
Vertex::new(0.5, -0.5, 0.5, 0.16, 0.36, 0.28),
],
None,
vec![],
MeshFlags::new().lines_mode().opt(),
)));
}
|
#![allow(clippy::all)]
enum ParseResult {
Incomplete(Vec<char>),
SyntaxError(u32),
}
fn parse_chunks(chunks: &str) -> ParseResult {
let mut open_chunks = vec![];
macro_rules! syntax_error_check {
($open:literal, $score:literal) => {
if let Some($open) = open_chunks.pop() {
} else {
return ParseResult::SyntaxError($score);
}
};
}
for c in chunks.chars() {
match c {
'(' | '[' | '{' | '<' => open_chunks.push(c),
')' => syntax_error_check!('(', 3),
']' => syntax_error_check!('[', 57),
'}' => syntax_error_check!('{', 1197),
'>' => syntax_error_check!('<', 25137),
_ => unreachable!(),
}
}
ParseResult::Incomplete(open_chunks)
}
pub fn part1(input: String) {
let score = input.split("\n").fold(0, |score_acc, l| {
if let ParseResult::SyntaxError(score) = parse_chunks(l) {
return score_acc + score;
}
score_acc
});
println!("Syntax error score: {}", score);
}
pub fn part2(input: String) {
let open_chunk_list = input.split("\n").fold(vec![], |mut open_chunks_acc, l| {
if let ParseResult::Incomplete(open_chunk) = parse_chunks(l) {
open_chunks_acc.push(open_chunk);
}
open_chunks_acc
});
let mut scores = vec![];
for mut open_chunk in open_chunk_list {
let mut score = 0u64;
while !open_chunk.is_empty() {
score *= 5;
match open_chunk.pop().unwrap() {
'(' => score += 1,
'[' => score += 2,
'{' => score += 3,
'<' => score += 4,
_ => unreachable!(),
}
}
scores.push(score)
}
scores.sort();
println!("Answer: {}", scores[scores.len() / 2]);
}
|
use super::*;
#[derive(Debug, PartialEq)]
pub struct Alias {
pub to: String,
pub from: String,
}
#[derive(Debug, PartialEq)]
pub struct Undef {
pub list: Vec<String>,
}
#[derive(Debug, PartialEq)]
pub struct Rescue {
pub body: Box<Node>,
pub rescue: Vec<RescueClause>,
pub otherwise: Box<Node>,
}
#[derive(Debug, PartialEq)]
pub struct RescueClause {
pub exceptions: Vec<Node>,
pub assigned_to: Box<Node>,
pub then: Box<Node>,
}
|
//! math.rs: Provides functionality for solving linear algebra problems.
use std::cell::RefCell;
use rand::{Rng,SeedableRng};
use rand::rngs::StdRng;
fn _seedable_rand() -> f32 {
thread_local! {
pub static THREAD_FAST_RNG: RefCell<StdRng> = RefCell::new(StdRng::seed_from_u64(801289018191233));
}
let mut_ptr = THREAD_FAST_RNG.with(|r| r.as_ptr());
unsafe { (*mut_ptr).gen() }
}
pub fn rand_f32() -> f32 {
_seedable_rand()
}
pub fn rand_int() -> u32 {
_seedable_rand() as u32
}
/// Finds the next largest power of base that is less than or equal to num.
pub fn next_power_of_n_le(num: usize, base: usize) -> usize {
let mut pow = 1;
while base.pow(pow + 1) <= num {
pow += 1;
}
base.pow(pow)
}
pub fn clamp(x: f32, min: f32, max: f32) -> f32 {
if x < min { return min; }
if x > max { return max; }
x
}
pub fn rad_to_degree(rad: f32) -> f32 {
rad * (180.0 / std::f32::consts::PI)
}
pub fn degree_to_rad(degrees: f32) -> f32 {
degrees * (std::f32::consts::PI / 180.0)
}
pub fn rand_in_range(min: f32, max: f32) -> f32 {
let n_0_to_1 : f32 = rand_f32();
min + n_0_to_1 * (max - min)
}
#[derive(Clone, Copy, PartialEq, Debug)]
pub struct Vec3 {
pub x : f32,
pub y : f32,
pub z : f32
}
impl Vec3 {
pub fn zero() -> Vec3 {
Vec3 { x: 0.0, y: 0.0, z: 0.0 }
}
pub fn one() -> Vec3 {
Vec3 { x: 1.0, y: 1.0, z: 1.0 }
}
pub fn new(x: f32, y: f32, z: f32) -> Vec3 {
Vec3 { x, y, z }
}
pub fn is_near_zero(&self) -> bool {
let eps = 1.0e-8;
(self.x.abs() < eps) && (self.y.abs() < eps) && (self.z.abs() < eps)
}
pub fn random() -> Vec3 {
Vec3 { x: rand_f32(), y: rand_f32(), z: rand_f32() }
}
pub fn random_range(min: f32, max: f32) -> Vec3 {
Vec3 { x: rand_in_range(min, max), y: rand_in_range(min, max), z: rand_in_range(min, max) }
}
pub fn at(&self, idx: usize) -> f32 {
match idx {
0 => self.x,
1 => self.y,
2 => self.z,
_ => unreachable!()
}
}
}
#[macro_export]
macro_rules! vec3 {
($x: expr, $y: expr, $z: expr ) => {
Vec3 { x: $x, y: $y, z: $z}
};
($replicate: expr) => {
Vec3 {x: $replicate, y: $replicate, z: $replicate}
};
}
macro_rules! element_wise_binary_op {
($op: tt, $trait: ident, $func: ident) => {
impl std::ops::$trait<Vec3> for Vec3 {
type Output = Vec3;
fn $func(self, rhs: Vec3) -> Vec3 {
Vec3 {
x: self.x $op rhs.x,
y: self.y $op rhs.y,
z: self.z $op rhs.z,
}
}
}
impl std::ops::$trait<f32> for Vec3 {
type Output = Vec3;
fn $func(self, rhs: f32) -> Vec3 {
Vec3 {
x: self.x $op rhs,
y: self.y $op rhs,
z: self.z $op rhs,
}
}
}
impl std::ops::$trait<Vec3> for f32 {
type Output = Vec3;
fn $func(self, rhs: Vec3) -> Vec3 {
Vec3 {
x: self $op rhs.x,
y: self $op rhs.y,
z: self $op rhs.z,
}
}
}
};
// TODO(phil): Implement taking references
}
element_wise_binary_op!(+, Add, add);
element_wise_binary_op!(-, Sub, sub);
element_wise_binary_op!(*, Mul, mul);
element_wise_binary_op!(/, Div, div);
macro_rules! element_wise_binary_op_assign {
($op: tt, $trait: ident, $func: ident) => {
impl std::ops::$trait<Vec3> for Vec3 {
fn $func(&mut self, rhs: Vec3) {
self.x $op rhs.x;
self.y $op rhs.y;
self.z $op rhs.z;
}
}
impl std::ops::$trait<f32> for Vec3 {
fn $func(&mut self, rhs: f32) {
self.x $op rhs;
self.y $op rhs;
self.z $op rhs;
}
}
};
// TODO(phil): Implement taking references
}
element_wise_binary_op_assign!(+=, AddAssign, add_assign);
element_wise_binary_op_assign!(-=, SubAssign, sub_assign);
element_wise_binary_op_assign!(*=, MulAssign, mul_assign);
element_wise_binary_op_assign!(/=, DivAssign, div_assign);
impl std::ops::Neg for Vec3 {
type Output = Vec3;
fn neg(self) -> Vec3 {
Vec3 { x: -self.x, y: -self.y, z: -self.z }
}
}
pub fn length(v: Vec3) -> f32 {
(v.x * v.x + v.y * v.y + v.z * v.z).sqrt()
}
pub fn length_sq(v: Vec3) -> f32 {
v.x * v.x + v.y * v.y + v.z * v.z
}
pub fn normalized(v: Vec3) -> Vec3 {
let inv_len = 1.0 / length(v);
Vec3 {x: v.x * inv_len, y: v.y * inv_len, z: v.z * inv_len}
}
pub fn dot(a: Vec3, b: Vec3) -> f32 {
a.x * b.x + a.y * b.y + a.z * b.z
}
pub fn cross(a: Vec3, b: Vec3) -> Vec3 {
Vec3 {
x: (a.y * b.z - a.z * b.y),
y: -(a.x * b.z - a.z * b.x),
z: (a.x * b.y - a.y * b.x)
}
}
pub fn reflect(v: Vec3, n: Vec3) -> Vec3 {
v - 2.0 * dot(v,n) * n
}
pub fn refract(v: Vec3, n: Vec3, ni_over_nt: f32) -> Vec3 {
let cos_theta = f32::min(dot(-v, n), 1.0);
let r_out_perp = ni_over_nt * (v + cos_theta * n);
let r_out_para = -((1.0 - length_sq(r_out_perp)).abs().sqrt()) * n;
r_out_perp + r_out_para
}
/// Returns a random point within a unit-radius sphere.
// pub fn rand_in_unit_sphere() -> Vec3 {
// loop {
// let p = vec3![rand_in_range(-1.0, 1.0), rand_in_range(-1.0, 1.0), rand_in_range(-1.0, 1.0)];
// if length_sq(p) < 1.0 { return p };
// }
// }
// http://corysimon.github.io/articles/uniformdistn-on-sphere/
pub fn rand_in_unit_sphere() -> Vec3 {
let theta = std::f32::consts::TAU * rand_in_range(0.0, 1.0);
let phi = f32::acos(1.0 - 2.0 * rand_in_range(0.0, 1.0));
vec3![f32::sin(phi) * f32::cos(theta),
f32::sin(phi) * f32::sin(theta),
f32::cos(phi)]
}
pub fn rand_unit_vector() -> Vec3 {
normalized(rand_in_unit_sphere())
}
pub fn rand_in_unit_disk() -> Vec3 {
loop {
let p = vec3![rand_in_range(-1.0, 1.0), rand_in_range(-1.0, 1.0), 0.0];
if length_sq(p) < 1.0 { return p };
}
}
#[cfg(test)]
mod test {
use super::*;
macro_rules! assert_nearly_eq {
($v1: expr, $v2: expr, $epsilon: expr) => {
match (&$v1, &$v2, $epsilon) {
(lhs, rhs, eps) => {
let abs_diff = (lhs - rhs).abs();
if (abs_diff > eps) {
panic!("assert failed: {:?} - {:?} = {:?} <= {:?}",
lhs, rhs, abs_diff, eps);
}
}
}
};
($v1: expr, $v2: expr) => {
const DEFAULT_EPSILON: f32 = 0.000000001;
assert_nearly_eq!($v1, $v2, DEFAULT_EPSILON);
};
}
#[test]
fn test_next_power_of_n_le() {
let pow_4 = next_power_of_n_le(484, 4);
assert_eq!(pow_4, 256);
let pow_2 = next_power_of_n_le(72, 2);
assert_eq!(pow_2, 64);
let pow_2_noop = next_power_of_n_le(64, 2);
assert_eq!(pow_2_noop, 64);
}
#[test]
fn test_vec3_add() {
{
let a = Vec3 {x: 1.0, y: 0.0, z: 1.0};
let b = Vec3 {x: 0.0, y: 1.0, z: 0.0};
let c = Vec3 {x: 1.0, y: 1.0, z: 1.0};
assert!(a + b == c);
}
{
let a = Vec3 {x: 3.2, y: 0.0, z: 1.2};
let b = Vec3 {x: 1.4, y: 0.0, z: 2.3};
let c = Vec3 {x: 4.6, y: 0.0, z: 3.5};
assert!(a + b == c);
}
}
#[test]
fn test_vec3_sub() {
{
let a = Vec3 {x: 1.0, y: 1.0, z: 1.0};
let b = Vec3 {x: 1.0, y: 1.0, z: 1.0};
let c = Vec3 {x: 0.0, y: 0.0, z: 0.0};
assert!(a - b == c);
}
{
let a = Vec3 {x: 5.0, y: 4.0, z: 3.0};
let b = Vec3 {x: 2.0, y: 3.0, z: 5.5};
let c = Vec3 {x: 3.0, y: 1.0, z: -2.5};
assert!(a - b == c);
}
}
#[test]
fn test_vec3_length() {
{
let v = Vec3 {x: 1.0, y: 0.0, z: 0.0};
assert_eq!(length(v), 1.0);
}
{
let v = Vec3 {x: 3.0, y: 3.0, z: 3.0};
assert_nearly_eq!(length(v), 5.19615242270663188058);
}
}
#[test]
fn test_vec3_length_sq()
{
{
let v = Vec3 {x: 1.0, y: 0.0, z: 0.0};
assert_nearly_eq!(length_sq(v), 1.0);
}
{
let v = Vec3 {x: 3.0, y: 3.0, z: 3.0};
assert_nearly_eq!(length_sq(v), 27.0);
}
}
#[test]
fn test_vec3_normalize()
{
{
let v = Vec3 {x: 3.0, y: 3.0, z: 3.0};
assert_nearly_eq!(length_sq(normalized(v)), 1.0, 0.00001);
}
{
let v = Vec3 {x: 1.0, y: 1.0, z: 1.0};
assert_nearly_eq!(length_sq(normalized(v)), 1.0, 0.00001);
}
{
let v = Vec3 {x: 12.2, y: 5.255, z: 3.129};
assert_nearly_eq!(length_sq(normalized(v)), 1.0, 0.00001);
}
}
#[test]
fn test_vec3_dot()
{
{
let a = vec3![1.0, 0.0, 0.0];
let b = vec3![0.0, 1.0, 0.0];
assert_eq!(dot(a, b), 0.0);
}
{
let a = normalized(vec3![0.0, 2.0, 0.0]);
let b = normalized(vec3![0.0, 2.0, 0.0]);
assert_eq!(dot(a, b), 1.0);
}
{
let a = normalized(vec3![0.0, 0.0, 0.45]);
let b = normalized(vec3![0.0, 0.0, -0.45]);
assert_eq!(dot(a, b), -1.0);
}
}
#[test]
fn test_vec3_cross()
{
{
let a = vec3![1.0, 0.0, 0.0];
let b = vec3![0.0, 1.0, 0.0];
assert_eq!(cross(a, b), vec3![0.0, 0.0, 1.0]);
}
{
let a = vec3![1.0, 0.0, 0.0];
let b = vec3![1.0, 0.0, 0.0];
assert_eq!(cross(a, b), vec3![0.0, 0.0, 0.0]);
}
}
}
|
pub mod binary;
pub mod boolean;
pub mod date;
pub mod date_time;
pub mod duration;
pub mod float;
pub mod integer;
pub mod list;
pub mod map;
pub mod node;
pub mod null;
pub mod path;
pub mod point;
pub mod relation;
pub mod string;
pub mod time;
pub use binary::BoltBytes;
pub use boolean::BoltBoolean;
pub use date::BoltDate;
pub use date_time::{BoltDateTime, BoltDateTimeZoneId, BoltLocalDateTime};
pub use duration::BoltDuration;
pub use float::BoltFloat;
pub use integer::BoltInteger;
pub use list::BoltList;
pub use map::BoltMap;
pub use node::BoltNode;
pub use null::BoltNull;
pub use path::BoltPath;
pub use point::{BoltPoint2D, BoltPoint3D};
pub use relation::{BoltRelation, BoltUnboundedRelation};
pub use string::BoltString;
pub use time::{BoltLocalTime, BoltTime};
use crate::errors::*;
use crate::version::Version;
use bytes::Bytes;
use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
#[derive(Debug, PartialEq, Clone)]
pub enum BoltType {
String(BoltString),
Boolean(BoltBoolean),
Map(BoltMap),
Null(BoltNull),
Integer(BoltInteger),
Float(BoltFloat),
List(BoltList),
Node(BoltNode),
Relation(BoltRelation),
UnboundedRelation(BoltUnboundedRelation),
Point2D(BoltPoint2D),
Point3D(BoltPoint3D),
Bytes(BoltBytes),
Path(BoltPath),
Duration(BoltDuration),
Date(BoltDate),
Time(BoltTime),
LocalTime(BoltLocalTime),
DateTime(BoltDateTime),
LocalDateTime(BoltLocalDateTime),
DateTimeZoneId(BoltDateTimeZoneId),
}
impl Display for BoltType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let value = match self {
BoltType::String(s) => s.to_string(),
_ => "to_string not implemented".to_owned(),
};
write!(f, "{}", value)
}
}
impl BoltType {
pub fn into_bytes(self, version: Version) -> Result<Bytes> {
match self {
BoltType::Null(t) => t.into_bytes(version),
BoltType::Boolean(t) => t.into_bytes(version),
BoltType::Integer(t) => t.into_bytes(version),
BoltType::Float(t) => t.into_bytes(version),
BoltType::String(t) => t.into_bytes(version),
BoltType::List(t) => t.into_bytes(version),
BoltType::Point2D(t) => t.into_bytes(version),
BoltType::Point3D(t) => t.into_bytes(version),
BoltType::Map(t) => t.into_bytes(version),
BoltType::Node(t) => t.into_bytes(version),
BoltType::Path(t) => t.into_bytes(version),
BoltType::Relation(t) => t.into_bytes(version),
BoltType::UnboundedRelation(t) => t.into_bytes(version),
BoltType::Bytes(t) => t.into_bytes(version),
BoltType::Duration(t) => t.into_bytes(version),
BoltType::Date(t) => t.into_bytes(version),
BoltType::Time(t) => t.into_bytes(version),
BoltType::LocalTime(t) => t.into_bytes(version),
BoltType::DateTime(t) => t.into_bytes(version),
BoltType::LocalDateTime(t) => t.into_bytes(version),
BoltType::DateTimeZoneId(t) => t.into_bytes(version),
}
}
fn parse(version: Version, input: Rc<RefCell<Bytes>>) -> Result<BoltType> {
let bolt_type = match input {
input if BoltInteger::can_parse(version, input.clone()) => {
BoltType::Integer(BoltInteger::parse(version, input)?)
}
input if BoltFloat::can_parse(version, input.clone()) => {
BoltType::Float(BoltFloat::parse(version, input)?)
}
input if BoltString::can_parse(version, input.clone()) => {
BoltType::String(BoltString::parse(version, input)?)
}
input if BoltList::can_parse(version, input.clone()) => {
BoltType::List(BoltList::parse(version, input)?)
}
input if BoltMap::can_parse(version, input.clone()) => {
BoltType::Map(BoltMap::parse(version, input)?)
}
input if BoltNode::can_parse(version, input.clone()) => {
BoltType::Node(BoltNode::parse(version, input)?)
}
input if BoltBoolean::can_parse(version, input.clone()) => {
BoltType::Boolean(BoltBoolean::parse(version, input)?)
}
input if BoltNull::can_parse(version, input.clone()) => {
BoltType::Null(BoltNull::parse(version, input)?)
}
input if BoltPoint2D::can_parse(version, input.clone()) => {
BoltType::Point2D(BoltPoint2D::parse(version, input)?)
}
input if BoltPoint3D::can_parse(version, input.clone()) => {
BoltType::Point3D(BoltPoint3D::parse(version, input)?)
}
input if BoltBytes::can_parse(version, input.clone()) => {
BoltType::Bytes(BoltBytes::parse(version, input)?)
}
input if BoltPath::can_parse(version, input.clone()) => {
BoltType::Path(BoltPath::parse(version, input)?)
}
input if BoltDuration::can_parse(version, input.clone()) => {
BoltType::Duration(BoltDuration::parse(version, input)?)
}
input if BoltDate::can_parse(version, input.clone()) => {
BoltType::Date(BoltDate::parse(version, input)?)
}
input if BoltTime::can_parse(version, input.clone()) => {
BoltType::Time(BoltTime::parse(version, input)?)
}
input if BoltLocalTime::can_parse(version, input.clone()) => {
BoltType::LocalTime(BoltLocalTime::parse(version, input)?)
}
input if BoltDateTime::can_parse(version, input.clone()) => {
BoltType::DateTime(BoltDateTime::parse(version, input)?)
}
input if BoltLocalDateTime::can_parse(version, input.clone()) => {
BoltType::LocalDateTime(BoltLocalDateTime::parse(version, input)?)
}
input if BoltDateTimeZoneId::can_parse(version, input.clone()) => {
BoltType::DateTimeZoneId(BoltDateTimeZoneId::parse(version, input)?)
}
input if BoltUnboundedRelation::can_parse(version, input.clone()) => {
BoltType::UnboundedRelation(BoltUnboundedRelation::parse(version, input)?)
}
input if BoltRelation::can_parse(version, input.clone()) => {
BoltType::Relation(BoltRelation::parse(version, input)?)
}
_ => return Err(Error::UnknownType(format!("{:#04X?}", input.borrow()))),
};
Ok(bolt_type)
}
}
|
//! This module describes a game map.
use cursive;
use game_item;
use low_level;
use std::cmp::{max, min};
//use decorators::decorators;
use loggers::{log, logger};
//-------------------------------Constants------------------------------------//
pub enum Direction {
Left,
Right,
Up,
Down,
}
// `LOCAL_MAP_WIDTH` and `LOCAL_MAP_HEIGHT` must be divisible by 6 without residue!
// Otherwise happy debugging ;)
pub const LOCAL_MAP_WIDTH: usize = 78;
pub const LOCAL_MAP_HEIGHT: usize = 48;
const MAP_BORDER: usize = 2;
pub const MAP_WIDTH: usize = LOCAL_MAP_WIDTH * 2 + MAP_BORDER * 2;
pub const MAP_HEIGHT: usize = LOCAL_MAP_HEIGHT * 2 + MAP_BORDER * 2;
type Tile = u32;
pub const tileGrass: Tile = 0;
const tileGround: Tile = 1;
const tileStairsUp: Tile = 2;
const tileStairsDown: Tile = 3;
const tileTrap: Tile = 4;
const tileLive: Tile = 5;
const tileFirstStopTile: Tile = 6;
const tileTree: Tile = tileFirstStopTile;
const tileStone: Tile = tileFirstStopTile + 1;
pub const tileLast: Tile = tileFirstStopTile + 1;
pub const TrapTileSet: [Tile; 1usize] = [tileTrap; 1usize];
pub const LiveTileSet: [Tile; 1usize] = [tileLive; 1usize];
pub const MaxDungeonLevel: usize = 7;
pub const SCROLL_DELTA: usize = 2;
//-------------------------------Data types-----------------------------------//
#[derive(Debug)]
pub struct TMapCell {
pub Tile: Tile,
pub IsVisible: bool,
}
impl Copy for TMapCell {}
impl Clone for TMapCell {
fn clone(&self) -> TMapCell {
*self
}
}
type Cells = [[TMapCell; MAP_HEIGHT as usize]; MAP_WIDTH as usize];
pub struct TMap {
pub Cells: Cells,
pub LocalMapLeft: usize,
pub LocalMapTop: usize,
}
impl Copy for TMap {}
impl Clone for TMap {
fn clone(&self) -> TMap {
*self
}
}
pub type TGameMap = [TMap; MaxDungeonLevel as usize];
pub static mut GAME_MAP: TGameMap = [TMap {
Cells: [[TMapCell {
Tile: tileGrass,
IsVisible: false,
}; MAP_HEIGHT as usize]; MAP_WIDTH as usize],
LocalMapLeft: 0,
LocalMapTop: 0,
}; MaxDungeonLevel as usize];
pub static mut CUR_MAP: usize = 0;
//-------------------------------Functions------------------------------------//
pub fn MapGeneration(MapLevel: usize) {
unsafe {
CUR_MAP = MapLevel;
}
let cur_map = get_mut_ref_curmap!();
let mut n = 0usize;
for x in 0..MAP_WIDTH {
for y in 0..MAP_HEIGHT {
let mut cell = get_mut_ref_cell!(x, y);
if (x < MAP_BORDER)
|| (x > MAP_WIDTH - MAP_BORDER - 1)
|| (y < MAP_BORDER)
|| (y > MAP_HEIGHT - MAP_BORDER - 1)
{
cell.Tile = tileStone;
} else {
if random(0, 100) < 32 {
cell.Tile = tileTree;
} else if random(0, 2) == 1 {
cell.Tile = tileGrass;
} else {
cell.Tile = tileGround;
}
if random(0, 50) == 0 {
if random(0, 2) == 0 {
cell.Tile = tileTrap;
} else {
cell.Tile = tileLive;
}
}
if FreeTile(&get_ref_cell!(x, y).Tile) {
if random(0, 100) == 0 {
if n < game_item::MaxItems {
unsafe {
let mut item = game_item::ItemTypes[random(0, game_item::MaxItemTypes)];
item.x = x;
item.y = y;
item.IsVisible = false;
game_item::ITEMS[n] = Some(item);
}
}
n += 1;
}
}
};
// All cells is invisible by default.
cell.IsVisible = false;
}
}
cur_map.LocalMapLeft = MAP_WIDTH / 3;
cur_map.LocalMapTop = MAP_HEIGHT / 3;
if MapLevel < MaxDungeonLevel {
for i in 0..2 {
let (x, y) = FreeMapPoint(&cur_map);
cur_map.Cells[x][y].Tile = tileStairsDown;
}
};
if MapLevel > 1 {
let (x, y) = FreeMapPoint(&cur_map);
cur_map.Cells[x][y].Tile = tileStairsUp;
};
}
pub fn ShowMap(app: &mut cursive::Cursive) {
let cur_map = get_ref_curmap!();
low_level::PrepareMap();
for x in cur_map.LocalMapLeft..cur_map.LocalMapLeft + LOCAL_MAP_WIDTH {
for y in cur_map.LocalMapTop..cur_map.LocalMapTop + LOCAL_MAP_HEIGHT {
low_level::ShowCell(app, get_ref_cell!(x, y), x, y);
}
}
}
pub fn ScrollMap(direction: Direction) {
let cur_map = get_mut_ref_curmap!();
let (mut new_local_map_left, mut new_local_map_top) =
(cur_map.LocalMapLeft, cur_map.LocalMapTop);
match direction {
Direction::Left => {
new_local_map_left = max(
0,
cur_map.LocalMapLeft as i32 - (LOCAL_MAP_WIDTH / 2) as i32,
) as usize;
}
Direction::Right => {
new_local_map_left = min(
MAP_WIDTH - LOCAL_MAP_WIDTH,
cur_map.LocalMapLeft + LOCAL_MAP_WIDTH / 2,
);
}
Direction::Up => {
new_local_map_top = max(
0,
cur_map.LocalMapTop as i32 - (LOCAL_MAP_HEIGHT / 2) as i32,
) as usize;
}
Direction::Down => {
new_local_map_top = min(
MAP_HEIGHT - LOCAL_MAP_HEIGHT,
cur_map.LocalMapTop + LOCAL_MAP_HEIGHT / 2,
);
}
}
let dx = cur_map.LocalMapLeft - new_local_map_left;
let dy = cur_map.LocalMapTop - new_local_map_top;
cur_map.LocalMapLeft = new_local_map_left;
cur_map.LocalMapTop = new_local_map_top;
unsafe {
low_level::CURSOR.x += dx;
low_level::CURSOR.y += dy;
}
}
/// Generates a number from a range from `start` to `end` not including `end`.
///
/// # Examples
///
/// ```
/// random(0, 5); // -> 0 or 1 or 2 or 3 or 4
/// ```
pub fn random(start: usize, end: usize) -> usize {
use rand::seq::sample_iter;
use rand::thread_rng;
if end <= start {
panic!("End={} should be more than Start={}", end, start)
};
let mut rng = thread_rng();
sample_iter(&mut rng, start..end, 1).unwrap()[0]
}
/// Checks the possibility of passing through a map cell.
///
/// # Examples
///
/// ```
/// FreeTile(tileLive); // -> true
/// ```
pub fn FreeTile(tile: &Tile) -> bool {
tile < &tileFirstStopTile
}
/// Looks up and returns coordinates of a first available free map cell.
///
/// # Examples
///
/// ```
/// let (x, y) = FreeMapPoint(get_ref_curmap!());
/// ```
pub fn FreeMapPoint(cur_map: &TMap) -> (usize, usize) {
let curhero = get_ref_curhero!();
loop {
let (x, y) = (
random(MAP_BORDER, MAP_WIDTH - MAP_BORDER - 1),
random(MAP_BORDER, MAP_HEIGHT - MAP_BORDER - 1),
);
if FreeTile(&cur_map.Cells[x][y].Tile) {
if x != curhero.x || y != curhero.y { break (x, y); } else { continue; }
};
}
}
/// Checks a location of a map cell with the `x` and `y` coordinates in the visible part of a map.
///
/// # Examples
///
/// ```
/// VisiblePoint(5, 7); // -> bool
/// ```
pub fn VisiblePoint(x: usize, y: usize) -> bool {
let cur_map = get_ref_curmap!();
get_ref_cell!(x, y).IsVisible
&& x >= cur_map.LocalMapLeft
&& x < cur_map.LocalMapLeft + LOCAL_MAP_WIDTH
&& y >= cur_map.LocalMapTop
&& y < cur_map.LocalMapTop + LOCAL_MAP_HEIGHT
}
|
/// ACK packets are acknowledged by DATA or ERROR packets.
/// the opcode is 4.
///
/// The block number in an ACK echoes
/// the block number of the DATA packet being acknowledged.
///
/// A WRQ is acknowledged with an ACK packet having a
/// block number of zero.
use crate::tftp::shared::{Deserializable, Serializable, TFTPPacket, TFTPParseError, OP_ACK};
use super::byteorder::{ByteOrder, NetworkEndian, WriteBytesExt};
const ACK_LEN: usize = 4;
const BLK_NUM_OFFSET: usize = 2;
#[derive(Debug, Eq, PartialEq)]
pub struct AckPacket {
op: u16,
blk: u16,
}
impl AckPacket {
pub fn new(blk: u16) -> Self {
AckPacket { op: OP_ACK, blk }
}
pub fn blk(&self) -> u16 {
self.blk
}
}
impl Serializable for AckPacket {
fn box_serialize(self: Box<Self>) -> Vec<u8> {
self.serialize()
}
fn serialize(self) -> Vec<u8> {
let mut buf = Vec::with_capacity(ACK_LEN);
buf.write_u16::<NetworkEndian>(self.op).unwrap();
buf.write_u16::<NetworkEndian>(self.blk).unwrap();
buf
}
}
impl Deserializable for AckPacket {
fn deserialize(buf: &[u8]) -> Result<TFTPPacket, TFTPParseError> {
let op = NetworkEndian::read_u16(buf);
if op != OP_ACK {
return Err(TFTPParseError::new(
format!("Bad OP code! [{}]", op).as_str(),
));
}
let blk = NetworkEndian::read_u16(&buf[BLK_NUM_OFFSET..]);
Ok(TFTPPacket::ACK(AckPacket::new(blk)))
}
}
#[cfg(test)]
mod tests {
use crate::tftp::shared::ack_packet::AckPacket;
use crate::tftp::shared::{Deserializable, Serializable, TFTPPacket, OP_ACK};
use super::super::byteorder::{NetworkEndian, WriteBytesExt};
#[test]
fn serialize_ack_packet() {
let blk = 42;
let p = AckPacket::new(blk);
let mut buf: Vec<u8> = Vec::new();
buf.write_u16::<NetworkEndian>(OP_ACK).unwrap();
buf.write_u16::<NetworkEndian>(blk).unwrap();
assert_eq!(Box::new(p).serialize(), buf);
}
#[test]
fn deserialize_ack_packet() {
let blk = 42;
let mut buf: Vec<u8> = Vec::new();
buf.write_u16::<NetworkEndian>(OP_ACK).unwrap();
buf.write_u16::<NetworkEndian>(blk).unwrap();
let p = AckPacket::new(blk);
if let TFTPPacket::ACK(d) = AckPacket::deserialize(&mut buf).unwrap() {
assert_eq!(d, p);
}
}
#[test]
fn deserialize_error() {
let blk = 42;
let bad_op = OP_ACK + 1;
let mut buf: Vec<u8> = Vec::new();
buf.write_u16::<NetworkEndian>(bad_op).unwrap();
buf.write_u16::<NetworkEndian>(blk).unwrap();
let p = AckPacket::deserialize(&mut buf).unwrap_err();
assert_eq!(p.details, format!("Bad OP code! [{}]", bad_op).as_str())
}
}
|
use std::{cell::RefCell, collections::HashMap, rc::Rc};
use crate::{
interpreter::RuntimeResult, literal::Literal, runtime_error::RuntimeError, token::Token,
};
#[derive(PartialEq, Debug, Clone, Eq)]
pub struct Environment {
values: HashMap<String, Literal>,
enclosing: Option<Rc<RefCell<Environment>>>,
}
impl Environment {
pub fn new() -> Rc<RefCell<Self>> {
Rc::new(RefCell::new(Self {
values: HashMap::new(),
enclosing: None,
}))
}
pub fn new_with(enclosing: Rc<RefCell<Self>>) -> Rc<RefCell<Self>> {
Rc::new(RefCell::new(Self {
values: HashMap::new(),
enclosing: Some(enclosing),
}))
}
pub fn define(&mut self, name: String, value: Literal) {
self.values.insert(name, value);
}
pub fn get(&self, name: &Token) -> RuntimeResult<Literal> {
let key = name.lexeme.as_str();
if let Some(val) = self.values.get(key) {
return Ok(val.clone());
} else if let Some(enclosing) = &self.enclosing {
let env = enclosing.try_borrow().unwrap();
return env.get(name);
}
Err(RuntimeError::new(
name.to_owned(),
format!("Undefined variable '{}'.", name.lexeme.to_owned()),
))
}
pub fn assign_at(
&mut self,
distance: usize,
token: Token,
value: Literal,
) -> RuntimeResult<()> {
self.ancestor(distance)
.try_borrow_mut()
.unwrap()
.values
.insert(token.lexeme, value)
.unwrap();
Ok(())
}
pub fn assign(&mut self, token: Token, value: Literal) -> RuntimeResult<()> {
if let std::collections::hash_map::Entry::Occupied(mut e) =
self.values.entry(token.lexeme.clone())
{
e.insert(value);
return Ok(());
} else if let Some(enclosing) = &mut self.enclosing {
return enclosing.borrow_mut().assign(token, value);
}
Err(RuntimeError::new(
token.clone(),
format!("Undefined variable '{}'.", token.lexeme),
))
}
pub fn get_at(&self, distance: usize, name: &str) -> RuntimeResult<Literal> {
let ancestor = self.ancestor(distance);
let borrowed_ancestor = ancestor.try_borrow().unwrap();
let value = borrowed_ancestor.values.get(name).unwrap();
Ok(value.clone())
}
fn ancestor(&self, distance: usize) -> Rc<RefCell<Environment>> {
let mut env = Rc::new(RefCell::new(self.clone()));
for _ in 0..distance {
env = self.enclosing.clone().unwrap()
}
env
}
}
|
use std::sync::{
Arc,
MutexGuard,
};
use log::trace;
use sourcerenderer_core::graphics::*;
use sourcerenderer_core::platform::{
Event,
Platform,
Window,
};
use sourcerenderer_core::{
Console,
ThreadPoolBuilder,
};
use crate::asset::loaders::{
FSContainer,
ShaderLoader,
};
use crate::asset::AssetManager;
use crate::game::Game;
use crate::input::Input;
use crate::renderer::{
LateLatchCamera,
LateLatching,
Renderer,
RendererInterface,
};
const TICK_RATE: u32 = 5;
pub struct Engine<P: Platform> {
renderer: Arc<Renderer<P>>,
game: Arc<Game<P>>,
asset_manager: Arc<AssetManager<P>>,
input: Arc<Input>,
late_latching: Option<Arc<dyn LateLatching<P::GraphicsBackend>>>,
console: Arc<Console>,
}
impl<P: Platform> Engine<P> {
#[cfg(not(feature = "web"))]
pub fn initialize_global() {
let cores = num_cpus::get();
ThreadPoolBuilder::new()
.num_threads(cores - 2)
.build_global()
.unwrap();
}
#[cfg(feature = "web")]
pub fn initialize_global() {}
pub fn run(platform: &P) -> Self {
let instance = platform
.create_graphics(false)
.expect("Failed to initialize graphics");
let surface = platform.window().create_surface(instance.clone());
let console = Arc::new(Console::new());
let input = Arc::new(Input::new());
let mut adapters = instance.clone().list_adapters();
let device = Arc::new(adapters.remove(0).create_device(&surface));
let swapchain = Arc::new(platform.window().create_swapchain(true, &device, &surface));
let asset_manager = AssetManager::<P>::new(platform, &device);
asset_manager.add_container(Box::new(FSContainer::new(platform, &asset_manager)));
asset_manager.add_loader(Box::new(ShaderLoader::new()));
let late_latching = Arc::new(LateLatchCamera::new(
device.as_ref(),
swapchain.width() as f32 / swapchain.height() as f32,
std::f32::consts::FRAC_PI_2,
));
let late_latching_trait_obj =
late_latching.clone() as Arc<dyn LateLatching<P::GraphicsBackend>>;
let renderer = Renderer::<P>::run(
platform,
&instance,
&device,
&swapchain,
&asset_manager,
&input,
Some(&late_latching_trait_obj),
&console,
);
let game = Game::<P>::run(platform, &input, &renderer, &asset_manager, TICK_RATE);
Self {
renderer,
game,
asset_manager,
input,
late_latching: Some(late_latching),
console,
}
}
pub fn is_mouse_locked(&self) -> bool {
self.input.poll().mouse_locked()
}
pub fn dispatch_event(&self, event: Event<P>) {
match event {
Event::MouseMoved(_)
| Event::KeyUp(_)
| Event::KeyDown(_)
| Event::FingerDown(_)
| Event::FingerUp(_)
| Event::FingerMoved { .. } => {
self.input.process_input_event(event);
}
Event::Quit => {
self.stop();
}
Event::WindowMinimized
| Event::WindowRestored(_)
| Event::WindowSizeChanged(_)
| Event::SurfaceChanged(_) => {
let event_1 = event.clone();
self.game.dispatch_window_event(event_1);
self.renderer.dispatch_window_event(event);
}
}
}
pub fn instance(&self) -> &Arc<<P::GraphicsBackend as Backend>::Instance> {
self.renderer.instance()
}
pub fn stop(&self) {
trace!("Stopping engine");
self.asset_manager.stop();
self.renderer.unblock_game_thread();
self.game.stop();
self.renderer.stop();
}
pub fn is_running(&self) -> bool {
if !self.game.is_running() || !self.renderer.is_running() {
self.stop(); // if just one system dies, kill the others too
return false;
}
true
}
pub fn device(&self) -> &Arc<<P::GraphicsBackend as Backend>::Device> {
self.renderer.device()
}
pub fn surface(&self) -> MutexGuard<Arc<<P::GraphicsBackend as Backend>::Surface>> {
self.renderer.surface()
}
pub fn frame(&self) {
self.game.update(&self.renderer);
self.renderer.render();
}
pub fn console(&self) -> &Console {
self.console.as_ref()
}
}
|
use std::io;
const MAX_LIST_ITEMS: usize = 6;
pub fn list() -> Vec<String>{
let mut items = Vec::new();
let mut read_in_str = String::new();
let mut count: usize = MAX_LIST_ITEMS + 1;
while count > MAX_LIST_ITEMS {
println!("How many items are in your list? (Max size is {})", MAX_LIST_ITEMS);
io::stdin().read_line(&mut read_in_str).expect("unable to read item count.");
count = read_in_str.trim().parse().expect("please enter an integer.");
}
for _ in 0..count {
let mut item = String::new();
io::stdin().read_line(&mut item).expect("unable to read guess.");
items.push(item.trim().to_string());
}
return items;
} |
fn main() {
println!(r"cargo:rustc-link-search=../libtts");
println!(r"cargo:rustc-link-search=../libtts/flite/lib");
println!(r"cargo:rustc-link-lib=static=flite_cmu_us_slt");
println!(r"cargo:rustc-link-lib=static=flite_usenglish");
println!(r"cargo:rustc-link-lib=static=flite_cmulex");
println!(r"cargo:rustc-link-lib=static=flite");
println!(r"cargo:rustc-link-lib=m");
//println!(r"cargo:rustc-link-lib=SDL2");
//println!(r"cargo:rustc-link-lib=SDL2_mixer");
//println!(r"cargo:rustc-link-lib=asound");
println!(r"cargo:rustc-link-lib=stdc++");
}
|
//Defining and naming opcodes
//Adressing modes: immediate, absolute, zeropage absolute, implied, Accumulator, indexed, zeropage indexed, indirect, pre-indexed indirect, post-indexed indirect, relative
//Adressing lettercuts: IMM, ABS, ZBS, IMP, ACC, IND, ZND, INR, PNR, PID, REL
//enum Opcode, ordered by opcode type, NOT hex
//Initializing registers
let mut reg_A: i8;
let mut reg_X: i8;
let mut reg_Y: i8;
let mut reg_SP: i8;
let mut reg_PC: i16;
let mut memory = [1,2,3] //TEMPORARY MEMORY BANK
fn updateCPU() {
reg_PC = reset_vector
execute()
}
//AddMemAccCarry, //ADC Add Memory to Accumulator with Carry
// AndMemAcc, //AND "AND" Memory with Accumulator
// ShftLOneMemOrAcc, //ASL Shift Left One Bit (Memory or Accumulator)
// BrOnCarryClr, //BCC Branch on Carry Clear
// BrOnCarrySet, //BCS Branch on Carry Set
// BrOnResZero, //BEQ Branch on Result Zero
// TestBitMemAcc, //BIT Test Bits in Memory with Accumulator
// BrOnResMinus, //BMI Branch on Result Minus
// BrOnResNoZero, //BNE Branch on Result not Zero
// BrOnResPlus, //BPL Branch on Result Plus
// ForceBreak, //BRK Force Break
// BrOverflowClr, //BVC Branch on Overflow Clear2
// BrOverflowSet, //BVS Branch on Overflow Set
// ClrCarryFlag, //CLC Clear Carry Flag
// ClrDecMode, //CLD Clear Decimal Mode
// ClrIntrDisableBit, //CLI Clear interrupt Disable Bit
// ClrOverflowFlag, //CLV Clear Overflow Flag
// CompMemAcc, //CMP Compare Memory and Accumulator
// CompMemX, //CPX Compare Memory and Index X
// CompMemy, //CPY Compare Memory and Index Y
// DecMemOne, //DEC Decrement Memory by One
// DecXOne, //DEX Decrement Index X by One
// DecYOne, //DEY Decrement Index Y by One
// EorMemw_Acc, //EOR "Exclusive-Or" Memory with Accumulator
// IncMemOne, //INC Increment Memory by One
// IncXOne, //INX Increment Index X by One
// IncYOne, //INY Increment Index Y by One
// JmpNoAddress, //JMP Jump to New Location
// JmpWAddress, //JSR Jump to New Location Saving Return Address
// LdAccWMem, //LDA Load Accumulator with Memory
// LdXWMem, //LDX Load Index X with Memory
// LdYWMem, //LDY Load Index Y with Memory
// ShftROneMemOrAcc, //LSR Shift Right One Bit (Memory or Accumulator)
// NoOp, //NOP No Operation 2
// OrMemWAcc, //ORA "OR" Memory with Accumulator
// PshAccStack, //PHA Push Accumulator on Stack
// PshProstatusStack, //PHP Push Processor Status on Stack
// PullAccStack, //PLA Pull Accumulator from Stack
// PullProstatusStack, //PLP Pull Processor Status from Stack
// RotOneBitL, //ROL Rotate One Bit Left (Memory or Accumulator)
// RotOneBitR, //ROR Rotate One Bit Right (Memory or Accumulator)
// RetInterrupt, //RTI Return from Interrupt
// RetSubroutine, //RTS Return from Subroutine
// SubMemFromAccWBorrow, //SBC Subtract Memory from Accumulator with Borrow
// SetCarryFlag, //SEC Set Carry Flag
// SetDecMode, //SED Set Decimal Mode
// SetInterruptDisatus, //SEI Set Interrupt Disable Status
// StrAccMem, //STA Store Accumulator in Memory
// StrXMem, //STX Store Index X in Memory
// StrYMem, //STY Store Index Y in Memory
// TranAX, //TAX Transfer Accumulator to Index X
// TranAccY, //TAY Transfer Accumulator to Index Y
// TranSpX, //TSX Transfer Stack Pointer to Index X
// TranXAcc, //TXA Transfer Index X to Accumulator
// TranXSp, //TXS Transfer Index X to Stack Pointer
// TranYAcc, //TYA Transfer Index Y to Accumulator
|
use std::fs::File;
use std::io::Write;
use std::path::Path;
use std::io::Read;
use std::io::Error;
use model::world::World;
// Returns the file content as a string
pub fn read_file(filepath: &str) -> String {
let path = Path::new(filepath);
let display = path.display();
let mut file = match File::open(&path) {
Err(why) => panic!("couldn't open {}: {}", display, &why),
Ok(file) => file,
};
let mut s = String::new();
match file.read_to_string(&mut s) {
Err(why) => panic!("Couldn't read {}: {}", display, &why),
Ok(_) => s
}
}
pub fn write_stock(filepath: &str, world: &World) -> Result<(), Error> {
let path = Path::new(filepath);
let mut f = File::create(&path).unwrap();
try!(f.write(b"Sector;Name;Ticker\n"));
for biz in &world.companies {
let begin = format!("{};{};{};", biz.sector, biz.name, biz.ticker);
let values_as_str : Vec<String>= world.stocks.
get_all(&biz.ticker).iter().map(|x| x.to_string()).collect();
let end = values_as_str.join(";");
let end2 = end + &"\n";
let final_line = begin + &end2;
try!(f.write(&final_line.into_bytes()));
}
try!(f.sync_all());
Ok(())
}
pub fn write_report(filepath: &str, world: &World) -> Result<(), Error>{
let path = Path::new(filepath);
let mut f = File::create(&path).unwrap();
try!(f.write(b"Name;Performance;Perceived;Shares outstanding;Market cap;Current value"));
for biz in &world.companies {
let line = format!(
"{};{};{};{};{};{}\n", biz, biz.performance,
biz.perception, biz.shares_outstanding,
biz.capitalisation, biz.get_current_stock_value()
);
try!(f.write(&line.into_bytes()));
}
try!(f.sync_all());
Ok(())
}
|
// Software rendering pipeline
//
// For each mesh m
// For each vertex v (dim 4) in m
// 1) Model to world space (MODEL matrix 4x4)
// 2) World to camera space (VIEW matrix 4x4)
// 3) Camera to homogeneous clip space (PROJECTION matrix 4x4), w = 1
// 4) Clipping + perspective divide (normalization) => NDC space [-1, 1]
// 5) Viewport transform => raster space [0, W-1, 0, H-1]
use na::{Matrix3x4, Matrix4, RowVector4, Vector3, Vector4};
/// Renderable represents any model that can be drawn to a display buffer
pub trait Renderable {
/// Draw the model to a display buffer (render target)
///
/// * `buffer` - Display buffer (render target)
fn render(&self, buffer: &mut DisplayBuffer);
}
#[derive(Copy, Clone)]
pub struct Vertex<T: Copy> {
/// Color of the vertex
pub color: Color,
/// Position of the vertex
pub position: T,
/// Normal vector of the vertex
pub normal: Vector3<f32>,
}
pub struct Face<T: Copy> {
/// Vertex of a triangle
pub v0: Vertex<T>,
/// Vertex of a triangle
pub v1: Vertex<T>,
/// Vertex of a triangle
pub v2: Vertex<T>,
}
impl Face<Vector4<f32>> {
/// Perform a linear transformation to all vertices of the triangle
pub fn transform(&self, m: Matrix4<f32>) -> Face<Vector4<f32>> {
// Normal vectors cannot simply be transformed with the matrix m like
// vertex coordinates. Instead the scales must be inverted. So when we
// scale the vertices by factor x in any axis, we must scale the normals
// by 1/x. This is achieved by transforming the normals using the
// inverse transpose of matrix m
let m_normal = m
.fixed_slice::<nalgebra::U3, nalgebra::U3>(0, 0)
.try_inverse()
.expect("Could not invert matrix")
.transpose();
Face {
v0: Vertex {
position: m * self.v0.position,
color: self.v0.color,
normal: m_normal * self.v0.normal,
},
v1: Vertex {
position: m * self.v1.position,
color: self.v1.color,
normal: m_normal * self.v1.normal,
},
v2: Vertex {
position: m * self.v2.position,
color: self.v2.color,
normal: m_normal * self.v2.normal,
},
}
}
}
fn build_perspective_matrix(n: f32, f: f32, angle_of_view: f32, aspect_ratio: f32) -> Matrix4<f32> {
let deg_to_rad = ::std::f32::consts::PI / 180.0;
let size = n * (deg_to_rad * angle_of_view / 2.0).tan();
let l = -size;
let r = size;
let b = -size / aspect_ratio;
let t = size / aspect_ratio;
return Matrix4::from_rows(&[
RowVector4::new(2.0 * n / (r - l), 0.0, (r + l) / (r - l), 0.0),
RowVector4::new(0.0, 2.0 * n / (t - b), (t + b) / (t - b), 0.0),
RowVector4::new(0.0, 0.0, -(f + n) / (f - n), -(2.0 * f * n) / (f - n)),
RowVector4::new(0.0, 0.0, -1.0, 0.0),
]);
}
fn build_view_matrix(eye: Vector3<f32>, lookat: Vector3<f32>, up: Vector3<f32>) -> Matrix4<f32> {
// Rotate so that the line of sight from the eye position to the target maps to the z axis.
// Camera up direction maps to y axis. x- axis is defined from the other two by cross
// product
// Unit vectors in camera space
let z = (lookat - eye).normalize();
let x = (up.cross(&z)).normalize();
let y = (z.cross(&x)).normalize();
// The view matrix is the inverse of a model matrix that would transform a model of the
// camera into world space (transformation and rotation)
// This is an orientation matrix that is transposed. Transpose effectively performs
// inversion. This achieves the effect that the world rotates around the camera
let rotation = Matrix4::from_rows(&[
RowVector4::new(x.x, x.y, x.z, 0.0),
RowVector4::new(y.x, y.y, y.z, 0.0),
RowVector4::new(z.x, z.y, z.z, 0.0),
RowVector4::new(0.0, 0.0, 0.0, 1.0),
]);
// Translate to the inverse of the eye position (the world moves in the opposite direction
// around the camera that is fixed)
let translation = Matrix4::from_rows(&[
RowVector4::new(1.0, 0.0, 0.0, -eye.x),
RowVector4::new(0.0, 1.0, 0.0, -eye.y),
RowVector4::new(0.0, 0.0, 1.0, -eye.z),
RowVector4::new(0.0, 0.0, 0.0, 1.0),
]);
// Use inverse multiplication order to produce inversed combined matrix
return rotation * translation;
}
/// Color in RGBA8888 format
#[derive(Copy, Clone)]
pub struct Color {
/// Red component intensity
pub r: u8,
/// Green component intensity
pub g: u8,
/// Blue component intensity
pub b: u8,
/// Alpha value (0 - fully transparent, 255 - fully opaque)
pub a: u8,
}
/// Display buffer defines a memory area that is used for rendering a raw image
pub struct DisplayBuffer {
/// Width of the display area in pixels
pub width: usize,
/// Height of the display area in pixels
pub height: usize,
/// Bytes per pixel
pub bpp: usize,
/// Contents of the buffer (pixel data)
pub data: Box<[u8]>,
/// Z/depth buffer
pub z_buffer: Box<[f32]>,
}
impl DisplayBuffer {
pub fn new(width: usize, height: usize, bpp: usize) -> DisplayBuffer {
return DisplayBuffer {
height: height,
width: width,
bpp: bpp,
data: vec![0; width * height * bpp].into_boxed_slice(),
z_buffer: vec![std::f32::MIN; width * height].into_boxed_slice(),
};
}
/// return the size of the buffer in bytes
pub fn size(&self) -> usize {
return self.height * self.width * self.bpp;
}
/// return the number of pixels
pub fn num_pixels(&self) -> usize {
return self.height * self.width;
}
/// Reset the contents of the buffer so that all pixels are black
pub fn clear(&mut self) {
self.data = vec![0; self.width * self.height * self.bpp].into_boxed_slice();
// this takes a lot of time when the initialization value is not 0.0
self.z_buffer = vec![std::f32::MIN; self.width * self.height].into_boxed_slice();
}
/// Set a single pixel to a desired color
///
/// # Arguments
///
/// * `x` - X coordinate in pixels, value 0 corresponds to left edge
/// * `y` - Y coordinate in pixels, value 0 correspoonds to bottom edge
/// * 'color' - Color of the pixel
pub fn set_pixel(&mut self, x: usize, y: usize, z: f32, color: Color) {
assert!(x < self.width);
assert!(y < self.height);
let index: usize = (self.height - y - 1) * self.width + x;
if index < self.num_pixels() {
if self.z_buffer[index] < z {
self.z_buffer[index] = z;
self.data[index * self.bpp] = color.r;
self.data[index * self.bpp + 1] = color.g;
self.data[index * self.bpp + 2] = color.b;
self.data[index * self.bpp + 3] = color.a;
}
}
}
}
/// A mesh is a collection of triangles that form a 3D surface
pub struct Mesh {
/// World position of the center of the mesh
pub position: Vector4<f32>,
/// Rotation of the mesh around all 3 axis vectors
pub angle: Vector3<f32>,
/// Triangle faces that make up the mesh surface
pub faces: Vec<Face<Vector4<f32>>>,
}
impl Mesh {
pub fn new() -> Mesh {
return Mesh {
position: Vector4::new(0.0, 0.0, 0.0, 1.0),
angle: Vector3::new(0.0, 0.0, 0.0),
faces: Vec::new(),
};
}
/// Render a mesh into a display buffer
///
/// # Arguments
///
/// * `eye` - Position of the camera eye
/// * 'lookat' - Focus point of the eye
/// * `buffer` - Display buffer (render target)
pub fn render(
self: &Mesh,
eye: Vector3<f32>,
lookat: Vector3<f32>,
buffer: &mut DisplayBuffer,
) {
let m_rot_x = Matrix4::from_rows(&[
RowVector4::new(1.0, 0.0, 0.0, 0.0),
RowVector4::new(0.0, self.angle.x.cos(), self.angle.x.sin(), 0.0),
RowVector4::new(0.0, -self.angle.x.sin(), self.angle.x.cos(), 0.0),
RowVector4::new(0.0, 0.0, 0.0, 1.0),
]);
let m_rot_y = Matrix4::from_rows(&[
RowVector4::new(self.angle.y.cos(), 0.0, -self.angle.y.sin(), 0.0),
RowVector4::new(0.0, 1.0, 0.0, 0.0),
RowVector4::new(self.angle.y.sin(), 0.0, self.angle.y.cos(), 0.0),
RowVector4::new(0.0, 0.0, 0.0, 1.0),
]);
let m_rot_z = Matrix4::from_rows(&[
RowVector4::new(self.angle.z.cos(), -self.angle.z.sin(), 0.0, 0.0),
RowVector4::new(self.angle.z.sin(), self.angle.z.cos(), 0.0, 0.0),
RowVector4::new(0.0, 0.0, 1.0, 0.0),
RowVector4::new(0.0, 0.0, 0.0, 1.0),
]);
let m_trans = Matrix4::from_rows(&[
RowVector4::new(1.0, 0.0, 0.0, self.position.x),
RowVector4::new(0.0, 1.0, 0.0, self.position.y),
RowVector4::new(0.0, 0.0, 1.0, self.position.z),
RowVector4::new(0.0, 0.0, 0.0, 1.0),
]);
let model = m_trans * m_rot_z * m_rot_y * m_rot_x;
let aspect_ratio = (buffer.width as f32) / (buffer.height as f32);
let view: Matrix4<f32> = build_view_matrix(eye, lookat, Vector3::new(0.0, 1.0, 0.0));
let projection: Matrix4<f32> = build_perspective_matrix(0.1, 5.0, 78.0, aspect_ratio);
for t in self.faces.iter() {
let face_world = t.transform(model);
let reduce_dim = Matrix3x4::from_rows(&[
RowVector4::new(1.0, 0.0, 0.0, 0.0),
RowVector4::new(0.0, 1.0, 0.0, 0.0),
RowVector4::new(0.0, 0.0, 1.0, 0.0),
]);
let triangle_world_3d = Face {
v0: Vertex {
position: reduce_dim * face_world.v0.position,
color: face_world.v0.color,
normal: face_world.v0.normal,
},
v1: Vertex {
position: reduce_dim * face_world.v1.position,
color: face_world.v1.color,
normal: face_world.v1.normal,
},
v2: Vertex {
position: reduce_dim * face_world.v2.position,
color: face_world.v2.color,
normal: face_world.v2.normal,
},
};
// Light vector is a unit vector from the mesh to the light source.
let brightness_v0 = (eye - triangle_world_3d.v0.position)
.normalize()
.dot(&triangle_world_3d.v0.normal);
let brightness_v1 = (eye - triangle_world_3d.v1.position)
.normalize()
.dot(&triangle_world_3d.v1.normal);
let brightness_v2 = (eye - triangle_world_3d.v2.position)
.normalize()
.dot(&triangle_world_3d.v2.normal);
assert!(brightness_v0 <= 1.0);
assert!(brightness_v1 <= 1.0);
assert!(brightness_v2 <= 1.0);
// If the dot product is positive, the light is hitting the outer
// surface of the mesh. In this case the value of the dot product
// determines the intensity of the reflected light. If the dot
// product is negative, the light is hitting the inner surface of
// the mesh and we can simply ignore the triangle (not render it)
if brightness_v0 > 0.0 || brightness_v1 > 0.0 || brightness_v2 > 0.0 {
// Step 2: World to camera space
let triangle_view = face_world.transform(view);
// Step 3: Camera to clip space
let triangle_camera = triangle_view.transform(projection);
// Step 4.2: PERSPECTIVE DIVIDE (normalization)
// Perspective division, far away points moved closer to origin
// To screen space. All visible points between [-1, 1].
let t_ndc = Face {
v0: Vertex {
position: Vector3::new(
triangle_camera.v0.position.x / triangle_camera.v0.position.w,
triangle_camera.v0.position.y / triangle_camera.v0.position.w,
triangle_camera.v0.position.z,
),
color: Color {
r: (triangle_camera.v0.color.r as f32 * brightness_v0) as u8,
g: (triangle_camera.v0.color.g as f32 * brightness_v0) as u8,
b: (triangle_camera.v0.color.b as f32 * brightness_v0) as u8,
a: (triangle_camera.v0.color.a as f32 * brightness_v0) as u8,
},
normal: triangle_camera.v0.normal,
},
v1: Vertex {
position: Vector3::new(
triangle_camera.v1.position.x / triangle_camera.v1.position.w,
triangle_camera.v1.position.y / triangle_camera.v1.position.w,
triangle_camera.v1.position.z,
),
color: Color {
r: (triangle_camera.v1.color.r as f32 * brightness_v1) as u8,
g: (triangle_camera.v1.color.g as f32 * brightness_v1) as u8,
b: (triangle_camera.v1.color.b as f32 * brightness_v1) as u8,
a: (triangle_camera.v1.color.a as f32 * brightness_v1) as u8,
},
normal: triangle_camera.v1.normal,
},
v2: Vertex {
position: Vector3::new(
triangle_camera.v2.position.x / triangle_camera.v2.position.w,
triangle_camera.v2.position.y / triangle_camera.v2.position.w,
triangle_camera.v2.position.z,
),
color: Color {
r: (triangle_camera.v2.color.r as f32 * brightness_v2) as u8,
g: (triangle_camera.v2.color.g as f32 * brightness_v2) as u8,
b: (triangle_camera.v2.color.b as f32 * brightness_v2) as u8,
a: (triangle_camera.v2.color.a as f32 * brightness_v2) as u8,
},
normal: triangle_camera.v2.normal,
},
};
// Step 5: Viewport transform
let t_viewport = Face {
v0: Vertex {
position: Vector3::new(
(1.0 + t_ndc.v0.position.x) * 0.5 * buffer.width as f32,
(1.0 + t_ndc.v0.position.y) * 0.5 * buffer.height as f32,
t_ndc.v0.position.z,
),
color: t_ndc.v0.color,
normal: t_ndc.v0.normal,
},
v1: Vertex {
position: Vector3::new(
(1.0 + t_ndc.v1.position.x) * 0.5 * buffer.width as f32,
(1.0 + t_ndc.v1.position.y) * 0.5 * buffer.height as f32,
t_ndc.v1.position.z,
),
color: t_ndc.v1.color,
normal: t_ndc.v1.normal,
},
v2: Vertex {
position: Vector3::new(
(1.0 + t_ndc.v2.position.x) * 0.5 * buffer.width as f32,
(1.0 + t_ndc.v2.position.y) * 0.5 * buffer.height as f32,
t_ndc.v2.position.z,
),
color: t_ndc.v2.color,
normal: t_ndc.v2.normal,
},
};
t_viewport.render(buffer);
}
}
}
/// Translate (move) a mesh in space
///
/// # Arguments
///
/// * `translation` - Vector that specifies the displacement
pub fn translate(self: &mut Mesh, translation: Vector3<f32>) {
let xform = Matrix4::from_rows(&[
RowVector4::new(1.0, 0.0, 0.0, translation.x),
RowVector4::new(0.0, 1.0, 0.0, translation.y),
RowVector4::new(0.0, 0.0, 1.0, translation.z),
RowVector4::new(0.0, 0.0, 0.0, 1.0),
]);
self.position = xform * self.position;
}
/// Rotate a mesh
///
/// # Arguments
///
/// * `angle` - Rotation angle around each cartesian axis in radians
pub fn rotate(self: &mut Mesh, angle: Vector3<f32>) {
self.angle.x = self.angle.x + angle.x;
self.angle.y = self.angle.y + angle.y;
self.angle.z = self.angle.z + angle.z;
}
}
|
// Copyright 2020 IOTA Stiftung
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and limitations under the License.
use bee_crypto::ternary::sponge::Kerl;
use bee_signing::ternary::{
wots::{Error as WotsError, WotsSecurityLevel, WotsShakePrivateKeyGeneratorBuilder},
PrivateKeyGenerator,
};
use bee_ternary::{T1B1Buf, TryteBuf};
#[test]
fn generator_missing_security_level() {
assert_eq!(
WotsShakePrivateKeyGeneratorBuilder::<Kerl>::default().build().err(),
Some(WotsError::MissingSecurityLevel)
);
}
#[test]
fn generator_valid() {
let security_levels = vec![
WotsSecurityLevel::Low,
WotsSecurityLevel::Medium,
WotsSecurityLevel::High,
];
for security in security_levels {
assert!(WotsShakePrivateKeyGeneratorBuilder::<Kerl>::default()
.with_security_level(security)
.build()
.is_ok(),);
}
}
#[test]
fn input_output() {
let tests = [
(
"MZKIHKDQLIBBQDMOWUPEOYDIWLTAJDCEINKGHFQFTQVCDSDIPORIGYTWFKRONVEDCXGJNRFBVZHSAEUE9",
WotsSecurityLevel::Low,
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
),
(
"UNFBMWQTHPUFGFCQSCUAWOXCSJQKSFRFUVSF99QH9LYBQL9OASSDLNDWZYSWLYYDNAWABHNHRCHVTVRIY",
WotsSecurityLevel::Medium,
"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"
),
(
"AMEPHMKZKJHNHMZROFQG9NWNSKDPUSGD9PDRQCLVQOELFXZTFBC9DCPZDCJBWKJYCWMFR9QXUGGSSWWXX",
WotsSecurityLevel::High,
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
),
(
"XPDJ9ULXSTNMNPFYDNOLVREKOAIVXRDPLTE9OQJOLQHZAIJDRDECNVKAJEQFMVWKFSYFDITOHKCBXGWIZ",
WotsSecurityLevel::Low,
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
),
(
"KMQUBEOMEWXUDWUMTPHSKQDCLCUVKFDACMRUSVADTOUAFRFJ9I9CBAVWRJIDCPHKVU9GPBOTPQ9BKBXHX",
WotsSecurityLevel::Medium,
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
),
(
"AXI9SUXLMMUNP9IITEIGRRMGDMHEQLDQBUCSHGMDNUMCPRMPIMXYXLPISPSMZSLPCPBHSDCDYWXCGEZJ9",
WotsSecurityLevel::High,
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
),
(
"JGMWZEDTJQWWYWMJICSFSOKOREVWDSXCHDYAJMJWMWOMEQVKPGOHEURTOGMDMYBPUYXKHQ9AIYITCZZRX",
WotsSecurityLevel::Low,
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
),
(
"JEOVOU9BYOJIKDIUOSJPFRDAQZRGIUBYLYNHTP9AOZCDABNFJCDCFJLZYQLBJKECC9JSW9KT9MVXIKHHZ",
WotsSecurityLevel::Medium,
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
),
(
"AJ9QZTEO9BIMSBGRGLZBZSIBQYEBZFGEFOGZXOBGQILYPUPJI9XTKKRWWFCLVGYPSMYCTVNMNBIU9INGD",
WotsSecurityLevel::High,
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
),
(
"MKTDRKMQVQRLEYCLW9JBXULWBNHXRRACETTVSPEZXJRSXYMRFWRXIJEUCK99QBLNTG9VPIO9OWCLWVECD",
WotsSecurityLevel::Low,
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
),
(
"BNSJBDSYVULPKHFPRHYJTOIZTVNZAUBJLXHPKUUVJQFGLXKEFDNHLHDUTWSZKFMXXVZEWWDTHDOF9UWNB",
WotsSecurityLevel::Medium,
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
),
(
"EVNHXHACRHYQYM9FCVHUAYPTYWTWNVLHGDIELVGDX9MYANQMMBWRRFHTE9TYMDMDYFFKWVOLPYA9RPYHA",
WotsSecurityLevel::High,
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
),
(
"PXO9TESXAAFIMPVCXCFMYWGXWGZVGNQFZNOQVNTROUCUKRRUFSUUQ9UYXPTVWYMLDUVTJCLRFAXLHZJMC",
WotsSecurityLevel::Low,
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
),
(
"Z9KAITRGNTHT9CTLTNT9IHKLXTNCPLIGRKTVYHTRTUMZGYGNJTNBMTAP9DDVVKGDDGHQWUXOTHOOQLQRA",
WotsSecurityLevel::Medium,
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
),
(
"QNQHOIWDQQVOLVXXJFXMSSLJDIS9ZXVNNWHIALCAREOZPLKCPCYWGHMLMMTKEHNWAYTCHSEIAOHQAKQMA",
WotsSecurityLevel::High,
"TIUCPKYLWUQYOJLQOIJLJDPQXEISCHPVCYHUVGW9MHIYHQF9SZ9IIDMNADJYAAHHHH9NQRP9FDUWTIGAWMQHNMZENJAZGOSCOQQXIFQIGDPLZGB9IUOJ9ZNFKCZMQRHE99CIJMHWWHFNZWDITSRSSTGOQQUFICHVFCEPPQEOTBMTUJKFCCQOAGEIOFJEBHPEKRZUFIYKMFVDL9OEBGZWEMBMMQIVOSYRWTZYOCJLGKMVLJVESJWIMPHTMIMMWJIOBVITVIMIOUHCZTCGLECNFZCEKJFMFMPRAISE9YNCQCIULIYNIVNBHJLTUJQLBNQIJQSYNAYGQSHDZBMRZPJU9OJODHTTHIWPDYDTJJHZUDRZZZMTIBFRIWHECBORHX9GZNEAHNUCTEUJUMT9AKWGXKXARGH9YCYEPJWEGTLNCJUVGPZVEMNUHGM9XTKJBYILRXWYJ9JZNZUCFVCAMJJVZBUDFZXVYMPLOUGMUDEHH9YH9VZNRHQTEYGWPRLESAAPLBNOPUANXIDOXTTOCZTEAHQAMWUDFIVYQQXBISQELAJDTWRCTTPFCOZCQXTKEKQGYUKYRRWLOVCJCVAQUIXWHHSFDLMCNPDWSFZVGLUCJVDLLHNFEGORTLTKYEXNVTSUAOAPQKVYOVDWZUEBDPSJQFBHSTGX9HYIX9UDOLPFNDFFZYAFZQRADDBRDZJXWV9DJAVXVXUXLGLHSMQFAPQ9LYIJ9LSOMOE9OPRDCHJNOOEGZGXYWUIAVGVUKVTLHYQINUAC9MECUAVDQVBXQNVKZIZDGYYVXHM9RBAOVCAOBW9IXPYLURTDKRXLXYAJMTPPEWEWBEMONP9FGHINQHSJOIHJKIBYEPAPLOLN9XSEZRMRIPLYNIANTCWCMHCXPAMXSSBPWGWVNRTWBIDTWNITSRJAGAZWRSJMMYBWCBZAORFCPJPSCGNNABUFHTKTU9SPMAJYGVPWBUDYUBKOQROGHOCBXFQOZEJUCXDVCXGORDVMAAPFH9IRAPZWCJEZUQZUZTSWLXXGJKGBBZFMDESOCVVWKOHEDCPBGMAXYPCBXABOVYMPBQLKPOFPRSBUJR9RIQSZCDNAGNLDTSPNCUSQBJUUYUEQRULWJJLAAB9PNVWLT9NCBREPFRRAKTMNDUS9UYTKCRFVBSHOZSMNMHQGKMMLILBISAQOC9KHZUHWIHNYFENAPXGGK9VAFKNBHSWMNXAKNCZJEIGJEAK9QIYDJOQRFKKHODPNTJKJTUYO9YVJZHFDHEABFPMYUAZGDCCTPCUYQHAJDLRKXMIDSCZGMPKACOOYHAMCGCPITYBTYYEGUETYHJYRXRZKEFIAUSLCJLHQEQHSZNWPZC9GICFZJZZZ9MBGRFKCARQAJZODBY9PJYHAYSLUMXDPV99OFZKUZTRJVJAE9NWYFHDGLOKZNVHMDOMPVUA9QIXMEZEHWJLMGT9YZWHGBUQZMQRZZDODXKWQFRYSPULPGHOQRJLUZUMRYSCKULZKIHEZSKWT9BHP9DDBWZ9MHZZVKYBCRMGZSADJRLEBNGRLAXXEYBGZSZBBOGIOP9APELLHZOUMMDAOETOXELOPURGK99ZJTIVSULHNIRKBWQOTXNRQPATXNPOKYHRSSPWBVFBLENRTZJUYQXNGSZXDFNLP9UXQWDSHXPARJAYOWFIJVUFFOSMBBLMIKFXIS9WOLUR9ZRTQDUUPRYSPFHXCDEQASJNUFZYDSXVC9SBMHQOWYAECIXDEJOZBKNAEYFTXUMRDNCJDIDXLWNXEJ9IFWYHODFFWNFZFPYXKKVFOIXEGHIPTAEFTWQBONKTNBY9GCNOEXQU99XRQSLDM9DQFW9KCUNSKGGUWQDFDXPXYBDOEWKZNQZELHTXYWFWNEWIKVWSSWI9ZSSMGUKGYYTKKLKAJMH9JEWGFXFMNRYTQHRWVPXHNUTZOINVDCAEICAEVRDAPYMOYFAGUBOYFFEBGXXAHFFNBSWNBLQNDUEBSMCJSNVFLHQMWCAJUHPZTMHGKODM9FGWCDYHJM9SIYGVVOXL9EJPNTPZHPGUSGOHYLIKDGYFKSN9W9VZIQQHGYZQ9EGYUJKFLDYZAEJKNKPSPSPCTKAGX9BIMGHEKLOUYIYQQVCKV9PQJNOZJBKXKPLMPHYBDFGVE9IKMOCROAFVXGEXIFQCNGYKHDPIGGZAS9DZEXAIPUCMCZSW9FXUUMDWQPNLFEWMDBMQUKWMRL9YZYOVHFMNGRKVHPHPPNLMKAEMXZWGAGOKMAAFFRUPDSUWIOILIUEAAYRTKYRJPRNWQRXSTA9XFVVYBEDFFYLQHDMPHMIYQYJNBQEUUXXXMHFQOLOVJBZOWMQGSYUXRWTDXOTFSPPEVOUO9MZJL9MMMBKSMTMS9UFXWPIRPVL9MIFSAOVHEHNRTJCKDLERZUBPDUSPEPKSXHDOYTULESZHGPJQZWWUSPTNOXPUMUPKTBQTLUBKUUFEDEE9WCNJPT9YCGCBDRNCBXHLQCVDQGOIGLTEDKVAHWPCOYUQKV9THLSVWZHCEHNOWTZAMRWTGPDWV9MWAHOGFYTPRZDZHY9MEGKHPZUBWOKGIPKVKZFQPGLKYCKVLWSPEGPUCPGBGGTPJDGIYHBKQCGMJYCAXDUWMPEW9IJHHGEAALUIEQNIUMHGGBGBCJDSUTSMWYMFTYY9UVEWZZPPTERUHPQLEARDTOFJWFASDOKCGEZTDTTHHQCFN9SEHIPOAXEQXSQSUPXFYLPWDGLZZXVFDUYGV9GBCCCBXMRQYPXAWYEKLMVRVEZFDQIBRPKAFOUQCOIIGHLQKGRFWJZBCLZB9YNBOAA9K9KYW9ZCBYC9AQQSZWDE9LNGYLDRCLHZN9AJLFMKMEJQGISJPRJHYTDMHEKHCCCMZBAWDBSUNXJERSO9OWHIAELOGDUHCLXFMKLEOIPMRXURZDXAF9EDGWCUZCGEKEQOUDDIODJYLMTTHAYFXVZVHMPGJ9SHAQRNEYTCBYZ9F9ACAW9GYCRJZEBYVEABSAPFIGVCDJE9RJXWHRRDYQIQDDOJEOJQPVMOLBDGAHL9JYZJKOPRLQEZBOZFQRMVJA9T9RUGJIOHGPMVYGMJTQBLDHFV9WUPJVTEUX9PRHSFYDYFMR9OBSQFHTS9TKFGOXEZEEEEEV9PCUSDZVPXBCIOYJ9VAAZLCXMEQWAASOLLXDGXWDBAFPUTMLN9QAFZVQAHSOOXIEKKVXLQQZENAGBFTCIVLDCWLYUVZTOVHXGMIZYYBVLZDILNWZUNLWHWE9CRELALUDJBJZYRVHFL9LTORVMWONGTRJHNDNZWZTQYYBTPSDKDOBZHTOQXQAY9VHEKTEAQRULXFOWLJAI9ORQ9VRUTUVSPSSMVULGWPKUWVOJMHUUUHPUUJZIFSBKCSRRKDPBJSKMZONSCAFX9PPOM9RXORKXYNBTEZFDZZATKQOBBFIPIKWFNBQPI9QQAASOEGM9HVJRFYDUSMLHZTAYWXWDIXOBQLLTIIXIPHVYTQCCMBMQFIZ9OBVRRCSLUCYOXEDIPNMZJGKWNEL9ZITGQXSCQDWXGXINNUBLYDHS9MFPLFBVUVYVKIBZWJDQKTWGBRNAHOWZXAKHBLBHXCIPXCXGVRWXUYODZOFPNMPCISLMRJHZRRJP9GAFFBUTJQLFGZXUBFLPPSKWVAZMTVSTEYFRJPBIHEAYJKPWWIAOVOPYCDNGJBWTGAWYWOEACI9GQBNTVBMYXSSICQKKOHP9AEODOCPZNMXW9DR9XGEBCSIF9QXPEEZDUSWGHBFORPEIYTOWRINRVZAQFPOYSLBZ9MIEAKUTUTUCGZYWSPIB9LZIKFFZILZBIZPHXWCNLWLLXJQLYZQHEV9SVG9WHQJKZBUXUJSHKDCYVIHVTVFSSXTH9HKNXWAGKFMEHFULJCERMFNBVAZVTUTLRGKOUPXLZ9SWXQZOSYUCSLEZDLMMXHLUQZYYSNTOYPWCXIDVGRNABXVHYCKGWOX9QNFWBIIRAAEINAWRWQYVWKAQLBHLYMLZHHWWDLMAJIITLFAUBMAFITVXXSFCFT9ZFZTAPWYAVQYJZVCLMHCTYZULECCBZDTGQSIOSEGDFXKMTSYTSWPSUEFVHWMICX99SMWMITGCWLAAFS9FCRRLSDRNILGAEGJKRWQFK9SJQXQPIZBKSTGCPRWZVECZPAPURM9GDRNVFJHWXNWRCARHNDGKMTMALJOSOAZOIJCDAIZIZKGPQ9LFYDWOZQSOVKIGEZPGHKRYVORKRWRXE9OKQDHBZPBDGBKGLM9NEYQZHSXPMHEAMKZTPVTGMZQFBRCTZQEAWKZWE9XKBXNQIIRUDDBUWOYCSK9RSLMWGRLRAULOFG9XIVDZBCXDHVZOCMZHJAMBSTLRENPFEYBNPGBCEMYJXTAUJLSU9XGBBFUWKOZHXNYH9RTMKGVWBOEWXCHBOJEDACWBHPBANTUDREZPCQAQ9BGXBGVYJ9OYCWOC9RPSZSOSSRINJFAYFTYFQGTINYPTERDERKBQIUMMANWIGXGLNCRQPDVKIVFQZWOABXSEOEJTPHJ9ISPMZHHAYCYZQEMZZBLSNXVORZWJCSXTJIXEYOIZCGSWJKYATXQBUVDMKVJFZYWERQAYBNVX9DNGJU9WRCBRWSBDFUEOHCZNCFRJRJWAXCTOAZEVAQLAMUWKRPTJXPACFQ99SLABWDSLRIJAEGECZNUEFKYFSUWEMDWGRHDCHUKRSPFASGHNWKOR9VXZ9JRXBUUKXMNCUUUPTXAAXIZKWDPEJAGRLUE9MBCMZVCSOIXKOAQRMTXEWPKUMMZIGSHGY9MBVSXPT9FCQRQRRD9SCZAOGIVHJVQXBOLJLWOSL9WBQLGHUJZXPXZZTJPLOUJEBJEDGJFAYXPLPGOBJONEDIWQWAARDITLHHLZFYRWFKODJYDJNFSKDCCJJALBFFXNSNCVKUXNIELKKVSLNIJGRZXSNDNKPHSBORPNIVQXLCWEDUOFYINTSCWHAUZR9LMUJEXRWYFITBPBLLZHLUNJXYXDWZHBC9QQEAIAZNGPSQCXCCEZQZGXRPZYWZBTWDCWGLDYRKDVVCHZWLRLBSGXID9ZRXGXQQYIAFR9QXPOXAJLIZDTDDREPUJOWSYQEBMFTHRBATRBZWVQEYQOGJBXGNQOSVKRC9IER9NQVWNSSLJKKRP9YCJ9Q9IYF9M9ALAV9MTGWUCVLQVCDCKXWHAOJISWVRSEICIKMPCBCCYDUOQZYNETA9YEADWRYDFHINARZCLUAHSLJ9BAKEBTWK9MZCNDGV9BT9NNZRHESNREZLLMEBPYQKNLTTAFOHATYTLNI9SKUBSOHWLRXWPZGYFM9UNFFYYDJDKGLGAMLOMAUE9KWXWKXXXRK9XITGXWXEMLPMRSXBVGY9JKCOVHZCIPLRGWKEWHJSRALBMCTP9F9LU9CWQRBFNQWAIVMVNEYAYZTAPJPBENYNSHDGNMGDGYGTBOABVLTXU9BXVRPSMSMQDXRHBEIYJYJMPXAXZPECIRNPCGUTJYSIGYMQKQILJEQYUFHMNTCHAGXVPYQFLTCLVMWVSFHRDUSDGXTCIUE9KYODXSCQGWYLDSZSXUCDBLDKNYURJXJUHFAQMQQXOBSJZTJ9B9IVVREAZSAVSYDDWQXCDZMHNXFAEBTAXXGEVWCEMVCQQWG9H9UFNKKHGFVY9UTBS9CGJZIECRDX9KXXGVHQZFPDMKZUZCKYUFPREUYSYZSRVTFNYAYNGIRBJQSTKNAKTAYEDEKEEGLMIEBLYPLCZXBXNXFPTUPFQZDHJ9FQJMBXKUPAIADNMBXIFVC9NEOSCVKBVQRXWNXVDEDPYFUD9UIOHYKGFEA9RXUJHRIGDHLOSWTWNEBEWANXXTPH9IRETWVKZ9GHDHTATYGKRULPMLJFPEMVICWNVWFTAYI9IMQGZIKBG9EYEEDOJZRGSQDSCNFBUYZNHGFTGPQEHT9RWOOW9WQR9TFMKRWINZKNUNXDKLSSHKVBS9JQWWJXPAJINIRZXJIF9WGWPMCOSUVJVGF9XWZKHNRGRNUGLVITAYXQVLTNCSRZVZYQRNIAWYRKWZPYZECMPGJVDDCZWYOSBOHNUSCLCLUIQTPVQPKLIKWLXFZQNPPEHHHBLDSBHCKGJRHCFAMDNCZECVLULMBZDEFXNBVXAMNE9D9MZMKSVMLEDCTBMZAADUTBGDHYHOQOCZHQYYZT9HKKSYYTLSXPCVDEV9UWIWUAMDOVYIIADYYXED9NOUBKDME9ZHSM9WRXFGMVUGDPHWWTU9DQTESRD9CD9ANEMVODUB9RBYTDJSRZLIZTXVKJAWDFCWBEZAZNTAODVHVAHJIHTDJDJ9JFYJCRUZ9TAZOSBKUAABVMWTTYQJ9CYVXVMQGGRGUYJEKCZPEUNLHKIVCCOJGYFCKBTENJLQZDNRDX9SEZWCDOJRAHFPWVXYGYIRZKMTQVLTDOMZMYLCKFBJZYCZWZZSVAJESQHGUDMHJYUWHTQOPYYFRXAFLHLKYKCQPBKKOEWGWFSEUJ9NLLZLFHMKVWWJXSOLFGQDSSOTOZBUYSKPOOHCROB"
),
(
"OTSLINJ9HAOYWQXJIDIDUXXCIXMJDQSETYFUSZMLJDNMGBPMTBIPKQ9MMHQX99OYSMQGJ9DSLKYZCIXP9",
WotsSecurityLevel::Low,
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
),
(
"MP9JSNOIPPBAJMTXAIRNVXXDLAYOPQKACJFPHBPFBUGHUJCWVSHQUEKWDSQAMKISSCOXSHIMCIUHJTLBD",
WotsSecurityLevel::Medium,
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
),
(
"QGGIMUTKTIRDVJEWLLWJEYWDYNANGDOXGMZPCIEWUVGEDP9DMAISBVSZVGPQJEYBYMBDYFZZE9BZPRMH9",
WotsSecurityLevel::High,
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
),
(
"MLVUBIDFTBCJPZL9EWQNNLEIOZPCKIPBZLSXKT9PNJCDTLGWNGOOIFITQGIBZZGMBCROSBJWLUMUHVJDD",
WotsSecurityLevel::Low,
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
),
(
"PKLDZBZKZUGYTNEU9CMAFDYEJZSATTGFM9FMDZEHVLHQZ9JXRYWSTTFPABWW9WSLHJPOZZIGNG9QECVIY",
WotsSecurityLevel::Medium,
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
),
(
"OOYVCYTHNQVGNUPSUDLCJONWMUSLZTRWOOADANLYNDDCMISVSLR9TZP9UREFPEZUTQQCAUFSGKZPUVVUD",
WotsSecurityLevel::High,
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
),
(
"ACUTSQQ9OMJKLAKTD9NTJUUYRRDKP9VTTXMAMPUDPCVJEF9BHXCMGHKCMKUVZTJKGQBJFFYNACAHETLFX",
WotsSecurityLevel::Low,
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
),
(
"IIASKL9IWXYCASAFQU9JFOPGCBRMVZR9DKEIWT9I99BWEOMTWQ9JATGYNWXVTDPTPSLNONGEROZSKUGS9",
WotsSecurityLevel::Medium,
"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"
),
(
"PPK9PS9DSCLDXAAQPMBMBEOVAUHMWRXMEJB9PSS9KDXFCAIBHMJUTVMMGXHLOUYCEPFYJSDBQUORBOMPC",
WotsSecurityLevel::High,
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
),
(
"CNWUBJWXCKBWTYWZPPDSKCNSOFMYKVSXSGKETHDXINWA9CMSDGCIEMQICXCJP9VYGBLWZONZYGFKR9EBC",
WotsSecurityLevel::Low,
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
),
(
"CYDZXLRYJSKCGCUUBPBIQLCGUY9BFTEIWWXFKIKZXVHFVDSIBAHQANWZGPWMOETFFMAXLOBRABXQLZCMA",
WotsSecurityLevel::Medium,
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
),
(
"DTKGFEGALGXZG9XWRSFCPCEFTJUGIFMZSOIJEURYSLGAWHTMJGUBFP9NNQYRHNKPXCPGATM9BODHVUCU9",
WotsSecurityLevel::High,
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
),
(
"ILOBAHEYOPZWR9PUIYSSVJFI9THVRZMQTUBDXRXFHSRONLTGGOMHW9RIFWEZNLIANXTARELEQOWTHSCGC",
WotsSecurityLevel::Low,
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
),
(
"AXGMFHAZLBCAZGLR9ENDLBFUOBOLLSZQHWUOXQKNBEHDZJSZZENFVEBIIXFC9GZFNR9WHHNPIYUOVYKBB",
WotsSecurityLevel::Medium,
"BGTQGCUWOTIXPATCPBCKPUHMKCTDEXHDIFTR9CFVWSTGGBWUZMPLCLMIDDZOXU9UWWABWJIAZFLSJCLAWKQFDKJDYRBPVCGODTWUWMOUZIQJEHOJWW9XIOLGZJHRERNO99LEQAZGLVSWRBJFEMVQUOMO9SKEUJKNQZ9GDUJO9SMKNYTKDVSPMLZDEUMYJJCYFSYYUVAUQQYCAFOUXMWJXLTATDUWRNZQ9FYDC9SO9XBGXQEULHCTLYOXVJGRSGUPVVBSYDFVQQLWJ9ELKEYFWMYEVVKZCHIGXUBLHCBGACX9ORQLQBHJTSYOIQEHRHD9UCYDRVBJHAFSGPCEXOZHGZDUMYSFIZHCTYDKGPMAFTHWVLHMQUWIKQZDSSOZOKFPNGXIGMUIBJRLUGSHKXAHDKPCSQBYBFLIQWLYXPGCJKCMQT9URZBTFJEUGPHGNJIWXVJQAEJYWCLLANXDZIOGNGGHYNXVUUVWQAWYOZFPCMRT9AOVZNWQGULZM9JTRTEKQWDOXZRYVPZQPARXW9DMKQLUOHHHMFHJMGOUUVMQRLANHNTEZACHGPWMTFXHXIJZHL9TNCOOADCPAVLTHVVHDBOVDLVPORIOERPDIIEAGSNREAFEFJOIP9NTLNO9VXORABRSZNDWYISMKL9EVSTOZUSLDMNGXVXFCGROYV9TPHTNKJGNYRCWRMAZJHWHXHTBOHXBZNFPIGTJPBEKBCVLLVJZBKWBOZYRKVLCK9YEWXJLPAHXYAOZPTBGNLDNTP9MXDWUSRGXQZZSRSLZOSTNBSQXQZOABFDMMFKO9GITRZVAAJCXBXECMEZTADLAALMYESVQMRCDIVCVPBTXZRDTUWLCD9GHOCACBOVVJMBWOVNAMNBMWTLSYMIOFRXJDMCYHLYHFSZNEQVSU9ATUOGVLXEBYSPQOREAFQTOCGB99NVKAYT9ODHVKRYPNOXIAQAJP9JZTRSEVHJDGYYKBWCWXKTBGOKQAOVOMTFFWYCGJNUXVFNGNOVUAFNLQHWECHPAXZENKXKRYKLWAPXDYVFPGFWXSHPIZEZKWCINHJFMNWCDPCKDJXUFNYQEQ9ZBHEEECONDQZNOZLRPKVDA9SJXYQBWTCRTDSCQRSLBNRCANODLBXUJEUFBCHGADMMNYZUFFGFCNZSSBXDKBIUCYTYMKWCONOIKEKHNW9MO9YRKHZXBLIMDQBXHRRMNCXDDBUXKHUANUTSZJKBDMUNWURREBEDYYEDGORHXXJAMHYWQGDBR9JSPWKKRHLJKUISKWHWEHVHKLHYJQQA9YTOWSAPIJXVGQLYXAUCMFMGTHRRUGRQWHIKTMYDEOPTLEKMVXN9RKMVZKIPGVNOOKNFOQSJRCUAANLRSZGGGWTZXNUHHTI9LZHOCVYVKAT9ANDKDGUSXHJWQSBFSFBOGNSHL9ORPFONHCDXWLNRNSMKIIWPQPG9KSDHCGWLNQPFGWYBJWBWZVQRMUPMZVUCVGTYGISWCJIJ9SWEEQQJNJFUWBLGCIZJRFNBBSFC9INPWUJETAKIMPHBRTECQYRRJ9BODXJBRWJFQXVDIHLDVYJKRC9DTQVGWBRAYMPOACHGUABYKKVOYQEBNHKCQDQXTGFTOJWUCOOWXZARSZZBXNBAELWDMUENRZGYOVDNGEEWFMLYMBSEF9KFUFMRPCDHVALJWJRFHEAGIOFKJSHURQZQMZPBRSKESGLDPNMXTHTWLENTCQYBOKXNUWIJYJGQRINBBPWVGDBKZOETFMFKKVO9QDOBVSRZYIC9DAZLWFYUXXMEMWCGVAWMQCGSMRGUPJODWPXILBDPZZLNDNFPPRMCELOILYFQBRKQTIWIBVYFVVXHTXTXYRTTGFLWLAKIORBDZZMGBUCAHLGKDXYWMLRMPT9MK9DQUMYZGDXLF9LRS9UUQMIDLCCPAM9KIQKSORQRQXOBJUPSCUM9KHPBVAVJHFKPBPHFQVBMTENGFN99XHQTYQJBAKAZU9LUDIEKMWVQUPXBRWSZSGQQRATTJIEUEEEVPAEKOKUDRFWCOQPHLOBHZWXEWRWIZOQJPXJALWBWWCT9TVUAYSUHQYFGRDGRZNUTBYJZHSZUBVQ9LUNWNRYKOGKQDPRMXAFNHSWSSCKIKTOI9BURMGUYPGMAOLYGZOTQWLENYEYOWHRZYYCXGGMXJYEBZBUEUQCLDJYXDAHPADYBZQESOWBTXQJAAMSUNGBYPWRFVLXBRXTZMINAYRMONJDASFQVAMHOAEW9TMCUVTNWYOSFWUOOZJJMIKYNHMXZELHWW9KUMYVFQ9GXMTUHDJZWKCQLJ9LOKBSUBCDYWFMOKVEGOONSTPSMXTPIRRTGAEIYPAVZUHLSUDQHRQX9WBUONPXBEZG9OUDUTONXRFLM9JAVPESEGP9MXSQHRSSAVVWHNTPNVESFIEFRDVNUGRWGNBSMWWCUAXQASHYGMUQN9QMNGXQRSXGACJXWRSOVWZDNFGUQMAI9ZYVYRWXNPFIMUNLQIYESYTILOAGCCNMYVIDXVASLRBMHYSTAQKGSZGHVVEWQATKWBMOVMP9CXFBTMLNGBDTYHHGSA9NNRFFSMYUNDQSVBEMLWCOPDLNWBCEBHQJNVKSLEYUMYBDPGYWGSSKECHWCGLPHGKDODSGFJQXTSLULQXARHWWUFJXXJ9VRTFE9HW9YGDPAVINHLWATUSK9JCXQZIWRGZQPFEWSFSFGSK99FFWQXMFSDDXGAZFVPAEJGYHBNELUKDPHUBIMSG9NBKWOLMUUYWSQFJXNHRXKTZRU9YBIZCMJPXFPRYBBOTONEJEOOU9PWVKVIXELE9YQI9AGDEGWWKMSWJBWRNSYWCTYYMIXFYEABQMKDXJQOVQKZBVLHJSYQJFDGJFGNDGJ9YDXODTVXFYHDSAWUSNPPZTOBUIKCNSAZJXWSAZQBIDXQGQRXIL9AGIJEVOJUZFQNELQDWTL9QUTGTSJZJ99PYFUTWVB9Z9MMEEFJPVNNHUFEBKGUXZWINUIZKVGCBBQUVUBMJWSHGXSFJYPHJBUZEA9NQVOMJSTLYGB9WWKYBESYSDWZTHBPDCULRBVSQ9OCSDXASMLZUUDODDEVUKCBEDCECDCKVONPH9BVZTZAEHMA9THSUDCUUWNVLRJQOTRLCXKCKMRTC9E9RGZBNFZLFKXRXHJDOWAI9WJMHZJEIXTPCK9ZHXRKNUVFAGNJ9VJMYPITQRBKWUHDBFQVHJVPLUWKKPGSPPCEKUPAOSLONUOZKBDCOQFALUSBVTNKGBPWFFYKLXWUUGMHOIWMRVTQTBPENAGFJYULGQIRXFUFPQ9SZWJII9IMCTTBXHUUNEXFNRJZALRLCBZCWNPSHNGPIQCKZBANMKXIVLJKNCZVFINMVRPETOIJYIUFNSVXVNKKWOWXVZXA9FGFHBEW9JQWEMKNECONKSCSKVOPJONFVRJLEHOWBFLOMDS9BSPEQRZKJE9CZVVGPNWOCPFYK9N9DNCQFOJKHWDYCWDLKKLPXIRMCPQLVPQPNWVLDUOSQDHVUTPVUHLFLXMMMPUHPUHNTSNMRENARUSABHLIHAGDFCXYNBJRJIIJXXIGHICFDHTCFDSUFLF9SWIVMMKFPIAERTHFWAJXECN9CWFOETRNQNFHOHOFRZPILXKZZWG9RTGYCBYMUBHLPQLULZJXDPFLEVJIDWPMJVZ9ZJPNJVTMQE99YUXRZSOETZ9MVPNXVUTAPLIMBDAVYDCFBLNJVLXM9WUUUBZJKIGJRGODQHTMQKVXXJQSFLIGGLTLUKJQBSTPSXRYXBGQGRMGVZVM9RCIZSCZOWDANZXYKAJMMMIFSGKJONLMSAURCFPCMQHWCUCAAGNSXGHCPUHTTNF9BWPPVLPBNWKYPNCNYJFFZDGBKZOWZZKGFFCKMLQRBTM9IGSUJTIEQJDTUNTATYB9ERHKSLSBTFKCXFJCJBFOUPYAKPMCCCPF9GPBOMNQIJMJWZMIXNNYWNVP9SVEDLVHDENBJLGJNTN9KDTOCD9RZHDFQYAOVXEIARYIZGNLGJGQQGXMTVTMHIIPYCEFDWUWTIHREWSNDMVSRAIAHQERPMKKLCYWYLXZJI9CTOVKYZRKYJZWOLFCCMCGJQUJOHBEHTOWLOIKXBZWVYBPVWIAHEYSDOTMIGQXGFVVRGZRAJWJCTKANZFCY9ZLIPBCFEJEIQHPGWFYPKYVMZRODFUTRRFSYYOAZFTCZDEHZ9QBIVTHFIIEATVXBLRCETBBGFHOGPCQUNXSEXNRRKPTSAAUUWGEE9VDST9OSQIMXLRERQRGBSODWQDITIZXN9E9XTCTVIOJ9ERJNLKJJBBCDFGOXHTVRHHZFKKNXARSZ9VXFDYUHEAPFLLO9BMAUOQZLHFSCX"
),
(
"IQGPYJZVYPWYFOZNUAWXODRKQTAYSWGYUGCZPJXHYMNBMLRRNITAMNNKZHSVXD9TOPYUDRZJLKSNQBTNZ",
WotsSecurityLevel::High,
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
),
(
"IFTPWRFBJXXNEFROUNNCICYTYQIT9DBFUUKKAUW9EIZAEOGUHUDAMGI9EAZRUWRTEFVXJUVRNEMCHHSDD",
WotsSecurityLevel::Low,
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
),
(
"CRLFZHQGATTEPVROKFTVWQERAVONJFQQHSVQZGDWH9MFKTVUAJTTJUCKHMMZEKZGDUCMFVIDZYABQOYWZ",
WotsSecurityLevel::Medium,
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
),
(
"QJOF9WCZFAMWOX9ZKWPAGZSEDONGCPUEPRTBDZPIZZMHTMFPNAFZRKRIQIQNSVMOUU9PKWVOLTXOWHDND",
WotsSecurityLevel::High,
"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"
),
(
"YZKVEJRZV9IJOFOGRJBNBVSHWHQQETAFCWWQAWM9UVKNCPGLMBMLMDIZIKWQWORCSEKKITGENOQJSRTZC",
WotsSecurityLevel::Low,
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
),
(
"FWCBRDFUESAUTOYDOCEKDA9MTKNACSDLZVAPA9ZOTCLFKDWRTGUHRFAAJBXRLWIOBJQVTACDJAVIMGSK9",
WotsSecurityLevel::Medium,
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
),
(
"PTTVED9OQUYSXNKSBUZSSLQGBEAC9CSJKMZJIAEHHWLMDPGUABMGULJTNQFLOGNQOXXFDMKAXYTWNXDSD",
WotsSecurityLevel::High,
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
),
(
"BIGECPHLEXRVLSKUBMMDXHTMRSWDTTVRMGOFU9UZYJZX9VRQFKKBYXVX9PBERFEUUXECHZVLTSMKTTUZW",
WotsSecurityLevel::Low,
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
),
(
"IVASKBTRAYFRQERPPNMXPREKZCCGBIYZHBFPNCNXIAHHAIQTNTPLEHACLDIUCWTEQLMVQJ9PGTFDEYVDB",
WotsSecurityLevel::Medium,
"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"
),
(
"RFUBEVQJDWPYHEXXPYYDDLDE9OYNIXSXQFBRIFGAZCLEVIFUBT9QOZTXNMPWRXH9XYPAFJVMUZNGRZDTZ",
WotsSecurityLevel::High,
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
),
(
"OYZTOBPLBJQAWGXQZNAYV9FOVNMDNCWWDMAQQUYLYTSWOTTMXJBAZXIMXWDSKO9AUJMMSNHEDCKKXSABA",
WotsSecurityLevel::Low,
"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"
),
(
"DMKNM9KG9RUJVKBBNWTNGLIADEDR9JLKHBPIHWRHLVWJMXVUWYOEEIMYDHHIOUGCPX9FVI9RZIRW9AKMY",
WotsSecurityLevel::Medium,
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
),
(
"UCOKCTHTYPFTKMFLLGYHZYIZYLUCT9VYVCCNTQDCVU9FMEAAR9PXJ9LHVWU9NARQJQBPRQIAXJMHSMNLD",
WotsSecurityLevel::High,
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
),
(
"UIUBPDHGOGVKBZQXIAOIRBKF9EKZXLAYEYIREGUPUFOPLSGPXDHUVEWYXTMTWBAFIUGAIXUUPQPGVVW9B",
WotsSecurityLevel::Low,
"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"
),
(
"DIVSQOTYKRRCF9SUCQLG9YNSFGNDYHHXODMKQSEUJCZVDTNSE99UVFXSMMIIUYKWXFLRFXXIXTFX9JJKB",
WotsSecurityLevel::Medium,
"HRRREKIRWFPYAWYWKYANUOWD9AUHXXOUGLTHBPNRVOZMAODNCPWCZKKCU9UFHBF9PNSOCUYFRBWQFV9GYPHNFHAGOEYXBPIFQBKRMGOBVGRIXUF9YKFZONMTWBPOSZCL9HWARMKMHUOWXJHEIKL9MXYBAOQCQYMDUD9AZDHCOHHFOQKAUZHLHWE9XGQTUHZFHNSGAKTZMHJNHIXZKQFPNVH9BNPURRWVOCPOQEMMZHKEGLECLF9LFGHGXKFEVHKJH9PZRGVHGDJZFJYPVWPNHGYGMQFDTBRGPKYCRMCBSEWDQHMOSAZSSVEDVEWEUOLSYMPZTEBCZFZMVUJYLWYTVNSHB9WWOFSONDHBPLCOCZW9XIRBBCREJSGAKEVWQNNCUZOALWPBKYYMSZDWFRFYYJUKLQIISHDXHIZRJVAGN9YLBRQUQSXT9RPDDGYIJXEUXXRG9NTKMWYBX9KFWDGEECPX9GDSAUHNAAXMX9VGYVATEEGYIOXNCCXNYFCGYDQEPHPJPJUSHIZPAVQOASUIPBBPIFBOTXSBSFKAIBVMDFKCXLUNQBGHER9IA9GW9GTLPVIKRBPJVIBEWXWMKTN9YAZURVWOMZAXPNXFMPXZLENXYILETLBXZSHBFPLLYVDJFMIVGKYATIHUSDBSJWWKCHMOZUOWTWGZUFUOHFCSTSIFYIXGCKNWC9VXGJFD9MUCOFSVUXT9PPPXSWCUUVHJEFZOCKACKKXXZPAMUPN9TVVBQRZRUYZXNTGMTXGXKJOQTIQGZVZZTNNPTD9GQZVRMV9RMQBTTJOVKT9JTUJNFWACVNMNCAQA9WJKTHLKGCBDODBYTHEMVWYUEPQAH9KRJFKUZTDLERXJJPKWKMUCIPACCAZS99NKMRZGGN9NAKIFF9AN9QYSVLVCEBBYMY9KDFEGJPRJMDKJPHJYIUIQJSQQDHKHEZT9P9NQ9UJNIEX9KVETCYVF9EGWFZ9KGHCIWCLWEWLYMJSZC9ROJBIPZCQWFGRXURIFJGG9PVWQLNBK9QMMULA9VLBPFXMWCQACHQCUOXCEXDRLCMVON9STXXRATZGTAWSANIWWXBWLRPVXBTRAA9PMEUTCKRRDZINESPOZMEBHZYSUBOCIVRACKMTXBWFVZZRZDZHGZWMWOUTU9HSYGTNHTMUSYODFWUCXOST9GZTMGCFFRIVBRLEZ9FEAUKRCVDWSCWXIYRUHVMZWGJSZBVYYGTXSNLWJD9FBDTUE9LFKCKFTWTMFYNXBBDWE9ZLHAPJ9JJEFH9GTPP9RQMIHIGQDPSCEAFD9RJXFVMHIBIJBFLKDMCJSLTBR9I9LLKIVZVXMPEDGHFWRJHJJTQQAGVEDBHOFMHSFZYBYM9RJMFXSONTIDEMT9TKUBRZIGCINNEUMCAJG9EHTIWDAMTWSFJVNFCFQXDPLLCBWEBXFWCUQHXHRHVBQAPESNPD99CVCGBES9CFFATNJKGYEQHEEJJEECVDDNWONQYLH9HDPHLJDZBWOTASBGIYTOCZPVH9CEVYTCBULULFIBFRKHQWPEBLBXHNFPOMPFTTB9BFYMCJXYHQBIORMHGFBBCWFPKCADPIAYNKZOGCVASAKHCGAAZBQVYOZWWXPLPSXWGXYJKMQH9RTELHLNLOSMFSF9GSKS9TZPMNMVRZFKNRPMDJLNKRWSC9MVXNLDWNUJRXLMLSNDDINYTVOWCHQOTQQGMROQMCNIMTIOQIJGNPNOSRUQZXJZXGHYYMJHIYSGWDSEKNTHCRVTQOBZVZEHYJTSXBKDTULRDGQABNTZKOFUAOWRJRQJXFDBEBRZHXKOKPDOXGHZY9LEIFGIMFMOFGPDDJPC9AAQJOMJFJCQNZGLEFFTRCSUOFKBHZJPRG9IBXROBSCCLLTNJXGVHFCB9EIPVDYFM9ABKEZ9UMZJHUBRLHEEECVSVZRG9AI9OENUKZ9QHSU9ZKAVRX9GQKHDTINNEAHXODHEVYSGTMPCWDOQPBNBWFIOZABRHITLGCCOYVWBKQ9NMSGUFKJJLDQAJPIIUNRYBLPNGAUJTJ9WKFMQTAKQCUFNVGTZQPRXZKPMIWMVLNSYLLGWCIMAEKXHQBRAGIJROULYHG9TWMGHPEACDXPBRAZXLGTYQIKOBZHPRAUKIIB9MHGXQNYJATHDUVZTNNGPODQSVSDCEWN9XZDHZOVVULBZDCQKATHKWFZYPDJDPKDIWAUQQYPXURLPHUWGNVPZXVJJSHHETYLTEEYWTVBRZEIBDZTQRLATSYXWCJGCDNBN9YFCNTBJKJDOQLRELFOTDLRWCEDTJIDNUQFT9CWUDGVGIAULOWQ9JVA9KDOWVPZILRVJETBNM9JAFLPY9SRMGNHIJQYAGVDGOCPDIUZQHPV9CKCHUSAYGVGZJYAXODDRQTRJHQNQPJGGGPVMVSJNDIRVOJMWS9EP9NGEEXRPUBIIPXXCEEZDYYZVQCHUFQZRXCNHXHNVHCIRYUBWVPKSGOESIYSYRJ9QGSAPFONEIJVBBZOWKWEKYJLDJKKDPSQUSQ9FXTGA9BSFMTHQKU9BVDIVXLBZUTXPQVNBHSLINRYKAMZKWFE9CSJRULSFIJICMZCDVNNDPKIWUMQRKT9TTRPVOANR9YMCCUOJONFWU9KZRFEXLJTVWRZDWUEVAQBTBIBYXZYPUHQUKIWOCSNDZJAUQKUTECVOPGZVRUOCTJKJKWUVBJDATNUG9PDD9IR9BYUTFIYZLF9GAREAICFEDBXZIMGFCSVULUQMAAKTMCIEJEPPFY9VGIDPIRHHCRHCLGIPEOSLJLWUEUNIX9THLBAJAJEIALQBAZAPCXWPYD99BJWIGSZFABRSXUATEST9SMUTFPJZCWTJHFZCBDTBNBCCTACKQDILHZDJWNGOXGWTLDPBRHYHXVHXCFQPGKRWFVDOCBALXYMEOPUVYIVXFQSLWHWEWBCQMKMYOMUZQRA9FXBFUFOV9WRSHPGCCPFOVDIZMBQDIKBKXJWISZAFYXGDEJXT9ZFLMPTJJNOFOEI9LNYQTVGJOLNIUMUEYIKJTZWRRJJPSSZNYHFXVZ9JGKLBJRRMOWW9WISSHUQLXSJTIFOPOUHFHXS9VZKKSPONLPQAT9LPZKQESEOPFCFAAIXOECGDJIKKCGCPLCQMBSNCPSCIUYHHMQKSNDLJFUOLFKUCGVXOAIVENXLSVD9OOGRAMOSS9EEXGKXBGMUPHMITRFECAHMFNMXZXWGINFZVTYSTBJIG9QBO9DNAPNGLAQKTZUFIPEKBKHAHYTFO9ILFNSGDA9PVUTA9UBAHWCMRNWYMYGCCNNYDFEWTEWSQOOGHLBZZOURKQ9VSCBNNWXFOTXRORCSBQLRD9OJBF9VENOXHZQNXBI9ZWMKOYTKEOPUEVDAKVLCAOWWWUERQUQBNBZKXEUJVQEGVX9NXBRINZ9QBUVWOPZBR9EXVJDKLHYLTXNQGBZ9PMNGHLGANAOPKQNAIMEBGLUBAQVCLTXRSRRFWRBWGPK9GYHNLHTRBHCZKDJCQBDKFNNV9SD9DFJSYVNEUOQQZTPUQSOBKFLEUBKFZIAFOCUD9DCCYPBGEBAZIWZFIZJOYNYDSEMPBERCNCSGGAQDOEZDZXAYHQTDPKONKJUVXPQMGBZEQYO9PTBBKRNBPZTTWWIQKQIUPWBBTVL9BLKTGYIC9ERRAMBPCICFGXHYIUOVT9RFTHZENQMBVTUIGJGSLWJEMUFWUENVPUDOJDDIWZNHPDRMTSRXVOJHPTTSATHQDLNHDJFEMAXKWIQDCKZGWXYQXWRLGH9VJJNHQHIPSJNMZIYMPHNUPSYHPWMJEBV9VDUTYYAIPQGXKATBHMFH9YCMPMBYIRTQTIXSGUPNSGYRNDLBLZRWZYVYXFAHNTUGAUTTR9HZHHEJHGKPNZLGWYUTKDFHACUYXEESWH9RIBZPNLIOJQFKKASQXEJ9KEXXLGERGWMKKS9QFKVPTKNDU9BABJCYJDXCSYROPXWXVQFYTBAUSNDRPOEA9YVCGKAOTSLJ9TDFDSVCBATKLMYYWEHUSKBQOPOGNJQIDHWLLX9DUBQLDCNLXNTW9MERQRATMC9OEWERCAHIYLGDMDYEQMADUAQETWLCOCQJTGLENYIHCRYMBJHCDKQSJ9YPNMDY9ZENNSF9CXN9JSMNELCRTCQFRHV9HKQEDNOCLTNGXRYIKKR9RXIB99O9ZBLSPXJVM9OT9JXGOOEWODDAUPCU9YZEILOXIQW9PVCAEIQUSWFBURQGECXISSYQBLEIUGUAQAZXWXJESKMQHZBHVYABSGVGSQNO9WAZCHVQWWDASTCCGIPQEZCXYXLHGSRZJFNKYUJXZZONPXZHFKSUTWZAEBJBVTCF9WHYGRMQCZLI9PBVXA"
),
(
"ONAIRVEBSNXIGIQOZKBTJNBVGSTQUBTZSLMSOZ9HGVPHXBVFMMGOWTOAFGOP9GOPFDIVKXNGPFHUDWVJD",
WotsSecurityLevel::High,
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
),
(
"VLZGQOTCLGYKIUHSZBVXBSNLEPADOYNXKHPSXUFETWGKNFPFCUCHLDEJPYLVYNPAFUPHUJTOKYOCZLMLD",
WotsSecurityLevel::Low,
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
),
(
"UHETTWFYX9R9RAAMRJZAFEOZGFTIMETNPJCKAGESCWW9SQZVGFHNYNHUWVRPPXYACARQLERLYQGKBIQOD",
WotsSecurityLevel::Medium,
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
),
(
"RXFQPW9PCUAUJ9PGXWAVHMNIYCWDHFUNCBBGIMHIVXSQFIVTFJBDZWBGQQFDPPZDT9RBKGZLFSWQR9NRZ",
WotsSecurityLevel::High,
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
),
(
"BNTJGBKX9IRSZDTQNFVUCZVELXHB9GISZVCSBKKTLIIRFZNVADJHGHWTNJJ9ELOJPMOVXGGZDHOBFXHWD",
WotsSecurityLevel::Low,
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
),
(
"TBIW9JEXBFYPXNMOPUJPA9Y9YPLDILSHVVAHGWWQANLSF9JMVTXGFBTKOFIOBSZYRYDZNGNOFYHVDMRQA",
WotsSecurityLevel::Medium,
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
),
(
"CBEYQSQRO9QYFLUGTMGNESTAHBID9LTLWGVEWPTYBMQKXCGISDTUYPHPBJQ9ZFHJTPN99MQAIFCHBYNVB",
WotsSecurityLevel::High,
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
),
(
"IDVOKREJR9XE9QTKEFKQWHXULTVSXYQNEEUQSRLIQYFSHEHCBIBQXPBJGFENBJRQDOXHARSQNHILVECPC",
WotsSecurityLevel::Low,
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
),
(
"LNUAXNBQKXUSVCFOVIOMH9AEYDMK9WLHVRMTPESTWC9JIYMEQGVOQPCNFGEVFX9WOFMJLLJRD9VQF9WGA",
WotsSecurityLevel::Medium,
"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"
),
(
"RCENQAZZZLJWBCYNKRZQZDEOGYGQZ9XVPJKFKYSNDEEJYXSKKJSYORMDLRVFBJDUAOL9TQZHJNOXZWSXB",
WotsSecurityLevel::High,
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
),
(
"OIUJMIXEWGFFTVPMRLAGDKTCKPDUQICQEUMYKKHYLETCPEFHBXXZQCLHQRDRYBKZJZUHJMBVACWKO9CXY",
WotsSecurityLevel::Low,
"SYSPPI9EPFL9SQWAFBZRHYINH9OOGJSJ99GCLFXNDHHPCI99DVMJC9FJRGDZXIIABSHJYEXKO9TURLHCZWWFIVCRUDYYC9KKLJLMEK9WTWDQNXAAKZMM9RJJWEXQOQCBPTD9KHHWAJPELCAMZPAXUIKLPTITNYAR99AVSRWUJXMXBXQISJRWZJNKBQWCNADNIQGWRLJLLXYXUGNCVOJXVYI9XHTX9ANKDXXHTOJLFZTKTZXPI9WGETU9UHNDWOHMJSAFHXTAZUKDXEJQQCYYTLQXLEMGBTYVBTZ99AWQQQTQGDUZOTKFYENUEVHFFCCFMZTXNZSMLZU9RCFDZ9LXPTBOZUYSAOZEWLZMLXUV9WTXXSH9RSOCDORHZAGQAYZJW9PMYLONZKGCDPFQCPOMYJEMKDQUBTZQDMFMYHKQERFUDUW9AQEHJSVHTASXYKBHGPKCYIL9GUZLWQGMFVNTXQCEZ9HRDEOSGLVGQDCTWLZJNMRVXMKEHZYVPSWC9RACQWJSPFLKRHDDBQBQWULYREBLZLNOUHMRMBXTLIL9DQSCEPRFAEEQMFCCTYBITCGDPWKDYNMSLVSGGIOIUZNTYVHRQYRTSWFJQHQSHSRCWQZBASISYBWXBHERN9LRVOVAOAENFUKWQSVZBRM9WDLFGGUKJCSAQKMHRWNPUFWWEKXSEGEVEMCLO9JJPTXEHJQRMFWWBUNKLTPATAFFTZFXADJABXRZ9BCIOAOJWEIVBQODUJJGKDLY9DNMKWQJQEOHSYXBWRLDIEGSK9DJLKAVCISXOHHKSACWAUCSJPQYIDMLGTOPAPP9DGLWNUCNGBABFVRN9WPGOTHUHDFMKGZVXZYJNDIZZAXXHRDNWJRENRZLRMJQ9UGLXBUKEM9OODGFCBYBMXSCZG9ULLFMJDXMYJAAAZAZTITGPKUIVYKSCRHWFTKJJIIHTSBCBROBWDP9VZKDZLAPRIFDZVEYGU9UIYIEEJHPIEJUPEUZWGB9BW9BXGVEOMJLIZHLCYUPYPZEHO9JLANC9JDGAJEXKHPPOZEUHGIKYYFNWNABJOQD9NEBMZBONOBD9MMQMPOREIWWOXOXTUKLFXPVDQUPZNTMBWXFAGLD9MOIUEFLDIRRALZOKZGSEJISEIGUQIDJUPJMHTPMOEHOEVXMPLPTESITNC9NG9AP9MNRYVDQYBQSITYEXWNTAFLUPTOVMCIKTIYQCPEOX9V9MGFZQABX9KDRVGAQCBULYIGKGBNGZHENSIUIWHTBGS9SQALZYW9CTLTGQKYMZXBIYOVNUYQXDKEGSCKOWPCHSB9NQBYBKRPZ9OZMSRFAKPPRLPWTJZFKEJEH9CRDMDXEOQWKHKCXRQPJSPHGZQHWOFOY99RVPMLXHB9RJFHRWBHPJBUAVBRNMYZNLPGPRFCOUNWCWWKZEIDALGFYYSCJRHCAXREALVZTIWHEMUQYRCGDWHHUAVFDTPBWNMWNPEQRQYAVGEP99ZAVLDMELLADXFKQPKZWKNQGANRNKAZXFFKRHLLBBSUKXMQPVGCTEXSPXWSRQGTAOQEQRFPEGBKXPBCSINLDIZAATPYFQVXIZYJKWVRMTEEKJQKTJJEBBB9PDRXAJIZQGYFZAOGGI9OSNQNRPVLMDCLIWAHXOQZWMTGJNIO9YIKOBOWW99VBH9SKXAZCIXZJDCURPPOLFMMFYCXXTVGQAYG9BKHGXVMANLSSUVZRFGJPQPNWBEHXUQZUSRFJIGAJZWVQUKXOQOZNOQHIZOOLGJXZKVQAJIDSPA9KJWFVQAY9VLDZEFNFTCHNNXFDNUJJPIPVIJTPJQWUNLPVMEXHTVRZWWWNEACEENQETOWAEJAZ9DHWSPYENAYJINSSSELISYJNMTOWRJFBYAPHIWLWHRNPQEMLVTTSBFAQXTUAKBEVOUDHBSIECPOWUVDSUYCQBRUIEWRBUSGWMWDFZYPAVPNIOUEUYHSOZUZBLZUBEHVDSECFMANEOALGEYZXNUNMHYDWGRWFCCBTYNLRXXDGMHZMXPAKLJOWOHLQEOXTDAWLKHUTUDFBUVBBWLPDBNCRBAYJZAEKLY9RKSCQSPELQVATSQJYDOEHMYRQAWGFGAPMYE9ULEJEEFXEMRZXGJYTKADJZVWXULMPSVZRBOEAPHZMLWCLMZWJC9IUMKXPUDKMQINVUHNFXLAE9LW"
),
(
"PXW9OSHJGDFVABJGXHWDRBAABKWMYWGKS9XLSNX9IUMAYPYAROXSLKBDPG9QSEQIVI9OVWFDYQCNHFERB",
WotsSecurityLevel::Medium,
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
),
(
"LMMENLHBFYZLUZMRXBBRYRHCCSSLXHMLYPQXRFVABYJMWXRAQEPQVWBNEBCGCUIKMDNDIOORCXQZKIJHY",
WotsSecurityLevel::High,
"SHZYQJOECURKAOGYRLKDNWUYPMEQRZIHBAXEK9MYVPJSZFFSJOKOC9DXBNYFJQHCUCOBQPFZMXNZZRAFBXYAOVUBWTZKX9NYUYHTY9SZFXEBFQPWHRTYJXPTQBZSBWLHXVAJRIFXAISRLKXLXZBAJXJTFISDQBBBPXMGPTCRGWGHHONRBPJLYTEODTOKBFMZWFCVUBMBKALBTW9KROLQOFCSMUDXGMIMEHKTSQLPGLJOCBFNQUAFVTROCEPXMRGDZXPACUPVQNKTROHPEZRAMVIWGDEBWHOJFXIVZOBOXTT9VWM9AJHFQNQFY9NMKJOBXFVCCRHOMHLOUANLCVIKOORYUTHAQLNARTYWALZU9VQKQVDMFSLKSPZSBRBNPJYYZDVMGCWCDMNWYLXBETFRX9WYSMXC9SHDTLWVQJOVIZNOZJUGOJCWNPXLSWOCKVFLKYBXNSPMXLKZIHGAKJYEWXGBJMJQ9VPP9UBBJZOKYEQSDJCHCCDJXXITMQQKLOP9S9OJFLQUSNF9O9MJSGDPRBICFP9PRKQCGTRTWYGSBUZVUULJPJAIDCAYIQZJMAKZEPTIKUJJXL9FTZIEEPKCIQ9PZCTAMBGQNZHWYBC9UHFMCHEDJFINYHP9IQJIXTTBHTHKJWMDBIDBOQUECXIBXWVBGOFFKJEWOXREYBDPVADWD9BDMVWL9UX9PL9MRPKEIT9EBFDBGR9YBGPVXM9YVAPIZZDIBNFBPEKARZGROVBDW9WQQEFNQVUYCTVSCL9EOIQVIRW99AEUYSTRYJNKNKXPIEJXTL9QUEHFQAAGTASXAQN9CVQXRFLHLGGVRDETJDMCTUCGOICGKMGTLDNWBOQOSWUHJZPTOR9SBOHHHBRBSSHUEKLVTYBAWPXMPVMOBDJOLIULCI9JAVNZIVOZEXPGOBEAYMQ9YAEYVNFIJ9IPVKIHKNWGXAMJFAUIXNNRT9EFS9JXPVBYCYOYXOJVCXVAXBUTNRYCOCJMLQSCUQXOSNCQCDBHE9RXYZPLUYZVQ9JK9OPNQCXZFJMA9FFDCQMJFGLZDALDKMOLTJBVMLXYJNWTSLPEG9BGKQXJHSMZMQWYFVILANJZZASLGNNFWZUVYUDNIIFXSJNJPSO9UNYJIZMDAGGEEOZ9KTXRMO9NCVJXWRPAY9XBCCHYNXQQHAUHYXFRPIROZJFNJRXXUDBBYPWVCWUOIPMFIJKLSXWBVAXDKGR9WDAAXXKNSUGVQIUFGPUENYQEKYXCKACQOFHQVGWEEDRJIERHIBQPNDAG9WUZVZJOEJSLCSU9BOIRWMZHMJKKMNFCDKZQPYXLSISDBCNFQHYPQNEBKVHMAGZEB9WXTEFCSKERVDJXLHANZMWDDYFTOWVYYVHKWGMXCGJXSDNYROSLTIGXEVZRZBVYLWDHM9BWEFS9BBODICLQ9TPRYU9VXBISND9TROEDBTPKMUEMHDLN9AYSRSP9VFGURTVJPOJAAVFAEQIQAFIPBWHEBMDHCNUOJIVDLCRFPBEKFVKPBPLIESCCUOZTFUAXOC9AZAUMSNEDWRMCWLWHGQYUWAGMFTGBM9JHUJIHHCJJRGRGHVYJQZWYURGZLSMCLPHMWUKFJXIDFRNCDONZLOVKTLHUQAULACHSMIJSLPGLALJ9LFPIHZVXNQRTY9LGKQRWXAMQAFIX9HABMHNRLUWEKOGNDYXKZXAIYFJCAFJQEBGLKPAVAJGSJFAWQNFBFMEIFOAYJPYHMTDJEBWTZRQTNCXHZJSNFRDQXMMEIIWILGYDPY9YQWQXQYIOXUDTDMTQVZSYWNGCKKWFEEVXYROKR9LUUUIZZJSMUAPEYZSNENA9DDOXCMF9DDUFFCIKZV9MUVDDJD9XFMTMKLQVZNJZYSBLDGCJHKIUWLTOTVSMVNMQWZEBTNJMDFAITGTGKWZIAMKNVKQMOCMWAKJONZE9OASGGHNZHMTLQDTQHKTL9RVJLDPHEJQBOG9QNOAKTMYTLJP9QTFXEQQDRXVFCGHSZSWOWWQYZZOOZXIGDM9OSIMDRXKAQKZL9CZYALQNACLLWFFFPEIK9ZAJE9ZCPZVVPFTIBSMGIKSMMZLMJTTVIAUWAUDPABZXPW9MQHJYGLDF9Y9JNYJAQYRTJIQYMMURVYEOTIDRIVMDMAEQIUXPYQHTMEKJJNKZ9VQDENOOQTPHUYA9YWASNVZPHWMCCKZIMSNMMZCRNAHSXASOWUDFQMVWJDFVLRBFXXYQZLSVVFWV9CBDKPPCJBHDBIVXDAALSK9CBFZDPCTK9NDP9SAPUOVSX9JJLFRWDILKUUSGZ9JEKHTKKWWHIDMVJXQTZGLCRDRKQUNVOMDAJXJ9LYXP9HSDRPSIQFU9UECAKYHJOXAEVXBROXCLCLTYUQVHDLPGQSNLGMFDSCYLOALQHFVZMSEQQVAGHZALXKNMADGNXNJJMJQMHIWBGSZBBSJICTANXJ9HZNVONQDLPXFZXOUGVSFTPPBNIAOKBGYGRW9ISCYYWHNUONCNCAW9KZRCTYHBWFQCFKVEWWWXBIEYRPAWA9FAHEANRBDFQAZJSFFNDB9PVDNUCUEGAWMCDXWPZHHVVTCZXDHYLPMZPAQAIEBOUOGMLBIUML9EFRTDYWDFUBMYLXWEVRSA9DFDR9VTQFPGKUTZU9LIXBXZZEWTAUZTOCSNDKIVULRXUEAGZUWZBDCKOSBHXQSZBHO9WLVGYYKGYSDRQQWDHHDWCICISNNXR9AZFPGSBYWVSAHZZ9BJEXTCMHSAHJEXUSDPUGHMXJVGGIBAZXOCAQCKAZIIHOFJONWMDNZOODRAXWZKLLBSIFZLDIDCTFRWVHMYWGDQRSWPVDDTQWCHVXOWXEARLAKXKSLLJKMSRLOJNIGESQT9LIZHDFINPWFMCDBV9QANDWDYZVVJ9XIVVVHBKRDCZVBYVLQUWRSJ9PGZUAWGI9BYMMYFXYFXZLHVF9TXDWKVOFRZOXZ9LEMSZASEITABFKNOUBZO9HDZDGRCTCFU9GJMNGBBGQUEIJGXEAEZFZSWXGVXTBGYRPGSIWFNRPHIYBTVQYXPCTPOVEHTN9WKNMKQBEGSJWYJFFTUNQMJCBUDWREQTFCASRQPNKFPPZZUUEMFJPFDFSBSUTXJXWUSYQGUGHRIUKNYQIDEMKAVNOZHOJ9Y9NMJPTFXZBYBLRKQMMNMDW9ZNXBVKGFXYKPEKKYRBXWYTDVOL9UERMZAKPCMGETAMAILQIYM9HFZIAIWKEJ9WNWMOBACFUTSG9BISKATFKBRZHGPNFKRGH99KHWFSVMFQXKTEFDDZPTLANJO9VUANJNMULKHAVJOWWFKOQKYEVGBPGDWISI9JNCQEYYFGRUEBFKDJWZZIARDRYPTTXCWBBLJQVGFBADAITEHV9FOYDXJVFXBOXKOHNSWOCDJOY9XXEUFVTPZDMVQZQJIMZTAZVVJZZFSAYATKVMBGYFPGPUFILDVMYAQCZYTYZYUXAWRGZWASRCVDXHEXUOVGXZDLGTCFCFCWVRZUYYIZRANSPPQHWEBSGROMUYLLSTNVNBBTIIEBKKJJSYQSQSDZYK9QTYH9QCQFLJLIHHHAXORU9KEXFLALN9U9LHTCBXXUEEVPJMBXDNHNGFQPDFODRQKIGMSAQINHJSYZRM9XLSIAKFXNHIDGKBPRUKUWUBUTJALUMLECVRPATQPFKUCPWYISKHFLUHFH9MCEZKFBJNUAU9LFPYVJU9SIDUMTCMXBFKLWZSWYKKWRKDVGZHVR9AKZ9FMLFOVLJVUNGQTMCGUBTTW9OWNMNTSWWMXHUDEUKKTFGOKSBZMODMTQQTCMNRFVY9ZVQMMETMDKMMTW9SZTJJLSXZBRAUWFPJMZPIDROBSGJTCNUGDUFBQPEWXRMXRDYDDTCFHIKQUMTUGRFPAORYUXTUSODRZAOTDOUIIOGFKPCSFNPBLNGQOPSAPDNZE9BKDPFBCEACJEFSNWUNN9NEPDYVLVREZVQTIB99SRWCYMUOYBWMXWWKYXUGYKCZKLMY9XLDGBFCYL9WKTWCCJXWRNNWFHFBVFIAPCB9C9ABFSHYKFGVQEWYSFVLV9SASTCNPST9I99IL9NWNROAHVTJHLJVBXL9PCGXRS9EPSJDXOOYORIWVUFBGZOQVK9DEDWLMXUIBGRWVOUAERJUELXRKZQHLYPTABIWXQDIIXSTCGDSYQAGAOOPRYFCWMBUH9VRXBS9C9QZXBEUAZDSWNJQTHBHJJFXSKXD9SUYODRHVTMRII9DQHDFJMOXFJWRSWILVNNNTHSSNSWPSB9JPADFPYNKCRXFKXQBC9PYOIQMPDHTNCATPHTSYDWMQB9COETDBNVQRTC9MLYKOVJLOCMMYPOJZMADEXBDBNRV9ABFZAL9QMFODSQPHUXONSDZHFQDJYSOXDDVIYPHRIQTGHDHUVFQXQWASFHKCMRMAFPEZKITKYUBFXMODZUDLMSDRLGLOIBTAJKKNGNZOGMOFVYRMEVWYYMFXPFNN9VSOM9O9W99RDFGZNVRKQCNWBQWCBLEDZJEUCDFBLZYWOOS9UKVWWVAISJDE9KVLAGKKIWJUWHVQTYYGEBXLHW9VDFXGSLBWSGXJVXSNAQEREQYKLVXGQYLDCCOCKFDFWGMSQTOUPCBLPUAAKDWZRTIKJ9NNXKCJ9IKXMWJHFNGICBIMLVYMQRBCBQIUSAFTPVWVSUYCRBUBJDMHXRBCCDRNGNDXBYQSFIFWNSHMGGORBOQFAPLQFLAEUJHKVZOPTZSFJIPLPRWKJPYKIXZHUPKMWXZYWGDFCXTEKU9NJMRPTIBRSJJIEHOXBNTELLKSESDXMZ9CM9EEDZVQZGZYHQNICXAFYMPWBAXMMXZPDWGYJDZOHAGVRPYRTWVFJGPUFSKGEKWYSZAWYWBCZBBBHHFNLKTJSSWZBRCWYJLSJTGXELLHSYGF9JFUSIQOWUGTMRKNKBD9QWK9KWWXUFVLBY9AKJFDLXLALWLUGDUKQKOXHLSJSXHHPAKVZWXAYDIKGGROLPIISSYZJWEDLUCJYKPCDJ9NLDQZFBQUOULL9UZA9KUQHCOPBOFMZSWOMIOOLNJYRLGWCZMFZGMDOLIVBPZAFELBOLCCGOONYKBCFHGQEZMKWORBSDISSGBWQHDIUPUJTJZQZQHPAQHZIJDDQKGDKWVQMEAZHPGDIOWZRHRWQYOAZBTKRRFEJDZQDDX9CNUVVFFOHAONSQ9YREWMAXWXYFXKKTEPSPILLDHZIHV9UILAZRBEQIRCRRIMTTCMBIKUNZARJZKBBBTMS9ODIPECZICILC9HBRTEHSHFUMQOPMOVAOLUEVVRFDNQQXROQUFVIWFFUQCLDVABIDVSHDISAYCAMDYXDNZXCFXMWATNQBAIQJZFUVHBNSQLJYLXKGUXXQRUZKYRSLYFBSIPPTMVKZOXWQ9GSVWKNQLOJDLFFFQCHCHNWDCHFGGTDSLLIOUMJBCYLFXTPAWJR9XYVGNRJJGOUUQZBUKDSG9MHXRHFEIWIJ9WRYAUQCTKBESDHIFCPHRQ9WZBLVHXBPJ9HBECLBUDTOTYHXTLIGWTKQJXWVWOCXO9GHDRJLAGFSYJFD9ADZNMMEWQQKSIHHBTIFWX9CAEOCVPAFPHMTNCSICMTGFVSRNWXTNPEFXGSOCXPUYNGLLPXNVZIEFPCBFRYBDG9JKDOXDIFPFRVQZLEN9JTLJJRXKBKSXDOCWVEYJKANLBKNHIQYOOMSTCPAYHUAXSETEBZRYLOIDP9SYEIMSEDZYCBDUVMBRPHJGEYJ9BPJKMOZWUKNKDDPZFQMCOFPCKEFURCWQYQKZTBOSUOK9BQKVNHOUMGVUXGWRFJLLQZKAGZUGXHZBSBLQKHRYDKQPNISPTUCKFKUTY9IPZBTERDAXLLJWT9TMKYLYQJNFBPFYWWPIQXDO9SJXI9JIYUYHKAF9HRIAGKGKZIDPURKYFZUSIGZIYZWSZDZVRPMFPZTDDJHGQDTKUGOGMMHSMJVJAZWDNQOYDCBQPORQWBQKDO9KRLYSIFNXTVTANQEJNSJXNJEXBBZTSFNPXTVZGGUZ9GJPQYTIUMYWWAGCNFYWENTLSHZUULAPIIMCJHFY9LEQWN9OCVBITOOHHOJYYPPNQLFTJAZFUHOZOIINIZCYEMVYZRXA9EXRQTSKDADTDYDTNWVEGABGORFHEPBAWAMHKZZ9SGKKOIJAFYKWPRRDDCDNMCRM9VICAHVFHGNDWEKG9FKYSBIHGWAIJUCLSCPKPYSXWWOVFIBWI9RQMAWLLLRRRAQMPJUCGMZHHHQJI9XIDBCJELYSZFZPSHZWIIHFOKBAOUBZL9EMOTYVVVWTNU9HVYSWYRJUHJIHUN9BHYBPJCKOXSBQK9ZHEWKDIDWFGYDOBTALJAGCDAFFAHLVMKQWABWSNYASJGCZCOUEHMBOQNRFCGKTNQYWMLN9YVM9BPTUXGARUGCXWDFESROYPBLOTFP9PVZTUXQFFQ9NCZSJPIVPCGCUJU9TAPDCIURBYETKZNJIGOJW9ZSZSGXNBIUSQPDBDAYZAFYF9ODBRKCXEJYXCAGBSRAPJX"
),
(
"KXCI9OMLV9H9PDENZYLYRPOPHTOZOZYTAWQSDQXOURPINVDKYAJYGIELDSUYTCCUZSYVGPKOGGIPLHNBY",
WotsSecurityLevel::Low,
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
),
(
"OOMQCGZWTUFMNPCDVQXWICWUKIKGURULMOT9FEHUKOZRBZYSIYNVSPNBKMYIHUIEOKUVHROCXTTSOQPHX",
WotsSecurityLevel::Medium,
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
),
(
"FOEZIZUKOYQWSXUN9BWXHQKPBXQJRKZWPTOYBVIUTLPPTKDUZMYKGFPCT9NFGCNMHHRXBGJWUNFCBAE9Z",
WotsSecurityLevel::High,
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
),
(
"STRGAQDPIXNETCGKHONCWUVFDZZCFBQMVCSBKOGTXGVBYYRAEJRICUEGLFGFU9BNLWWDDDKGSTMUFLNAZ",
WotsSecurityLevel::Low,
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
),
(
"BYVVELYIJLVDYO99MMDUZCARKALJVADZAHTGRKWQVSXSVDLWVBPEFARNPJTWNEYML9FFMUXSANYAAXQ9C",
WotsSecurityLevel::Medium,
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
),
(
"WYCMXXQZDSXPZWZPNJQLSTH9THQEGLFBLBWIDOA9LTGTMXQUFD9IHMIXXDEVCLBQCZHFYNJEAFYUHLKMD",
WotsSecurityLevel::High,
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
),
(
"YVVAHMBTS9SNAOXCNEIQJCGBTYPIRHAC9DHGDRYRFAIBUIKHWCOMVWWNIRIMVADYCIQVEDRBCC9O9YNSB",
WotsSecurityLevel::Low,
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
),
(
"YENBUJTUOPXEVXVSKKALYBSRUJYGXY9GBUGRBKRPLVBYQHRIDTOTGMFTWCGJFNMDBIKPOOGTXYELBQOJW",
WotsSecurityLevel::Medium,
"NIOOGIPWRTIQKGES9GWXVQ9HANVAMZHNPVGBVKJUJQZCVLTFUZRTDDIUQSFPCK9JZGHNDXMZSM9TYICAWRRYQQUWYLHSOAB9AQGZFOYZWRSTHRCMFBE9OWDNWQGIBLBFLCEKWOOQCNPYWXWSLXSWJCTGBXSMEHOEICYDCVBKJ9D9SPGFU9CGTWNZIFQXELEB9EZISKEIKTRHWNJTDAFLXDGHDVGWGVYAGRCTPYORGZRDDDYBSMDSFRGHROOKFMRNPG9HHVKLY9CNPBWGVERQQRXBL9ELSMLETNEGSDJTPFLERKC9ABYTONKNUIWFRLCMLNBWTAEDWHLSTDVNFPJCGRDIUK9EMUOOQRHNFKTGQXFFQRGUSRUXUKAZSQMLJHMU9LBEAUZSDUZNDOYWKQKPWDNEMYKTHUNDQYRAKODAAPYTLN9OJ99RBGVZSTWUKVRCNNVVRECZLGOSAZBAPNPOPJ9T9SMYBZKMCPJIDCSYAWGWAEEPIMEHSKNIWXZPAEQBELLETCNUKDPXXYQLLOSVHC9HQQVTFSFFVVYXVUKWRCAFGHPIRTJMIKCCQQMT9FDIEGNDFPLIOZOOQEHFITUT9LOFO9EPXW9TBKJTORZLPRECUXHDQFKLSXQDNTSGIRBJTIHGQAG9OYGCCYOKKYUNYVUASFKSFK9UKOCFRHEPKPOOZJOGKEKK9OQJJKOVFABK9SGRGFQADFJZVDKXAUSZPLFV9SRHOLSNYTBUHUIRKBBIGAHOV9EBUHQADAUBIB9HRJ9QNOPTMJ9PJPVDNTUPZDZRAATAWRVAWXILTZSYLBXVOHMBYJIVA9YAARSDSIGHRHQOPBNUIVZXNDNOVXUEARBAUJTBKOEKCMGLEJDGFDXQFZXJHUX9YAKWFGZGUSQNECD9OLV9NLYBTNSULGZA9NV9LGAGKNZHKZIYUKX9VZNXVNSMMEFJSRBGRBIHYNIUGTSSXIIOQDIDSHGKE9QZWCQJQZMFJKTYZXXQCDBLFXILTLXOCGIWELNXWVELPHAODSKEKWSBNGQNABQGZCPGADOYOFCCXAIIHXWBPSSATBNBIE99YWVTQVATAZDBMEKTRMVJKD9QQOPQAAEVLPICOXNQYMHPXFPPOKUDOEJYYKOPACYVTPITVY9VSMZJB9WCKOAOROU9UDUBOMBDHMHTLFMBPKXPOGGPJIDCDFHZHLGLGUTIZSYABVUXSHQINAWXX9BUKMUUQLEGZEBNHHWCPXYOXFXSFXDHIAXQQYSWHUQAZIVZICLQHYBXHBOJKAAWVXNRRW9RUGFYJVABWEUDRTUXXYGCINPQUMWJZBZDREWXIIKNRQSPWAZSSTOWETNYHTWRFHSVRLQIXZVAVANHJJUWYQGMXTODBMGCMXROZPXOZEBHZWU9KXFAJXJPKVSKWTAZYBAJIPMBCEVYVQOIFLKISFA9YHNI9EOBZACBETKZCNULYZHTEOYBFLHETWQHDXDCWKTFZYVNFQGPAZRAOMNDBWISBABUBQBGLA9QDISVHEROPMXACEXD9OPUSBIQGNWARXZDVCYCVUFSGISOHQANSJXVBSXHPD9MKLSEBVNVUBDDDD9JGLDGNWGYFEPSCTZLDELOLCOUKSZMXVTYDPETNKPTXXEULN9YTDEPERASVNQOD9PWEYFRSVJ9SAQDHLFPOCOS9VZHYAFWAHELHJCMLWAJCUKLS9HWZPCHNHEOTPPY9VFEPWNGUMNP9UGFMREGCAGMHPKCTSZDXOFX9ZBGVUEHPDFNIRFNRL9IKJIOTMJVQHTOODOPSUKVAA9ZBLAYOGTAIERIZCYJFREZKAYIXLUHJKHNHZPLSMOFJJYZD9LCRZ9PTSCSFLBO9QLLVNXRNUWEEVNAQNKEJIXLDW9IDLSPYCNHVDRXEQIERVOFYWRBBXUVYFKEYHNKDZBOMKPHIJIHHMLGYMOCXGVFLBNXOHJRNFHMLVQFKEOBFVJXFVHIOBSQGEQFMOQETWDCVDBGIMQTULROBHSMYFVSFJSXKYB9ZWODRONCBNXNDTGWBMKYRFBDNMQZOVQCGPNCGUPUAGMXWCNWCMSMBOLYVZUNWHLRTMJWCCMGQLDKDFOYFXTOEYXT99LMHCXQJO9QNPHUQHYPCDTOUPYWCIUK9HLJHNMQUBLOAKGYWAQVDIMHRUQHQMEGZZ9MWXZFLDRFPNDXNKUCVADTRYV9JZGLDTAOFS9GIFMVMX9RXIDIVDLHKCJMSLGDJFABTUISH9Y9XOISHKJKMQUNJFQGJEOFZ9AJXPUDBJJRLBPUUTBHSNZBKQRWWDSTBKJK9TSVWWUESWXFAFQFHHFDHUZYUNMRBB9UECQDKYIYYLNERLFGVSMUXQTXEXFYPCVX9DJWKRUOYELHSONGXUBQUZI9CDGE9XIXIEHKBBJEEVBXXWXQAGFKRYAUKGVNDMTTERHGNCUZAPKPOMJAVKLQDOHLREILDOHGAUALNYZOANWLMJ9HTJQQTBZZKWLKPDGGFZLXQNLDRPGBDDADSSNBHBCBGLXRMYKFWLXULXHWIANB9HYDGWXYKGZ9JDHQIISPAKFIMEXMCCVOMDXVAL9OPIEITLK9JNYYXGVFITVAQT9DJZMFJILGGIX9CQCJZY9YVZMWPZIJEWNJMIWSLFNJLJWKDYDGEBDTVFPBUQYCKTJYRVPMIDDWRYWXWLLIFKQWFRNQKXZJXXRJUVVUUSEGFPRQZLJP9WCOPOTVKQG9ERNSIJUND9LZRNEFKDRNRNLZAICBKCDUDXRQHKKKTIYJAPTUPCFJZFZYMJQEP9KZZHHARTYRULKUBKZAORZZFDMTUJRG9IDZKVTJHJUUBVCQQGCYYGDRFDPXBARLZITUYHYTMSQEM9FRWHWRDR9IHFCLYY9LLGZWFMT9PEWVRZCAND9VGIWHJMSIN9XLUCDBDBEANGODIXPOLBBMZIDOMLMUCZQIMNKZNLYXZJFPOZEPDYTKBPEFYPIJMJKDIBCQDOGGTONWTHFXBKACMVYZXLBMQFOGPBPWZGTXE9OQNJVUTGYBHSTVIQCACMQZKHSRMUONAPWLQIRJSKDAFHFMGBMXZKH9GXQBXZWVOXJDRAUCYFMIHQITUAHQXCCKBMB9BMWVEASEBYALJNO9GZDYRHWIATBBSSZOYITMM9XARQHEOVTXAUBBN9CIXW9NPEJXDQHU9URIXBRLMAJCOQVNCVXQXOEHCDLJGPVYBGITGBBNNZMGGB9YFXKUPUCWRCVTDVFTXDHZTWRWHROILEMJ9SSUMLMMTCIZF9IQBKDGDTWAWIIPXZBDFLPMXUIQZDZFFSBCLNTPLVXZDNOKUEFUDRECYVLHCI9ITYWHSSS9JLUOTZWOPUH9DZNWQMZZCUUFHAJLJLFACTRRNUKAXKZIYPWKFLNBICKAXWXYATVIKWVFDLBDTEYQOPNYWOUPVIUPEBCMBOZRDVBSQNRWEGJTXNWFETUCVKQZDEZDXKLPXHFVHDDOPYUK9BH9QNBREOOAMZKPBPTVEIOSIJMTHFTRXTIBEHXOMLVHIHDHMOQCHAVJBZPKUUWCHKQE9KDZLOCLYXKECOHZIIODJYJESMAGIRXMGYKMINWTBFHNHFMFWGRE99ZUT9OWME9YLOBALRODJXZJQRMSLFCWMZUYPVBUE9GIV9ZLZMZETSKFDTUNOCAAIW9YFUGELB9SAJLFMHSMRZITVXCKGZAKIDTJWZAOPRJDX9PHUIXAQXQMECB9ZBRLMDIKFSWJTLUBDMISMTVWUEYXJXSODBDJIOL9TQJJQDUYLJFCXQKMUWBXEEIWYWBDZLBVVMUHRAPMBBVWHDBJOJCPVEKHGSOZOM9VQZRTWGREJQHX9SKZWZEQODX9LUAXLZU9UDZJSTDOOF9QWDTHOHZYPZFUAXEYDADWCCVTRMMUNRGSYBYAJQPCXUJEDIJBORLPWAASOLRYHEQTGYASNJYHDEREUFUKYYYCKDWQMMDNDPZDZRZRA9VOKEHVOGANYHTTRFHTMVJEKBIWVYHLXEAGMI9ECSCH9PUMXXBXIKWIBRIIUOITAGTNIFYSVR9SX9WPZBBVKISGVQDCYZ9ZBWPPVBKLVYNPVMMUANKSVZGNIGXUIUMXJARJGUWIRDIMQXFDWWV9UOCSHDVHNXPOL9BRHKENKLFXLZZJVPRHWKAGBAHCSPELZNXBUG9K9MELZUJPKHVIQXDQLFDBCWESAHMGRCECBVQIZCSOTDKDNXGLTFATZKRCNTLRZOVZYASSJATRNBQRGPGSCSNOMVLZWWMEKRPIRTWSGAZIADQURLRSJMVTOJCCOCSHWYSRWYEANHZRXKHTKWHHKQXQMPVCXMCBULAMUWMTIGUWFQQQSFPFCGTUMURLRVDTG9UR9MFMUKRKCHZCG9"
),
(
"HYODBQENCS9JZQMFTNFGEZODXPBYCBITKUQBDJJPMCDZAI9FWYHQOHCM9YVXGFKBSAGQTZUVDTCRCJYBW",
WotsSecurityLevel::High,
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
),
(
"TUSGRXUXNLXWGUEIBMSSTAYY9JCCE9PEJJVDKPBNJWNNSMSHPBBORJHIQGAZJACIVWBFJGFHW9UDVXKHA",
WotsSecurityLevel::Low,
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
),
(
"DKBEJJJYPCFCCVVOZSGOOISPBDYNWJTENRRCHQYMKPYAPOOCRCWRZLFP9RBBGFXYOON99ZWXFUU9TNNPY",
WotsSecurityLevel::Medium,
"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"
),
(
"EAZIIAWTGGGRNLKKQNZFOXVFKOVUINNHDCOAD9MENJSQFYMLRSQVOWWCRTLV9ERTMKHSEZDOOTSLSIALA",
WotsSecurityLevel::High,
"MYAKLRGLYMDBO9ZXENWUNNXPGGTCIK9WGNGDZJIGNUDJGVQZRWPCDRIIEQYXTUCWYHHEYUKSOHPCVSZJDYJRNYJQWOLMCEENIZKMCMRHEOOQEKTARUQBYGZKJIXMEFUOSNRIGWKRTDAOTAMSDSIQ9WEJFCZADDGNRDFMHTFULRKODJOCFCOVNXDAGKUPTEXAAHODLYEQFXDJCFQBCPOUGUIDLQACWHVDIGULLGLGHNZZUXR9BCCQWCPCUBYBZBVIURHWKAQIFVPJRJNCIRAUBIZBTIEFRLBVBRCRPDVUAEBISIIJR9OYLYXUYCJIJZMHSEADUUSGVQ9TQPKWWEULNORVCKSIVTTNAO99EFQFESGRKZCSXOQFYTMYWXCK9YLMEKOXOKRKZMMECOPSELDQ9YSVNDCKGRGUHLECDPGJNQSB9VIPRALJVCOVEUTGZTWOCRLIDGMZGNYWHLCDZOHQ9VJMT9B9JUNQOMATEW9RFZRNRB9JAJSX9LEPARJXR9UNABXNDEHZXDTEDJILCLZUEUFG9JPERSXONTHQJPCWMZSTJ9VBHVYVJRBJIVFSEUYBZLNNNKWWDFL9OZVJPXNDUFTLPRQUMMWTIBHELLQ9DCFSJANCRUKWXZEFPEZFVM9UWRDXPCPANZYBUANJUOGI9P9HUFRNJPFNUOGZRJKZMGMWYTIYZCVIBDRSATCWIUBXLDQRDDZHY9NXDLQIIXBFSEUODMFDSPCXHBMZAGVLTUOTNLNCJSUKWLSYADJCONZNTIDYDMGQ9TMWSKXH9DKXTIGCPEEAXVEA9COGOOWQQXRG9ADRBWSTPSHWSIWN9DJKSHLCZ9CLESXKCFGGPDGIVGYJLSKTJ9KIANIYKR9AEQLRTLDEISBBDMCJMZXQMINUCFGFCTSVHQFNO9EBPPPUDGWIMUFUHD9ONRLCTYXDXCZDBCMZMBOZLLCGPQBCQPAZZWZIHMVMXHSDOLIJUQNAZJEIY9TFPVULV9HENGAOVFHHPJJXFZVFBSYYFHCMKKIERNTQRJL9VXEDUCNFBYKOXBELVZEHWRLBQCCCLVXDIBLGRIYTBIBTRYJLBTGQ9UTXEIH9YKYYCGCBUTIDY9ISN9HDZOMZCVGFIKFKECHQUBEADAMKGDUXKBMJSSNNBYHDNCLDZGUCJNIYYGAW9FCPYRGZHAPDEIMJCKZTSFGEVTYDCAISYYFXLONMKKUFARZTJQCRF9JZWWBJD9SKXKGPXBGMCDRXFUUGNFLCYRVQUXLFROLYMJIHHYPDYGHZRNLQHVNAME9SAVYPTJVXLTHZTKWVIAENPQ9MAPNRPNYSQBUOGGBYQCLNNTOXLGUTZFZDJDWNAAJAGEIEOQDGTIKUANNSGCBDULGYDVZGXV9RFUNVPIVZDAVSVKEPJJX9DNNVXCQSKWS9SQDUNAOMPRCOJIABJVLJZKGECWXWJPZPAXYHIKEYLBWBDCVQIFHJYRKSQWRQPLOCTAKFBOELHVXOGFGEZKGXZIWRNGPIRXNOKSEFKWDMNE99SET9FLNOCZPSQYDHKWORWCWNBGGEQIELRUTRLZXXKBZKHSTMPGMWCADGBHGSZZLFQQKYSUKPRCKYPIBSEANUGENAIHYJIXMZKCLWWAXFUNKM9LNLZFBDIREIPNFAQDCW9FVTZNISNERMPWEDLASZWIQWGJYDMQKGAMFLCECZNPPMPYNKDQVQSZIBZLWI9YSGYZULAFADCBPCSGAAWUWRHLGTDLHPRISNSSSRCWS9SBRGHEIDOPXBQFAWACHEKYUXJAYH9DDC9EEYCIQNUMTPVBNQYLIVNMYORMMCDZCSZCWXKWPVYCVOAIEIBXETUYUJZWOQSMYNJTSS9MWVWYXMKOIBWSYNAOHJHRANUMZZHQEFYH9NDSPZATCSFYV9QSYOCRQWJUCFHTSJYPJMJYAMYW999GJOUAZQRKBAEFKFW9TYZGCOOHHMYYCOPCYPUKNGVRMZHHRBFNJSFQACTWJNZFGVHSIARGRKPKV9JNHPKSNLIXZYDFLQYABRLYKXCCCYU9WREJRYJWYHMLMZCECNJKZXIZL9GFXOXIEXAWUDDKAURZSEHNGBPYQJNFMKBJZZEQYWGDLIVZZOWTXE9TGZCJJEPUIXOFESUSXQZBRGUMSSKDTRBG9VJOX9ANSEITHJYYVZYLHN9WXSTCZLKQFSQW99CJ9QRBUFGPCTVUUMXZHNWFXFF9XN9TTUUUPBDGH9XVLNPSALUIGIJJDTNAJZDDWHAAKXFRRQAVZTPFWDXQDFKEYBNOLKMJVHHVYZPHXODESQQMNDJQYGYQKYYJRTOEJLTNRWCWOZORMPCFQAUMJJBJHUIBYJCDDOD9NEJKZEIYSTVGSWT9ELFFENUAWLNMFJOIBKNKQERONBMQESZCELCLALOALOYXMCPUMNQVNKMKWEPJZUKWPWSKBQ9IU9VTEUFRRHDYBMIFPHVOQJMHDCAQERENDZDRE9RLFZYGRRRKFBSNFXOBVOIPDYOMLCRGVONYXLIY9ZIXQFPYDWOFJNXDBQXFUS9KUCNYFWIR9DOGPAOYZDGFGAVSRBDSGVCJWTPIPDHCYJDKDUBFPKSEVZAMMUSYLDGHRAP9JNFERTEOE9BKMGXKGERRYBKWTDVHHQNQSIGFFIDBLKCTXUGLSBGRX9YW9QYFBSHVB99KIQWMHSKIJVJSQI9AEPGVKGKR9OCOED9PQRZEKKZSNBTRMFFFRIKRKMJBWRGDFMOQWFRINBCFARZAKJBBOSDJHYPXISLEM9WXLOITDWPKUHAVDUNXTXWTPRDNAAYBWLVEJFGONZQMXIIXWKZLGOLDCJAIPGLCPOCXWEPXD9XNNHICAFE9IVEVIYFGXWLFYIVARIIIX9TJ9STKTC9XWCDAFVMYYFPYORSXXFYOBXMIAABHONJQPDXAJTNMUIHFRMUCZZTKOM9FOFSNZXEBU9LFNNRXKXZWHXAJMGWQTNPXMTXWOWC9MNXMDXRUHBQGPNRAAFCENLNXBNROONOOCRBIRPJPCKVYSTDCLJJSVRRVEWRJDUDYZGCYXGERMEYTJRDEFFQW9ZLVAGFUA9OLUCFZOSKYBUQQNXQSJAHTQQNKIELIDL9LJFL9KAELEICXJDAAUQEYYLOMCDODDQH9VPTLJLSHTGOHYKUDLQJYX9AUQCFLNOZTNZUPYMIWFBBNKHJTUVWKTDWGZVGG9HZZLSPL9QNPCILXSDKQD9JNBKOLGTMKOC9KYIPRLYQLFONIDGJBCPOWNMMWQUWXPSSB9OHHJFVSCJUKCREOOZUDFRBBXSHNGHZXQLCGNSNBXAHGP9XUFSUOSJCBNTCDALZWLLEFOQJ9WDTO9SJMQLQMSIOXCIJARRVGUIOI9OZPTCJQRBIFMWWJT9KJUDINVNZZFXCZXERWZUQWCWOPLONZUCF9LVUUBTCGMSAVKDINDMPIJUFDVTCPAONUJABPWIFDMTWZ9YIEAKBXQQMYIFZPPPMUDCUTAOUW9TZAGVHYJOKURS9POTDNUTMVVKDIYZ9YCTFZ9NIZRGQQLGAF9SWN9SIEWLIDEQBMWWLIEXIBVCYLHAPXOJONRWA9RIFCXCAWMPTRQSDDUGNCMWYUHLFG9RCQKLKJEUKRENWYXMZDNDZKGDJNMTLENSDJLEWFAHK9ZBLQEZKABE9E9VSFIPM9FAIHT9LYADUDWLDRQSJQTHCAXMDBGUQKXWACBK9SJELIVKEDGWKICDHWNGSDE9UXFCHTZKGNXQOTOHRXGKKKALCLUW9AMLEOBKWRTAAEFQLILQMFJEKADAOYLKRQMHTEVZVNKPZNDTNBYEYRKHOTRMNFWM9TOHEKZHJGMJZGZGHDNOIZRDBPZQRWJEIPS9KGKGPOUGOTKTZI9LXIKUEISYXQMBZKCQSZCPOYYHOOSJZVJKUANRKAPFEWDAMYAADH9OBYNRUMPKVOXEEWAPMMQVFMEYEWOH9LICJFOFDNY9ZAA9BADFEADMIIUAW9SZXQZI9OFPWEHYADGYAX9ORMVOHLJZHHNLCKZNHWTVFM9YGZBXOCJXUDLZ9EA9FWKCMQPRR9NVGSIXNKBA9JULEMXTNBOJEBDVPHMKQBCBNCWFYQESIYOE9IPJKZZVSJSPQNEFBI9LQUUQCHAZEQGZISKABSXPINHGUATQEZIZOBWECQONRTRXHEKNWOGWXXOLKLLCNSVAAQROPMJFTWDCNYOJHPJZQEEDAFKUZFBPTVEIPINQMM9TMYRS9SUT9RNZSLIWYH9WXKYRJWHRSFUVDPSQVDTXYHQSWHETYXSUPUSKAJOJXAIAIDJOHZJAUEZOHBRTHJHKKRSZAUUXQEUXQMLWLUSOYIUJFLIXDOKBTFWQWAPEQTHFFQGE9NVMTRJMYXLOCBNBRH9DDR9DTHEMCGAKOZLEXRJPSIZROBMISJMCVZTFFOUS9K9VJDZIVQMGFTOTVODEVCZFPOYAPGBMPEDTRCOCDWHQASSNZCCFAQTEMEEIXHWQVDUPIRUVEJLRGVWETRYJDI9UJZQYBPFZLGHQZSVPVSTYRZDXE9WIIEJVSAVIXYDQ9GLET9WYWYUAQNFVYGZBRVSRFZQ9J9UWOOISYPGOR9YHJLFUUGQ9WSPSU9IHGLOZ9HBECEZTEIFSNYVGNEGV9OJXIV9QCVKXEYNCFGQQJRQTESAWKPNGOXHIGQHXQAAQGUXYCDPNRYGXJCVKLYQRPGDDMNZZXTMFNBFRQWWTDEZSVZVFAUYWMUXDLUGBMUOYKVJFIRQSUQJSYFJQOCIKQNXTIRY99FVF9PWJXJDODSMPUUQFB9HFWWZEMWNBEQPYHZTZBK9UZETRHOE9MSYDMUZ9SYVYTCTYBPHXKWAZYFAOMMQHACYCXNFHAGQGYDUBDAIYA9PALSSPFZUFQXMQPJMEUVQNIDSMQCQLOVUSISZQHEKXVR9VUBJCECZOULTWU9KUWSIEAASETMAWZLDGBOPRAXAWMJXSSAGTTQISIEBLEJBKWXGMGPQLRMUKJCTIJH9XQHERPXUSSOQWSCFPUDAZDKKKWLXSVIAAGCMLJ9UMNFWNQLWJKHGEHVOSDAXECGKBIHOPDKDAAWDPEWFXEEPYAKFTJYUBSVLBYKDDSR9Z9RRWQVVSOXFXTVJAKZYQJAIOSNFXHHNHICDZAODGJOTPBBOYPYRDRYCCWDCNASNYDVNGKLMDRJACWNJAABM9RL9ELX99VWSQPREZO9JJSRJFXNGZDGDKMVHZSQRL9M9KESQRVGXVYGXLLGCWMMADNWINH9BTDDOUREAKTOFYZNQVVEXBKDCMRIRPMJYCHSHUIMTHNGPKPYBVSQXMQLBOKRFFLQJ9HI9WOZAHENGOUCSCMAVHMBYERKCY9YULREPZVONHRRYHYEVNDHPUYTJRPXCYHA9OWRQIHNPPMJYTTYBDTWSTTGHXWF9OBIKNBR9MELSTMZIYLBIMPLXSXLYOJSWGH9FDBE9FEOBKCGPIJGLEMNNEDRBVHFJCGPWFWWEGH9BGJMLHUCMHQFUXLTN99JVKAEELWJ9GMCW9OY9L9OCKCXAOPEWRMFYCPYFHHRXYDWKBPLSVWFPIOPPVYOMPREMOYILIONGRXGKNZVXOZXYMVXHFFTRDBECYEEDFFMKLLHXHCYKTKXXHVLJKP9TOKXMLXYOAXHPMIZMVMPQRMYYUS9RURBMBMCUSGVEXKWNKKGMYSOJVQFISOBXOANYUCHLKKSVKOFVRKTAJSGRIPZ9RJOW9DJZKPXTXMKKNRRVPZJCDAHC9GWWW9PPJOIPQHYSNMOHUXGBFCWCY9KZJFAEFTOMWNGAMLFREKIJCOBBKTGPSLH9ILQAERJVLDDZYOJWLHTDGSBNPJCCCULYXIHZYL9JPMKDKAW9SXQXIT9UYDCFLSCJJWVLLPEJUDU9WFNYPHLVADOAKYAXRDBZHXFROBQVOIYPMO9ZBDJQGEPYLZUKNG9ZTJEIDNTWMGJOTGALCYRKRCSDLASWQCKAPEJPSJQDELHONZCWPOULWEOVIBIWKIOIQVMUJYLRLK99BEYOPVZW9SWFOKNADIPXCVCKYKRHWYWYKDQXIGABNGNUBFMBMCBXHXN9WUMVELELXIVAAZMQIDIZMAHRSD9KSEBHDIJJYJMXGGXKTAIDD9VOEOBMWQCTABC9ZRQTVSNMWHRQ9LSDZFROOHSGFKSVUSKXDLDBDBR9TAF9SRZGZRKQMHHZPAOCHKVBJIXGCOGZSPYCYMOLKFBHDPTCFDFRNYIMCNZEFKKMHGIXLWWI9V9DNCCYAFZSRTTKBRJWYBY9QQZQJUKGZUINHEJOIRBRHPUQPMSVJSITCNDEIACGWIQUNHRKHTQGYUHFHNWZQTYIVMKRFXNCCVLALYBNVIHXRPEDQLPOKFOTTROZGIKOAMABYLQMXRSUBJRDBKINMLF99INWODQCIVCIMXIVIHZIHOFUZZPEWDQRDOFSMWMFQFRAFYCCINRHDCRVJNVPTFUTYEYQYGUDBPURWPU9DYPMXELHDZVZUJNTUEXUFDAMRWMCKAHYQKRZ9HAASVRLKJ9BTPIPOMAUATPUIZARZASLHLKCLC"
),
(
"SQSMASJZZFVUFB9SPLCCEBGPCYYFMROILKUMWHOGOJVJOSBIBSE9OAVKDXAWWHFERZCGVL9QDMSLVBUYY",
WotsSecurityLevel::Low,
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
),
(
"GXGZAWYNLCXDOOSQFCRIGZQHMGHZWQTBVMTXFSEOAAMPIWISGVAHWLSDGPUOMWNZORWDQMRXLFMXTAVGY",
WotsSecurityLevel::Medium,
"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"
),
(
"FUWBDRBUSSYKIKNVTVLSWUQSSCZAGSOGVRQYOSAWKZDTJSAMWWRZUMQDHND9ICFQZDY9UBQTZNBCRUZTY",
WotsSecurityLevel::High,
"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"
),
(
"XIWMNWEPEYBQURH9JHHDA9C9LSDXJNQZJ9SBLFTIEUCFRZKD9KQWMITKMROHMTJKTFDHKKJGIRQPSONRX",
WotsSecurityLevel::Low,
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
),
(
"NDBPLZTHBBQOVMIENKRQGMN9UG9KYSWRZCBQQTONXNKBXDPCLVUZRRLAAZ9WSYTSQIFIBRACWCMEIXLDY",
WotsSecurityLevel::Medium,
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
),
(
"RQNIJBEFDBIXXVG9XIHMNKGBAOKJPAKO9DS9FNBQBPTAOWEBUWSJGMHAFBOCYPPLHAZAHNVNLGRVLFQFD",
WotsSecurityLevel::High,
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
),
(
"ILFTLNNQHRDGJHUHXINKDHHIKDELKHBQMYOERP9FTAKMXRFIWUX9RECFMYSPZKRAGIXWFIJ9RYYKCLWV9",
WotsSecurityLevel::Low,
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
),
(
"IGQDOHITOFOBYTZKSJIHBJRFZIEFMYISKFXOTHHIVIEQ99MQ9MJDGUXRNCNJCCCCNYKXUGMHGZXABHMYC",
WotsSecurityLevel::Medium,
"SKBXMSFJNQZBRRW9LRYFZJTHQJ9MSKPAJDGMGTUHIYROSNJQLOTHVAVO9UB9CXIRCUUFZKHDASFQZAGJBOCHLVOVBLTDPAZXUCWOSGDRQNFKBGZ9VAFLWLYKWBGCDXEIBSAUFNYNRRRTSGOTDAHUOPRTPWKGCMIDKAPQLLYSCVYODSLJLH9VY9KFISVFCQGFFVHKYQND99PEZSARQCIFFGB9NPNBJSPJ9ESVODBUDYFCN9ZLC9WKFUHNXQRHQXJNTGSERFKCKMBEH9DKZHVTAYCWKKQYVWMLHPYIHJEUKDDQDXK9JBYUNDGQUWJWETMXAWKYUDVLARBVTUYSSNJUPEBSMHFBWOHBXPATPYOOA9SBFJXJS9DMVZSQJXQQTFZACKPAYLPLMTKUBKNOHJWGCLRZVHQXSJ9MXCUJ9KUJVGUKOPSNJZFJUULFPSUNWPXGBHPVKGSG9TVKTUH9TZQOPFWESJCNYJGEICJWOWT9RGMULWHQQAC9CHISHMRGIYFIWXSWPGBSSRQSAHUZCWGYGPIDISJBZEUUHFNDCZDZUNMZ9HBCTNFMTK99BRQWECBWATHIEPFNDTIXDCJGJOXHTLRRKZZOIDMKIPVXSKXEOKSCAYPRPWIGTFHUFCTFVYVKQATXCQPAMKWHG9AKMMLFOHQFQPJXGPYTDMEFLVJRAIINNHTST9RZAMAXZJAUSRTPIRRMILLIRWRLHKLVTMYZCVZYWUBDMHDQUKSHTALOTPOSNPHDDHATFFGPGWEIWHFNY9KSQ9BFMSCHUNVVHLQTK9KLDYJLGJLTHVMGKNRMFWNNJQBAWVMMZJGLN9LWIUKFPHXSGTDULODWJHANNULZDXDQOWLDL9ALMLVDPHFHQY9EGUYWXPCERWZUOSBDRCUVMBBMCEZZONUIIBRFXWPLOBJXEWQDL9POLG9KGZJKEIJZPRPVYTLYHOBSHOPOGTCBLMJXWUTLSC9CGZSGNAEZNDUJSDI9IYJPKCSHDTLBJMZIBXASNNJRKWAUS99PGDVNUYHMQ9HDWCDGKXHNHEBRZYHFAGJHWKX9SGOIYTCRZJSO99FYDIQQUNFNR9WZTSESVEMMPXWOKNQGASVDNTUJUHIAHYKOC9JMZZLRUPICUQAGWXTSUNYFPRWDEABELOSMSNBGPCWEWXBD9GTUBUJHSMTVQ9TJRUXCPDPTJOFGNIKSLSQFWMSWUKXHZNXZH9BMLRQNFBRIFQDHUCZCEKRRNRJAZSOFOETKCGIH9IDOUIGSRJOKQ9VBAGFVRPVUJ9ZHQUJRHRHJEA9KILBBBSGVGDCPAGJXU9LHWQYQFOJHCHP9ZGVGRGFGWEVZLUMRGJOXJRPDHZBRDJU9BKX9CITNOORYXVGVLZQNYCQGFCMRWSTIURTCOG9TWEJF9VIRCSRUIEZZQAFWC9HVRPYO9BRWXKDXNDMXWZJZ9KEJMLLZD9THLVPRZDYMUWNHMCNZ9RVFGOZYEXATNUHASJNCCGSMW9ZQP9ZCEWQIIREMMOXOCSWRTWDFONINNTWZCPCSYYDEJGWMSPLXCQBKTNFDWMUBIUCZQOEPOIJ9HEVPROE9FFAGIHSBFPRYNVFZZHVKMSAVNY999RXRQLQAIOVXWYYCGPVQMXDBYSZOFOXSTVKNBTX9XDRLRVEIAGGJJVYBNMEIDCIKPTMCFQJADIDRGZLTXMZVNVGMLDCOJMVSWRHXWGYHKRMPDXRAZLTDFWCXTLWNAAPG9TEASXXLGKEJUOSUGJEOIEXNOMMF9DVVWSITJXADJJCHDJSUZZQRR9FFODFANLHUNMSNHKMNLSSAXULERWIKVWCWROWFQZBEXCCZNPEIHE9KJZKDAKZUOD9UJOJYKLWLTQ9PKIGQGQFZOG9ZWCKV9WIDHPKIPCGEVZBWCKPLMQPUCYTPBHKTLMRRQFTVBFARNZHCNOMEHVVJNAMXCLIY999XN9YPEAQZ9YHTOTSKJFQXZPQEFUNSUCE9JMDOHFAOXVASTYYTTGV9QIZDXTQLDTPOD9SSZFFUEAPNCZYEGNZUFA9KQZFMYHIHTQYCUQGCIJZBGEHHLMZZGAGCQIVSVB9YMXCMYQWUXAVFOMJNGLOJHNTYIDECFWCBWDNJHOJXCEGSVAJHHBROFAXBTGR9NJJTIAPBUXWQITKWRASEUQPOTWFIAVYVTRRCFSZAYNH9RDBZNHWAFZWWUQPIFIKXWRUHTLYRHJPLFCBFTXWJSGKLHJDDGIBCEBGRGXOYVSZT9RTNFPTBM9OQVTKJTQLBBAICYRBOOZDINIDBCU9IMLWTOPKAOIMRUXPNHS9IBJVRDOVIRVBPM9NSSUNEOI9QJSIQZACHWYKLCLOUTCWEW9KKGUPSROTJQSZXTHRNJYTIJAQDOYZVSTWLMLTIRUABPQZRRTESNKLTPULMJOOOEWKHPPJODMPDTMYOXXVWF9VCATEQIJKAOLBNULDMKXNZMICFMXYQU9COHZSLWFVBRD9FUHRUFYCDXGBXDANAFZRAO9YVUIDIFUXSMYGGIVBDJYPWMMLYNUSNVZBRKKAKJMIHL9JXVIQLWVAOMAMWJSHETMOVYGBCKNMRLPNGKKLERQCJUUJWBJPUDNOSNBIYBKBCFFWBRKBGN9FSQILDRBSFMUM99QTHLCXNPRILRVKTNNSQHYCSGKBMNKF9EOSRTTLEDHMEZXGXWGOG9IXVFDOT9LYDFLMXIFCWWZXPBBLMUQAUFYVNXGATXZSZ9AWSAQIBDRA9QC9UWIUDQLJLPZOUTQSJHQKUOBMEVGFJZTDKEXJGEDQPXLEOSXHAPUVTMQHQUCBBPLXZKMCSON9M9VEA9DCUKPCHYXI9MOZERHMNMUSRRNDFUCRRBWEMJULYSAJPXBSIRTHREXXULJXYBMO9GMOJRAHMNJSATAFBRTCO9FCQVFDWSOYWFNAQHDWNXTSVIMENLUJBZGCWNLQNVMSDCOJYWGI9PSNVWYGVHTGDTHR9MBULKQLDJZHGKFGIQNAU9JDH9JRFZTSHDQMLKHDDFJJYVOANMNSWTGTSBZTROKHVYKCUCISXYEZMZIIIXKJJASDBHLDHCUBCPCU9IBALRWGZFRRXJNBMD9OIIXSTMLGVDXNZTVQEASAQQXVEBVTCXXJER9YEEMYVSOXPIWJBPSAZWWQXTPAACCXYZSWNJ9KZTR9SAFRWDXOOZBLVFUNQJODSFTTNDTPWO9AQJPIPQCHOLDXGSNSMACOGBFQBJKNLCKYLSTOLIWCAVSSVUWNIEPMUPTULAUZ99MTMTICTIUDCOEAWVNTZZZEBUGEAHWFQIQLNSVHJCAJKZAZYTHH9ZZDLQKIM9FUL9UZKYRTGYFCPTCBGQUDJEPRBJRDD9VQYLQPSYIQHNLPUGSHACHABKNAEVPEUNUUBAARJ9AVMRPK9WBXQYKOSUDCOIPPQDPTACAYIWIQVUQXWMFSVNPZCPXXJMCZRCXIKXRE9DYRQRERQBMXEKHJLLNONPMCKJZXDNQNSRNNAYPMHQCLRVXFJGEKY9EQ9XXQHFAPUIHBQKDECTC9OZNKQAWKGSFWLJSUEY9IRLHXCTYHSZAZYSNWXWAEMYEVJEQETUIMBXLLXIYHAQODQTRRUTKBWCIEYH9VOEXROMBIRIYFGJLIZEGKXEI9FB9IMGFHVWEXWUZWGNZVNFMRDVPX9LFFKNJBMMRYHOUOMJCZRMFPCJHOHVBZXHPNGJDPDPCXJFZMEQJGSXRPTCDHECXWWRVWUOAOUEFLJHEGIPJIMOZDH9KRFUZHXZZDJY9PRAZYVORBWPLRRLQBEUMRRUJLSJYTFY9FHOJRFZRX9ZBKSQHUOWQ9IKMEFUHTKTQGYDZK9D9LCUCWPYIP9MBBYFNXFOMNCTEFMV9QDREXKIVVHNGGKJFZGEKYXMYAHXDY9SHINTHALB9CLLPTNRSFMZTCODZBYTFUZUMACWUWHCMKO9YYZ9LXLABAUCYCIH9RASDGMTQCLCOAQNVLSFEHUMXPMBJSZKUVQCCRVPHOFFQWHQ9UHJFGMUJVNDRQAAYOYFMK9OQHBHDTT9MIRRXYHMNQMPWAHCD9RCJQJCJRPTSXJOBPLHNCNTJQVBBOQTMFPLEQFXLL9YIGMSQMMGNKNXQDULGJQIDNG9KYDWPBULFXBQ9YHTFBTGGUKIEJRSJTTCCXJHNNAOQHBDWOLJDHKBNNOFOXXLDLJTOQGWNYBCDIQL9HRVSZOFYHLTGMCKKIPXQSLIZIWLLVWVVEDBAYDSJPVLQCISAOVFHFETMKZJATMSFLCQLKFFVKSPTBEZKSANHFCPFHSJERMWOUBDDOIYYAWVRCPZKAGENAAEPWEQXORSDQXFSIZPHE9ASOUZQTHJJURQHTILYJQMFVOBSYTICZOACDEWY"
),
(
"LVRSOEEWSQBUTNCXULEPWCZFVOZAYFDUJRHMQXSPNYDCAVO9CHTL9MLCPOFKMFZCCFGZTMCNKT9ZZZQ9Y",
WotsSecurityLevel::High,
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
),
(
"C9TLWSSSXNPIJLLWLOWLPOLYYCDNSFBKVNSXTUCGRNGCPBRYFJB9BKTXEJ9O9GXIXFQVDNWILOWXHUKZY",
WotsSecurityLevel::Low,
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
),
(
"VMMYMHSWRG9JQAMPCCCOPWN9MRMEFKGPELRHPIAFOJYFYWJBGWUVZETMHPOSXWZMTMDI9JPSVXSAP9WMA",
WotsSecurityLevel::Medium,
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
),
(
"SDKNYPSKPDNZGYJIXLBBRHFNTDUTDZ9WGCYKOGCTXHZJXXAQBFAWTDBSLCRD9BKWMPQHIWZSPVLKBKGI9",
WotsSecurityLevel::High,
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
),
(
"CTEIJUOBDCP9PSMKZZRKRGHJ9IBMWHFXCOERRRRSWEHFEENRWCUBVABLZIMQWJAJYYHEPYPHIVAHHFDGD",
WotsSecurityLevel::Low,
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
),
(
"RWDEBEEHUWQFHL9FPSVFDQEVJIONLSKQRAGT9YDONITIVNARXHVIPUYHUQZMETDYQVMVQVOTMRTXHPRAD",
WotsSecurityLevel::Medium,
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
),
(
"MIMALAOEMKYEZERHHDVVVIDKEZNFIUTVRZWOQTZHWRYIXPGJWPGVMVKUHFULLSUOCXYECRTBRVVDJI9UY",
WotsSecurityLevel::High,
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
),
(
"GYYEITKGKUBHPISEGXYYPZROCKNDBBFXBIZVYEIWGERDABXZB9UZPJSUUNDKDIHVGFQIICEDGYCSTOKEX",
WotsSecurityLevel::Low,
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
),
(
"FCJUNKJSZQUGWRWU9VVKFJXOBFHAZWURGSSSZWSHWUDUYKRSHDYAIOWRXEY9SOOSEGWLUGXIOWXBUVDRX",
WotsSecurityLevel::Medium,
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
),
(
"ZRXUIBPPPJOPFDKCTUFPODLRIAIZVM9NDSDXDPCKYIUKGUDEOAIEWHXNLYA9ZQZDUAH9CWYBQEAFORAZW",
WotsSecurityLevel::High,
"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"
),
(
"TMFHVNCGVGRWMVEJSOPGBFYB9RIJLRKGFCLCOPBQOBFVNLMMTBAQIZHETRTBPLQOABCNLZCGIKVFXTQWY",
WotsSecurityLevel::Low,
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
),
(
"JRDHQCMDRPYHUQCBQVIFFLOYOMPBANSPQHYTHZ9DMCRAPOODBILCPYCJIHZMDTFGIZGMMWMNADCOFSLEA",
WotsSecurityLevel::Medium,
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
),
(
"9SRDKDYNJKNWUCADVUGXRUEPPTEGPPKWJADDMZP9OBDAG9ET9LYKCYIUOQPSITWARZDQZD9CIKHVUUU99",
WotsSecurityLevel::High,
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
),
(
"VFDLIIUVFKRYLTOSYYKMQRJPOLMRDXZTQP9VGCCFZWHGNECCJJPNDBDOZLYTEQ9WCVPLOCZCOJALNTGWW",
WotsSecurityLevel::Low,
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
),
(
"BHKSLVQPFWXNTIJWOUKTKHTUA9YPIOAIZIQS9NYCPBENNCOGUUZKFQOJBAZBLUKHXXEDABBEHUPFF9PSD",
WotsSecurityLevel::Medium,
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
),
(
"YQCLT9ODIPPKPICHKPLGUCDDKYBGRJJSTJLYSALM9PBQQKSFUQKZKAFVJXNUWXXZSESPBAXNRV9XPYLJ9",
WotsSecurityLevel::High,
"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"
),
(
"GSBAQEFXCKZRWMSZTNCWQZWUKERBKRNH9PTLEOUMDUR9EOOKMAGKXLUPERLOOWGXP9RDCYYLAUBVE9GGD",
WotsSecurityLevel::Low,
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
),
(
"IBYVDIILBCDHFEHFPWXCBCBSSXIMWDUPLDUBXBKDXCYINBVXBOPPSOLIXXQZAAQPJWGCXLZNLVU9MUEAX",
WotsSecurityLevel::Medium,
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
),
(
"BNHQOWMJMWLWSTVITPCGLRQ9EZXBYFSJCKLFVINGCQAZT9LSZCSRHQWBEXXZXPLHGQC9RVQDVP9BHIYIW",
WotsSecurityLevel::High,
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
),
(
"JGKXFROFVTNKVK99MEGLPGCALZOKCUGGVZNVTBSFXMZMFJAGQWDDMFMKDRGCBNCARDHAZIB9GZAPHQUP9",
WotsSecurityLevel::Low,
"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"
),
(
"9SKLOJPXRNHSSGKNCZKGYVNRMTCYGUPDJZYNVAZQMIQFCWYVJQBUPEDHAVNUSPSPRFEWOYIWSLUYJPUY9",
WotsSecurityLevel::Medium,
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
),
(
"MXDKJJTSCOMTOXQNEKHNDTMLIDSPOEXFLSOBJYFPSVGNOTAEQCPVSIDSSCAREDOGRRIRNRHJYIBKMRCOX",
WotsSecurityLevel::High,
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
)
];
for test in tests.iter() {
let entropy = TryteBuf::try_from_str(test.0).unwrap().as_trits().encode::<T1B1Buf>();
let key = TryteBuf::try_from_str(test.2).unwrap().as_trits().encode::<T1B1Buf>();
let private_key_generator = WotsShakePrivateKeyGeneratorBuilder::<Kerl>::default()
.with_security_level(test.1)
.build()
.unwrap();
let generated_key = private_key_generator.generate_from_entropy(&entropy).unwrap();
assert_eq!(&key.as_slice(), &generated_key.as_trits());
}
}
#[test]
fn example() {
let key_trytes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
let entropy =
TryteBuf::try_from_str("CEFLDDLMF9TO9ZLLTYXIPVFIJKAOFRIQLGNYIDZCTDYSWMNXPYNGFAKHQDY9ABGGQZHEFTXKWKWZXEIUD")
.unwrap()
.as_trits()
.encode::<T1B1Buf>();
let key = TryteBuf::try_from_str(key_trytes)
.unwrap()
.as_trits()
.encode::<T1B1Buf>();
let private_key_generator = WotsShakePrivateKeyGeneratorBuilder::<Kerl>::default()
.with_security_level(WotsSecurityLevel::Medium)
.build()
.unwrap();
let generated_key = private_key_generator.generate_from_entropy(&entropy).unwrap();
assert_eq!(&key.as_slice(), &generated_key.as_trits());
}
#[test]
fn invalid_entropy_length() {
let entropy = TryteBuf::try_from_str("CEFLDDLMF9TO9ZLLTYXINXPYNGFAKHQDY9ABGGQZHEFTXKWKWZXEIUD")
.unwrap()
.as_trits()
.encode::<T1B1Buf>();
let private_key_generator = WotsShakePrivateKeyGeneratorBuilder::<Kerl>::default()
.with_security_level(WotsSecurityLevel::Medium)
.build()
.unwrap();
assert_eq!(
private_key_generator.generate_from_entropy(&entropy).err(),
Some(WotsError::InvalidEntropyLength(entropy.len()))
);
}
#[test]
fn non_null_last_entropy_trit() {
let entropy =
TryteBuf::try_from_str("CEFLDDLMF9TO9ZLLTYXIPVFIJKAOFRIQLGNYIDZCTDYSWMNXPYNGFAKHQDY9ABGGQZHEFTXKWKWZXEIUS")
.unwrap()
.as_trits()
.encode::<T1B1Buf>();
let private_key_generator = WotsShakePrivateKeyGeneratorBuilder::<Kerl>::default()
.with_security_level(WotsSecurityLevel::Medium)
.build()
.unwrap();
assert_eq!(
private_key_generator.generate_from_entropy(&entropy).err(),
Some(WotsError::NonNullEntropyLastTrit)
);
}
|
use super::ema::ema_func;
use super::ema::series_rma;
use super::sma::{declare_ma_var, wma_func};
use super::tr::tr_func;
use super::VarResult;
use crate::ast::stat_expr_types::VarIndex;
use crate::ast::syntax_type::{FunctionType, FunctionTypes, SimpleSyntaxType, SyntaxType};
use crate::helper::err_msgs::*;
use crate::helper::str_replace;
use crate::helper::{
ensure_srcs, float_abs, float_max2, ge1_param_i64, move_element, pine_ref_to_bool,
pine_ref_to_f64, pine_ref_to_f64_series, pine_ref_to_i64, require_param, series_index,
};
use crate::runtime::context::{downcast_ctx, Ctx};
use crate::runtime::InputSrc;
use crate::types::{
downcast_pf_ref, int2float, Arithmetic, Callable, CallableCreator, CallableFactory, Evaluate,
EvaluateVal, Float, Int, ParamCollectCall, PineRef, RefData, RuntimeErr, Series, SeriesCall,
Tuple,
};
use std::mem;
use std::rc::Rc;
pub fn calc_rsi(
s0: Float,
length: i64,
s1: Float,
upwards: &mut Series<Float>,
downwards: &mut Series<Float>,
) -> Result<(Float, Float, Float), RuntimeErr> {
let upward = float_max2(s0.minus(s1), Some(0f64));
let downward = float_max2(s1.minus(s0), Some(0f64));
let rma1 = series_rma(upward, length, upwards)?;
let rma2 = series_rma(downward, length, downwards)?;
let rs = rma1.div(rma2);
let res = Some(100f64).minus(Some(100f64).div(rs.add(Some(1f64))));
Ok((res, upward, downward))
}
pub fn calc_rsi_series(s0: Float, s1: Float) -> Result<Float, RuntimeErr> {
// rs = x / y
// res = 100 - 100 / (1 + rs)
let rs = s0.div(s1);
Ok(Some(100f64).minus(Some(100f64).div(Some(1f64).add(rs))))
}
#[derive(Debug, Clone, PartialEq)]
pub struct KcVal<'a> {
upwards: Series<'a, Float>,
downwards: Series<'a, Float>,
}
impl<'a> KcVal<'a> {
pub fn new() -> KcVal<'a> {
KcVal {
upwards: Series::new(),
downwards: Series::new(),
}
}
fn process_rsi(
&mut self,
_ctx: &mut dyn Ctx<'a>,
mut param: Vec<Option<PineRef<'a>>>,
_func_type: FunctionType<'a>,
) -> Result<Float, RuntimeErr> {
move_tuplet!((x, y) = param);
match _func_type.get_type(1) {
Some(&SyntaxType::Simple(SimpleSyntaxType::Int)) => {
let series = require_param("x", pine_ref_to_f64_series(x))?;
let length = ge1_param_i64("y", pine_ref_to_i64(y))?;
let s0 = series.index_value(0).unwrap();
let s1 = series.index_value(1).unwrap();
let (res, upward, downward) =
calc_rsi(s0, length, s1, &mut self.upwards, &mut self.downwards)?;
self.upwards.commit();
self.downwards.commit();
Ok(res)
}
_ => {
let s1 = pine_ref_to_f64(x);
let s2 = pine_ref_to_f64(y);
// rs = x / y
// res = 100 - 100 / (1 + rs)
let rs = s1.div(s2);
Ok(Some(100f64).minus(Some(100f64).div(Some(1f64).add(rs))))
}
}
}
}
impl<'a> SeriesCall<'a> for KcVal<'a> {
fn step(
&mut self,
_ctx: &mut dyn Ctx<'a>,
param: Vec<Option<PineRef<'a>>>,
_func_type: FunctionType<'a>,
) -> Result<PineRef<'a>, RuntimeErr> {
let res = self.process_rsi(_ctx, param, _func_type)?;
Ok(PineRef::new_rc(Series::from(res)))
}
fn copy(&self) -> Box<dyn SeriesCall<'a> + 'a> {
Box::new(self.clone())
}
}
pub fn declare_var<'a>() -> VarResult<'a> {
let value = PineRef::new(CallableFactory::new(|| {
Callable::new(
None,
Some(Box::new(ParamCollectCall::new_with_caller(Box::new(
KcVal::new(),
)))),
)
}));
let func_type = FunctionTypes(vec![
FunctionType::new((
vec![("x", SyntaxType::float_series()), ("y", SyntaxType::int())],
SyntaxType::float_series(),
)),
FunctionType::new((
vec![
("x", SyntaxType::float_series()),
("y", SyntaxType::float_series()),
],
SyntaxType::float_series(),
)),
]);
let syntax_type = SyntaxType::Function(Rc::new(func_type));
VarResult::new(value, syntax_type, "rsi")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ast::syntax_type::SyntaxType;
use crate::runtime::VarOperate;
use crate::runtime::{AnySeries, NoneCallback};
use crate::types::Series;
use crate::{LibInfo, PineParser, PineRunner};
// use crate::libs::{floor, exp, };
#[test]
fn rsi_int_test() {
let lib_info = LibInfo::new(
vec![declare_var()],
vec![("close", SyntaxType::float_series())],
);
let src = "m = rsi(close, 2)\n";
let blk = PineParser::new(src, &lib_info).parse_blk().unwrap();
let mut runner = PineRunner::new(&lib_info, &blk, &NoneCallback());
runner
.run(
&vec![(
"close",
AnySeries::from_float_vec(vec![Some(20f64), Some(10f64)]),
)],
None,
)
.unwrap();
assert_eq!(
runner.get_context().move_var(VarIndex::new(0, 0)),
Some(PineRef::new(Series::from_vec(vec![None, Some(0.0)])))
);
}
#[test]
fn rsi_series_test() {
let lib_info = LibInfo::new(
vec![declare_var()],
vec![("close", SyntaxType::float_series())],
);
let src = "m = rsi(close, close)\n";
let blk = PineParser::new(src, &lib_info).parse_blk().unwrap();
let mut runner = PineRunner::new(&lib_info, &blk, &NoneCallback());
runner
.run(
&vec![(
"close",
AnySeries::from_float_vec(vec![Some(20f64), Some(10f64)]),
)],
None,
)
.unwrap();
assert_eq!(
runner.get_context().move_var(VarIndex::new(0, 0)),
Some(PineRef::new(Series::from_vec(vec![
Some(50f64),
Some(50f64)
])))
);
}
}
|
//! PICL a LISP written in Rust
//! It follows and extends the edn format defined by Clojure but it is not
//! Clojure in Rust.
#[macro_use]
extern crate lazy_static;
#[macro_use]
pub mod utils;
// Internal modules
pub mod builtins;
pub mod env;
pub mod eval;
pub mod float;
pub mod interpretor;
pub mod list;
pub mod pmatch;
pub mod read;
pub mod repl;
pub mod types;
#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.