text stringlengths 8 4.13M |
|---|
pub mod blocks;
pub use self::blocks::Blocks;
pub mod defs_ok_false;
pub use self::defs_ok_false::DefsOkFalse;
pub mod defs_ok_true;
pub use self::defs_ok_true::DefsOkTrue;
pub mod objs_bot_profile;
pub use self::objs_bot_profile::ObjsBotProfile;
pub mod objs_bot_profile_icons;
pub use self::objs_bot_profile_icons::ObjsBotProfileIcons;
pub mod objs_channel;
pub use self::objs_channel::ObjsChannel;
pub mod objs_channel_purpose;
pub use self::objs_channel_purpose::ObjsChannelPurpose;
pub mod objs_comment;
pub use self::objs_comment::ObjsComment;
pub mod objs_comments;
pub use self::objs_comments::ObjsComments;
pub mod objs_enterprise_user;
pub use self::objs_enterprise_user::ObjsEnterpriseUser;
pub mod objs_external_org_migrations;
pub use self::objs_external_org_migrations::ObjsExternalOrgMigrations;
pub mod objs_external_org_migrations_current;
pub use self::objs_external_org_migrations_current::ObjsExternalOrgMigrationsCurrent;
pub mod objs_file;
pub use self::objs_file::ObjsFile;
pub mod objs_file_shares;
pub use self::objs_file_shares::ObjsFileShares;
pub mod objs_icon;
pub use self::objs_icon::ObjsIcon;
pub mod objs_message;
pub use self::objs_message::ObjsMessage;
pub mod objs_message_attachments;
pub use self::objs_message_attachments::ObjsMessageAttachments;
pub mod objs_message_icons;
pub use self::objs_message_icons::ObjsMessageIcons;
pub mod objs_paging;
pub use self::objs_paging::ObjsPaging;
pub mod objs_primary_owner;
pub use self::objs_primary_owner::ObjsPrimaryOwner;
pub mod objs_reaction;
pub use self::objs_reaction::ObjsReaction;
pub mod objs_reminder;
pub use self::objs_reminder::ObjsReminder;
pub mod objs_resources;
pub use self::objs_resources::ObjsResources;
pub mod objs_scopes;
pub use self::objs_scopes::ObjsScopes;
pub mod objs_subteam;
pub use self::objs_subteam::ObjsSubteam;
pub mod objs_subteam_prefs;
pub use self::objs_subteam_prefs::ObjsSubteamPrefs;
pub mod objs_team;
pub use self::objs_team::ObjsTeam;
pub mod objs_team_profile_field;
pub use self::objs_team_profile_field::ObjsTeamProfileField;
pub mod objs_team_sso_provider;
pub use self::objs_team_sso_provider::ObjsTeamSsoProvider;
pub mod objs_user_profile;
pub use self::objs_user_profile::ObjsUserProfile;
pub mod objs_user_profile_short;
pub use self::objs_user_profile_short::ObjsUserProfileShort;
|
fn main() {
let (x, y, a, b) = {
let mut s = String::new();
std::io::stdin().read_line(&mut s).unwrap();
let mut ws = s.trim_end().split_whitespace();
let x = ws.next().unwrap().parse().unwrap();
let y = ws.next().unwrap().parse().unwrap();
let a = ws.next().unwrap().parse().unwrap();
let b = ws.next().unwrap().parse().unwrap();
(x, y, a, b)
};
println!("{}", run(x, y, a, b));
}
fn run(begin_x: i64, y: i64, a: i64, b: i64) -> String {
let mut exp = 0;
let mut x = begin_x;
loop {
let (next_x, overflow) = a.overflowing_mul(x);
if overflow || next_x > x + b || next_x >= y {
break;
}
x = next_x;
exp += 1;
}
exp += (y - x - 1) / b;
format!("{}", exp)
}
#[test]
fn test_run_sample1() {
assert_eq!(run(4, 20, 2, 10), "2");
}
#[test]
fn test_run_sample2() {
assert_eq!(run(1, 1000000000000000000, 10, 1000000000), "1000000007");
}
#[test]
fn test_run_sample3() {
assert_eq!(run(4, 1, 10, 10), "0");
}
#[test]
fn test_run_sample4() {
assert_eq!(run(4, 4, 10, 10), "0");
}
#[test]
fn test_run_sample5() {
assert_eq!(run(4, 10, 2, 20), "1");
}
#[test]
fn test_run_sample6() {
assert_eq!(run(4, 16, 2, 40), "1");
}
#[test]
fn test_run_sample7() {
assert_eq!(run(6, 30, 2, 10), "2");
}
|
use hlt::direction::Direction;
use hlt::entity::Entity;
use hlt::input::Input;
use hlt::map_cell::MapCell;
use hlt::map_cell::Structure;
use hlt::position::Position;
use hlt::ship::Ship;
use std::cmp::min;
use std::collections::BinaryHeap;
use std::cmp::Ordering;
pub struct GameMap {
pub width: usize,
pub height: usize,
cells: Vec<Vec<MapCell>>,
}
impl GameMap {
pub fn at_position(&self, position: &Position) -> &MapCell {
let normalized = self.normalize(position);
&self.cells[normalized.y as usize][normalized.x as usize]
}
pub fn at_position_mut(&mut self, position: &Position) -> &mut MapCell {
let normalized = self.normalize(position);
&mut self.cells[normalized.y as usize][normalized.x as usize]
}
pub fn at_entity(&self, entity: &Entity) -> &MapCell {
self.at_position(&entity.position())
}
pub fn at_entity_mut(&mut self, entity: &Entity) -> &mut MapCell {
self.at_position_mut(&entity.position())
}
pub fn calculate_distance(&self, source: &Position, target: &Position) -> usize {
let normalized_source = self.normalize(source);
let normalized_target = self.normalize(target);
let dx = (normalized_source.x - normalized_target.x).abs() as usize;
let dy = (normalized_source.y - normalized_target.y).abs() as usize;
let toroidal_dx = min(dx, self.width - dx);
let toroidal_dy = min(dy, self.height - dy);
return toroidal_dx + toroidal_dy;
}
pub fn normalize(&self, position: &Position) -> Position {
let width = self.width as i32;
let height = self.height as i32;
let x = ((position.x % width) + width) % width;
let y = ((position.y % height) + height) % height;
Position { x, y }
}
pub fn get_unsafe_moves(&self, source: &Position, destination: &Position) -> Vec<Direction> {
let normalized_source = self.normalize(source);
let normalized_destination = self.normalize(destination);
let dx = (normalized_source.x - normalized_destination.x).abs() as usize;
let dy = (normalized_source.y - normalized_destination.y).abs() as usize;
let wrapped_dx = self.width - dx;
let wrapped_dy = self.height - dy;
let mut possible_moves: Vec<Direction> = Vec::new();
if normalized_source.x < normalized_destination.x {
possible_moves.push(if dx > wrapped_dx { Direction::West } else { Direction::East });
} else if normalized_source.x > normalized_destination.x {
possible_moves.push(if dx < wrapped_dx { Direction::West } else { Direction::East });
}
if normalized_source.y < normalized_destination.y {
possible_moves.push(if dy > wrapped_dy { Direction::North } else { Direction::South });
} else if normalized_source.y > normalized_destination.y {
possible_moves.push(if dy < wrapped_dy { Direction::North } else { Direction::South });
}
possible_moves
}
pub fn naive_navigate(&mut self, ship: &Ship, destination: &Position) -> Direction {
let ship_position = &ship.position;
// get_unsafe_moves normalizes for us
for direction in self.get_unsafe_moves(&ship_position, destination) {
let target_pos = ship_position.directional_offset(direction);
let target_cell = self.at_position_mut(&target_pos);
if !target_cell.is_occupied() {
target_cell.mark_unsafe(ship.id);
return direction;
}
}
Direction::Still
}
pub fn most_halite_near_ship_direction(&mut self, position: &Position) -> Option<Direction> {
let mut most_halite = 0;
let mut best_direction = Direction::Still;
let current_pos = position;
for direction in Direction::get_all_cardinals() {
let target_pos = current_pos.directional_offset(direction);
let cell = self.at_position(&target_pos);
if !cell.is_occupied() && cell.halite > most_halite {
most_halite = cell.halite;
best_direction = direction;
}
}
if most_halite > 10 {
Some(best_direction)
} else {
None
}
}
pub fn move_towards_rich_halite(&mut self, position: &Position) -> Direction {
let mut best_direction = Direction::Still;
let mut lowest_distance = 0;
for direction in Direction::get_all_cardinals() {
let mut distance = 0;
let mut current_pos = *position;
let mut move_not_found = false;
while self.at_position(¤t_pos).halite < 25 {
distance += 1;
current_pos = current_pos.directional_offset(direction);
let cell = self.at_position(¤t_pos);
if (cell.is_occupied() && distance == 1) || distance > 10 {
move_not_found = true;
break;
}
}
if (lowest_distance == 0 || distance < lowest_distance) && !move_not_found {
lowest_distance = distance;
best_direction = direction;
}
}
best_direction
}
pub fn find_suitable_dropoffs(&mut self) -> Position {
let mut heap = BinaryHeap::new();
let zone_radius = if self.width < 33 {
(3i32
} else if self.width < 50 {
4i32)
} else if self.width < 70 {
5i32
} else {
6i32
};
for x in 0..self.width {
for y in 0..self.height {
let mut total_halite = 0;
for radx in -zone_radius..zone_radius {
for rady in -zone_radius..zone_radius {
let posx = x as i32 + radx;
let posy = y as i32 + rady;
let pos = Position { x: posx, y: posy };
let norm_pos = self.normalize(&pos);
total_halite += self.at_position(&norm_pos).halite;
}
}
heap.push(HaliteScore { score: total_halite, x: x as i32, y: y as i32});
}
}
let winner = heap.pop(); {
Position { x: winner.x, y: winner.y }
}
pub fn update(&mut self, input: &mut Input) {
for y in 0..self.height {
for x in 0..self.width {
self.cells[y][x].ship = None;
}
}
input.read_and_parse_line();
let update_count = input.next_usize();
for _ in 0..update_count {
input.read_and_parse_line();
let x = input.next_usize();
let y = input.next_usize();
let halite = input.next_usize();
self.cells[y][x].halite = halite;
}
}
pub fn generate(input: &mut Input) -> GameMap {
input.read_and_parse_line();
let width = input.next_usize();
let height = input.next_usize();
let mut cells: Vec<Vec<MapCell>> = Vec::with_capacity(height);
for y in 0..height {
input.read_and_parse_line();
let mut row: Vec<MapCell> = Vec::with_capacity(width);
for x in 0..width {
let halite = input.next_usize();
let position = Position { x: x as i32, y: y as i32 };
let cell = MapCell { position, halite, ship: None, structure: Structure::None };
row.push(cell);
}
cells.push(row);
}
GameMap { width, height, cells }
}
}
#[derive(Eq, PartialEq)]
struct HaliteScore {
score: usize,
x: i32,
y: i32
}
impl Ord for HaliteScore {
fn cmp(&self, other: &HaliteScore) -> Ordering {
self.score.cmp(&other.score)
.then_with(|| self.x.cmp(&other.x))
}
}
impl PartialOrd for HaliteScore {
fn partial_cmp(&self, other: &HaliteScore) -> Option<Ordering> {
Some(self.cmp(other))
}
} |
use crate::{
border::BorderBuilder,
brush::Brush,
core::{
color::Color,
inspect::{CastError, Inspect, PropertyInfo},
pool::Handle,
},
expander::ExpanderBuilder,
formatted_text::WrapMode,
grid::{Column, GridBuilder, Row},
inspector::editors::{
Layout, PropertyEditorBuildContext, PropertyEditorDefinition,
PropertyEditorDefinitionContainer, PropertyEditorMessageContext,
},
message::{InspectorMessage, MessageDirection, UiMessage, UiMessageData, WidgetMessage},
stack_panel::StackPanelBuilder,
text::TextBuilder,
widget::{Widget, WidgetBuilder},
BuildContext, Control, Thickness, UiNode, UserInterface, VerticalAlignment,
};
use std::{
any::{Any, TypeId},
collections::{hash_map::Entry, HashMap},
fmt::{Debug, Formatter},
ops::{Deref, DerefMut},
sync::Arc,
};
pub mod editors;
pub trait InspectorEnvironment: Any + Send + Sync {
fn as_any(&self) -> &dyn Any;
}
#[derive(Clone)]
pub struct Inspector {
widget: Widget,
stack_panel: Handle<UiNode>,
context: InspectorContext,
}
crate::define_widget_deref!(Inspector);
impl Inspector {
pub fn context(&self) -> &InspectorContext {
&self.context
}
}
pub const NAME_COLUMN_WIDTH: f32 = 150.0;
pub const HEADER_MARGIN: Thickness = Thickness {
left: 4.0,
top: 1.0,
right: 4.0,
bottom: 1.0,
};
#[derive(Debug)]
pub enum InspectorError {
CastError(CastError),
OutOfSync,
Custom(String),
Group(Vec<InspectorError>),
}
impl From<CastError> for InspectorError {
fn from(e: CastError) -> Self {
Self::CastError(e)
}
}
#[derive(Clone, Debug)]
pub struct ContextEntry {
pub property_name: String,
pub property_owner_type_id: TypeId,
pub property_editor_definition: Arc<dyn PropertyEditorDefinition>,
pub property_editor: Handle<UiNode>,
}
#[allow(clippy::vtable_address_comparisons)]
impl PartialEq for ContextEntry {
fn eq(&self, other: &Self) -> bool {
self.property_editor == other.property_editor
&& self.property_name == other.property_name
&& std::ptr::eq(
&*self.property_editor_definition,
&*other.property_editor_definition,
)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Group {
section: Handle<UiNode>,
entries: Vec<ContextEntry>,
}
#[derive(Clone)]
pub struct InspectorContext {
groups: Vec<Group>,
property_definitions: Arc<PropertyEditorDefinitionContainer>,
sync_flag: u64,
}
impl PartialEq for InspectorContext {
fn eq(&self, other: &Self) -> bool {
self.groups == other.groups
}
}
impl Default for InspectorContext {
fn default() -> Self {
Self {
groups: Default::default(),
property_definitions: Arc::new(PropertyEditorDefinitionContainer::new()),
sync_flag: 0,
}
}
}
impl Debug for InspectorContext {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
writeln!(f, "InspectorContext")
}
}
fn create_header(ctx: &mut BuildContext, text: &str) -> Handle<UiNode> {
TextBuilder::new(WidgetBuilder::new().with_margin(HEADER_MARGIN))
.with_text(text)
.with_vertical_text_alignment(VerticalAlignment::Center)
.build(ctx)
}
fn wrap_property(
title: Handle<UiNode>,
editor: Handle<UiNode>,
layout: Layout,
ctx: &mut BuildContext,
) -> Handle<UiNode> {
match layout {
Layout::Horizontal => {
ctx[editor].set_row(0).set_column(1);
}
Layout::Vertical => {
ctx[editor].set_row(1).set_column(0);
}
}
GridBuilder::new(WidgetBuilder::new().with_child(title).with_child(editor))
.add_rows(match layout {
Layout::Horizontal => {
vec![Row::strict(26.0)]
}
Layout::Vertical => {
vec![Row::strict(26.0), Row::stretch()]
}
})
.add_columns(match layout {
Layout::Horizontal => {
vec![Column::strict(NAME_COLUMN_WIDTH), Column::stretch()]
}
Layout::Vertical => {
vec![Column::stretch()]
}
})
.build(ctx)
}
impl InspectorContext {
pub fn from_object(
object: &dyn Inspect,
ctx: &mut BuildContext,
definition_container: Arc<PropertyEditorDefinitionContainer>,
environment: Option<Arc<dyn InspectorEnvironment>>,
sync_flag: u64,
) -> Self {
let mut property_groups = HashMap::<&'static str, Vec<PropertyInfo>>::new();
for info in object.properties() {
match property_groups.entry(info.group) {
Entry::Vacant(e) => {
e.insert(vec![info]);
}
Entry::Occupied(e) => {
e.into_mut().push(info);
}
}
}
let mut sorted_groups = property_groups.into_iter().collect::<Vec<_>>();
sorted_groups.sort_by_key(|(name, _)| *name);
let groups = sorted_groups
.iter()
.map(|(group, infos)| {
let mut entries = Vec::new();
let editors = infos
.iter()
.enumerate()
.map(|(i, info)| {
if let Some(definition) = definition_container
.definitions()
.get(&info.value.type_id())
{
match definition.create_instance(PropertyEditorBuildContext {
build_context: ctx,
property_info: info,
environment: environment.clone(),
definition_container: definition_container.clone(),
sync_flag,
}) {
Ok(instance) => {
entries.push(ContextEntry {
property_editor: instance.editor,
property_editor_definition: definition.clone(),
property_name: info.name.to_string(),
property_owner_type_id: info.owner_type_id,
});
if info.read_only {
ctx[instance.editor].set_enabled(false);
}
wrap_property(
if instance.title.is_some() {
instance.title
} else {
create_header(ctx, info.display_name)
},
instance.editor,
definition.layout(),
ctx,
)
}
Err(e) => wrap_property(
create_header(ctx, info.display_name),
TextBuilder::new(WidgetBuilder::new().on_row(i).on_column(1))
.with_wrap(WrapMode::Word)
.with_vertical_text_alignment(VerticalAlignment::Center)
.with_text(format!(
"Unable to create property \
editor instance: Reason {:?}",
e
))
.build(ctx),
Layout::Horizontal,
ctx,
),
}
} else {
wrap_property(
create_header(ctx, info.display_name),
TextBuilder::new(WidgetBuilder::new().on_row(i).on_column(1))
.with_wrap(WrapMode::Word)
.with_vertical_text_alignment(VerticalAlignment::Center)
.with_text("Property Editor Is Missing!")
.build(ctx),
Layout::Horizontal,
ctx,
)
}
})
.collect::<Vec<_>>();
let section = BorderBuilder::new(
WidgetBuilder::new()
.with_margin(Thickness::uniform(1.0))
.with_child(
ExpanderBuilder::new(WidgetBuilder::new())
.with_header(create_header(ctx, group))
.with_content(
StackPanelBuilder::new(
WidgetBuilder::new().with_children(editors),
)
.build(ctx),
)
.build(ctx),
)
.with_foreground(Brush::Solid(Color::opaque(130, 130, 130))),
)
.build(ctx);
Group { section, entries }
})
.collect::<Vec<_>>();
Self {
groups,
property_definitions: definition_container,
sync_flag,
}
}
pub fn sync(
&self,
object: &dyn Inspect,
ui: &mut UserInterface,
) -> Result<(), Vec<InspectorError>> {
let mut sync_errors = Vec::new();
for info in object.properties() {
if let Some(constructor) = self
.property_definitions
.definitions()
.get(&info.value.type_id())
{
let ctx = PropertyEditorMessageContext {
sync_flag: self.sync_flag,
instance: self.find_property_editor(info.name),
ui,
property_info: &info,
definition_container: self.property_definitions.clone(),
};
match constructor.create_message(ctx) {
Ok(message) => {
if let Some(mut message) = message {
message.flags = self.sync_flag;
ui.send_message(message);
}
}
Err(e) => sync_errors.push(e),
}
}
}
if sync_errors.is_empty() {
Ok(())
} else {
Err(sync_errors)
}
}
pub fn property_editors(&self) -> impl Iterator<Item = &ContextEntry> + '_ {
self.groups.iter().map(|g| g.entries.iter()).flatten()
}
pub fn find_property_editor(&self, name: &str) -> Handle<UiNode> {
for group in self.groups.iter() {
if let Some(property_editor) = group
.entries
.iter()
.find(|e| e.property_name == name)
.map(|e| e.property_editor)
{
return property_editor;
}
}
Default::default()
}
}
impl Control for Inspector {
fn handle_routed_message(&mut self, ui: &mut UserInterface, message: &mut UiMessage) {
self.widget.handle_routed_message(ui, message);
if message.destination() == self.handle && message.direction() == MessageDirection::ToWidget
{
if let UiMessageData::Inspector(InspectorMessage::Context(ctx)) = message.data() {
// Remove previous content.
for child in ui.node(self.stack_panel).children() {
ui.send_message(WidgetMessage::remove(*child, MessageDirection::ToWidget));
}
// Link new sections to the panel.
for group in ctx.groups.iter() {
ui.send_message(WidgetMessage::link(
group.section,
MessageDirection::ToWidget,
self.stack_panel,
));
}
self.context = ctx.clone();
}
}
// Check each message from descendant widget and try to translate it to
// PropertyChanged message.
if message.flags != self.context.sync_flag {
for group in self.context.groups.iter() {
for entry in group.entries.iter() {
if message.destination() == entry.property_editor {
if let Some(args) = entry.property_editor_definition.translate_message(
&entry.property_name,
entry.property_owner_type_id,
message,
) {
ui.send_message(InspectorMessage::property_changed(
self.handle,
MessageDirection::FromWidget,
args,
));
}
}
}
}
}
}
}
pub struct InspectorBuilder {
widget_builder: WidgetBuilder,
context: InspectorContext,
}
impl InspectorBuilder {
pub fn new(widget_builder: WidgetBuilder) -> Self {
Self {
widget_builder,
context: Default::default(),
}
}
pub fn with_context(mut self, context: InspectorContext) -> Self {
self.context = context;
self
}
pub fn build(self, ctx: &mut BuildContext) -> Handle<UiNode> {
let sections = self
.context
.groups
.iter()
.map(|g| g.section)
.collect::<Vec<_>>();
let stack_panel =
StackPanelBuilder::new(WidgetBuilder::new().with_children(sections)).build(ctx);
let canvas = Inspector {
widget: self.widget_builder.with_child(stack_panel).build(),
stack_panel,
context: self.context,
};
ctx.add_node(UiNode::new(canvas))
}
}
|
// Copyright (c) The Diem Core Contributors
// SPDX-License-Identifier: Apache-2.0
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct StateSyncConfig {
// Size of chunk to request for state synchronization
pub chunk_limit: u64,
// The timeout of the state sync client to process a commit notification (in milliseconds)
pub client_commit_timeout_ms: u64,
// default timeout used for long polling to remote peer
pub long_poll_timeout_ms: u64,
// valid maximum chunk limit for sanity check
pub max_chunk_limit: u64,
// valid maximum timeout limit for sanity check
pub max_timeout_ms: u64,
// The timeout of the state sync coordinator to receive a commit ack from mempool (in milliseconds)
pub mempool_commit_timeout_ms: u64,
// default timeout to make state sync progress by sending chunk requests to a certain number of networks
// if no progress is made by sending chunk requests to a number of networks,
// the next sync request will be multicasted, i.e. sent to more networks
pub multicast_timeout_ms: u64,
// The timeout for ensuring sync requests are making progress (i.e., the maximum time between
// commits when processing a sync request).
pub sync_request_timeout_ms: u64,
// interval used for checking state synchronization progress
pub tick_interval_ms: u64,
// TODO(joshlind): plug these in when required.
// Everything above belongs to state sync v1 and will be removed in the future.
// pub data_streaming_service: DataStreamingServiceConfig,
// pub storage_service: StorageServiceConfig,
}
impl Default for StateSyncConfig {
fn default() -> Self {
Self {
chunk_limit: 1000,
client_commit_timeout_ms: 5_000,
long_poll_timeout_ms: 10_000,
max_chunk_limit: 1000,
max_timeout_ms: 120_000,
mempool_commit_timeout_ms: 5_000,
multicast_timeout_ms: 30_000,
sync_request_timeout_ms: 60_000,
tick_interval_ms: 100,
}
}
}
#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct StorageServiceConfig {
pub max_account_states_chunk_sizes: u64, // Max num of accounts per chunk
pub max_concurrent_requests: u64, // Max num of concurrent storage server tasks
pub max_epoch_chunk_size: u64, // Max num of epoch ending ledger infos per chunk
pub max_transaction_chunk_size: u64, // Max num of transactions per chunk
pub max_transaction_output_chunk_size: u64, // Max num of transaction outputs per chunk
}
impl Default for StorageServiceConfig {
fn default() -> Self {
Self {
max_account_states_chunk_sizes: 1000,
max_concurrent_requests: 50,
max_epoch_chunk_size: 100,
max_transaction_chunk_size: 1000,
max_transaction_output_chunk_size: 1000,
}
}
}
#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct DataStreamingServiceConfig {
// The interval (milliseconds) at which to refresh the global data summary.
pub global_summary_refresh_interval_ms: u64,
// Maximum number of concurrent data client requests (per stream).
pub max_concurrent_requests: u64,
// Maximum channel sizes for each data stream listener. If messages are not
// consumed, they will be dropped (oldest messages first). The remaining
// messages will be retrieved using FIFO ordering.
pub max_data_stream_channel_sizes: u64,
// Maximum number of retries for a single client request before a data
// stream will terminate.
pub max_request_retry: u64,
// Maximum number of notification ID to response context mappings held in
// memory. Once the number grows beyond this value, garbage collection occurs.
pub max_notification_id_mappings: u64,
// The interval (milliseconds) at which to check the progress of each stream.
pub progress_check_interval_ms: u64,
}
impl Default for DataStreamingServiceConfig {
fn default() -> Self {
Self {
global_summary_refresh_interval_ms: 1000,
max_concurrent_requests: 3,
max_data_stream_channel_sizes: 1000,
max_request_retry: 10,
max_notification_id_mappings: 2000,
progress_check_interval_ms: 100,
}
}
}
|
//! Event builder
use crate::{Entity, Event, EventBuilder, EventData};
use chrono::Utc;
use uuid::Uuid;
/// Purge event builder
///
/// Build an [`Event`] from a session id, used to purge entities. Purging deletes the entities.
/// It keeps the event history but sets the `data` property of all events related to the entity to None.
///
/// # Examples
///
/// ## Build a purge event with session ID
///
/// ```rust
/// # fn main() -> Result<(), ()> {
/// use event_sauce::{prelude::*, Event, PurgeEventBuilder, PurgeEntityBuilder};
/// use uuid::Uuid;
///
/// #[derive(event_sauce_derive::Entity)]
/// #[event_sauce(entity_name = "users")]
/// struct User {
/// #[event_sauce(id)]
/// id: Uuid,
///
/// // ...
/// }
///
/// #[derive(
/// serde_derive::Serialize,
/// serde_derive::Deserialize,
/// event_sauce_derive::PurgeEventData,
/// Clone,
/// Debug,
/// )]
/// #[event_sauce(User)]
/// struct UserPurged;
///
/// let session_id = Uuid::new_v4();
///
/// let user = User { id: Uuid::new_v4() };
///
/// let event = UserPurged {}.with_session_id(session_id);
///
/// let purge_builder = user.try_purge(UserPurged {});
///
/// // purge_builder.purge(&store).await?;
/// # Ok(()) }
/// ```
pub struct PurgeEventBuilder<D: EventData> {
session_id: Option<Uuid>,
payload: D,
}
impl<D: EventData> PurgeEventBuilder<D> {
/// Consume the builder and produce the final event
pub fn build(self, entity: &D::Entity) -> Event<D> {
self.build_with_entity_id(entity.entity_id())
}
/// Workaround method to get an entity ID out of entities when implementing
/// `DeleteEntityBuilder`
pub(crate) fn build_with_entity_id(self, entity_id: Uuid) -> Event<D> {
Event {
id: Uuid::new_v4(),
event_type: String::from(self.payload.event_type()),
entity_type: D::Entity::entity_type(),
entity_id,
session_id: self.session_id,
purger_id: self.session_id,
created_at: Utc::now(),
purged_at: Some(Utc::now()),
data: None,
}
}
fn new(payload: D) -> Self {
Self {
session_id: None,
payload,
}
}
}
impl<D> EventBuilder<D> for PurgeEventBuilder<D>
where
D: EventData,
{
/// Create a new event builder with a given event data payload
fn new(payload: D) -> Self {
Self {
payload,
session_id: None,
}
}
/// Set the session ID field of the event
fn session_id(mut self, session_id: Uuid) -> Self {
self.session_id = Some(session_id);
self
}
}
impl<D> From<D> for PurgeEventBuilder<D>
where
D: EventData,
{
fn from(payload: D) -> Self {
Self::new(payload)
}
}
|
// q0024_swap_nodes_in_pairs
struct Solution;
use crate::util::ListNode;
impl Solution {
pub fn swap_pairs(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
let mut list = head;
let mut buf = vec![];
while let Some(l) = list {
buf.push(l.val);
list = l.next;
}
if buf.len() < 1 {
return None;
}
let mut i = 0;
while i < buf.len() - 1 {
let t = buf[i];
buf[i] = buf[i + 1];
buf[i + 1] = t;
i += 2;
}
let len = buf.len();
let mut ret = None;
for i in 1..=len {
ret = Some(Box::new(ListNode {
val: buf[len - i],
next: ret,
}))
}
ret
}
}
#[cfg(test)]
mod tests {
use super::Solution;
use crate::util::ListNode;
#[test]
fn it_works() {
assert_eq!(
Solution::swap_pairs(ListNode::build(vec![1, 2, 3, 4])),
ListNode::build(vec![2, 1, 4, 3])
)
}
}
|
pub trait DigitalInput: Send {
fn get_value(&self) -> bool;
} |
use anyhow::Result;
use super::super::ascii85::decode;
pub fn flip_every_other_bit(n: u8) -> u8 {
let mask = 0b0101_0101;
n ^ mask
}
pub fn rotate_right(n: u8) -> u8 {
let last_bit = n & 1;
(n >> 1) | (last_bit << 7)
}
#[test]
fn test_flip_every_other_bit() {
let input = 0b1010_1010;
let expected = 0b1111_1111;
assert_eq!(flip_every_other_bit(input), expected);
assert_eq!(0b0000_0000, flip_every_other_bit(0b0101_0101));
assert_eq!(0b0101_0101, flip_every_other_bit(0b0000_0000));
}
#[test]
fn test_rotate_right() {
assert_eq!(0b1000_0000, rotate_right(0b0000_0001));
assert_eq!(0b0101_0101, rotate_right(0b1010_1010));
assert_eq!(0b1000_1000, rotate_right(0b0001_0001));
}
pub fn run(input: &[u8]) -> Result<Vec<u8>> {
let decoded = decode(input)?;
Ok(decoded
.iter()
.map(|&byte| rotate_right(flip_every_other_bit(byte)))
.collect())
}
|
use std::collections::BTreeMap;
use std::fs;
use eyre::Result;
use serde::Serialize;
use tera::Context;
use crate::content::posts::{PostItem, PostRef};
use crate::markdown::markdown_to_html;
use crate::paths::AbsPath;
use crate::{item::RenderContext, item::TeraItem, site_url::SiteUrl};
use super::posts::PostRefContext;
#[derive(Debug)]
pub struct HomepageItem {
pub about: String,
pub url: SiteUrl,
pub recent: Vec<PostRef>,
pub recommended: Vec<PostRef>,
}
impl HomepageItem {
pub fn new(dir: &AbsPath, posts: &BTreeMap<PostRef, PostItem>) -> Result<Self> {
let about = fs::read_to_string(dir.join("about.markdown"))?;
let url = SiteUrl::parse("/").expect("Should be able to create a url");
Ok(Self {
url,
about,
recent: Self::get_recent(posts),
recommended: Self::get_recommended(posts),
})
}
pub fn update_posts(&mut self, posts: &BTreeMap<PostRef, PostItem>) {
self.recent = Self::get_recent(posts);
self.recommended = Self::get_recommended(posts);
}
fn get_recent(posts: &BTreeMap<PostRef, PostItem>) -> Vec<PostRef> {
posts.keys().take(5).map(Clone::clone).collect()
}
fn get_recommended(posts: &BTreeMap<PostRef, PostItem>) -> Vec<PostRef> {
posts
.iter()
.filter(|(_, post)| post.recommended)
.map(|(post_ref, _)| post_ref.clone())
.collect()
}
}
impl TeraItem for HomepageItem {
fn context(&self, ctx: &RenderContext) -> Context {
Context::from_serialize(HomepageContext {
title: "Home",
about: markdown_to_html(&self.about),
recommended: self
.recommended
.iter()
.map(|x| PostRefContext::from_ref(x, ctx))
.collect(),
recent: self
.recent
.iter()
.map(|x| PostRefContext::from_ref(x, ctx))
.collect(),
})
.unwrap()
}
fn template(&self) -> &str {
"homepage.html"
}
fn url(&self) -> &SiteUrl {
&self.url
}
}
#[derive(Debug, Clone, Serialize)]
struct HomepageContext<'a> {
title: &'static str,
about: String,
recommended: Vec<PostRefContext<'a>>,
recent: Vec<PostRefContext<'a>>,
}
|
use std::sync::{Arc, Mutex};
use std::collections::HashMap;
use serde::{Serialize, Deserialize};
use std::net::{SocketAddr};
use super::mempool::{Mempool};
use super::message::{Message, ServerSignal};
use super::blockchain::{BlockChain};
use mio_extras::channel::Sender as MioSender;
use crossbeam::channel::{Receiver, Sender, self};
use std::{thread, time};
use super::cmtda::{BlockHeader, Block, H256, HEADER_SIZE, Transaction, read_codes};
use super::contract::utils;
use ser::{deserialize, serialize};
use super::contract::interface::{Handle, Answer};
use super::contract::interface::Message as ContractMessage;
use super::contract::interface::Response as ContractResponse;
use crypto::sha3::Sha3;
use crypto::digest::Digest;
use std::time::{SystemTime, UNIX_EPOCH, Duration};
use web3::types::Address;
use crate::experiment::snapshot::PERFORMANCE_COUNTER;
use chain::constants::{TRANSACTION_SIZE, BLOCK_SIZE, BASE_SYMBOL_SIZE, RATE, UNDECODABLE_RATIO};
use chain::decoder::{Code, Decoder, TreeDecoder, CodingErr, IncorrectCodingProof};
use chain::decoder::{Symbol};
use super::cmtda::Block as CMTBlock;
use super::cmtda::H256 as CMTH256;
use rand::Rng;
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Token {
pub version: usize,
pub ring_size: usize,
pub node_list: Vec<SocketAddr>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub enum Signal {
Data(Token),
Control,
}
pub struct Scheduler {
pub addr: SocketAddr, //p2p
pub token: Option<Token>,
pub mempool: Arc<Mutex<Mempool>>,
pub server_control_sender: MioSender<ServerSignal>,
pub contract_handler: Sender<Handle>,
pub handle: Receiver<Signal>,
pub chain: Arc<Mutex<BlockChain>>,
//pub side_id: u64,
pub sidenodes: Vec<SocketAddr>,
pub address: Address,
pub slot_time: f32,
pub start_sec: u64,
pub start_millis: u64,
pub prepared_block: Option<BlockHeader>,
pub num_nodes: u64, //scale nodes
pub symbols_by: Option<HashMap<u64, (Vec<Vec<Symbol>>, Vec<Vec<u64>>)>>,
pub codes_for_encoding: Vec<Code>,
}
impl Scheduler {
pub fn new(
addr: SocketAddr,
token: Option<Token>,
mempool: Arc<Mutex<Mempool>>,
server_control_sender: MioSender<ServerSignal>,
handle: Receiver<Signal>,
chain: Arc<Mutex<BlockChain>>,
contract_handler: Sender<Handle>,
//side_id: u64,
sidenodes: Vec<SocketAddr>,
address: Address,
slot_time: f32,
start_sec: u64,
start_millis: u64,
num_scale: u64,
codes_for_encoding: Vec<Code>
) -> Scheduler {
Scheduler {
addr,
token,
mempool,
server_control_sender,
contract_handler,
handle,
chain: chain,
//side_id,
sidenodes,
address,
slot_time: slot_time,
start_sec: start_sec,
start_millis: start_millis,
prepared_block: None,
num_nodes: num_scale,
symbols_by: None,
codes_for_encoding: codes_for_encoding,
}
}
// to participate a token ring group
pub fn register_token(&mut self) -> bool {
if let Some(ref mut token) = self.token {
token.ring_size += 1;
token.node_list.push(self.addr.clone());
return true;
} else {
return false;
}
}
//pub fn start(mut self) {
//let _ = std::thread::spawn(move || {
//loop {
//match self.handle.recv() {
//Ok(v) => {
//match v {
//Signal::Control => {
//// try transmit
//match self.token.as_mut() {
//None => (),
//Some(token) => {
////info!("with token, propose a block");
//self.propose_block();
//},
//}
//},
//Signal::Data(token) => {
////info!("reiceive a token, propose a block");
//self.token = Some(token);
//self.propose_block();
//}
//}
//},
//Err(e) => info!("scheduler error"),
//}
//}
//});
//}
//pub fn get_time_diff() {
//let curr_time: u64 = match time::SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
//Ok(n) => n.as_secs(),
//Err(_) => panic!("SystemTime before UNIX EPOCH!"),
//};
//}
//
pub fn get_side_id(&self) -> u64 {
match self.sidenodes.
iter().
position(|&x| x== self.addr)
{
Some(i) => i as u64,
None => panic!("my socketaddr is not included in the side nodes ring"),
}
}
pub fn start(mut self) {
info!("scheduler started");
let _ = std::thread::spawn(move || {
loop {
// setup
let round = self.sidenodes.len() as u64;
let round_millis = (self.slot_time * 1000.0) as u64 * round ;
let side_id = self.get_side_id();
// pipelining
match &self.prepared_block {
None => {
//info!("start preparing a block");
match self.prepare_block() {
None => thread::sleep(time::Duration::from_millis(100)),
_ => (),
}
},
Some(h) => {
let (curr_slot, elapsed) = get_curr_slot(self.start_sec, self.start_millis, self.slot_time);
let curr_id = curr_slot % round;
// my slot
if curr_id == side_id {
PERFORMANCE_COUNTER.record_token_update(true);
if self.propose_block() {
let (curr_slot, elapsed) = get_curr_slot(self.start_sec, self.start_millis, self.slot_time);
// go over the deadline
if curr_slot%round != side_id {
PERFORMANCE_COUNTER.record_token_update(false);
continue;
} else {
// to next slot
let target_time = ((side_id+1) * (self.slot_time*1000.0) as u64) - elapsed%round_millis;
thread::sleep(time::Duration::from_millis(target_time));
PERFORMANCE_COUNTER.record_token_update(false);
}
}
} else if curr_id < side_id {
PERFORMANCE_COUNTER.record_token_update(false);
let target = side_id*(self.slot_time* 1000.0) as u64 - elapsed%round_millis;
thread::sleep(time::Duration::from_millis(target));
} else {
PERFORMANCE_COUNTER.record_token_update(false);
let time_left = round*(self.slot_time*1000.0) as u64 - elapsed%round_millis + side_id*(self.slot_time*1000.0) as u64;
thread::sleep(time::Duration::from_millis(time_left));
}
}
}
}
});
}
//let curr_time = time::SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
//let round_time = self.slot_time* (self.sidenodes.len() as u64);
//let curr_id = (curr_time.as_secs() % round_time) / self.slot_time;
//let side_id = self.get_side_id();
//// my slot
//if curr_id == side_id {
//PERFORMANCE_COUNTER.record_token_update(true);
//if self.propose_block() {
//let curr_time = time::SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
//let r_time = curr_time.as_secs() % round_time ;
//let ceil_time = (( r_time/self.slot_time + 1) as u64) *self.slot_time;
//if ceil_time <= r_time {
//continue;
//} else {
//let n_time = (ceil_time - r_time as u64) * 1_000_000_000 - curr_time.subsec_nanos() as u64;
//thread::sleep(time::Duration::from_nanos(n_time));
//}
//} else {
//thread::sleep(time::Duration::from_millis(500));
//}
//} else if curr_id < side_id {
//PERFORMANCE_COUNTER.record_token_update(false);
//let time_left = ((side_id)*self.slot_time - (curr_time.as_secs() % round_time)) * 1_000_000_000 - curr_time.subsec_nanos() as u64;
//let sleep_sec = time::Duration::from_nanos(time_left);
//thread::sleep(sleep_sec);
//} else {
//PERFORMANCE_COUNTER.record_token_update(false);
//let time_left = (round_time - (curr_time.as_secs() % round_time)+ side_id*self.slot_time) * 1_000_000_000 - curr_time.subsec_nanos() as u64;
//let sleep_sec = time::Duration::from_nanos(time_left);
//thread::sleep(sleep_sec);
//}
//fn pass_token(&mut self, token: Token) {
//info!("{:?} passing token.", self.addr);
//if token.ring_size >= 2 {
//let mut index = 0;
//for sock in &token.node_list {
//if *sock == self.addr {
//let next_index = (index + 1) % token.ring_size;
//let next_sock = token.node_list[next_index];
//let message = Message::PassToken(token);
//let signal = ServerSignal::ServerUnicast((next_sock, message));
//self.server_control_sender.send(signal);
//break;
//}
//index = (index + 1) % token.ring_size;
//}
//} else {
//let sleep_time = time::Duration::from_millis(1000);
//thread::sleep(sleep_time);
//self.propose_block();
//}
//}
pub fn create_cmt_block(&mut self, trans: &Vec<Transaction>) -> Option<BlockHeader> {
let mut rng = rand::thread_rng();
let header = BlockHeader {
version: 1,
previous_header_hash: CMTH256::default(),
merkle_root_hash: CMTH256::default(),
time: 4u32,
bits: 5.into(),
nonce: rng.gen(),
coded_merkle_roots_hashes: vec![CMTH256::default(); 8],
};
let (block, trans_len) = CMTBlock::new(
header.clone(),
&trans,
BLOCK_SIZE as usize,
HEADER_SIZE,
&self.codes_for_encoding,
vec![true; self.codes_for_encoding.len()]
);
let cmt_header = block.block_header.clone();
let num_symbol = BLOCK_SIZE/(BASE_SYMBOL_SIZE as u64) *((1.0/RATE) as u64);
let mut symbols_by: HashMap<u64, (Vec<Vec<Symbol>>, Vec<Vec<u64>>)> = HashMap::new();
// debug
//let mut symbols =
for scale_id in (1..self.num_nodes+1) {
//info!("scale_id {}", scale_id);
let samples_idx = get_sample_index(
scale_id,
num_symbol,
self.num_nodes);
let (mut symbols, mut idx) = block.sample_vec(samples_idx);
// add sample, sample idx to mempool
symbols_by.insert(scale_id, (symbols, idx));
}
//match decoder.run_tree_decoder(symbols.clone(), idx.clone(), cmt_block.block_header.clone()) {
//Ok(transactions) => {
//println!("transactions {:?}", transactions);
//},
//_ => info!("tree decoder error"),
//};
self.symbols_by = Some(symbols_by);
self.prepared_block = Some(cmt_header);
Some(header)
}
pub fn prepare_block(&mut self) -> Option<BlockHeader> {
let tx_thresh = BLOCK_SIZE / TRANSACTION_SIZE - 1;
// generate a coded block
let mut mempool = self.mempool.lock().unwrap();
let num_tx = mempool.get_num_transaction();
if num_tx <= tx_thresh { // transation size
info!("{:?} Skip: {} less than {:?}", self.addr, num_tx, tx_thresh);
return None;
}
let trans = mempool.prepare_transaction_block();
drop(mempool);
let new_block_id = self.my_next_slot();
PERFORMANCE_COUNTER.record_propose_block_update(new_block_id);
let header = self.create_cmt_block(&trans);
PERFORMANCE_COUNTER.record_propose_block_stop();
header
}
pub fn propose_block(&mut self) -> bool {
// construct message and broadcast
let (curr_slot, elapsed)= get_curr_slot(self.start_sec, self.start_millis, self.slot_time);
let new_block_id = curr_slot + 1; // a hack, to make sure curr_slot > 0, otherwise block rejected
//info!("************start propose block with {}", new_block_id);
PERFORMANCE_COUNTER.record_block_update(new_block_id);
PERFORMANCE_COUNTER.record_propose_block_id(new_block_id as usize);
let header = match &self.prepared_block {
Some(header) => header.clone(),
None => panic!("propose block without block ready"),
};
let mut mempool = self.mempool.lock().unwrap();
let symbols = match self.symbols_by.take() {
Some(s) => s,
None => panic!("unable to take symbols in scheduler"),
};
mempool.insert_symbols(new_block_id, &header, symbols);
drop(mempool);
self.prepared_block = None;
self.symbols_by = None;
let header_bytes = serialize(&header);
let header_message: Vec<u8> = header_bytes.clone().into();
let hash_str = utils::hash_header_hex(&header_message);
let message = Message::ProposeBlock(
self.addr,
new_block_id as u64,
header_message);
let signal = ServerSignal::ServerBroadcast(message);
// last check before sending out the block
let side_id = self.get_side_id();
let (curr_slot, _) = get_curr_slot(self.start_sec, self.start_millis, self.slot_time);
let curr_id = curr_slot % self.sidenodes.len() as u64;
if curr_id != side_id {
info!("{:?} preempt take too long to construct block", self.addr);
return false;
}
// send the block
self.server_control_sender.send(signal);
//PERFORMANCE_COUNTER.record_propose_block_stop();
//let (curr_slot, elapsed) = get_curr_slot(self.start_sec, self.start_millis, self.slot_time);
//info!("sent Propose_block {:?}", elapsed);
true
}
pub fn my_next_slot(&self) -> u64 {
let (curr_slot, elapsed) = get_curr_slot(self.start_sec, self.start_millis, self.slot_time);
let round = self.sidenodes.len() as u64;
let curr_round = curr_slot / round;
let side_id = self.get_side_id();
let mut next_slot = curr_round * round + side_id;
if next_slot <= curr_slot {
next_slot += round;
}
next_slot
}
}
// return slot and time elapsed as nano
// precision to millis, return curr_slot
pub fn get_curr_slot(start_sec: u64, start_millis: u64, slot_time: f32) -> (u64, u64) {
let curr_time = time::SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
let time_elapsed_millis = (curr_time.as_secs() - start_sec) *1000 + curr_time.subsec_millis() as u64 - start_millis;
(time_elapsed_millis/((slot_time*1000.0) as u64), time_elapsed_millis)
}
// scale id starts at 1
pub fn get_sample_index(scale_id: u64, num_trans: u64, num_node: u64) -> Vec<u32> {
let num_sample = ((num_trans as f32) / (num_node as f32)).ceil() as u64;
let mut sample_idx = vec![];
let start = (scale_id-1)*num_sample;
let stop = if scale_id*num_sample > num_trans {
num_trans
} else {
scale_id*num_sample
};
for i in start..stop {
sample_idx.push(i as u32);
}
sample_idx
}
|
use std::any::Any;
pub trait Animal : Any {
fn speak(&self) -> &'static str;
}
|
use api_client::ApiClient;
use utils::decode_list;
use serde_json::value::Value;
use std::collections::hash_map::HashMap;
use errors::*;
// Struct for Cookbook List from /_latest URL
#[derive(Debug)]
pub struct Cookbooks {
count: usize,
cookbooks: Vec<String>,
client: ApiClient,
}
// Struct for Cookbook Metadata
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct CookbookMetadata {
pub cookbook_name: String,
chef_type: String,
pub version: String,
pub attributes: Vec<HashMap<String, Value>>,
pub metadata: HashMap<String, Value>,
pub recipes: Vec<HashMap<String, Value>>,
providers: Vec<HashMap<String, Value>>,
resources: Vec<HashMap<String, Value>>,
templates: Vec<HashMap<String, Value>>,
root_files: Vec<HashMap<String, Value>>,
#[serde(default, rename = "frozen?")]
pub frozen: bool,
json_class: String,
}
//
impl Cookbooks {
// Return Cookbook Array from Last Version
pub fn new(client: &ApiClient) -> Cookbooks {
let org = &client.config.organization_path();
let path = format!("{}/cookbooks/_latest", org);
client
.get(path.as_ref())
.and_then(decode_list)
.and_then(|list| {
Ok(Cookbooks {
count: 0,
cookbooks: list,
client: client.clone(),
})
})
.unwrap()
}
// Return Cookbook Metadata
pub fn show(client: &ApiClient, name: String) -> Result<CookbookMetadata> {
let org = &client.config.organization_path();
let path = format!("{}/cookbooks/{}/_latest", org, name);
client.get::<CookbookMetadata>(path.as_ref())
}
pub fn version(client: &ApiClient, name: String, version: String) -> Result<CookbookMetadata> {
let org = &client.config.organization_path();
let path = format!("{}/cookbooks/{}/{}", org, name, version);
client.get::<CookbookMetadata>(path.as_ref())
}
}
#[derive(Debug)]
pub struct CookbooksList {
count: usize,
pub cookbooks: Vec<String>,
client: ApiClient,
}
impl CookbooksList {
pub fn new(client: &ApiClient) -> Self {
let org = &client.config.organization_path();
let path = format!("{}/cookbooks", org);
client
.get(path.as_ref())
.and_then(decode_list)
.and_then(|list| {
Ok(CookbooksList {
cookbooks: list,
count: 0,
client: client.clone(),
})
})
.unwrap()
}
}
// Itenarator for Cookbooks
impl Iterator for CookbooksList {
type Item = Result<CookbookMetadata>;
fn count(self) -> usize {
self.cookbooks.len()
}
fn next(&mut self) -> Option<Result<CookbookMetadata>> {
if self.cookbooks.len() >= 1 {
Some(Cookbooks::show(&self.client, self.cookbooks.remove(0)))
} else {
None
}
}
}
|
pub mod fps;
pub mod tracing;
|
pub fn abbreviate(phrase: &str) -> String {
// phrase.split_whitespace().fold(String::new(), |mut acc, s| {
// acc.push(s.chars().next().unwrap());
// acc
// })
phrase
.split_whitespace()
.flat_map(|word| {
word.split('-').map(move |split_word: &str| {
if split_word
.chars()
.all(|c| !c.is_alphabetic() || c.is_uppercase())
{
word.chars().nth(0).unwrap().to_string()
} else {
split_word
.chars()
.enumerate()
.filter_map(|(i, c)| {
if i == 0 || c.is_uppercase() {
Some(c.to_uppercase().nth(0).unwrap())
} else {
None
}
})
.collect::<String>()
}
})
})
.collect()
}
|
use rand::Rng;
use crate::Number;
use super::Term;
///A term which computes a random value each time it is called
pub struct RandomTerm<T: Number>
{
min: Box<dyn Term<T> + Send + Sync>,
max: Box<dyn Term<T> + Send + Sync>
}
impl<T: Number> RandomTerm<T>
{
///A term which randomly generates values between the given min and max terms
///
/// # Examples
///
/// ```
/// use crate::parametrizer::term::randomterm::RandomTerm;
/// use crate::parametrizer::term::variableterm::VariableTerm;
/// use crate::parametrizer::term::constantterm::ConstantTerm;
/// use crate::parametrizer::term::Term;
///
/// let const1 = ConstantTerm::new(6);
/// let const2 = ConstantTerm::new(10);
/// let const3 = ConstantTerm::new(2.5);
/// let variable = VariableTerm::new();
///
/// let rand1 = RandomTerm::new(Box::new(const1), Box::new(const2));
/// let rand2 = RandomTerm::new(Box::new(const3), Box::new(variable));
///
/// assert!(rand1.evaluate(2) < 10);
/// assert!(rand1.evaluate(9) >= 6);
/// assert!(rand2.evaluate(3.0) >= 2.5);
/// assert!(rand2.evaluate(15.0) < 15.0);
/// ```
pub fn new(min: Box<dyn Term<T> + Send + Sync>, max: Box<dyn Term<T> + Send + Sync>) -> RandomTerm<T>
{
return RandomTerm {min, max};
}
}
impl<T: Number> Term<T> for RandomTerm<T>
{
///Generates a random value between the min and max terms
///
/// # Panics
/// Panics if min is not less than max
fn evaluate(&self, t: T) -> T
{
let mut rng = rand::thread_rng();
let minimum = self.min.evaluate(t).to_f64().expect("Unable to convert generic type to f64 for random generation.");
let maximum = self.max.evaluate(t).to_f64().expect("Unable to convert generic type to f64 for random generation.");
if minimum >= maximum
{
panic!("Minimum is not smaller than maximum when attempting to generate a random value in parametrized RandomTerm.");
}
let random = rng.gen_range(minimum..maximum);
return T::from_f64(random).expect("Unable to convert f64 to generic type after random generation.");
}
}
|
struct Solution;
const CHAR_LE: u8 = 'e' as u8;
const CHAR_BE: u8 = 'E' as u8;
const CHAR_0: u8 = '0' as u8;
const CHAR_9: u8 = '9' as u8;
const CHAR_DOT: u8 = '.' as u8;
const CHAR_POS: u8 = '+' as u8;
const CHAR_NEG: u8 = '-' as u8;
const CHAR_SPACE: u8 = ' ' as u8;
use std::collections::HashMap;
#[derive(Debug, PartialEq, Eq, Hash)]
enum State {
Initial,
IntSign, // + -
Integer, // 整数
Point, // .
PointWithoutInt, // . 前没有整数
Fraction, // 小数部分
Exp, // e E
ExpSign, // 指数的符号
ExpNumber, // 指数的数字
End,
}
#[derive(Debug, PartialEq, Eq, Hash)]
enum CharType {
Number, // 数字
Exp, // e E
Point, // .
Sign, // + -
Space, // 空格
Illegal, // 非法字符
}
impl CharType {
fn new(c: char) -> Self {
match c {
'0'..='9' => CharType::Number,
'e' | 'E' => CharType::Exp,
'.' => CharType::Point,
'+' | '-' => CharType::Sign,
' ' => CharType::Space,
_ => CharType::Illegal,
}
}
}
impl Solution {
pub fn is_number(s: String) -> bool {
// 状态机
let mut transfer = HashMap::new();
transfer.insert(State::Initial, {
let mut m = HashMap::new();
m.insert(CharType::Space, State::Initial);
m.insert(CharType::Number, State::Integer);
m.insert(CharType::Point, State::PointWithoutInt);
m.insert(CharType::Sign, State::IntSign);
m
});
transfer.insert(State::IntSign, {
let mut m = HashMap::new();
m.insert(CharType::Number, State::Integer);
m.insert(CharType::Point, State::PointWithoutInt);
m
});
transfer.insert(State::Integer, {
let mut m = HashMap::new();
m.insert(CharType::Number, State::Integer);
m.insert(CharType::Exp, State::Exp);
m.insert(CharType::Point, State::Point);
m.insert(CharType::Space, State::End);
m
});
transfer.insert(State::Point, {
let mut m = HashMap::new();
m.insert(CharType::Number, State::Fraction);
m.insert(CharType::Exp, State::Exp);
m.insert(CharType::Space, State::End);
m
});
transfer.insert(State::PointWithoutInt, {
let mut m = HashMap::new();
m.insert(CharType::Number, State::Fraction);
m
});
transfer.insert(State::Fraction, {
let mut m = HashMap::new();
m.insert(CharType::Number, State::Fraction);
m.insert(CharType::Exp, State::Exp);
m.insert(CharType::Space, State::End);
m
});
transfer.insert(State::Exp, {
let mut m = HashMap::new();
m.insert(CharType::Number, State::ExpNumber);
m.insert(CharType::Sign, State::ExpSign);
m
});
transfer.insert(State::ExpSign, {
let mut m = HashMap::new();
m.insert(CharType::Number, State::ExpNumber);
m
});
transfer.insert(State::ExpNumber, {
let mut m = HashMap::new();
m.insert(CharType::Number, State::ExpNumber);
m.insert(CharType::Space, State::End);
m
});
transfer.insert(State::End, {
let mut m = HashMap::new();
m.insert(CharType::Space, State::End);
m
});
let mut state = &State::Initial;
for c in s.chars() {
let typ = CharType::new(c);
match transfer.get(state).unwrap().get(&typ) {
Some(next_state) => state = next_state,
None => return false,
}
}
match state {
State::Integer | State::Point | State::Fraction | State::ExpNumber | State::End => true,
_ => false,
}
}
pub fn is_number1(s: String) -> bool {
// 直接用库函数。
if let Ok(_x) = s.trim().parse::<f64>() {
true
} else {
false
}
}
// 情况太多了，硬编码搞不定。
pub fn is_number_falied(s: String) -> bool {
// 正则：[+-]?(\d)+ (([eE][+-]?\d+) | ([.]\d+)), 这个正则不完全正确，只是打个样。
let s = s.as_bytes();
let mut state = Self::skip_space(s, 0);
if state.0 == s.len() {
return false;
}
state = Self::have_sign_or_not(s, state.0);
state = Self::at_least_one_number(s, state.0);
if state.0 < s.len() {
match s[state.0] {
CHAR_LE | CHAR_BE => {
// e|E 的前面至少要有一个数字
if !state.1 {
return false;
}
state = Self::have_sign_or_not(s, state.0 + 1);
state = Self::at_least_one_number(s, state.0);
}
CHAR_DOT => {
// '.' 前有数字时后面可以没有，后面有时前面可以没有。
let prev_have_number = state.1;
state = Self::at_least_one_number(s, state.0 + 1);
if prev_have_number {
state.1 = true;
}
}
CHAR_SPACE => {}
_ => return false,
}
if !state.1 {
return false;
}
}
state = Self::skip_space(s, state.0);
state.1 && state.0 == s.len()
}
fn have_sign_or_not(s: &[u8], i: usize) -> (usize, bool) {
if i >= s.len() {
return (i, true);
}
match s[i] {
CHAR_POS | CHAR_NEG => (i + 1, true),
_ => (i, true),
}
}
fn at_least_one_number(s: &[u8], i: usize) -> (usize, bool) {
let mut j = i;
while j < s.len() && CHAR_0 <= s[j] && s[j] <= CHAR_9 {
j += 1;
}
(j, j > i)
}
fn skip_space(s: &[u8], mut i: usize) -> (usize, bool) {
while i < s.len() && s[i] == CHAR_SPACE {
i += 1;
}
(i, true)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_is_number() {
assert_eq!(Solution::is_number(" 0".to_owned()), true); // 前后的空格都忽略。
assert_eq!(Solution::is_number("1 ".to_owned()), true);
assert_eq!(Solution::is_number(".1".to_owned()), true); // 这也算？
assert_eq!(Solution::is_number("3.".to_owned()), true); // 这也算？
assert_eq!(Solution::is_number("+100".to_owned()), true);
assert_eq!(Solution::is_number("5e2".to_owned()), true);
assert_eq!(Solution::is_number("-123".to_owned()), true);
assert_eq!(Solution::is_number("3.1416".to_owned()), true);
assert_eq!(Solution::is_number("-1E-16".to_owned()), true);
assert_eq!(Solution::is_number("0123".to_owned()), true);
assert_eq!(Solution::is_number("46.e3".to_owned()), true);
assert_eq!(Solution::is_number(" ".to_owned()), false);
assert_eq!(Solution::is_number("12e".to_owned()), false);
assert_eq!(Solution::is_number("1a3.14".to_owned()), false);
assert_eq!(Solution::is_number("1.2.3".to_owned()), false);
assert_eq!(Solution::is_number("+-5".to_owned()), false);
assert_eq!(Solution::is_number("12e+5.4".to_owned()), false);
}
}
|
use crate::utils::lines_from_file;
use std::time::Instant;
pub fn main() {
let start = Instant::now();
assert_eq!(part_1_test(), 127);
// println!("part_1 {:?}", part_1());
assert_eq!(part_2_test(), 62);
println!("part_2 {:?}", part_2());
let duration = start.elapsed();
println!("Finished after {:?}", duration);
}
fn part_2() -> u64 {
let entries = lines_from_file("src/day_09/input.txt");
find_weakness(&entries, 1504371145)
}
fn part_2_test() -> u64 {
let entries = lines_from_file("src/day_09/input-test.txt");
find_weakness(&entries, 127)
}
fn part_1() -> u64 {
let entries = lines_from_file("src/day_09/input.txt");
find_first_not_sum(&entries, 25)
}
fn part_1_test() -> u64 {
let entries = lines_from_file("src/day_09/input-test.txt");
find_first_not_sum(&entries, 5)
}
fn find_weakness(entries: &Vec<String>, target: u64) -> u64 {
let numbers: Vec<u64> = entries.iter().map(|line| line.parse().unwrap()).collect();
let mut index_a: usize = 0;
loop {
let mut index_b = index_a + 1;
loop {
if index_b == numbers.len() {
break;
}
let slice = &numbers[index_a..=index_b];
let sum = slice.into_iter().fold(0, |a, b| a + b);
if sum == target {
return slice.into_iter().min().unwrap() + slice.into_iter().max().unwrap();
}
index_b += 1;
}
index_a += 1;
}
}
fn find_first_not_sum(entries: &Vec<String>, preamble: u8) -> u64 {
let numbers: Vec<u64> = entries.iter().map(|line| line.parse().unwrap()).collect();
let mut i = preamble as usize;
loop {
let target = numbers[i];
if !is_sum(target, &numbers[(i - (preamble as usize))..i]) {
return target;
}
i += 1;
}
}
fn is_sum(target: u64, choices: &[u64]) -> bool {
for choice_a in choices {
for choice_b in choices {
if choice_a + choice_b == target && choice_a != choice_b {
return true;
}
}
}
return false;
}
|
extern crate oxygengine_composite_renderer as renderer;
#[macro_use]
extern crate oxygengine_core as core;
use core::{
assets::{asset::AssetId, database::AssetsDatabase},
error::*,
Scalar,
};
use js_sys::{Array, Uint8Array};
use renderer::{
composite_renderer::*, font_asset_protocol::FontAsset, font_face_asset_protocol::FontFaceAsset,
jpg_image_asset_protocol::JpgImageAsset, math::*, png_image_asset_protocol::PngImageAsset,
svg_image_asset_protocol::SvgImageAsset,
};
use std::collections::HashMap;
use wasm_bindgen::{prelude::*, JsCast};
use web_sys::*;
pub mod prelude {
pub use crate::*;
}
pub fn get_canvas_by_id(id: &str) -> HtmlCanvasElement {
let document = window().document().expect("Could not get window document");
let canvas = document
.get_element_by_id(id)
.unwrap_or_else(|| panic!("no `{}` canvas in document", id));
canvas
.dyn_into::<HtmlCanvasElement>()
.map_err(|_| ())
.unwrap()
}
fn window() -> web_sys::Window {
web_sys::window().expect("no global `window` exists")
}
pub struct WebCompositeRenderer {
state: RenderState,
view_size: Vec2,
canvas: HtmlCanvasElement,
context: CanvasRenderingContext2d,
images_cache: HashMap<String, HtmlCanvasElement>,
images_table: HashMap<AssetId, String>,
fontfaces_cache: HashMap<String, FontFace>,
fontfaces_table: HashMap<AssetId, String>,
font_family_map: HashMap<String, String>,
cached_image_smoothing: Option<bool>,
surfaces_cache: HashMap<String, (HtmlCanvasElement, CanvasRenderingContext2d)>,
}
unsafe impl Send for WebCompositeRenderer {}
unsafe impl Sync for WebCompositeRenderer {}
impl WebCompositeRenderer {
pub fn new(canvas: HtmlCanvasElement) -> Self {
let context = canvas
.get_context("2d")
.unwrap()
.unwrap()
.dyn_into::<CanvasRenderingContext2d>()
.unwrap();
Self {
state: RenderState::default(),
view_size: Vec2::zero(),
canvas,
context,
images_cache: Default::default(),
images_table: Default::default(),
fontfaces_cache: Default::default(),
fontfaces_table: Default::default(),
font_family_map: Default::default(),
cached_image_smoothing: None,
surfaces_cache: Default::default(),
}
}
pub fn with_state(canvas: HtmlCanvasElement, state: RenderState) -> Self {
let mut result = Self::new(canvas);
*result.state_mut() = state;
result
}
#[allow(clippy::many_single_char_names)]
fn execute_with<'a, I>(
&self,
context: &CanvasRenderingContext2d,
mut current_alpha: Scalar,
commands: I,
) -> Result<(usize, usize)>
where
I: IntoIterator<Item = Command<'a>>,
{
let mut render_ops = 0;
let mut renderables = 0;
let mut alpha_stack = vec![current_alpha];
for command in commands {
match command {
Command::Draw(renderable) => match renderable {
Renderable::None => {}
Renderable::Rectangle(rectangle) => {
context.set_fill_style(&rectangle.color.to_string().into());
context.fill_rect(
rectangle.rect.x.into(),
rectangle.rect.y.into(),
rectangle.rect.w.into(),
rectangle.rect.h.into(),
);
render_ops += 2;
renderables += 1;
}
Renderable::FullscreenRectangle(color) => {
context.save();
drop(context.set_transform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0));
context.set_fill_style(&color.to_string().into());
context.fill_rect(
0.0,
0.0,
self.view_size.x.into(),
self.view_size.y.into(),
);
context.restore();
render_ops += 2;
renderables += 1;
}
Renderable::Text(text) => {
let name = if let Some(name) = self.font_family_map.get(text.font.as_ref())
{
&name
} else {
text.font.as_ref()
};
context.set_fill_style(&text.color.to_string().into());
context.set_font(&format!("{}px \"{}\"", text.size, name));
context.set_text_align(match text.align {
TextAlign::Left => "left",
TextAlign::Center => "center",
TextAlign::Right => "right",
});
context.set_text_baseline(match text.baseline {
TextBaseLine::Top => "top",
TextBaseLine::Middle => "middle",
TextBaseLine::Bottom => "bottom",
TextBaseLine::Alphabetic => "alphabetic",
TextBaseLine::Hanging => "hanging",
});
for (i, line) in text.text.lines().enumerate() {
if let Some(max_width) = text.max_width {
drop(context.fill_text_with_max_width(
line,
text.position.x.into(),
(text.position.y + text.size * i as Scalar).into(),
max_width.into(),
));
} else {
drop(context.fill_text(
line,
text.position.x.into(),
(text.position.y + text.size * i as Scalar).into(),
));
}
render_ops += 1;
}
render_ops += 3;
renderables += 1;
}
Renderable::Path(path) => {
let mut ops = 0;
context.begin_path();
for element in &path.elements {
match element {
PathElement::MoveTo(pos) => {
context.move_to(pos.x.into(), pos.y.into());
ops += 1;
}
PathElement::LineTo(pos) => {
context.line_to(pos.x.into(), pos.y.into());
ops += 1;
}
PathElement::BezierCurveTo(cpa, cpb, pos) => {
context.bezier_curve_to(
cpa.x.into(),
cpa.y.into(),
cpb.x.into(),
cpb.y.into(),
pos.x.into(),
pos.y.into(),
);
ops += 1;
}
PathElement::QuadraticCurveTo(cp, pos) => {
context.quadratic_curve_to(
cp.x.into(),
cp.y.into(),
pos.x.into(),
pos.y.into(),
);
ops += 1;
}
PathElement::Arc(pos, r, a) => {
drop(context.arc(
pos.x.into(),
pos.y.into(),
(*r).into(),
a.start.into(),
a.end.into(),
));
ops += 1;
}
PathElement::Ellipse(pos, r, rot, a) => {
drop(context.ellipse(
pos.x.into(),
pos.y.into(),
r.x.into(),
r.y.into(),
(*rot).into(),
a.start.into(),
a.end.into(),
));
ops += 1;
}
PathElement::Rectangle(rect) => {
context.rect(
rect.x.into(),
rect.y.into(),
rect.w.into(),
rect.h.into(),
);
ops += 1;
}
}
}
context.set_fill_style(&path.color.to_string().into());
context.close_path();
context.fill();
render_ops += 4 + ops;
renderables += 1;
}
Renderable::Mask(mask) => {
let mut ops = 0;
context.begin_path();
for element in &mask.elements {
match element {
PathElement::MoveTo(pos) => {
context.move_to(pos.x.into(), pos.y.into());
ops += 1;
}
PathElement::LineTo(pos) => {
context.line_to(pos.x.into(), pos.y.into());
ops += 1;
}
PathElement::BezierCurveTo(cpa, cpb, pos) => {
context.bezier_curve_to(
cpa.x.into(),
cpa.y.into(),
cpb.x.into(),
cpb.y.into(),
pos.x.into(),
pos.y.into(),
);
ops += 1;
}
PathElement::QuadraticCurveTo(cp, pos) => {
context.quadratic_curve_to(
cp.x.into(),
cp.y.into(),
pos.x.into(),
pos.y.into(),
);
ops += 1;
}
PathElement::Arc(pos, r, a) => {
drop(context.arc(
pos.x.into(),
pos.y.into(),
(*r).into(),
a.start.into(),
a.end.into(),
));
ops += 1;
}
PathElement::Ellipse(pos, r, rot, a) => {
drop(context.ellipse(
pos.x.into(),
pos.y.into(),
r.x.into(),
r.y.into(),
(*rot).into(),
a.start.into(),
a.end.into(),
));
ops += 1;
}
PathElement::Rectangle(rect) => {
context.rect(
rect.x.into(),
rect.y.into(),
rect.w.into(),
rect.h.into(),
);
ops += 1;
}
}
}
context.close_path();
context.clip();
render_ops += 3 + ops;
}
Renderable::Image(image) => {
let path = image.image.as_ref();
if let Some(elm) = self.images_cache.get(path) {
let mut src = if let Some(src) = image.source {
src
} else {
Rect {
x: 0.0,
y: 0.0,
w: elm.width() as Scalar,
h: elm.height() as Scalar,
}
};
let dst = if let Some(dst) = image.destination {
dst
} else {
Rect {
x: 0.0,
y: 0.0,
w: src.w,
h: src.h,
}
}
.align(image.alignment);
src.x += self.state.image_source_inner_margin;
src.y += self.state.image_source_inner_margin;
src.w -= self.state.image_source_inner_margin * 2.0;
src.h -= self.state.image_source_inner_margin * 2.0;
if src.x < 0.0 {
src.w += src.x;
src.x = 0.0;
}
if src.y < 0.0 {
src.h += src.y;
src.y = 0.0;
}
src.w = src.w.max(1.0);
src.h = src.h.max(1.0);
drop(context
.draw_image_with_html_canvas_element_and_sw_and_sh_and_dx_and_dy_and_dw_and_dh(
elm,
src.x.into(),
src.y.into(),
src.w.into(),
src.h.into(),
dst.x.into(),
dst.y.into(),
dst.w.into(),
dst.h.into(),
));
render_ops += 1;
renderables += 1;
} else if let Some((elm, _)) = self.surfaces_cache.get(path) {
let mut src = if let Some(src) = image.source {
src
} else {
Rect {
x: 0.0,
y: 0.0,
w: elm.width() as Scalar,
h: elm.height() as Scalar,
}
};
let dst = if let Some(dst) = image.destination {
dst
} else {
Rect {
x: 0.0,
y: 0.0,
w: src.w,
h: src.h,
}
}
.align(image.alignment);
src.x += self.state.image_source_inner_margin;
src.y += self.state.image_source_inner_margin;
src.w -= self.state.image_source_inner_margin * 2.0;
src.h -= self.state.image_source_inner_margin * 2.0;
if src.x < 0.0 {
src.w += src.x;
src.x = 0.0;
}
if src.y < 0.0 {
src.h += src.y;
src.y = 0.0;
}
src.w = src.w.max(1.0);
src.h = src.h.max(1.0);
drop(context
.draw_image_with_html_canvas_element_and_sw_and_sh_and_dx_and_dy_and_dw_and_dh(
elm,
src.x.into(),
src.y.into(),
src.w.into(),
src.h.into(),
dst.x.into(),
dst.y.into(),
dst.w.into(),
dst.h.into(),
));
render_ops += 1;
renderables += 1;
}
}
Renderable::Triangles(triangles) => {
let path: &str = &triangles.image;
if let Some(elm) = self.images_cache.get(path) {
let w = elm.width() as Scalar;
let h = elm.height() as Scalar;
let s = Vec2::new(w, h);
for triangle in &triangles.faces {
let a = triangles.vertices[triangle.a];
let b = triangles.vertices[triangle.b];
let c = triangles.vertices[triangle.c];
let nab = (b.0 - a.0).normalized();
let nbc = (c.0 - b.0).normalized();
let nca = (a.0 - c.0).normalized();
if !Vec2::is_clockwise(nab, nbc) {
continue;
}
let pa = a.0 - nbc.right() * self.state.triangles_outer_margin;
let pb = b.0 - nca.right() * self.state.triangles_outer_margin;
let pc = c.0 - nab.right() * self.state.triangles_outer_margin;
context.save();
context.begin_path();
context.move_to(pa.x.into(), pa.y.into());
context.line_to(pb.x.into(), pb.y.into());
context.line_to(pc.x.into(), pc.y.into());
context.close_path();
context.clip();
let s0 = a.1 * s;
let s1 = b.1 * s;
let s2 = c.1 * s;
let denom = s0.x * (s2.y - s1.y) - s1.x * s2.y
+ s2.x * s1.y
+ (s1.x - s2.x) * s0.y;
if denom.abs() > 0.0 {
let m11 = -(s0.y * (c.0.x - b.0.x) - s1.y * c.0.x
+ s2.y * b.0.x
+ (s1.y - s2.y) * a.0.x)
/ denom;
let m12 = (s1.y * c.0.y + s0.y * (b.0.y - c.0.y)
- s2.y * b.0.y
+ (s2.y - s1.y) * a.0.y)
/ denom;
let m21 = (s0.x * (c.0.x - b.0.x) - s1.x * c.0.x
+ s2.x * b.0.x
+ (s1.x - s2.x) * a.0.x)
/ denom;
let m22 = -(s1.x * c.0.y + s0.x * (b.0.y - c.0.y)
- s2.x * b.0.y
+ (s2.x - s1.x) * a.0.y)
/ denom;
let dx = (s0.x * (s2.y * b.0.x - s1.y * c.0.x)
+ s0.y * (s1.x * c.0.x - s2.x * b.0.x)
+ (s2.x * s1.y - s1.x * s2.y) * a.0.x)
/ denom;
let dy = (s0.x * (s2.y * b.0.y - s1.y * c.0.y)
+ s0.y * (s1.x * c.0.y - s2.x * b.0.y)
+ (s2.x * s1.y - s1.x * s2.y) * a.0.y)
/ denom;
drop(context.transform(
m11.into(),
m12.into(),
m21.into(),
m22.into(),
dx.into(),
dy.into(),
));
drop(
context.draw_image_with_html_canvas_element(elm, 0.0, 0.0),
);
render_ops += 2;
renderables += 1;
}
context.restore();
render_ops += 8;
}
} else if let Some((elm, _)) = self.surfaces_cache.get(path) {
let w = elm.width() as Scalar;
let h = elm.height() as Scalar;
let s = Vec2::new(w, h);
for triangle in &triangles.faces {
let a = triangles.vertices[triangle.a];
let b = triangles.vertices[triangle.b];
let c = triangles.vertices[triangle.c];
let nab = (b.0 - a.0).normalized();
let nbc = (c.0 - b.0).normalized();
let nca = (a.0 - c.0).normalized();
if !Vec2::is_clockwise(nab, nbc) {
continue;
}
let pa = a.0 - nbc.right() * self.state.triangles_outer_margin;
let pb = b.0 - nca.right() * self.state.triangles_outer_margin;
let pc = c.0 - nab.right() * self.state.triangles_outer_margin;
context.save();
context.begin_path();
context.move_to(pa.x.into(), pa.y.into());
context.line_to(pb.x.into(), pb.y.into());
context.line_to(pc.x.into(), pc.y.into());
context.close_path();
context.clip();
let s0 = a.1 * s;
let s1 = b.1 * s;
let s2 = c.1 * s;
let denom = s0.x * (s2.y - s1.y) - s1.x * s2.y
+ s2.x * s1.y
+ (s1.x - s2.x) * s0.y;
if denom.abs() > 0.0 {
let m11 = -(s0.y * (c.0.x - b.0.x) - s1.y * c.0.x
+ s2.y * b.0.x
+ (s1.y - s2.y) * a.0.x)
/ denom;
let m12 = (s1.y * c.0.y + s0.y * (b.0.y - c.0.y)
- s2.y * b.0.y
+ (s2.y - s1.y) * a.0.y)
/ denom;
let m21 = (s0.x * (c.0.x - b.0.x) - s1.x * c.0.x
+ s2.x * b.0.x
+ (s1.x - s2.x) * a.0.x)
/ denom;
let m22 = -(s1.x * c.0.y + s0.x * (b.0.y - c.0.y)
- s2.x * b.0.y
+ (s2.x - s1.x) * a.0.y)
/ denom;
let dx = (s0.x * (s2.y * b.0.x - s1.y * c.0.x)
+ s0.y * (s1.x * c.0.x - s2.x * b.0.x)
+ (s2.x * s1.y - s1.x * s2.y) * a.0.x)
/ denom;
let dy = (s0.x * (s2.y * b.0.y - s1.y * c.0.y)
+ s0.y * (s1.x * c.0.y - s2.x * b.0.y)
+ (s2.x * s1.y - s1.x * s2.y) * a.0.y)
/ denom;
drop(context.transform(
m11.into(),
m12.into(),
m21.into(),
m22.into(),
dx.into(),
dy.into(),
));
drop(
context.draw_image_with_html_canvas_element(elm, 0.0, 0.0),
);
render_ops += 2;
renderables += 1;
}
context.restore();
render_ops += 8;
}
}
}
Renderable::Commands(commands) => {
let (o, r) =
self.execute_with(context, current_alpha, commands.into_iter())?;
render_ops += o;
renderables += r;
}
},
Command::Stroke(line_width, renderable) => match renderable {
Renderable::None => {}
Renderable::Rectangle(rectangle) => {
context.set_stroke_style(&rectangle.color.to_string().into());
context.set_line_width(line_width.into());
context.stroke_rect(
rectangle.rect.x.into(),
rectangle.rect.y.into(),
rectangle.rect.w.into(),
rectangle.rect.h.into(),
);
render_ops += 3;
renderables += 1;
}
Renderable::FullscreenRectangle(color) => {
context.save();
drop(context.set_transform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0));
context.set_stroke_style(&color.to_string().into());
context.set_line_width(line_width.into());
context.fill_rect(
0.0,
0.0,
self.view_size.x.into(),
self.view_size.y.into(),
);
context.restore();
render_ops += 2;
renderables += 1;
}
Renderable::Text(text) => {
let name = if let Some(name) = self.font_family_map.get(text.font.as_ref())
{
&name
} else {
text.font.as_ref()
};
context.set_stroke_style(&text.color.to_string().into());
context.set_line_width(line_width.into());
context.set_font(&format!("{}px \"{}\"", text.size, name));
context.set_text_align(match text.align {
TextAlign::Left => "left",
TextAlign::Center => "center",
TextAlign::Right => "right",
});
context.set_text_baseline(match text.baseline {
TextBaseLine::Top => "top",
TextBaseLine::Middle => "middle",
TextBaseLine::Bottom => "bottom",
TextBaseLine::Alphabetic => "alphabetic",
TextBaseLine::Hanging => "hanging",
});
for (i, line) in text.text.lines().enumerate() {
if let Some(max_width) = text.max_width {
drop(context.stroke_text_with_max_width(
line,
text.position.x.into(),
(text.position.y + text.size * i as Scalar).into(),
max_width.into(),
));
} else {
drop(context.stroke_text(
line,
text.position.x.into(),
(text.position.y + text.size * i as Scalar).into(),
));
}
render_ops += 1;
}
render_ops += 4;
renderables += 1;
}
Renderable::Path(path) => {
let mut ops = 0;
context.begin_path();
for element in &path.elements {
match element {
PathElement::MoveTo(pos) => {
context.move_to(pos.x.into(), pos.y.into());
ops += 1;
}
PathElement::LineTo(pos) => {
context.line_to(pos.x.into(), pos.y.into());
ops += 1;
}
PathElement::BezierCurveTo(cpa, cpb, pos) => {
context.bezier_curve_to(
cpa.x.into(),
cpa.y.into(),
cpb.x.into(),
cpb.y.into(),
pos.x.into(),
pos.y.into(),
);
ops += 1;
}
PathElement::QuadraticCurveTo(cp, pos) => {
context.quadratic_curve_to(
cp.x.into(),
cp.y.into(),
pos.x.into(),
pos.y.into(),
);
ops += 1;
}
PathElement::Arc(pos, r, a) => {
drop(context.arc(
pos.x.into(),
pos.y.into(),
(*r).into(),
a.start.into(),
a.end.into(),
));
ops += 1;
}
PathElement::Ellipse(pos, r, rot, a) => {
drop(context.ellipse(
pos.x.into(),
pos.y.into(),
r.x.into(),
r.y.into(),
(*rot).into(),
a.start.into(),
a.end.into(),
));
ops += 1;
}
PathElement::Rectangle(rect) => {
context.rect(
rect.x.into(),
rect.y.into(),
rect.w.into(),
rect.h.into(),
);
ops += 1;
}
}
}
context.set_stroke_style(&path.color.to_string().into());
context.set_line_width(line_width.into());
context.close_path();
context.stroke();
render_ops += 5 + ops;
renderables += 1;
}
Renderable::Mask(_) => error!("Trying to make stroked mask"),
Renderable::Image(image) => {
error!("Trying to render stroked image: {}", image.image)
}
Renderable::Triangles(triangles) => {
context.save();
context.set_stroke_style(&triangles.color.to_string().into());
context.set_line_width(line_width.into());
for triangle in &triangles.faces {
let a = triangles.vertices[triangle.a];
let b = triangles.vertices[triangle.b];
let c = triangles.vertices[triangle.c];
context.begin_path();
context.move_to(a.0.x.into(), a.0.y.into());
context.line_to(b.0.x.into(), b.0.y.into());
context.line_to(c.0.x.into(), c.0.y.into());
context.close_path();
context.stroke();
render_ops += 6;
renderables += 1;
}
context.restore();
render_ops += 4;
}
Renderable::Commands(commands) => {
error!("Trying to render stroked subcommands: {:#?}", commands)
}
},
Command::Transform(a, b, c, d, e, f) => {
drop(context.transform(
a.into(),
b.into(),
c.into(),
d.into(),
e.into(),
f.into(),
));
render_ops += 1;
}
Command::Effect(effect) => {
drop(context.set_global_composite_operation(&effect.to_string()));
render_ops += 1;
}
Command::Alpha(alpha) => {
current_alpha = alpha_stack.last().copied().unwrap_or(1.0) * alpha;
context.set_global_alpha(current_alpha.max(0.0).min(1.0).into());
render_ops += 1;
}
Command::Filter(data) => {
context.set_filter(data.as_ref());
render_ops += 1;
}
Command::Smoothing(value) => {
context.set_image_smoothing_enabled(value);
render_ops += 1;
}
Command::Store => {
alpha_stack.push(current_alpha);
context.save();
render_ops += 1;
}
Command::Restore => {
current_alpha = alpha_stack.pop().unwrap_or(1.0);
context.restore();
render_ops += 1;
}
Command::None => {}
}
}
Ok((render_ops, renderables))
}
}
impl CompositeRenderer for WebCompositeRenderer {
fn execute<'a, I>(&mut self, commands: I) -> Result<(usize, usize)>
where
I: IntoIterator<Item = Command<'a>>,
{
self.execute_with(&self.context, 1.0, commands)
}
fn images_count(&self) -> usize {
self.images_cache.len()
}
fn fontfaces_count(&self) -> usize {
self.fontfaces_cache.len()
}
fn surfaces_count(&self) -> usize {
self.surfaces_cache.len()
}
fn state(&self) -> &RenderState {
&self.state
}
fn state_mut(&mut self) -> &mut RenderState {
&mut self.state
}
fn view_size(&self) -> Vec2 {
self.view_size
}
fn update_state(&mut self) {
let w = self.canvas.client_width();
let h = self.canvas.client_height();
if (self.view_size.x - w as Scalar).abs() > 1.0
|| (self.view_size.y - h as Scalar).abs() > 1.0
{
self.canvas.set_width(w as u32);
self.canvas.set_height(h as u32);
self.view_size = Vec2::new(w as Scalar, h as Scalar);
self.cached_image_smoothing = None;
}
if self.cached_image_smoothing.is_none()
|| self.cached_image_smoothing.unwrap() != self.state.image_smoothing
{
self.context
.set_image_smoothing_enabled(self.state.image_smoothing);
self.cached_image_smoothing = Some(self.state.image_smoothing);
}
}
fn update_cache(&mut self, assets: &AssetsDatabase) {
for id in assets.lately_loaded_protocol("png") {
let id = *id;
let asset = assets
.asset_by_id(id)
.expect("trying to use not loaded png asset");
let path = asset.path().to_owned();
let asset = asset
.get::<PngImageAsset>()
.expect("trying to use non-png asset");
let width = asset.width() as u32;
let height = asset.height() as u32;
let buffer = Uint8Array::from(asset.bytes());
let buffer_val: &JsValue = buffer.as_ref();
let parts = Array::new_with_length(1);
parts.set(0, buffer_val.clone());
let mut options = BlobPropertyBag::new();
options.type_("image/png");
let blob =
Blob::new_with_u8_array_sequence_and_options(parts.as_ref(), &options).unwrap();
let elm = HtmlImageElement::new_with_width_and_height(width, height).unwrap();
elm.set_src(&Url::create_object_url_with_blob(&blob).unwrap());
let document = window().document().expect("Could not get window document");
let canvas = document
.create_element("canvas")
.expect("Could not create canvas element")
.dyn_into::<HtmlCanvasElement>()
.unwrap();
canvas.set_width(width);
canvas.set_height(height);
let context = canvas
.get_context("2d")
.unwrap()
.unwrap()
.dyn_into::<CanvasRenderingContext2d>()
.unwrap();
let elm2 = elm.clone();
let closure = Closure::wrap(Box::new(move |_: web_sys::Event| {
drop(context.draw_image_with_html_image_element(&elm2, 0.0, 0.0));
}) as Box<dyn FnMut(_)>);
elm.set_onload(Some(closure.as_ref().unchecked_ref()));
closure.forget();
self.images_cache.insert(path.clone(), canvas);
self.images_table.insert(id, path);
}
for id in assets.lately_unloaded_protocol("png") {
if let Some(path) = self.images_table.remove(id) {
self.images_cache.remove(&path);
}
}
for id in assets.lately_loaded_protocol("jpg") {
let id = *id;
let asset = assets
.asset_by_id(id)
.expect("trying to use not loaded jpg asset");
let path = asset.path().to_owned();
let asset = asset
.get::<JpgImageAsset>()
.expect("trying to use non-jpg asset");
let width = asset.width() as u32;
let height = asset.height() as u32;
let buffer = Uint8Array::from(asset.bytes());
let buffer_val: &JsValue = buffer.as_ref();
let parts = Array::new_with_length(1);
parts.set(0, buffer_val.clone());
let mut options = BlobPropertyBag::new();
options.type_("image/jpeg");
let blob =
Blob::new_with_u8_array_sequence_and_options(parts.as_ref(), &options).unwrap();
let elm = HtmlImageElement::new_with_width_and_height(width, height).unwrap();
elm.set_src(&Url::create_object_url_with_blob(&blob).unwrap());
let document = window().document().expect("Could not get window document");
let canvas = document
.create_element("canvas")
.expect("Could not create canvas element")
.dyn_into::<HtmlCanvasElement>()
.unwrap();
canvas.set_width(width);
canvas.set_height(height);
let context = canvas
.get_context("2d")
.unwrap()
.unwrap()
.dyn_into::<CanvasRenderingContext2d>()
.unwrap();
let elm2 = elm.clone();
let closure = Closure::wrap(Box::new(move |_: web_sys::Event| {
drop(context.draw_image_with_html_image_element(&elm2, 0.0, 0.0));
}) as Box<dyn FnMut(_)>);
elm.set_onload(Some(closure.as_ref().unchecked_ref()));
closure.forget();
self.images_cache.insert(path.clone(), canvas);
self.images_table.insert(id, path);
}
for id in assets.lately_unloaded_protocol("jpg") {
if let Some(path) = self.images_table.remove(id) {
self.images_cache.remove(&path);
}
}
for id in assets.lately_loaded_protocol("svg") {
let id = *id;
let asset = assets
.asset_by_id(id)
.expect("trying to use not loaded svg asset");
let path = asset.path().to_owned();
let asset = asset
.get::<SvgImageAsset>()
.expect("trying to use non-svg asset");
let width = asset.width() as u32;
let height = asset.height() as u32;
let buffer = Uint8Array::from(asset.bytes());
let buffer_val: &JsValue = buffer.as_ref();
let parts = Array::new_with_length(1);
parts.set(0, buffer_val.clone());
let mut options = BlobPropertyBag::new();
options.type_("image/svg+xml;charset=utf-8");
let blob =
Blob::new_with_u8_array_sequence_and_options(parts.as_ref(), &options).unwrap();
let elm = HtmlImageElement::new_with_width_and_height(width, height).unwrap();
elm.set_src(&Url::create_object_url_with_blob(&blob).unwrap());
let document = window().document().expect("Could not get window document");
let canvas = document
.create_element("canvas")
.expect("Could not create canvas element")
.dyn_into::<HtmlCanvasElement>()
.unwrap();
canvas.set_width(width);
canvas.set_height(height);
let context = canvas
.get_context("2d")
.unwrap()
.unwrap()
.dyn_into::<CanvasRenderingContext2d>()
.unwrap();
let elm2 = elm.clone();
let closure = Closure::wrap(Box::new(move |_: web_sys::Event| {
drop(context.draw_image_with_html_image_element(&elm2, 0.0, 0.0));
}) as Box<dyn FnMut(_)>);
elm.set_onload(Some(closure.as_ref().unchecked_ref()));
closure.forget();
self.images_cache.insert(path.clone(), canvas);
self.images_table.insert(id, path);
}
for id in assets.lately_unloaded_protocol("svg") {
if let Some(path) = self.images_table.remove(id) {
self.images_cache.remove(&path);
}
}
for id in assets.lately_loaded_protocol("fontface") {
let id = *id;
let asset = assets
.asset_by_id(id)
.expect("trying to use not loaded font face asset");
let path = asset.path().to_owned();
let asset = asset
.get::<FontFaceAsset>()
.expect("trying to use non-font-face asset");
let font_asset = assets
.asset_by_id(asset.font_asset())
.expect("trying to use not loaded font asset");
let font_asset = font_asset
.get::<FontAsset>()
.expect("trying to use non-font asset");
let mut descriptors = FontFaceDescriptors::new();
if let Some(style) = &asset.face().style {
descriptors.style(style);
}
descriptors.weight(&asset.face().weight.to_string());
descriptors.stretch(&format!("{}%", asset.face().stretch));
if let Some(variant) = &asset.face().variant {
descriptors.variant(variant);
}
let name = path.replace(|c: char| !c.is_alphanumeric(), "-");
let elm = FontFace::new_with_u8_array_and_descriptors(
&name,
#[allow(mutable_transmutes, clippy::transmute_ptr_to_ptr)]
unsafe {
std::mem::transmute(font_asset.bytes())
},
&descriptors,
)
.unwrap();
drop(
elm.load()
.unwrap_or_else(|_| panic!("Could not load font: {}", path)),
);
window()
.document()
.expect("Could not get window document")
.fonts()
.add(&elm)
.unwrap_or_else(|_| panic!("Could not add font: {}", path));
self.fontfaces_cache.insert(path.clone(), elm);
self.fontfaces_table.insert(id, path.clone());
self.font_family_map.insert(path, name);
}
for id in assets.lately_unloaded_protocol("fontface") {
if let Some(path) = self.fontfaces_table.remove(id) {
self.fontfaces_cache.remove(&path);
self.font_family_map.remove(&path);
}
}
}
fn create_surface(&mut self, name: &str, width: usize, height: usize) -> bool {
let document = window().document().expect("Could not get window document");
let canvas = document
.create_element("canvas")
.expect("Could not create canvas element")
.dyn_into::<HtmlCanvasElement>()
.unwrap();
canvas.set_width(width as u32);
canvas.set_height(height as u32);
let context = canvas
.get_context("2d")
.unwrap()
.unwrap()
.dyn_into::<CanvasRenderingContext2d>()
.unwrap();
self.surfaces_cache
.insert(name.to_owned(), (canvas, context));
true
}
fn destroy_surface(&mut self, name: &str) -> bool {
if let Some((canvas, _)) = self.surfaces_cache.remove(name) {
canvas.remove();
true
} else {
false
}
}
fn has_surface(&mut self, name: &str) -> bool {
self.surfaces_cache.contains_key(name)
}
fn get_surface_size(&self, name: &str) -> Option<(usize, usize)> {
self.surfaces_cache
.get(name)
.map(|(canvas, _)| (canvas.width() as usize, canvas.height() as usize))
}
fn update_surface<'a, I>(&mut self, name: &str, commands: I) -> Result<(usize, usize)>
where
I: IntoIterator<Item = Command<'a>>,
{
if let Some((canvas, context)) = self.surfaces_cache.get(name) {
context.clear_rect(0.0, 0.0, canvas.width().into(), canvas.height().into());
self.execute_with(context, 1.0, commands)
} else {
Err(Error::Message(format!("There is no surface: {}", name)))
}
}
}
impl CompositeRendererResources<HtmlCanvasElement> for WebCompositeRenderer {
fn add_resource(&mut self, id: String, resource: HtmlCanvasElement) -> Result<AssetId> {
let asset_id = AssetId::new();
self.images_cache.insert(id.clone(), resource);
self.images_table.insert(asset_id, id);
Ok(asset_id)
}
fn remove_resource(&mut self, id: AssetId) -> Result<HtmlCanvasElement> {
if let Some(id) = self.images_table.remove(&id) {
if let Some(resource) = self.images_cache.remove(&id) {
Ok(resource)
} else {
Err(Error::Message(format!(
"Image resource does not exists in cache: {:?}",
id
)))
}
} else {
Err(Error::Message(format!(
"Image resource does not exists in table: {:?}",
id
)))
}
}
}
impl CompositeRendererResources<FontFace> for WebCompositeRenderer {
fn add_resource(&mut self, id: String, resource: FontFace) -> Result<AssetId> {
let asset_id = AssetId::new();
self.fontfaces_cache.insert(id.clone(), resource);
self.fontfaces_table.insert(asset_id, id);
Ok(asset_id)
}
fn remove_resource(&mut self, id: AssetId) -> Result<FontFace> {
if let Some(id) = self.fontfaces_table.remove(&id) {
if let Some(resource) = self.fontfaces_cache.remove(&id) {
Ok(resource)
} else {
Err(Error::Message(format!(
"Font face resource does not exists in cache: {:?}",
id
)))
}
} else {
Err(Error::Message(format!(
"Font face esource does not exists in table: {:?}",
id
)))
}
}
}
|
use std::collections::{BTreeMap, HashMap};
use rbatis::crud::{CRUD, Skip};
use rbatis::plugin::page::{Page, PageRequest};
use crate::domain::domain::SysRes;
use crate::domain::dto::{ResEditDTO, ResPageDTO};
use crate::domain::vo::SysResVO;
use crate::error::Error;
use crate::error::Result;
use crate::service::CONTEXT;
use crate::util::string::IsEmpty;
use crate::service::cache_service::ICacheService;
const RES_KEY: &'static str = "sys_res:all";
/// 资源服务
pub struct SysResService {}
impl SysResService {
///资源分页
pub async fn page(&self, arg: &ResPageDTO) -> Result<Page<SysResVO>> {
let page_req = PageRequest::new(arg.page_no.unwrap_or(1), arg.page_size.unwrap_or(10));
let data = CONTEXT
.rbatis
.fetch_page_by_wrapper::<SysRes>(
&CONTEXT
.rbatis
.new_wrapper()
.eq("del", 0)
.do_if(!arg.name.is_empty(), |w| w.like("name", &arg.name))
.is_null("parent_id")
.order_by(false, &["create_date"]),
&page_req,
)
.await?;
let all_res = self.finds_all_map().await?;
let mut all_res_vo = HashMap::new();
for (k, v) in all_res {
all_res_vo.insert(k, SysResVO::from(&v));
}
let mut datas = vec![];
for x in data.records {
let mut vo = SysResVO::from(&x);
vo.set_childs_recursive(&all_res_vo);
datas.push(vo);
}
let new_page = Page {
records: datas,
total: data.total,
pages: data.pages,
page_no: data.page_no,
page_size: data.page_size,
search_count: data.search_count,
};
Ok(new_page)
}
///添加资源
pub async fn add(&self, arg: &SysRes) -> Result<u64> {
let old: Vec<SysRes> = CONTEXT
.rbatis
.fetch_list_by_wrapper(
&CONTEXT
.rbatis
.new_wrapper()
.eq("permission", &arg.permission)
.or()
.eq("name", &arg.name),
)
.await?;
if old.len() > 0 {
return Err(Error::from(format!(
"权限已存在! 权限:{:?}",
rbatis::make_table_field_vec!(old, name)
)));
}
let result = Ok(CONTEXT.rbatis.save(arg,&[]).await?.rows_affected);
self.update_cache().await?;
return result;
}
///修改资源
pub async fn edit(&self, arg: &ResEditDTO) -> Result<u64> {
let mut data = SysRes {
id: arg.id.clone(),
parent_id: arg.parent_id.clone(),
name: arg.name.clone(),
permission: arg.permission.clone(),
path: arg.path.clone(),
del: None,
create_date: None,
};
let result = Ok(CONTEXT.rbatis.update_by_wrapper(&mut data,
&CONTEXT.rbatis.new_wrapper().eq("id",&arg.id),
&[Skip::Column("del"), Skip::Column("id"), Skip::Column("create_date")]).await?);
self.update_cache().await?;
return result;
}
///删除资源
pub async fn remove(&self, id: &str) -> Result<u64> {
let num = CONTEXT
.rbatis
.remove_by_column::<SysRes, _>("id", &id.to_string())
.await?;
//删除父级为id的记录
CONTEXT
.rbatis
.remove_by_wrapper::<SysRes>(&CONTEXT.rbatis.new_wrapper().eq("parent_id", id))
.await;
//删除关联数据
CONTEXT.sys_role_res_service.remove_by_res_id(id).await;
self.update_cache().await?;
return Ok(num);
}
pub fn make_res_ids(&self, args: &Vec<SysResVO>) -> Vec<String> {
let mut ids = vec![];
for x in args {
ids.push(x.id.clone().unwrap_or_default());
match &x.childs {
Some(childs) => {
let child_ids = self.make_res_ids(childs);
for child in child_ids {
ids.push(child);
}
}
_ => {}
}
}
ids
}
/// 查找res数组
pub async fn finds_all(&self) -> Result<Vec<SysRes>> {
let js = CONTEXT
.cache_service
.get_json::<Option<Vec<SysRes>>>(RES_KEY)
.await;
if js.is_err()
|| js.as_ref().unwrap().is_none()
|| js.as_ref().unwrap().as_ref().unwrap().is_empty()
{
let all = self.update_cache().await?;
return Ok(all);
}
if CONTEXT.config.debug {
log::info!("[abs_admin] get from redis:{}", RES_KEY);
}
return Ok(js?.unwrap_or_default());
}
/// 更新所有
pub async fn update_cache(&self) -> Result<Vec<SysRes>> {
let all = CONTEXT.rbatis.fetch_list::<SysRes>().await?;
CONTEXT.cache_service.set_json(RES_KEY, &all).await?;
return Ok(all);
}
/// 查找res数组
pub async fn finds_all_map(&self) -> Result<BTreeMap<String, SysRes>> {
let all = self.finds_all().await?;
let mut result = BTreeMap::new();
for x in all {
result.insert(x.id.clone().unwrap_or_default(), x);
}
return Ok(result);
}
/// 查找res数组
pub async fn finds(&self, ids: &Vec<String>) -> Result<Vec<SysRes>> {
Ok(CONTEXT
.rbatis
.fetch_list_by_wrapper(&CONTEXT.rbatis.new_wrapper().r#in("id", ids))
.await?)
}
/// 查找res数组
pub fn finds_res(&self, ids: &Vec<String>, all_res: &BTreeMap<String, SysRes>) -> Vec<SysRes> {
let mut res = vec![];
//filter res id
for (k, v) in all_res {
for x in ids {
if k.eq(x) {
res.push(v.clone());
}
}
}
res
}
///顶层权限
pub async fn finds_layer_top(&self) -> Result<Vec<SysResVO>> {
let list = CONTEXT
.rbatis
.fetch_list_by_wrapper::<SysRes>(
&CONTEXT
.rbatis
.new_wrapper()
.is_null("parent_id")
.order_by(false, &["create_date"]),
)
.await?;
let all = self.finds_all_map().await?;
self.finds_layer(&rbatis::make_table_field_vec!(list, id), &all)
.await
}
///带有层级结构的 res数组
pub async fn finds_layer(
&self,
ids: &Vec<String>,
all_res: &BTreeMap<String, SysRes>,
) -> Result<Vec<SysResVO>> {
let res = self.finds_res(ids, &all_res);
//find tops
let mut tops = vec![];
for item in res {
//parent id null, it is an top resource
if item.parent_id.is_none() {
tops.push(SysResVO::from(&item));
}
}
//find child
for mut item in &mut tops {
self.loop_find_childs(&mut item, all_res);
}
Ok(tops)
}
///死循环找出父-子 关联关系数组
pub fn loop_find_childs(&self, arg: &mut SysResVO, all_res: &BTreeMap<String, SysRes>) {
let mut childs: Option<Vec<SysResVO>> = None;
for (key, x) in all_res {
if x.parent_id.is_some() && x.parent_id.eq(&arg.id) {
let mut item = SysResVO::from(x);
self.loop_find_childs(&mut item, all_res);
match &mut childs {
Some(childs) => {
childs.push(item);
}
None => {
let mut vec = vec![];
vec.push(item);
childs = Some(vec);
}
}
}
}
if childs.is_some() {
arg.childs = childs;
}
}
}
|
use std::env::args;
use std::result::Result;
use regex::Regex;
#[derive(Debug, Clone)]
struct Passport {
byr: String, //(Birth Year)
iyr: String, //(Issue Year)
eyr: String, //(Expiration Year)
hgt: String, //(Height)
hcl: String, //(Hair Color)
ecl: String, //(Eye Color)
pid: String, //(Passport ID)
cid: String, //(Country ID) - Optional
}
impl Passport {
pub fn new() -> Passport {
Passport {
byr: String::from(""), //(Birth Year)
iyr: String::from(""), //(Issue Year)
eyr: String::from(""), //(Expiration Year)
hgt: String::from(""), //(Height)
hcl: String::from(""), //(Hair Color)
ecl: String::from(""), //(Eye Color)
pid: String::from(""), //(Passport ID)
cid: String::from(""),
}
}
pub fn isvalid(&self) -> bool {
self.byr != ""
&& self.iyr != ""
&& self.eyr != ""
&& self.hgt != ""
&& self.hcl != ""
&& self.ecl != ""
&& self.pid != ""
}
pub fn isvalid_strict(&self) -> bool {
let mut isvalid = false;
let re = Regex::new(r"^\d{4}$").unwrap();
if re.is_match(self.byr.as_str()) {
let number: i32 = self.byr.as_str().parse().unwrap_or(0);
isvalid = number >= 1920 && number <= 2002
} else {
isvalid = false;
}
if isvalid && re.is_match(self.iyr.as_str()) {
let number: i32 = self.iyr.as_str().parse().unwrap_or(0);
isvalid = number >= 2010 && number <= 2020;
} else {
isvalid = false;
}
if isvalid && re.is_match(self.eyr.as_str()) {
let number: i32 = self.eyr.as_str().parse().unwrap_or(0);
isvalid = number >= 2020 && number <= 2030;
} else {
isvalid = false;
}
let re_cm = Regex::new(r"^\d{3}cm$").unwrap();
let re_in = Regex::new(r"^\d{2}in$").unwrap();
if isvalid && re_cm.is_match(self.hgt.as_str()) {
let cm_height = &self.hgt[0..3];
let number: i32 = cm_height.parse().unwrap_or(0);
isvalid = number >= 150 && number <= 193;
} else if isvalid && re_in.is_match(self.hgt.as_str()) {
let in_height = &self.hgt[0..2];
let number: i32 = in_height.parse().unwrap_or(0);
isvalid = number >= 59 && number <= 76;
} else {
isvalid = false;
}
if isvalid {
let re = Regex::new(r"^#[a-fA-F0-9]{6,}$").unwrap();
isvalid = re.is_match(self.hcl.as_str());
} else {
isvalid = false;
}
//amb blu brn gry grn hzl oth
if isvalid {
isvalid = self.ecl == "amb" || self.ecl == "blu" || self.ecl == "brn"
|| self.ecl == "gry" || self.ecl == "grn"|| self.ecl == "hzl" || self.ecl == "oth";
} else {
isvalid = false;
}
if isvalid {
let re = Regex::new(r"^\d{9}$").unwrap();
isvalid = re.is_match(self.pid.as_str());
} else {
isvalid = false;
}
isvalid
}
}
fn part1(passports: &Vec<Passport>) -> usize {
passports
.iter()
.map(|p| if p.isvalid() { 1 } else { 0 })
.sum()
}
fn part2(passports: &Vec<Passport>) -> u64 {
passports
.iter()
.map(|p| if p.isvalid_strict() { 1 } else { 0 })
.sum()
}
fn read_passports(content: &String) -> Vec<Passport> {
let mut passports: Vec<Passport> = Vec::new();
let mut passport_count = 0;
let mut passport = Passport::new();
let mut valid_passport = 0;
let count: usize = content.split(|c| c == ' ' || c == '\n')
.map(|s| {
if s == "" {
passport_count += 1;
passports.push(passport.clone()); // push existing passport as it is complete
passport = Passport::new(); // create a new passport
valid_passport = 1;
} else {
let key_values: Vec<&str> = s.split(|t| t == ':').collect();
if key_values.len() == 2 {
match key_values[0] {
"byr" => passport.byr = String::from(key_values[1]),
"iyr" => passport.iyr = String::from(key_values[1]),
"eyr" => passport.eyr = String::from(key_values[1]),
"hgt" => passport.hgt = String::from(key_values[1]),
"hcl" => passport.hcl = String::from(key_values[1]),
"ecl" => passport.ecl = String::from(key_values[1]),
"pid" => passport.pid = String::from(key_values[1]),
"cid" => passport.cid = String::from(key_values[1]),
_ => println!("Error"),
}
}
valid_passport = 0;
}
valid_passport
})
.sum();
println!("Count: {}", count);
passports
}
#[cfg(test)]
mod test {
use super::*;
const TEST_INPUT: &str = r#"ecl:gry pid:860033327 eyr:2020 hcl:#fffffd
byr:1937 iyr:2017 cid:147 hgt:183cm
iyr:2013 ecl:amb cid:350 eyr:2023 pid:028048884
hcl:#cfa07d byr:1929
hcl:#ae17e1 iyr:2013
eyr:2024
ecl:brn pid:760753108 byr:1931
hgt:179cm
hcl:#cfa07d eyr:2025 pid:166559648
iyr:2011 ecl:brn hgt:59in
"#;
const TEST_INPUT2: &str = r#"hgt:159cm
iyr:1997 byr:1994
hgt:189cm
ecl:gry pid:564165515
eyr:2029 hcl:#ceb3a1
hcl:#602927 eyr:2024
cid:130
iyr:2015 ecl:blu
hgt:184cm byr:1996
pid:897871188
pid:561068005 eyr:2025 iyr:2017 cid:139 ecl:blu hcl:#ceb3a1
byr:1940
iyr:2014
byr:1986 pid:960679613 eyr:2025 ecl:hzl
cid:211 ecl:blu hcl:#7d3b0c iyr:2011 pid:006632702
byr:1982 eyr:2023 hgt:68in
hcl:#341e13 hgt:192 iyr:2028
ecl:utc
eyr:2027 byr:1979 pid:653515689
eyr:2026 hgt:161cm ecl:#1850b8
pid:298779494 hcl:b2114e iyr:1953
hgt:155cm
hcl:#a97842 iyr:2019
ecl:gry byr:1939
pid:935099157 eyr:2027
"#;
#[test]
fn testcase1() {
let content = String::from(TEST_INPUT);
let passports = read_passports(&content);
let count = part1(&passports);
assert_eq!(count, 2);
}
#[test]
fn testcase2() {
let content = String::from(TEST_INPUT2);
let passports = read_passports(&content);
let count = part1(&passports);
assert_eq!(count, 5);
}
#[test]
fn testcase3() {
let content = String::from(TEST_INPUT);
let passports = read_passports(&content);
let count = part2(&passports);
assert_eq!(count, 5);
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
let filename = args().nth(1).ok_or("I need a filename")?;
let content = std::fs::read_to_string(&filename)?;
let passports = read_passports(&content);
let part1_answer = part1(&passports);
println!("Part1 Answer: {}", part1_answer);
let part2_answer = part2(&passports);
println!("Part2 Answer: {}", part2_answer);
Ok(())
}
|
use ape;
use core;
use diesel;
use diesel_migrations;
use id3;
use getopts;
use image;
use hyper;
use iron::IronError;
use iron::status::Status;
use lewton;
use metaflac;
use regex;
use serde_json;
use std;
use toml;
error_chain! {
foreign_links {
Ape(ape::Error);
Diesel(diesel::result::Error);
DieselConnection(diesel::ConnectionError);
DieselMigration(diesel_migrations::RunMigrationsError);
Encoding(core::str::Utf8Error);
Flac(metaflac::Error);
GetOpts(getopts::Fail);
Hyper(hyper::Error);
Id3(id3::Error);
Image(image::ImageError);
Io(std::io::Error);
Json(serde_json::Error);
Time(std::time::SystemTimeError);
Toml(toml::de::Error);
Regex(regex::Error);
Vorbis(lewton::VorbisError);
}
errors {
DaemonError {}
AuthenticationRequired {}
AdminPrivilegeRequired {}
MissingConfig {}
MissingUsername {}
MissingPassword {}
MissingPlaylist {}
IncorrectCredentials {}
CannotServeDirectory {}
UnsupportedFileType {}
FileNotFound {}
MissingIndexVersion {}
MissingPlaylistName {}
EncodingError {}
}
}
impl From<Error> for IronError {
fn from(err: Error) -> IronError {
match err {
e @ Error(ErrorKind::AuthenticationRequired, _) => {
IronError::new(e, Status::Unauthorized)
}
e @ Error(ErrorKind::AdminPrivilegeRequired, _) => IronError::new(e, Status::Forbidden),
e @ Error(ErrorKind::MissingUsername, _) => IronError::new(e, Status::BadRequest),
e @ Error(ErrorKind::MissingPassword, _) => IronError::new(e, Status::BadRequest),
e @ Error(ErrorKind::IncorrectCredentials, _) => {
IronError::new(e, Status::Unauthorized)
}
e @ Error(ErrorKind::CannotServeDirectory, _) => IronError::new(e, Status::BadRequest),
e @ Error(ErrorKind::UnsupportedFileType, _) => IronError::new(e, Status::BadRequest),
e => IronError::new(e, Status::InternalServerError),
}
}
}
|
// Copyright (C) 2021 Deeper Network Inc.
// SPDX-License-Identifier: Apache-2.0
// 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.
#[cfg(test)]
use crate::{mock::*, CampaignIdSwitch, Error, MaintainDevices, UserCredit, UserCreditHistory};
use frame_support::traits::Currency;
use frame_support::{assert_err, assert_noop, assert_ok, dispatch::DispatchError};
use frame_system::RawOrigin;
use node_primitives::{
credit::{CreditData, CreditInterface, CreditLevel, CreditSetting},
user_privileges::Privilege,
};
use sp_core::H160;
use sp_runtime::traits::BadOrigin;
use sp_runtime::Percent;
#[test]
fn get_credit_level() {
new_test_ext().execute_with(|| {
assert_eq!(CreditLevel::get_credit_level(0), CreditLevel::Zero);
assert_eq!(CreditLevel::get_credit_level(50), CreditLevel::Zero);
assert_eq!(CreditLevel::get_credit_level(99), CreditLevel::Zero);
assert_eq!(CreditLevel::get_credit_level(100), CreditLevel::One);
assert_eq!(CreditLevel::get_credit_level(150), CreditLevel::One);
assert_eq!(CreditLevel::get_credit_level(199), CreditLevel::One);
assert_eq!(CreditLevel::get_credit_level(200), CreditLevel::Two);
assert_eq!(CreditLevel::get_credit_level(250), CreditLevel::Two);
assert_eq!(CreditLevel::get_credit_level(299), CreditLevel::Two);
assert_eq!(CreditLevel::get_credit_level(300), CreditLevel::Three);
assert_eq!(CreditLevel::get_credit_level(350), CreditLevel::Three);
assert_eq!(CreditLevel::get_credit_level(399), CreditLevel::Three);
assert_eq!(CreditLevel::get_credit_level(400), CreditLevel::Four);
assert_eq!(CreditLevel::get_credit_level(450), CreditLevel::Four);
assert_eq!(CreditLevel::get_credit_level(499), CreditLevel::Four);
assert_eq!(CreditLevel::get_credit_level(500), CreditLevel::Five);
assert_eq!(CreditLevel::get_credit_level(550), CreditLevel::Five);
assert_eq!(CreditLevel::get_credit_level(599), CreditLevel::Five);
assert_eq!(CreditLevel::get_credit_level(600), CreditLevel::Six);
assert_eq!(CreditLevel::get_credit_level(650), CreditLevel::Six);
assert_eq!(CreditLevel::get_credit_level(699), CreditLevel::Six);
assert_eq!(CreditLevel::get_credit_level(700), CreditLevel::Seven);
assert_eq!(CreditLevel::get_credit_level(750), CreditLevel::Seven);
assert_eq!(CreditLevel::get_credit_level(799), CreditLevel::Seven);
assert_eq!(CreditLevel::get_credit_level(800), CreditLevel::Eight);
assert_eq!(CreditLevel::get_credit_level(950), CreditLevel::Eight);
assert_eq!(CreditLevel::get_credit_level(1099), CreditLevel::Eight);
});
}
#[test]
fn update_credit_setting() {
new_test_ext().execute_with(|| {
let credit_setting = CreditSetting {
campaign_id: 0,
credit_level: CreditLevel::One,
staking_balance: 20_000,
base_apy: Percent::from_percent(39),
bonus_apy: Percent::from_percent(0),
max_rank_with_bonus: 1u32,
tax_rate: Percent::from_percent(10),
max_referees_with_rewards: 1,
reward_per_referee: 18,
};
assert_noop!(
Credit::update_credit_setting(RuntimeOrigin::signed(1), credit_setting.clone()),
BadOrigin
);
assert_ok!(Credit::update_credit_setting(
RawOrigin::Root.into(),
credit_setting.clone()
));
assert_eq!(Credit::credit_settings(0, CreditLevel::One), credit_setting);
let credit_setting_updated = CreditSetting {
campaign_id: 0,
credit_level: CreditLevel::One,
staking_balance: 40_000,
base_apy: Percent::from_percent(45),
bonus_apy: Percent::from_percent(3),
max_rank_with_bonus: 2u32,
tax_rate: Percent::from_percent(9),
max_referees_with_rewards: 2,
reward_per_referee: 18,
};
assert_ok!(Credit::update_credit_setting(
RawOrigin::Root.into(),
credit_setting_updated.clone()
));
assert_eq!(
Credit::credit_settings(0, CreditLevel::One),
credit_setting_updated
);
});
}
#[test]
fn add_or_update_credit_data() {
new_test_ext().execute_with(|| {
let credit_data = CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 0,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 0,
};
// Only sudo can call update_credit_data
assert_noop!(
Credit::add_or_update_credit_data(RuntimeOrigin::signed(1), 2, credit_data.clone()),
BadOrigin
);
assert_eq!(Credit::get_credit_balance(&1, Some(5)), Vec::new());
assert_eq!(
Credit::get_credit_balance(&1, Some(1)),
Credit::get_credit_balance(&1, Some(4))
);
// update_credit_data works
run_to_block(1);
assert_ok!(Credit::add_or_update_credit_data(
RawOrigin::Root.into(),
1,
credit_data.clone()
));
assert_eq!(Credit::user_credit(1), Some(credit_data.clone()));
assert_eq!(
<frame_system::Pallet<Test>>::events()
.pop()
.expect("should contains events")
.event,
crate::tests::RuntimeEvent::from(crate::Event::CreditUpdateSuccess(1, 100))
);
// add_credit_data works
run_to_block(2 * BLOCKS_PER_ERA - 1);
assert_ok!(Credit::add_or_update_credit_data(
RawOrigin::Root.into(),
14,
credit_data.clone()
));
assert_eq!(Credit::user_credit(14), Some(credit_data.clone()));
assert_eq!(Credit::user_credit_history(14), vec![]);
assert_eq!(
<frame_system::Pallet<Test>>::events()
.pop()
.expect("should contains events")
.event,
crate::tests::RuntimeEvent::from(crate::Event::CreditUpdateSuccess(14, 100))
);
// credit_data invalid
let credit_data = CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::Two,
rank_in_initial_credit_level: 0,
number_of_referees: 1,
current_credit_level: CreditLevel::Two,
reward_eras: 0,
};
assert_eq!(
Credit::add_or_update_credit_data(RawOrigin::Root.into(), 1, credit_data.clone()),
Err(DispatchError::from(Error::<Test>::InvalidCreditData))
);
let credit_data = CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 0,
number_of_referees: 10,
current_credit_level: CreditLevel::One,
reward_eras: 100,
};
assert_eq!(
Credit::add_or_update_credit_data(RawOrigin::Root.into(), 1, credit_data.clone()),
Err(DispatchError::from(Error::<Test>::InvalidCreditData))
);
});
}
#[test]
fn add_or_update_credit_data_check_credit_history_and_reward() {
new_test_ext().execute_with(|| {
// era 0
assert_ok!(DeeperNode::im_online(RuntimeOrigin::signed(3)));
// era 1
run_to_block(BLOCKS_PER_ERA);
assert_eq!(Credit::user_credit_history(3), vec![]);
assert!(Credit::init_delegator_history(&3, 0));
assert_eq!(Credit::get_reward(&3, 0, 0).0, Some(21369858941948251800));
let credit_historys = vec![(
0,
CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 1,
},
)];
assert_eq!(Credit::user_credit_history(3), credit_historys);
let credit_data = CreditData {
campaign_id: 0,
credit: 400,
initial_credit_level: CreditLevel::Four,
rank_in_initial_credit_level: 0,
number_of_referees: 1,
current_credit_level: CreditLevel::Four,
reward_eras: 270,
};
assert_ok!(Credit::add_or_update_credit_data(
RawOrigin::Root.into(),
3,
credit_data.clone()
));
assert_eq!(Credit::user_credit(3), Some(credit_data));
let credit_historys = vec![
(
0,
CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 1,
},
),
(
1,
CreditData {
campaign_id: 0,
credit: 400,
initial_credit_level: CreditLevel::Four,
rank_in_initial_credit_level: 0,
number_of_referees: 1,
current_credit_level: CreditLevel::Four,
reward_eras: 270,
},
),
];
assert_eq!(Credit::user_credit_history(3), credit_historys);
// era 2
run_to_block(BLOCKS_PER_ERA * 2);
assert_eq!(Credit::get_reward(&3, 1, 1).0, Some(223068450647875213020));
// era 3
run_to_block(BLOCKS_PER_ERA * 3);
assert_eq!(Credit::get_reward(&3, 2, 2).0, Some(223068450647875213020));
});
}
#[test]
fn get_credit_score() {
new_test_ext().execute_with(|| {
UserCredit::<Test>::insert(
1,
CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 1,
},
);
assert_eq!(Credit::get_credit_score(&1).unwrap(), 100);
});
}
#[test]
fn slash_credit() {
new_test_ext().execute_with(|| {
UserCredit::<Test>::insert(
1,
CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
reward_eras: 1,
current_credit_level: CreditLevel::One,
},
);
run_to_block(1);
Credit::slash_credit(&1, None);
assert_eq!(
Credit::get_credit_score(&1).unwrap(),
100 - CREDIT_ATTENUATION_STEP
);
assert_eq!(
<frame_system::Pallet<Test>>::events()
.pop()
.expect("should contains events")
.event,
crate::tests::RuntimeEvent::from(crate::Event::CreditUpdateSuccess(
1,
100 - CREDIT_ATTENUATION_STEP
))
);
});
}
#[test]
fn update_credit_by_traffic() {
new_test_ext().execute_with(|| {
Credit::update_credit_by_traffic(1);
assert_eq!(Credit::user_credit(&1).unwrap().credit, 0);
assert_ok!(DeeperNode::im_online(RuntimeOrigin::signed(1)));
Credit::update_credit_by_traffic(1);
assert_eq!(Credit::user_credit(&1).unwrap().credit, 0);
run_to_block(BLOCKS_PER_ERA * 2);
Credit::update_credit_by_traffic(1);
assert_eq!(Credit::user_credit(&1).unwrap().credit, 1); // 0 + 1
run_to_block(BLOCKS_PER_ERA * 3);
Credit::update_credit_by_traffic(1);
assert_eq!(Credit::user_credit(&1).unwrap().credit, 2); // 1 + 1
run_to_block(BLOCKS_PER_ERA * 4);
Credit::update_credit_by_traffic(1);
assert_eq!(Credit::user_credit(&1).unwrap().credit, 3); // 2 + 1
run_to_block(BLOCKS_PER_ERA * 5);
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
2,
Privilege::DeviceAdmin
));
assert_ok!(Credit::set_maintain_device(RuntimeOrigin::signed(2), 1));
Credit::update_credit_by_traffic(1); // device maintain doesn't affect credit increase
assert_eq!(Credit::user_credit(&1).unwrap().credit, 4);
});
}
#[test]
fn update_credit_by_tip() {
new_test_ext().execute_with(|| {
Credit::update_credit_by_tip(1, 8);
assert_eq!(Credit::user_credit(&1).unwrap().credit, 0);
assert_ok!(DeeperNode::im_online(RuntimeOrigin::signed(1)));
Credit::update_credit_by_tip(1, 8);
assert_eq!(Credit::user_credit(&1).unwrap().credit, 8); // 0 + 8
});
}
#[test]
fn update_credit_by_burn_nft() {
new_test_ext().execute_with(|| {
assert_ok!(Credit::update_credit_by_burn_nft(1, 8));
assert_eq!(Credit::user_credit(&1).unwrap().credit, 8); // 0 + 8
});
}
#[test]
fn get_reward_work() {
new_test_ext().execute_with(|| {
assert_eq!(Credit::get_reward(&3, 0, 0).0, None);
assert!(Credit::init_delegator_history(&3, 0));
assert!(Credit::init_delegator_history(&7, 0));
assert!(Credit::init_delegator_history(&8, 0));
assert!(Credit::init_delegator_history(&9, 0));
assert!(Credit::init_delegator_history(&10, 0));
assert!(Credit::init_delegator_history(&11, 0));
run_to_block(BLOCKS_PER_ERA); // era 1
assert_eq!(Credit::get_reward(&3, 0, 0).0, Some(21369858941948251800));
assert_eq!(Credit::get_reward(&7, 0, 0).0, Some(223068450647875213020));
assert_eq!(Credit::get_reward(&8, 0, 0).0, Some(223068450647875213020));
assert_eq!(Credit::get_reward(&9, 0, 0).0, Some(223068450647875213020));
assert_eq!(Credit::get_reward(&10, 0, 0).0, Some(223068450647875213020));
assert_eq!(Credit::get_reward(&11, 0, 0).0, Some(56416427606743384752));
run_to_block(BLOCKS_PER_ERA * 2); // era 2, credit expires at era 1
assert_eq!(Credit::get_reward(&3, 1, 1).0, None);
assert_eq!(Credit::get_reward(&7, 1, 1).0, Some(223068450647875213020));
assert_eq!(Credit::get_reward(&8, 1, 1).0, Some(223068450647875213020));
assert_eq!(Credit::get_reward(&9, 1, 1).0, Some(223068450647875213020));
assert_eq!(Credit::get_reward(&10, 1, 1).0, Some(223068450647875213020));
assert_eq!(Credit::get_reward(&11, 1, 1).0, Some(56416427606743384752));
});
}
#[test]
fn get_reward_with_slash_credit_with_bonus() {
new_test_ext().execute_with(|| {
assert_eq!(Credit::user_credit(&7).unwrap().credit, 400);
assert!(Credit::init_delegator_history(&7, 0));
run_to_block(BLOCKS_PER_ERA);
assert_eq!(Credit::get_reward(&7, 0, 0).0, Some(223068450647875213020));
Credit::slash_credit(&7, None);
assert_eq!(
Credit::user_credit(&7).unwrap().credit,
400 - CREDIT_ATTENUATION_STEP
);
run_to_block(BLOCKS_PER_ERA * 2);
assert_eq!(Credit::get_reward(&7, 1, 1).0, Some(111517786970905338624));
});
}
#[test]
fn get_reward_failed() {
new_test_ext().execute_with(|| {
run_to_block(BLOCKS_PER_ERA);
assert_eq!(Credit::get_reward(&5, 0, 0).0, None); // 5 credit 0
assert_eq!(Credit::get_reward(&8, 0, 0).0, None); // 8 not contains in storage
});
}
#[test]
fn slash_offline_devices_credit() {
new_test_ext().execute_with(|| {
assert_eq!(Credit::user_credit(&3).unwrap().credit, 100);
assert_ok!(DeeperNode::im_online(RuntimeOrigin::signed(3)));
run_to_block(BLOCKS_PER_ERA);
Credit::slash_offline_device_credit(&3);
assert_eq!(Credit::user_credit(&3).unwrap().credit, 100);
run_to_block(BLOCKS_PER_ERA * 3);
Credit::slash_offline_device_credit(&3);
assert_eq!(Credit::user_credit(&3).unwrap().credit, 99);
run_to_block(BLOCKS_PER_ERA * 5);
Credit::slash_offline_device_credit(&3);
assert_eq!(Credit::user_credit(&3).unwrap().credit, 99);
run_to_block(BLOCKS_PER_ERA * 6);
Credit::slash_offline_device_credit(&3);
assert_eq!(Credit::user_credit(&3).unwrap().credit, 98);
run_to_block(BLOCKS_PER_ERA * 8);
Credit::slash_offline_device_credit(&3);
assert_eq!(Credit::user_credit(&3).unwrap().credit, 98);
run_to_block(BLOCKS_PER_ERA * 9);
Credit::slash_offline_device_credit(&3);
assert_eq!(Credit::user_credit(&3).unwrap().credit, 97);
run_to_block(BLOCKS_PER_ERA * 12);
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
1,
Privilege::DeviceAdmin
));
assert_ok!(Credit::set_maintain_device(RuntimeOrigin::signed(1), 3));
Credit::slash_offline_device_credit(&3);
assert_eq!(Credit::user_credit(&3).unwrap().credit, 97);
});
}
#[test]
fn update_credit_history_when_era_is_the_same() {
new_test_ext().execute_with(|| {
UserCredit::<Test>::insert(
1,
CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
);
assert!(Credit::init_delegator_history(&1, 0));
//default era=0
let credit_historys = vec![(
0,
CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
)];
assert_eq!(Credit::user_credit_history(1), credit_historys);
});
}
#[test]
fn update_credit_history_when_era_is_non_zero() {
new_test_ext().execute_with(|| {
//default era = 0
UserCredit::<Test>::insert(
1,
CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
);
// run_to_block, era=1
run_to_block(BLOCKS_PER_ERA);
assert!(Credit::init_delegator_history(&1, 1));
Credit::update_credit_history(&1, 10);
let credit_historys = vec![
(
1,
CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
(
10,
CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
];
assert_eq!(Credit::user_credit_history(1), credit_historys);
});
}
#[test]
fn burn_dpr_add_credit() {
new_test_ext().execute_with(|| {
// 1,3's gennesis balance = 500
let _ = Balances::deposit_creating(&1, 5000);
let _ = Balances::deposit_creating(&3, 10000);
// genesis 1's credit score 100
UserCreditHistory::<Test>::insert(
1,
vec![
(
1,
CreditData {
campaign_id: 0,
credit: 10,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
(
2,
CreditData {
campaign_id: 0,
credit: 50,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
],
);
// genesis 3's credit score 100
UserCreditHistory::<Test>::insert(
3,
vec![
(
1,
CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
(
2,
CreditData {
campaign_id: 0,
credit: 300,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::Three,
reward_eras: 270,
},
),
],
);
// run_to_block, era=1
run_to_block(BLOCKS_PER_ERA * 3);
assert!(Credit::burn_for_add_credit(RuntimeOrigin::signed(1), 100).is_ok());
assert!(Credit::burn_for_add_credit(RuntimeOrigin::signed(3), 200).is_ok());
assert_eq!(Credit::user_credit(1).unwrap().credit, 100);
assert_eq!(Credit::user_credit(3).unwrap().credit, 300);
assert_eq!(Balances::free_balance(&1), 500);
assert_eq!(Balances::free_balance(&3), 500);
assert_eq!(Treasury::pot(), 10000 + 5000);
});
}
#[test]
fn switch_campaign_duration() {
new_test_ext().execute_with(|| {
// 1,3's gennesis balance = 500
let _ = Balances::deposit_creating(&13, 5000);
CampaignIdSwitch::<Test>::insert(0, 1);
//let credit_data = Credit::user_credit(1).unwrap();
assert!(Credit::init_delegator_history(&13, 1));
// run_to_block, era=1
run_to_block(BLOCKS_PER_ERA * 2);
assert_eq!(Credit::get_reward(&13, 1, 1).0, Some(60263002216294070076));
run_to_block(BLOCKS_PER_ERA * 3);
assert_eq!(Credit::get_reward(&13, 2, 2).0, Some(56416427606743384752));
assert_eq!(Credit::user_credit(13).unwrap().campaign_id, 1);
assert_eq!(Credit::user_credit(13).unwrap().reward_eras, 3650);
run_to_block(BLOCKS_PER_ERA * 4);
assert_eq!(Credit::get_reward(&13, 3, 3).0, Some(56416427606743384752));
});
}
#[test]
fn switch_campaign_same_id() {
new_test_ext().execute_with(|| {
// 1,3's gennesis balance = 500
let _ = Balances::deposit_creating(&13, 5000);
CampaignIdSwitch::<Test>::insert(0, 0);
//let credit_data = Credit::user_credit(1).unwrap();
assert!(Credit::init_delegator_history(&13, 1));
// run_to_block, era=1
run_to_block(BLOCKS_PER_ERA * 2);
assert_eq!(Credit::get_reward(&13, 1, 1).0, Some(60263002216294070076));
run_to_block(BLOCKS_PER_ERA * 3);
assert_eq!(Credit::get_reward(&13, 2, 2).0, Some(60263002216294070076));
assert_eq!(Credit::user_credit(13).unwrap().campaign_id, 0);
assert_eq!(Credit::user_credit(13).unwrap().reward_eras, 1 + 180);
});
}
#[test]
fn force_modify_credit_history() {
new_test_ext().execute_with(|| {
UserCreditHistory::<Test>::insert(
1,
vec![
(
6,
CreditData {
campaign_id: 0,
credit: 110,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
(
10,
CreditData {
campaign_id: 0,
credit: 109,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
],
);
assert!(Credit::force_modify_credit_history(RuntimeOrigin::root().into(), 1, 8).is_ok());
assert_eq!(
Credit::user_credit_history(1),
vec![
(
8,
CreditData {
campaign_id: 0,
credit: 110,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
(
10,
CreditData {
campaign_id: 0,
credit: 109,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
]
);
assert!(Credit::force_modify_credit_history(RuntimeOrigin::root().into(), 1, 6).is_err()); // do not modify
assert_eq!(
Credit::user_credit_history(1),
vec![
(
8,
CreditData {
campaign_id: 0,
credit: 110,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
(
10,
CreditData {
campaign_id: 0,
credit: 109,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
),
]
);
assert!(Credit::force_modify_credit_history(RuntimeOrigin::root().into(), 1, 10).is_ok());
assert_eq!(
Credit::user_credit_history(1),
vec![(
10,
CreditData {
campaign_id: 0,
credit: 109,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
)]
);
assert!(Credit::force_modify_credit_history(RuntimeOrigin::root().into(), 1, 12).is_ok());
assert_eq!(
Credit::user_credit_history(1),
vec![(
12,
CreditData {
campaign_id: 0,
credit: 109,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
)]
);
assert!(Credit::force_modify_credit_history(RuntimeOrigin::root().into(), 1, 12).is_ok());
assert_eq!(
Credit::user_credit_history(1),
vec![(
12,
CreditData {
campaign_id: 0,
credit: 109,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
},
)]
);
});
}
#[test]
fn update_nft_class_credit() {
new_test_ext().execute_with(|| {
assert_noop!(
Credit::update_nft_class_credit(RuntimeOrigin::signed(1), 0, 5),
Error::<Test>::NotAdmin
);
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
3,
Privilege::CreditAdmin
));
assert_ok!(Credit::update_nft_class_credit(
RuntimeOrigin::signed(3),
0,
5
));
assert_eq!(crate::MiningMachineClassCredit::<Test>::get(0), 5);
assert_ok!(Credit::update_nft_class_credit(
RuntimeOrigin::signed(3),
1,
10
));
assert_eq!(crate::MiningMachineClassCredit::<Test>::get(1), 10);
});
}
#[test]
fn update_sum_of_credit_nft_burn_history() {
new_test_ext().execute_with(|| {
assert_noop!(
Credit::update_sum_of_credit_nft_burn_history(RuntimeOrigin::signed(1), 0, 5),
Error::<Test>::NotAdmin
);
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
3,
Privilege::CreditAdmin
));
assert_ok!(Credit::update_sum_of_credit_nft_burn_history(
RuntimeOrigin::signed(3),
0,
5
));
assert_eq!(crate::CreditFromBurnNft::<Test>::get(0), 5);
});
}
#[test]
fn burn_nft() {
new_test_ext().execute_with(|| {
assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 1, 1, true));
assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 2, 1, true));
assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 1));
assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 1, 42, 1));
assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 2, 42, 1));
assert_noop!(
Credit::burn_nft(RuntimeOrigin::signed(1), 0, 42),
Error::<Test>::MiningMachineClassCreditNoConfig
);
assert_noop!(
Credit::burn_nft(RuntimeOrigin::signed(1), 1, 42),
Error::<Test>::MiningMachineClassCreditNoConfig
);
assert_noop!(
Credit::burn_nft(RuntimeOrigin::signed(1), 2, 42),
Error::<Test>::MiningMachineClassCreditNoConfig
);
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
3,
Privilege::CreditAdmin
));
assert_ok!(Credit::update_nft_class_credit(
RuntimeOrigin::signed(3),
0,
50
));
assert_eq!(crate::MiningMachineClassCredit::<Test>::get(0), 50);
assert_ok!(Credit::update_nft_class_credit(
RuntimeOrigin::signed(3),
1,
30
));
assert_eq!(crate::MiningMachineClassCredit::<Test>::get(1), 30);
let credit_data = CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 0,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 0,
};
// update_credit_data works
assert_ok!(Credit::add_or_update_credit_data(
RuntimeOrigin::root(),
1,
credit_data.clone()
));
assert_eq!(Credit::user_credit(&1).unwrap().credit, 100);
assert_ok!(Credit::burn_nft(RuntimeOrigin::signed(1), 0, 42));
assert_eq!(Credit::user_credit(&1).unwrap().credit, 150);
assert_noop!(
Credit::burn_nft(RuntimeOrigin::signed(1), 1, 42),
Error::<Test>::OutOfMaxBurnCreditPerAddress
);
assert_noop!(
Credit::burn_nft(RuntimeOrigin::signed(1), 2, 42),
Error::<Test>::MiningMachineClassCreditNoConfig
);
});
}
#[test]
fn unstaking_slash_credit() {
new_test_ext().execute_with(|| {
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
1,
Privilege::CreditAdmin
));
assert_ok!(Credit::set_user_staking_credit(
RuntimeOrigin::signed(1),
vec!((3, 50))
));
run_to_block(1);
let new_credit_data = CreditData {
campaign_id: 0,
credit: 100,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 1u32,
number_of_referees: 1,
current_credit_level: CreditLevel::One,
reward_eras: 270,
};
assert_ok!(Credit::add_or_update_credit_data(
RuntimeOrigin::root(),
3,
new_credit_data
));
assert_ok!(Credit::unstaking_slash_credit(RuntimeOrigin::signed(1), 3));
assert_eq!(Credit::get_credit_score(&3).unwrap(), 50);
assert_eq!(Credit::user_credit(&3).unwrap().campaign_id, 4);
assert_eq!(
<frame_system::Pallet<Test>>::events()
.pop()
.expect("should contains events")
.event,
crate::tests::RuntimeEvent::from(crate::Event::CreditUpdateSuccess(3, 50))
);
});
}
#[test]
fn new_campaign_usdt_reward() {
new_test_ext().execute_with(|| {
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
1,
Privilege::OracleWorker
));
assert_ok!(Credit::set_dpr_price(
RuntimeOrigin::signed(1),
25_000_000_000_000_000,
H160::zero()
));
run_to_block(1);
let credit_setting = CreditSetting {
campaign_id: 5,
credit_level: CreditLevel::One,
staking_balance: 3_000,
base_apy: Percent::from_percent(20),
bonus_apy: Percent::from_percent(0),
max_rank_with_bonus: 0u32,
tax_rate: Percent::from_percent(0),
max_referees_with_rewards: 0,
reward_per_referee: 0,
};
assert_ok!(Credit::update_credit_setting(
RawOrigin::Root.into(),
credit_setting.clone()
));
let credit_setting = CreditSetting {
campaign_id: 5,
credit_level: CreditLevel::Two,
staking_balance: 5_000,
base_apy: Percent::from_percent(30),
bonus_apy: Percent::from_percent(0),
max_rank_with_bonus: 0u32,
tax_rate: Percent::from_percent(0),
max_referees_with_rewards: 0,
reward_per_referee: 0,
};
assert_ok!(Credit::update_credit_setting(
RawOrigin::Root.into(),
credit_setting.clone()
));
Credit::set_staking_balance(
&1000,
75_000_000_000_000_000_000,
3_000_000_000_000_000_000_000,
);
let new_credit_data = CreditData {
campaign_id: 5,
credit: 102,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 0u32,
number_of_referees: 0,
current_credit_level: CreditLevel::One,
reward_eras: 270,
};
assert_ok!(Credit::add_or_update_credit_data(
RuntimeOrigin::root(),
1000,
new_credit_data
));
assert!(Credit::init_delegator_history(&1000, 1));
run_to_block(BLOCKS_PER_ERA * 2);
assert_eq!(Credit::get_reward(&1000, 1, 1).0, Some(1643835616438356164));
let new_credit_data = CreditData {
campaign_id: 5,
credit: 202,
initial_credit_level: CreditLevel::One,
rank_in_initial_credit_level: 0u32,
number_of_referees: 0,
current_credit_level: CreditLevel::Two,
reward_eras: 270,
};
assert_ok!(Credit::add_or_update_credit_data(
RuntimeOrigin::root(),
1000,
new_credit_data
));
// add 50 usdt
Credit::set_staking_balance(
&1000,
50_000_000_000_000_000_000,
2_000_000_000_000_000_000_000,
);
run_to_block(BLOCKS_PER_ERA * 3);
assert_eq!(Credit::get_reward(&1000, 2, 2).0, Some(4109589041095890410));
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
2,
Privilege::CreditAdmin
));
assert_ok!(Credit::unset_staking_balance(
RuntimeOrigin::signed(2),
1000
));
run_to_block(BLOCKS_PER_ERA * 4);
// Even not staking, user also get reward based on virtual staking balance 25 USDT,
assert_eq!(Credit::get_reward(&1000, 3, 3).0, Some(821917808219178082));
});
}
#[test]
fn set_dpr_price_test() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Balances::set_balance(RuntimeOrigin::root(), 2, 1_000, 0));
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
1,
Privilege::OracleWorker
));
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
2,
Privilege::OracleWorker
));
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
1,
Privilege::CreditAdmin
));
assert_ok!(Credit::set_dpr_price(
RuntimeOrigin::signed(1),
100,
H160::zero()
));
assert_ok!(Credit::set_price_diff_rate(
RuntimeOrigin::signed(1),
Percent::from_percent(10)
));
run_to_block(2);
assert_eq!(Credit::dpr_price(), Some(100));
assert_err!(
Credit::set_dpr_price(RuntimeOrigin::signed(1), 111, H160::zero()),
Error::<Test>::PriceDiffTooMuch
);
assert_ok!(Credit::set_dpr_price(
RuntimeOrigin::signed(1),
110,
H160::zero()
));
assert_ok!(Credit::set_dpr_price(
RuntimeOrigin::signed(2),
102,
H160::zero()
));
run_to_block(3);
assert_eq!(Credit::dpr_price(), Some(106));
});
}
#[test]
fn set_and_unset_maintain_device() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_err!(
Credit::set_maintain_device(RuntimeOrigin::signed(1), 2),
Error::<Test>::NotDeviceAdmin
);
run_to_block(2);
assert_ok!(UserPrivileges::set_user_privilege(
RuntimeOrigin::root(),
1,
Privilege::DeviceAdmin
));
assert_ok!(Credit::set_maintain_device(RuntimeOrigin::signed(1), 2));
assert_eq!(MaintainDevices::<Test>::get(), vec![2]);
});
}
|
#[doc = "Register `VERR` reader"]
pub type R = crate::R<VERR_SPEC>;
#[doc = "Field `MINREV` reader - Minor Revision"]
pub type MINREV_R = crate::FieldReader;
#[doc = "Field `MAJREV` reader - Major Revision"]
pub type MAJREV_R = crate::FieldReader;
impl R {
#[doc = "Bits 0:3 - Minor Revision"]
#[inline(always)]
pub fn minrev(&self) -> MINREV_R {
MINREV_R::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - Major Revision"]
#[inline(always)]
pub fn majrev(&self) -> MAJREV_R {
MAJREV_R::new(((self.bits >> 4) & 0x0f) as u8)
}
}
#[doc = "IPCC version register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`verr::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct VERR_SPEC;
impl crate::RegisterSpec for VERR_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`verr::R`](R) reader structure"]
impl crate::Readable for VERR_SPEC {}
#[doc = "`reset()` method sets VERR to value 0x10"]
impl crate::Resettable for VERR_SPEC {
const RESET_VALUE: Self::Ux = 0x10;
}
|
pub use self::artist_builder::*;
pub use self::code_builder::*;
pub use self::comp_builder::*;
pub use self::event_builder::*;
pub use self::fee_schedule_builder::*;
pub use self::hold_builder::*;
pub use self::order_builder::*;
pub use self::organization_builder::*;
pub use self::organization_invite_builder::*;
pub use self::payment_method_builder::*;
pub use self::region_builder::*;
pub use self::stage_builder::*;
pub use self::user_builder::*;
pub use self::venue_builder::*;
mod artist_builder;
mod code_builder;
mod comp_builder;
mod event_builder;
mod fee_schedule_builder;
mod hold_builder;
mod order_builder;
mod organization_builder;
mod organization_invite_builder;
mod payment_method_builder;
mod region_builder;
mod stage_builder;
mod user_builder;
mod venue_builder;
|
pub mod collectible;
pub mod dialog_box;
pub mod side_panel;
use self::{collectible::*, dialog_box::*, side_panel::*};
use crate::utils::rgba_to_raui_color;
use oxygengine::user_interface::raui::core::prelude::*;
use serde::{Deserialize, Serialize};
#[derive(PropsData, Debug, Default, Copy, Clone, Serialize, Deserialize)]
pub struct GuiProps {
pub steps: usize,
pub collected_stars: usize,
pub collected_shields: usize,
}
pub type GuiRemoteProps = DataBinding<GuiProps>;
fn use_gui(context: &mut WidgetContext) {
context.life_cycle.change(|context| {
for msg in context.messenger.messages {
if let Some(data) = msg.as_any().downcast_ref::<GuiRemoteProps>() {
drop(context.state.write_with(data.clone()));
}
}
});
}
#[pre_hooks(use_gui)]
pub fn gui(mut context: WidgetContext) -> WidgetNode {
let WidgetContext { key, state, .. } = context;
let gui_props = state
.read_cloned_or_default::<GuiRemoteProps>()
.read_cloned_or_default();
let steps_size_props = Props::new(ContentBoxItemLayout {
anchors: Rect {
left: 0.0,
right: 0.0,
top: 0.0,
bottom: 0.0,
},
align: Vec2 { x: 0.0, y: 0.0 },
offset: Vec2 { x: 0.0, y: 40.0 },
..Default::default()
})
.with(SizeBoxProps {
width: SizeBoxSizeValue::Exact(300.0),
..Default::default()
});
let steps_props = SidePanelProps {
label: "Steps".to_owned(),
label_height: 32.0,
side: Side::Left,
};
let steps_value_props = TextBoxProps {
text: gui_props.steps.to_string(),
height: TextBoxSizeValue::Exact(48.0),
horizontal_align: TextBoxHorizontalAlign::Right,
font: TextBoxFont {
name: "fonts/aquatico.json".to_owned(),
size: 48.0,
},
color: rgba_to_raui_color(0, 0, 0, 255),
..Default::default()
};
let collected_size_props = Props::new(ContentBoxItemLayout {
anchors: Rect {
left: 1.0,
right: 1.0,
top: 0.0,
bottom: 0.0,
},
align: Vec2 { x: 1.0, y: 0.0 },
offset: Vec2 { x: 0.0, y: 40.0 },
..Default::default()
})
.with(SizeBoxProps {
width: SizeBoxSizeValue::Exact(300.0),
..Default::default()
});
let collected_props = SidePanelProps {
label: "Collected".to_owned(),
label_height: 32.0,
side: Side::Right,
};
let dialog_size_props = Props::new(ContentBoxItemLayout {
anchors: Rect {
left: 0.0,
right: 1.0,
top: 1.0,
bottom: 1.0,
},
align: Vec2 { x: 0.0, y: 1.0 },
..Default::default()
})
.with(SizeBoxProps {
width: SizeBoxSizeValue::Fill,
height: SizeBoxSizeValue::Exact(180.0),
..Default::default()
});
widget! {
(#{key} content_box [
(#{"steps-size"} size_box: {steps_size_props} {
content = (#{"steps"} side_panel: {steps_props} {
content = (#{"value"} text_box: {steps_value_props})
})
})
(#{"collected-size"} size_box: {collected_size_props} {
content = (#{"collected"} side_panel: {collected_props} {
content = (#{"list"} vertical_box [
(#{"stars"} collectible: {CollectibleProps {
image: "images/item-star.svg".to_owned(),
value: gui_props.collected_stars,
}})
(#{"shields"} collectible: {CollectibleProps {
image: "images/item-shield.svg".to_owned(),
value: gui_props.collected_shields,
}})
])
})
})
(#{"dialog-size"} size_box: {dialog_size_props} {
content = (#{"dialog"} dialog_box: {DialogBoxProps {
name: Some("Narrator".to_owned()),
text: "Hello,\nWorld!".to_owned(),
}})
})
])
}
}
|
#[doc = "Register `PRAR_PRG` reader"]
pub type R = crate::R<PRAR_PRG_SPEC>;
#[doc = "Register `PRAR_PRG` writer"]
pub type W = crate::W<PRAR_PRG_SPEC>;
#[doc = "Field `PROT_AREA_START` reader - Bank 1 PCROP area start configuration bits"]
pub type PROT_AREA_START_R = crate::FieldReader<u16>;
#[doc = "Field `PROT_AREA_START` writer - Bank 1 PCROP area start configuration bits"]
pub type PROT_AREA_START_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 12, O, u16>;
#[doc = "Field `PROT_AREA_END` reader - Bank 1 PCROP area end configuration bits"]
pub type PROT_AREA_END_R = crate::FieldReader<u16>;
#[doc = "Field `PROT_AREA_END` writer - Bank 1 PCROP area end configuration bits"]
pub type PROT_AREA_END_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 12, O, u16>;
#[doc = "Field `DMEP` reader - Bank 1 PCROP protected erase enable option configuration bit"]
pub type DMEP_R = crate::BitReader;
#[doc = "Field `DMEP` writer - Bank 1 PCROP protected erase enable option configuration bit"]
pub type DMEP_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
impl R {
#[doc = "Bits 0:11 - Bank 1 PCROP area start configuration bits"]
#[inline(always)]
pub fn prot_area_start(&self) -> PROT_AREA_START_R {
PROT_AREA_START_R::new((self.bits & 0x0fff) as u16)
}
#[doc = "Bits 16:27 - Bank 1 PCROP area end configuration bits"]
#[inline(always)]
pub fn prot_area_end(&self) -> PROT_AREA_END_R {
PROT_AREA_END_R::new(((self.bits >> 16) & 0x0fff) as u16)
}
#[doc = "Bit 31 - Bank 1 PCROP protected erase enable option configuration bit"]
#[inline(always)]
pub fn dmep(&self) -> DMEP_R {
DMEP_R::new(((self.bits >> 31) & 1) != 0)
}
}
impl W {
#[doc = "Bits 0:11 - Bank 1 PCROP area start configuration bits"]
#[inline(always)]
#[must_use]
pub fn prot_area_start(&mut self) -> PROT_AREA_START_W<PRAR_PRG_SPEC, 0> {
PROT_AREA_START_W::new(self)
}
#[doc = "Bits 16:27 - Bank 1 PCROP area end configuration bits"]
#[inline(always)]
#[must_use]
pub fn prot_area_end(&mut self) -> PROT_AREA_END_W<PRAR_PRG_SPEC, 16> {
PROT_AREA_END_W::new(self)
}
#[doc = "Bit 31 - Bank 1 PCROP protected erase enable option configuration bit"]
#[inline(always)]
#[must_use]
pub fn dmep(&mut self) -> DMEP_W<PRAR_PRG_SPEC, 31> {
DMEP_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "FLASH protection address for bank 1\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`prar_prg::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`prar_prg::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct PRAR_PRG_SPEC;
impl crate::RegisterSpec for PRAR_PRG_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`prar_prg::R`](R) reader structure"]
impl crate::Readable for PRAR_PRG_SPEC {}
#[doc = "`write(|w| ..)` method takes [`prar_prg::W`](W) writer structure"]
impl crate::Writable for PRAR_PRG_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets PRAR_PRG to value 0"]
impl crate::Resettable for PRAR_PRG_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
use std::collections::BTreeMap;
use std::collections::btree_map;
use super::errors::*;
use super::models::*;
/// Adds the into_model() method for all types that supports ConvertToModel.
pub trait Merge {
/// Convert the current type to a model.
fn merge(&mut self, other: Self) -> Result<()>;
}
impl<T> Merge for Token<T>
where T: Merge
{
fn merge(&mut self, source: Token<T>) -> Result<()> {
self.inner.merge(source.inner)?;
Ok(())
}
}
impl Merge for SubType {
fn merge(&mut self, source: SubType) -> Result<()> {
self.fields.merge(source.fields)?;
self.codes.merge(source.codes)?;
self.names.extend(source.names);
Ok(())
}
}
impl Merge for InterfaceBody {
fn merge(&mut self, source: InterfaceBody) -> Result<()> {
self.fields.merge(source.fields)?;
self.codes.merge(source.codes)?;
self.sub_types.merge(source.sub_types)?;
Ok(())
}
}
impl Merge for TypeBody {
fn merge(&mut self, source: TypeBody) -> Result<()> {
self.fields.merge(source.fields)?;
self.codes.merge(source.codes)?;
Ok(())
}
}
impl Merge for TupleBody {
fn merge(&mut self, source: TupleBody) -> Result<()> {
self.fields.merge(source.fields)?;
self.codes.merge(source.codes)?;
Ok(())
}
}
impl Merge for EnumBody {
fn merge(&mut self, source: EnumBody) -> Result<()> {
self.codes.merge(source.codes)?;
Ok(())
}
}
impl Merge for Vec<Token<Code>> {
fn merge(&mut self, source: Vec<Token<Code>>) -> Result<()> {
self.extend(source);
Ok(())
}
}
impl Merge for Vec<Token<Field>> {
fn merge(&mut self, source: Vec<Token<Field>>) -> Result<()> {
for f in source {
if let Some(field) = self.iter().find(|e| e.name == f.name) {
return Err(Error::field_conflict(f.name.clone(), f.pos.clone(), field.pos.clone()));
}
self.push(f);
}
Ok(())
}
}
impl Merge for Token<Decl> {
fn merge(&mut self, source: Token<Decl>) -> Result<()> {
let dest_pos = self.pos.clone();
match self.inner {
Decl::Type(ref mut body) => {
if let Decl::Type(other) = source.inner {
return body.merge(other);
}
}
Decl::Enum(ref mut body) => {
if let Decl::Enum(other) = source.inner {
if let Some(value) = other.values.iter().next() {
return Err(Error::extend_enum("cannot extend enum with additional values"
.to_owned(),
value.pos.clone(),
dest_pos));
}
if let Some(field) = other.fields.iter().next() {
return Err(Error::extend_enum("cannot extend enum with additional fields"
.to_owned(),
field.pos.clone(),
dest_pos));
}
return body.merge(other);
}
}
Decl::Interface(ref mut body) => {
if let Decl::Interface(other) = source.inner {
return body.merge(other);
}
}
Decl::Tuple(ref mut body) => {
if let Decl::Tuple(other) = source.inner {
return body.merge(other);
}
}
}
return Err(Error::decl_merge(format!("cannot merge with {}", source.display()),
source.pos,
dest_pos));
}
}
impl<K, T> Merge for BTreeMap<K, T>
where T: Merge,
K: ::std::cmp::Ord
{
fn merge(&mut self, source: BTreeMap<K, T>) -> Result<()> {
for (key, value) in source {
match self.entry(key) {
btree_map::Entry::Vacant(entry) => {
entry.insert(value);
}
btree_map::Entry::Occupied(entry) => {
Merge::merge(entry.into_mut(), value)?;
}
}
}
Ok(())
}
}
|
use crate::ast;
use crate::{Parse, ParseError, ParseErrorKind, Parser, Peek, Resolve, Spanned, Storage, ToTokens};
use runestick::Source;
use std::borrow::Cow;
/// A label, like `'foo`
#[derive(Debug, Clone, Copy, ToTokens, Spanned)]
pub struct Label {
/// The token of the label.
pub token: ast::Token,
/// The kind of the label.
#[rune(skip)]
pub kind: ast::StringSource,
}
impl Parse for Label {
fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError> {
let token = parser.token_next()?;
match token.kind {
ast::Kind::Label(kind) => Ok(Self { token, kind }),
_ => Err(ParseError::new(
token,
ParseErrorKind::TokenMismatch {
expected: ast::Kind::Label(ast::StringSource::Text),
actual: token.kind,
},
)),
}
}
}
impl Peek for Label {
fn peek(p1: Option<ast::Token>, _: Option<ast::Token>) -> bool {
match p1 {
Some(p1) => matches!(p1.kind, ast::Kind::Label(..)),
_ => false,
}
}
}
impl<'a> Resolve<'a> for Label {
type Output = Cow<'a, str>;
fn resolve(&self, storage: &Storage, source: &'a Source) -> Result<Cow<'a, str>, ParseError> {
let span = self.token.span();
match self.kind {
ast::StringSource::Text => {
let span = self.token.span();
let ident = source
.source(span.trim_start(1))
.ok_or_else(|| ParseError::new(span, ParseErrorKind::BadSlice))?;
Ok(Cow::Borrowed(ident))
}
ast::StringSource::Synthetic(id) => {
let ident = storage.get_string(id).ok_or_else(|| {
ParseError::new(span, ParseErrorKind::BadSyntheticId { kind: "ident", id })
})?;
Ok(Cow::Owned(ident))
}
}
}
}
|
pub struct Publisher {
connected: bool,
}
|
use crate::eval::{Expr, ExprSource};
use crate::value::NixValue;
use gc::{Finalize, Gc, GcCell, Trace};
use std::{collections::HashMap, path::PathBuf};
/// A parent Expr's scope is used to provide tooling for its child Exprs.
/// This enum would provide four scope types:
/// - None: Used for calculated literals. For example, for the string
/// interpolation `"prefix${suffix}"`, the literal `prefix` by itself
/// cannot be referenced anywhere except at its definition, so we don't
/// need context-aware tooling for it. For `${suffix}`, however, we would
/// inherit the parent's scope.
/// - Root: Provided for each file. Used for providing global variables
/// and tracking the `import` dependency tree. Also used for detecting
/// which file an expression is defined in.
/// - Let: Created by `let in` and `rec { }`. All the variable names
/// can be derived using static analysis with rnix-parser; we don't need
/// to evaluate anything to detect if a variable name is in this scope
/// - With: Created by `with $VAR` expressions. We need to evaluate $VAR
/// to determine whether a variable name is in scope.
#[derive(Trace, Finalize)]
pub enum Scope {
Root(PathBuf),
Let {
parent: Gc<Scope>,
contents: GcCell<HashMap<String, Gc<Expr>>>,
},
None,
}
impl Scope {
/// Finds the Expr of an identifier in the scope.
///
/// This would do two passes up the tree:
/// 1. Check Scope::Normal and Scope::Root
/// 2. Check Scope::With, which requires evaluation
///
/// See https://github.com/NixOS/nix/issues/490 for an explanation
/// of why Nix works this way.
///
/// Examples:
/// ```plain
/// nix-repl> let import = 1; in import
/// 1 # found in Scope::Normal, which we reach before Scope::Root
/// nix-repl> import
/// «primop» # found in Scope::Root
/// nix-repl> with { import = 1; }; import
/// «primop» # found in Scope::Root, which we reach before Scope::With
/// ```
pub fn get(&self, name: &str) -> Option<Gc<Expr>> {
self.get_let(name) // we haven't yet implemented fallback to a future get_with method
}
pub fn get_let(&self, name: &str) -> Option<Gc<Expr>> {
match self {
Scope::None | Scope::Root(_) => Some(Gc::new(Expr {
range: None,
value: GcCell::new(None),
source: ExprSource::Literal {
// TODO: add more keys here, such as `builtins`
value: match name {
"true" => NixValue::Bool(true),
"false" => NixValue::Bool(false),
"null" => NixValue::Null,
_ => return None,
},
},
scope: Gc::new(Scope::None),
})),
Scope::Let { parent, contents } => match contents.borrow().get(name) {
Some(x) => Some(x.clone()),
None => parent.get_let(name),
},
}
}
pub fn root_path(&self) -> Option<PathBuf> {
match &self {
Scope::None => None,
Scope::Root(path) => Some(path.clone()),
Scope::Let { parent, .. } => parent.root_path(),
}
}
}
|
use std::io::{self, *};
fn main() {
let mut rd = io::BufReader::new(io::stdin());
let mut n: usize;
let mut s = String::new();
rd.read_line(&mut s).unwrap();
n = s.trim().parse::<usize>().unwrap();
let rst = [0, 1, 0, 0, 2, 10, 4, 40, 92, 352, 724, 2680, 14200, 73712, 365596]
print!("{}", rst[n])
}
|
use crate::parser::Error;
use crate::schedule_at;
use crate::time_domain::RuleKind::*;
#[test]
fn exact_date() -> Result<(), Error> {
assert_eq!(
schedule_at!(r#"2020Jun01 open"#, "2020-05-31"),
schedule! {}
);
assert_eq!(
schedule_at!(r#"2020Jun01:10:00-12:10"#, "2020-06-01"),
schedule! { 10,00 => Open => 12,10 }
);
assert_eq!(
schedule_at!(r#"2020Jun01 open"#, "2020-06-02"),
schedule! {}
);
Ok(())
}
#[test]
fn range() -> Result<(), Error> {
assert_eq!(
schedule_at!(r#"Jan-Jun:11:58-11:59"#, "2020-06-01"),
schedule! { 11,58 => Open => 11,59 }
);
assert_eq!(
schedule_at!(r#"May15-01:10:00-12:00"#, "2020-06-01"),
schedule! { 10,00 => Open => 12,00 }
);
assert_eq!(
schedule_at!(r#"May15-01:10:00-12:00"#, "2020-06-02"),
schedule! {}
);
assert_eq!(
schedule_at!(r#"2019Sep01-2020Jul31:10:00-12:00"#, "2020-06-01"),
schedule! { 10,00 => Open => 12,00 }
);
assert_eq!(
schedule_at!(r#"2019Sep01+:10:00-12:00"#, "2020-06-01"),
schedule! { 10,00 => Open => 12,00 }
);
assert_eq!(
schedule_at!(r#"2019Sep01-Jul01:10:00-12:00"#, "2020-06-01"),
schedule! { 10,00 => Open => 12,00 }
);
assert_eq!(
schedule_at!(r#"Sep01-Jul01:10:00-12:00"#, "2020-06-01"),
schedule! { 10,00 => Open => 12,00 }
);
Ok(())
}
|
// ClientMode
#![forbid(unsafe_code)]
#![deny(missing_docs)]
use anyhow::Result;
use std::str::FromStr;
/// Valid modes that `s3du` can operate in.
#[derive(Debug, Eq, PartialEq)]
pub enum ClientMode {
/// CloudWatch mode is available when compiled with the `cloudwatch`
/// feature.
#[cfg(feature = "cloudwatch")]
CloudWatch,
/// S3 mode is available when compiled with the `s3` feature.
#[cfg(feature = "s3")]
S3,
}
/// This is used to work out which mode we're in after parsing the CLI.
/// We shouldn't ever hit the error condition here.
impl FromStr for ClientMode {
type Err = &'static str;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
#[cfg(feature = "cloudwatch")]
"cloudwatch" => Ok(Self::CloudWatch),
#[cfg(feature = "s3")]
"s3" => Ok(Self::S3),
_ => Err("no match"),
}
}
}
|
// io is a stl that can be used to handle user inputs
// Rust automatically imports several packages by default which is called prelude, this helps in
// keeping the code less verbose https://doc.rust-lang.org/std/prelude/index.html
use std::io;
use rand::Rng;
use std::cmp::Ordering;
fn main() {
println!("Guessing game");
println!("Enter the number");
// let is used to crate a variable let foo = bar
// The rand::thread_rng function will give us the particular random number generator that we’re
// going to use: one that is local to the current thread of execution and seeded by the operating system.
// gen_range takes 2 ints and returns a number between them, in this case 1, 100
let secret_number = rand::thread_rng().gen_range(1, 101);
loop {
// variables by default are immutable in rust, to make them mutable, we need to add mut
// String is a type provided by stl that is growable and is utf-8 encoded
// ::new line indicates that new is an associated function of the String type.
// An associated function is implemented on a type, in this case String, rather than on a
// particular instance of a String. Some languages call this a static method. The new() method
// creates a new empty string without allocating memory
let mut guess = String::new();
// If we hadn't put the use std::io line at the beginning of the program, we could have written
// this function call as std::io::stdin.
// References are immutable by default, to make them mutable we need to add &mut
// read_line puts what the user types into the string we’re passing it, but it also returns a
// value—in this case, an io::Result.
//
//For Result, the variants are Ok or Err.
// The Ok variant indicates the operation was successful, and inside Ok is the successfully generated value.
// The Err variant means the operation failed, and Err contains information about how or why the
// operation failed.
// Result has an expect() method which takes in a string.
// On error that method get triggered by a program crash with the message inside it
// But on Ok, expect() will take the value in Ok and will return it
// If we do not use expect the program will compile but will throw warning during `cargo build`
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed {}", guess);
let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("You guessed: {}", guess);
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
|
use crate::cartridge::Mirror;
impl super::Ppu {
pub fn read(&mut self, address: usize) -> u8 {
match address {
0x0000..=0x1FFF => self.mapper.borrow().read(address),
0x2000..=0x3EFF => self.read_nametable(address),
0x3F00..=0x3FFF => {
let a = address % 0x0020;
let value = self.palette_ram[a];
value
},
_ => 0,
}
}
pub fn write(&mut self, address: usize, value: u8) {
// let address = addr % 0x4000;
match address {
0x0000..=0x1FFF => self.mapper.borrow_mut().write(address, value),
0x2000..=0x3EFF => self.write_nametable(address, value),
0x3F00..=0x3FFF => {
// I did not read this closely enough for a long time.
// Addresses $3F10/$3F14/$3F18/$3F1C are mirrors of $3F00/$3F04/$3F08/$3F0C.
// Note that this goes for writing as well as reading.
// A symptom of not having implemented this correctly in an emulator is the sky being black in Super Mario Bros.,
// which writes the backdrop color through $3F10.
match address % 0x10 {
0x00 => {
self.palette_ram[0] = value;
self.palette_ram[0x10] = value;
},
0x04 => {
self.palette_ram[0x04] = value;
self.palette_ram[0x14] = value;
},
0x08 => {
self.palette_ram[0x08] = value;
self.palette_ram[0x18] = value;
},
0x0C => {
self.palette_ram[0x0C] = value;
self.palette_ram[0x1C] = value;
},
_ => self.palette_ram[address % 0x0020] = value,
}
},
_ => (),
}
}
fn read_nametable(&mut self, address: usize) -> u8 {
let base = address % 0x1000;
let offset = base % 0x0400;
match self.mapper.borrow().get_mirroring() {
Mirror::LowBank => self.nametable_a[offset],
Mirror::HighBank => self.nametable_b[offset],
Mirror::Horizontal => {
match base {
0x0000..=0x07FF => self.nametable_a[offset],
0x0800..=0x0FFF => self.nametable_b[offset],
_ => panic!("panicked reading nametable base: {}", base),
}
},
Mirror::Vertical => {
match base {
0x0000..=0x03FF | 0x0800..=0x0BFF => self.nametable_a[offset],
0x0400..=0x07FF | 0x0C00..=0x0FFF => self.nametable_b[offset],
_ => panic!("panicked reading nametable base: {}", base),
}
},
Mirror::FourScreen => {
match base {
0x0000..=0x03FF => self.nametable_a[offset],
0x0400..=0x07FF => self.nametable_b[offset],
0x0800..=0x0BFF => self.nametable_c[offset],
0x0C00..=0x0FFF => self.nametable_d[offset],
_ => panic!("panicked reading nametable base: {}", base),
}
},
}
}
fn write_nametable(&mut self, address: usize, value: u8) {
let base = address % 0x1000;
let offset = base % 0x0400;
match self.mapper.borrow().get_mirroring() {
Mirror::LowBank => self.nametable_a[offset] = value,
Mirror::HighBank => self.nametable_b[offset] = value,
Mirror::Horizontal => {
match base {
0x0000..=0x07FF => self.nametable_a[offset] = value,
0x0800..=0x0FFF => self.nametable_b[offset] = value,
_ => panic!("panicked writing nametable base: {}", base),
}
},
Mirror::Vertical => {
match base {
0x0000..=0x03FF | 0x0800..=0x0BFF => self.nametable_a[offset] = value,
0x0400..=0x07FF | 0x0C00..=0x0FFF => self.nametable_b[offset] = value,
_ => panic!("panicked writing nametable base: {}", base),
}
},
Mirror::FourScreen => {
match base {
0x0000..=0x03FF => self.nametable_a[offset] = value,
0x0400..=0x07FF => self.nametable_b[offset] = value,
0x0800..=0x0BFF => self.nametable_c[offset] = value,
0x0C00..=0x0FFF => self.nametable_d[offset] = value,
_ => panic!("panicked writing nametable base: {}", base),
}
},
}
}
}
|
use crossbeam_channel::RecvTimeoutError::*;
use serde::{Deserialize, Serialize};
use std::thread;
use std::time::{Duration, Instant};
mod system;
use system::Lighting;
mod environment;
use environment::Environment;
mod state;
use state::RoomState;
mod commands;
use commands::handle_cmd;
use crate::errors::Error;
use crate::input::jobs::WakeUp;
use crate::input::mpd_status::MpdStatus;
pub use commands::Command;
use sensor_value::{Button, Press, SensorValue};
pub use state::{State, WakeUpStateError};
#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
pub enum Event {
Update,
WakeUp,
Test,
Command(Command),
Sensor(SensorValue),
}
pub struct Modifications {
//change name to: alteration, deviation, overrides or something else?
lighting: bool,
mpd: bool,
//Desk,
//Alarm,
}
impl Modifications {
fn reset(&mut self) {
self.lighting = false;
self.mpd = false;
}
}
impl Default for Modifications {
fn default() -> Self {
Modifications {
lighting: false,
mpd: false,
}
}
}
pub struct System {
update_period: Duration,
next_update: Instant,
lights: Lighting,
mpd: MpdStatus,
wakeup: WakeUp,
}
fn saturating_duration_till(target: std::time::Instant) -> std::time::Duration {
let now = Instant::now();
if now < target {
target - now
} else {
Duration::from_secs(0)
}
}
pub fn start(
rx: crossbeam_channel::Receiver<Event>,
mpd_status: MpdStatus,
wakeup: WakeUp,
) -> Result<thread::JoinHandle<()>, Error> {
let mut system = System {
update_period: Duration::from_secs(5),
next_update: Instant::now() + Duration::from_secs(5),
lights: Lighting::init()?,
mpd: mpd_status,
wakeup,
};
let handle = thread::spawn(move || {
let mut mods = Modifications::default();
let mut env = Environment::default();
// TODO guess best init state from statefile or lamps+mpd+time
let mut state: Box<dyn RoomState> = state::Normal::setup(&mut mods, &mut system).unwrap(); //initial state
let mut current_state = State::Normal;
loop {
//wait for next update or an incoming event
let time_till_update = saturating_duration_till(system.next_update);
let event = match rx.recv_timeout(time_till_update) {
Ok(event) => event,
Err(Timeout) => {
system.next_update = Instant::now() + system.update_period;
Event::Update
}
Err(Disconnected) => return,
};
let res = handle_event(
event,
current_state,
&mut mods,
&mut system,
&mut env,
&mut state,
);
match res {
Err(e) => error!("Ran into an error handling an event: {:?}", e),
Ok(Some(target_state)) => {
//should switch to another state
if let Ok(new_state) = change_state(target_state, &mut mods, &mut system) {
state = new_state;
current_state = target_state;
} //if state setup ran into an error we do not switch state
}
_ => (),
}
if let Event::Sensor(s) = event {
env.update(s);
}
}
});
Ok(handle)
}
fn handle_event(
event: Event,
current_state: State,
mods: &mut Modifications,
system: &mut System,
env: &mut Environment,
state: &mut Box<dyn RoomState>,
) -> Result<Option<State>, Error> {
//state changes may not return errors
let next_state = match (event, current_state) {
//specific test code for normal state
(Event::Test, State::Normal) => {
dbg!("a test happend while in normal state");
None
}
//general code that is the same for all functions, unless specific handlers exist above
(Event::Command(cmd), _) => handle_cmd(cmd, mods, system),
(Event::Update, _) => state.update(mods, system, env)?,
(Event::WakeUp, _) => {
system.wakeup.reset()?;
Some(State::WakeUp)
}
(Event::Test, _) => {
dbg!("a test happend");
None
}
(Event::Sensor(s), _) => handle_sensor(s, mods, system),
};
Ok(next_state)
}
fn handle_sensor(
value: SensorValue,
mods: &mut Modifications,
system: &mut System,
) -> Option<State> {
match value {
SensorValue::ButtonPress(press) => handle_buttonpress(press, mods, system),
// SensorValue::BathroomHum(b) => {dbg!(b); None}
// SensorValue::BathroomTemp(t) => {dbg!(t); None}
// SensorValue::MovementShower => {dbg!(b); None}
// SensorValue::MovementToilet => {dbg!(b); None}
_ => None, // for now we ignore the other sensor data
}
}
fn handle_buttonpress(
press: Press,
mods: &mut Modifications,
system: &mut System,
) -> Option<State> {
const LONG_PRESS: u16 = 500; //ms
if press.duration < LONG_PRESS {
// millisec
match press.button {
Button::LampLeft => Some(State::Quiet),
Button::LampMid => Some(State::Silent),
Button::LampRight => Some(State::Off),
Button::DeskLeftMost => Some(State::Sleep),
Button::DeskLeft => Some(State::Normal),
Button::DeskRight => Some(State::Quiet),
Button::DeskRightMost => Some(State::Off),
Button::DeskTop => handle_cmd(Command::MpdIncreaseVolume, mods, system),
Button::DeskMid => handle_cmd(Command::MpdPause, mods, system),
Button::DeskBottom => handle_cmd(Command::MpdDecreaseVolume, mods, system),
}
} else {
let cmd = match press.button {
Button::LampLeft => Command::LampsDim,
Button::LampMid => Command::LampsDimmest,
Button::LampRight => Command::LampsToggle,
Button::DeskLeftMost => Command::LampsNight,
Button::DeskLeft => Command::LampsEvening,
Button::DeskRight => Command::LampsDay,
Button::DeskRightMost => Command::LampsToggle,
Button::DeskTop => Command::MpdIncreaseVolume,
Button::DeskMid => Command::MpdPause,
Button::DeskBottom => Command::MpdDecreaseVolume,
};
handle_cmd(cmd, mods, system)
}
}
fn change_state(
next_state: State,
mods: &mut Modifications,
system: &mut System,
) -> Result<Box<dyn RoomState>, Error> {
let res = match &next_state {
State::Normal => state::Normal::setup(mods, system),
State::LightLoop => state::LightLoop::setup(mods, system),
State::WakeUp => state::WakeUp::setup(mods, system),
State::Sleep => state::Sleep::setup(mods, system),
State::Silent => state::Silent::setup(mods, system),
State::Quiet => state::Quiet::setup(mods, system),
State::Off => state::Off::setup(mods, system),
};
if let Err(ref e) = &res {
error!(
"ran into error trying to switch to state: {:?}, error: {:?}",
next_state, e
);
}
res
}
|
use std::convert::TryInto;
use std::future::Future;
use hyper::upgrade::OnUpgrade;
use sha1::{Digest, Sha1};
use crate::{
Body, Error, FromRequest, HeaderName, HeaderValue, IntoResponse, Method, Request, Response,
ResponseBuilder, Result, StatusCode,
};
use tokio_tungstenite::tungstenite::protocol::Role;
pub struct WebSocket {
key: HeaderValue,
on_upgrade: OnUpgrade,
}
#[async_trait::async_trait]
impl FromRequest for WebSocket {
async fn from_request(req: &mut Request) -> Result<Self> {
if req.method() != Method::Get
|| req.headers().get(HeaderName::CONNECTION)
== Some(HeaderValue::from_static("upgrade"))
|| req.headers().get(HeaderName::UPGRADE) == Some(HeaderValue::from_static("websocket"))
|| req.headers().get(HeaderName::SEC_WEBSOCKET_VERSION)
== Some(HeaderValue::from_static("13"))
{
return Err(Error::bad_request(anyhow::anyhow!("bad request")));
}
let key = req
.headers()
.get(HeaderName::SEC_WEBSOCKET_KEY)
.ok_or_else(|| Error::bad_request(anyhow::anyhow!("bad request")))?;
let req = req.take_http_request();
let upgraded = hyper::upgrade::on(req);
Ok(Self { key, upgraded })
}
}
impl WebSocket {
pub fn on_upgrade<F, Fut>(self, callback: F) -> impl IntoResponse
where
F: FnOnce(WebSocket) -> Fut + Send + 'static,
Fut: Future + Send + 'static,
{
WebSocketUpgraded {
websocket: self,
callback,
}
}
}
struct WebSocketUpgraded<F> {
websocket: WebSocket,
callback: F,
}
impl<F, Fut> IntoResponse for WebSocketUpgraded<F>
where
F: FnOnce(WebSocket) -> Fut + Send + 'static,
Fut: Future + Send + 'static,
{
fn into_response(self) -> Result<Response> {
let resp = Response::builder()
.status(StatusCode::SWITCHING_PROTOCOLS)
.header(HeaderName::CONNECTION, "upgrade")
.header(HeaderName::UPGRADE, "websocket")
.header(
HeaderName::SEC_WEBSOCKET_ACCEPT,
sign(self.websocket.key.as_bytes()),
)
.body(Body::empty())?;
tokio::spawn(async move {
let upgraded = match self.websocket.on_upgrade.await {
Ok(upgraded) => upgraded,
Err(err) => return,
};
let stream =
tokio_tungstenite::WebSocketStream::from_raw_socket(upgraded, Role::Server, None);
WebSocketStream { stream };
});
Ok(resp)
}
}
pin_project_lite::pin_project! {
pub struct WebSocketStream {
inner: tokio_tungstenite::WebSocketStream,
}
}
fn sign(key: &[u8]) -> HeaderValue {
let mut sha1 = Sha1::default();
sha1.update(key);
sha1.update(&b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"[..]);
base64::encode(sha1.digest().bytes()).try_into().unwrap()
}
|
use crate::errors::Errcode;
use std::os::unix::io::RawFd;
use nix::sys::socket::{socketpair, AddressFamily, SockType, SockFlag, send, MsgFlags, recv};
pub fn generate_socketpair() -> Result<(RawFd, RawFd), Errcode> {
match socketpair(
AddressFamily::Unix,
SockType::SeqPacket,
None,
SockFlag::SOCK_CLOEXEC) {
Ok(res) => Ok(res),
Err(_) => Err(Errcode::SocketError(0))
}
}
pub fn send_boolean(fd: RawFd, boolean: bool) -> Result<(), Errcode> {
let data: [u8;1] = [boolean.into()];
if let Err(e) = send(fd, &data, MsgFlags::empty()) {
log::error!("Cannot send boolean through socket: {:?}", e);
return Err(Errcode::SocketError(1));
};
Ok(())
}
pub fn receive_boolean(fd: RawFd) -> Result<bool, Errcode> {
let mut data: [u8;1] = [0];
if let Err(e) = recv(fd, &mut data, MsgFlags::empty()) {
log::error!("Cannot receiv boolean through socket: {:?}", e);
return Err(Errcode::SocketError(2));
};
Ok(data[0] == 1)
} |
#[cfg(feature = "extern")]
pub mod ex;
#[cfg(feature = "python")]
pub mod py;
mod test;
/// The freely-jointed chain (FJC) model thermodynamics in the isometric ensemble approximated using a Legendre transformation.
pub mod legendre;
use super::
{
treloar_sums,
treloar_sum_0_with_prefactor
};
use std::f64::consts::PI;
use crate::physics::
{
PLANCK_CONSTANT,
BOLTZMANN_CONSTANT
};
use crate::physics::single_chain::ZERO;
/// The structure of the thermodynamics of the FJC model in the isometric ensemble.
pub struct FJC
{
/// The mass of each hinge in the chain in units of kg/mol.
pub hinge_mass: f64,
/// The length of each link in the chain in units of nm.
pub link_length: f64,
/// The number of links in the chain.
pub number_of_links: u8,
/// The thermodynamic functions of the model in the isometric ensemble approximated using a Legendre transformation.
pub legendre: legendre::FJC
}
/// The expected force as a function of the applied end-to-end length and temperature, parameterized by the number of links and link length.
pub fn force(number_of_links: &u8, link_length: &f64, end_to_end_length: &f64, temperature: &f64) -> f64
{
nondimensional_force(number_of_links, &(end_to_end_length/((*number_of_links as f64)*link_length)))*BOLTZMANN_CONSTANT*temperature/link_length
}
/// The expected nondimensional force as a function of the applied nondimensional end-to-end length per link, parameterized by the number of links.
pub fn nondimensional_force(number_of_links: &u8, nondimensional_end_to_end_length_per_link: &f64) -> f64
{
let sums = treloar_sums(number_of_links, nondimensional_end_to_end_length_per_link, &[0, 1]);
let number_of_links_f64 = *number_of_links as f64;
(1.0/nondimensional_end_to_end_length_per_link + (0.5*number_of_links_f64 - 1.0)*sums[1]/sums[0])/number_of_links_f64
}
/// The Helmholtz free energy as a function of the applied end-to-end length and temperature, parameterized by the number of links, link length, and hinge mass.
pub fn helmholtz_free_energy(number_of_links: &u8, link_length: &f64, hinge_mass: &f64, end_to_end_length: &f64, temperature: &f64) -> f64
{
nondimensional_helmholtz_free_energy(number_of_links, link_length, hinge_mass, &(end_to_end_length/((*number_of_links as f64)*link_length)), temperature)*BOLTZMANN_CONSTANT*temperature
}
/// The Helmholtz free energy per link as a function of the applied end-to-end length and temperature, parameterized by the number of links, link length, and hinge mass.
pub fn helmholtz_free_energy_per_link(number_of_links: &u8, link_length: &f64, hinge_mass: &f64, end_to_end_length: &f64, temperature: &f64) -> f64
{
nondimensional_helmholtz_free_energy_per_link(number_of_links, link_length, hinge_mass, &(end_to_end_length/((*number_of_links as f64)*link_length)), temperature)*BOLTZMANN_CONSTANT*temperature
}
/// The relative Helmholtz free energy as a function of the applied end-to-end length and temperature, parameterized by the number of links and link length.
pub fn relative_helmholtz_free_energy(number_of_links: &u8, link_length: &f64, end_to_end_length: &f64, temperature: &f64) -> f64
{
nondimensional_relative_helmholtz_free_energy(number_of_links, &(end_to_end_length/((*number_of_links as f64)*link_length)))*BOLTZMANN_CONSTANT*temperature
}
/// The relative Helmholtz free energy per link as a function of the applied end-to-end length and temperature, parameterized by the number of links and link length.
pub fn relative_helmholtz_free_energy_per_link(number_of_links: &u8, link_length: &f64, end_to_end_length: &f64, temperature: &f64) -> f64
{
nondimensional_relative_helmholtz_free_energy_per_link(number_of_links, &(end_to_end_length/((*number_of_links as f64)*link_length)))*BOLTZMANN_CONSTANT*temperature
}
/// The nondimensional Helmholtz free energy as a function of the nondimensional end-to-end length per link and temperature, parameterized by the number of links, link length, and hinge mass.
pub fn nondimensional_helmholtz_free_energy(number_of_links: &u8, link_length: &f64, hinge_mass: &f64, nondimensional_end_to_end_length_per_link: &f64, temperature: &f64) -> f64
{
-(equilibrium_distribution(number_of_links, link_length, &(nondimensional_end_to_end_length_per_link*(*number_of_links as f64)*link_length))).ln() - ((*number_of_links as f64) - 1.0)*(8.0*PI.powi(2)*hinge_mass*link_length.powi(2)*BOLTZMANN_CONSTANT*temperature/PLANCK_CONSTANT.powi(2)).ln()
}
/// The nondimensional Helmholtz free energy per link as a function of the nondimensional end-to-end length per link and temperature, parameterized by the number of links, link length, and hinge mass.
pub fn nondimensional_helmholtz_free_energy_per_link(number_of_links: &u8, link_length: &f64, hinge_mass: &f64, nondimensional_end_to_end_length_per_link: &f64, temperature: &f64) -> f64
{
nondimensional_helmholtz_free_energy(number_of_links, link_length, hinge_mass, nondimensional_end_to_end_length_per_link, temperature)/(*number_of_links as f64)
}
/// The nondimensional relative Helmholtz free energy as a function of the nondimensional end-to-end length per link, parameterized by the number of links.
pub fn nondimensional_relative_helmholtz_free_energy(number_of_links: &u8, nondimensional_end_to_end_length_per_link: &f64) -> f64
{
(nondimensional_equilibrium_distribution(number_of_links, &ZERO)/nondimensional_equilibrium_distribution(number_of_links, nondimensional_end_to_end_length_per_link)).ln()
}
/// The nondimensional relative Helmholtz free energy per link as a function of the nondimensional end-to-end length per link, parameterized by the number of links.
pub fn nondimensional_relative_helmholtz_free_energy_per_link(number_of_links: &u8, nondimensional_end_to_end_length_per_link: &f64) -> f64
{
nondimensional_relative_helmholtz_free_energy(number_of_links, nondimensional_end_to_end_length_per_link)/(*number_of_links as f64)
}
/// The equilibrium probability density of end-to-end vectors as a function of the end-to-end length, parameterized by the number of links and link length.
pub fn equilibrium_distribution(number_of_links: &u8, link_length: &f64, end_to_end_length: &f64) -> f64
{
let contour_length = (*number_of_links as f64)*link_length;
nondimensional_equilibrium_distribution(number_of_links, &(end_to_end_length/contour_length))/contour_length.powi(3)
}
/// The nondimensional equilibrium probability density of nondimensional end-to-end vectors per link as a function of the nondimensional end-to-end length per link, parameterized by the number of links.
pub fn nondimensional_equilibrium_distribution(number_of_links: &u8, nondimensional_end_to_end_length_per_link: &f64) -> f64
{
treloar_sum_0_with_prefactor(number_of_links, nondimensional_end_to_end_length_per_link)
}
/// The equilibrium probability density of end-to-end lengths as a function of the end-to-end length, parameterized by the number of links and link length.
pub fn equilibrium_radial_distribution(number_of_links: &u8, link_length: &f64, end_to_end_length: &f64) -> f64
{
let contour_length = (*number_of_links as f64)*link_length;
nondimensional_equilibrium_radial_distribution(number_of_links, &(end_to_end_length/contour_length))/contour_length
}
/// The nondimensional equilibrium probability density of nondimensional end-to-end lengths per link as a function of the nondimensional end-to-end length per link, parameterized by the number of links.
pub fn nondimensional_equilibrium_radial_distribution(number_of_links: &u8, nondimensional_end_to_end_length_per_link: &f64) -> f64
{
4.0*PI*nondimensional_end_to_end_length_per_link.powi(2)*nondimensional_equilibrium_distribution(number_of_links, nondimensional_end_to_end_length_per_link)
}
/// The implemented functionality of the thermodynamics of the FJC model in the isometric ensemble.
impl FJC
{
/// Initializes and returns an instance of the thermodynamics of the FJC model in the isometric ensemble.
pub fn init(number_of_links: u8, link_length: f64, hinge_mass: f64) -> Self
{
FJC
{
hinge_mass,
link_length,
number_of_links,
legendre: legendre::FJC::init(number_of_links, link_length, hinge_mass)
}
}
/// The expected force as a function of the applied end-to-end length and temperature.
pub fn force(&self, end_to_end_length: &f64, temperature: &f64) -> f64
{
force(&self.number_of_links, &self.link_length, end_to_end_length, temperature)
}
/// The expected nondimensional force as a function of the applied nondimensional end-to-end length per link.
pub fn nondimensional_force(&self, nondimensional_end_to_end_length_per_link: &f64) -> f64
{
nondimensional_force(&self.number_of_links, nondimensional_end_to_end_length_per_link)
}
/// The Helmholtz free energy as a function of the applied end-to-end length and temperature.
pub fn helmholtz_free_energy(&self, end_to_end_length: &f64, temperature: &f64) -> f64
{
helmholtz_free_energy(&self.number_of_links, &self.link_length, &self.hinge_mass, end_to_end_length, temperature)
}
/// The Helmholtz free energy per link as a function of the applied end-to-end length and temperature.
pub fn helmholtz_free_energy_per_link(&self, end_to_end_length: &f64, temperature: &f64) -> f64
{
helmholtz_free_energy_per_link(&self.number_of_links, &self.link_length, &self.hinge_mass, end_to_end_length, temperature)
}
/// The relative Helmholtz free energy as a function of the applied end-to-end length and temperature.
pub fn relative_helmholtz_free_energy(&self, end_to_end_length: &f64, temperature: &f64) -> f64
{
relative_helmholtz_free_energy(&self.number_of_links, &self.link_length, end_to_end_length, temperature)
}
/// The relative Helmholtz free energy per link as a function of the applied end-to-end length and temperature.
pub fn relative_helmholtz_free_energy_per_link(&self, end_to_end_length: &f64, temperature: &f64) -> f64
{
relative_helmholtz_free_energy_per_link(&self.number_of_links, &self.link_length, end_to_end_length, temperature)
}
/// The nondimensional Helmholtz free energy as a function of the applied nondimensional end-to-end length per link and temperature.
pub fn nondimensional_helmholtz_free_energy(&self, nondimensional_end_to_end_length_per_link: &f64, temperature: &f64) -> f64
{
nondimensional_helmholtz_free_energy(&self.number_of_links, &self.link_length, &self.hinge_mass, nondimensional_end_to_end_length_per_link, temperature)
}
/// The nondimensional Helmholtz free energy per link as a function of the applied nondimensional end-to-end length per link and temperature.
pub fn nondimensional_helmholtz_free_energy_per_link(&self, nondimensional_end_to_end_length_per_link: &f64, temperature: &f64) -> f64
{
nondimensional_helmholtz_free_energy_per_link(&self.number_of_links, &self.link_length, &self.hinge_mass, nondimensional_end_to_end_length_per_link, temperature)
}
/// The nondimensional relative Helmholtz free energy as a function of the applied nondimensional end-to-end length per link.
pub fn nondimensional_relative_helmholtz_free_energy(&self, nondimensional_end_to_end_length_per_link: &f64) -> f64
{
nondimensional_relative_helmholtz_free_energy(&self.number_of_links, nondimensional_end_to_end_length_per_link)
}
/// The nondimensional relative Helmholtz free energy per link as a function of the applied nondimensional end-to-end length per link.
pub fn nondimensional_relative_helmholtz_free_energy_per_link(&self, nondimensional_end_to_end_length_per_link: &f64) -> f64
{
nondimensional_relative_helmholtz_free_energy_per_link(&self.number_of_links, nondimensional_end_to_end_length_per_link)
}
/// The equilibrium probability density of end-to-end vectors as a function of the end-to-end length.
pub fn equilibrium_distribution(&self, end_to_end_length: &f64) -> f64
{
equilibrium_distribution(&self.number_of_links, &self.link_length, end_to_end_length)
}
/// The nondimensional equilibrium probability density of nondimensional end-to-end vectors per link as a function of the nondimensional end-to-end length per link.
pub fn nondimensional_equilibrium_distribution(&self, nondimensional_end_to_end_length_per_link: &f64) -> f64
{
nondimensional_equilibrium_distribution(&self.number_of_links, nondimensional_end_to_end_length_per_link)
}
/// The equilibrium probability density of end-to-end lengths as a function of the end-to-end length.
pub fn equilibrium_radial_distribution(&self, end_to_end_length: &f64) -> f64
{
equilibrium_radial_distribution(&self.number_of_links, &self.link_length, end_to_end_length)
}
/// The nondimensional equilibrium probability density of nondimensional end-to-end lengths per link as a function of the nondimensional end-to-end length per link.
pub fn nondimensional_equilibrium_radial_distribution(&self, nondimensional_end_to_end_length_per_link: &f64) -> f64
{
nondimensional_equilibrium_radial_distribution(&self.number_of_links, nondimensional_end_to_end_length_per_link)
}
}
|
#![allow(non_snake_case)]
#[allow(unused_imports)]
use std::io::{self, Write};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
macro_rules! input {
(source = $s:expr, $($r:tt)*) => {
let mut iter = $s.split_whitespace();
let mut next = || { iter.next().unwrap() };
input_inner!{next, $($r)*}
};
($($r:tt)*) => {
let stdin = std::io::stdin();
let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
let mut next = move || -> String{
bytes
.by_ref()
.map(|r|r.unwrap() as char)
.skip_while(|c|c.is_whitespace())
.take_while(|c|!c.is_whitespace())
.collect()
};
input_inner!{next, $($r)*}
};
}
macro_rules! input_inner {
($next:expr) => {};
($next:expr, ) => {};
($next:expr, $var:ident : $t:tt $($r:tt)*) => {
let $var = read_value!($next, $t);
input_inner!{$next $($r)*}
};
}
macro_rules! read_value {
($next:expr, ( $($t:tt),* )) => {
( $(read_value!($next, $t)),* )
};
($next:expr, [ $t:tt ; $len:expr ]) => {
(0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
};
($next:expr, chars) => {
read_value!($next, String).chars().collect::<Vec<char>>()
};
($next:expr, char) => {
read_value!($next, String).chars().collect::<Vec<char>>()[0]
};
($next:expr, usize1) => {
read_value!($next, usize) - 1
};
($next:expr, isize1) => {
read_value!($next, isize) - 1
};
($next:expr, $t:ty) => {
$next().parse::<$t>().expect("Parse error")
};
}
macro_rules! debug {
($($a:expr),*) => {
println!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
}
}
#[allow(dead_code)]
const MOD: usize = 998244353;
#[allow(dead_code)]
fn to_num(c: char) -> i64 {
c as i64 - 48
}
#[derive(Debug)]
struct FactInv {
fact: Vec<u64>,
inv: Vec<u64>,
factinv: Vec<u64>,
m: u64,
}
#[allow(dead_code)]
impl FactInv {
fn new(n: u64, m: u64) -> Self {
let mut fact = vec![0; n as usize + 1];
fact[0] = 1;
for i in 1..n+1 {
fact[i as usize] = i * &fact[i as usize - 1] % m;
}
let mut inv = vec![0; n as usize + 1];
inv[0] = 0;
inv[1] = 1;
for i in 2..n+1 {
inv[i as usize] = inv[(m % i) as usize] * (m - m / i) % m;
}
let mut factinv = vec![0; n as usize + 1];
factinv[0] = 1;
for i in 1..n+1 {
factinv[i as usize] = factinv[i as usize - 1] * inv[i as usize] % m;
}
FactInv {
fact: fact,
inv: inv,
factinv: factinv,
m: m,
}
}
fn comb(&self, n: u64, r: u64) -> u64 {
if n < r {
0
} else {
(self.fact[n as usize] * self.factinv[r as usize] % self.m) * self.factinv[(n-r) as usize] % self.m
}
}
}
fn main() {
input!{
N: usize,
S: chars,
}
let fi = FactInv::new(N as u64, MOD as u64);
let mut red = vec![];
let mut green = vec![];
let mut blue = vec![];
for j in 0..3*N {
if S[j] == 'R' {
red.push(j);
} else if S[j] == 'G' {
green.push(j);
} else {
blue.push(j);
}
}
let mut ans = fi.fact[N];
let mut i = 0;
let mut j = 1;
while j < N {
if red[j] < green[i] && green[j] < blue[i] {
} else {
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = j;
}
j += 1;
}
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = 0;
j = 1;
while j < N {
if red[j] < blue[i] && blue[j] < green[i] {
} else {
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = j;
}
j += 1;
}
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = 0;
j = 1;
while j < N {
if blue[j] < red[i] && red[j] < green[i] {
} else {
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = j;
}
j += 1;
}
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = 0;
j = 1;
while j < N {
if blue[j] < green[i] && green[j] < red[i] {
} else {
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = j;
}
j += 1;
}
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = 0;
j = 1;
while j < N {
if green[j] < red[i] && red[j] < blue[i] {
} else {
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = j;
}
j += 1;
}
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = 0;
j = 1;
while j < N {
if green[j] < blue[i] && blue[j] < red[i] {
} else {
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
i = j;
}
j += 1;
}
ans = ans * (fi.fact[j - i].pow(2)) % MOD as u64;
println!("{}", ans);
} |
fn try_parse(s: String) -> i32 {
unimplemented!();
}
fn main() {
let input = include_str!("../../input");
let sum: i32 = input.lines().map(|x| x.parse::<i32>().unwrap()).sum();
println!("{}", sum);
}
|
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_end_to_end_length(number_of_links: u8, link_length: f64, link_stiffness: f64, force: f64, temperature: f64) -> f64
{
super::end_to_end_length(&number_of_links, &link_length, &link_stiffness, &force, &temperature)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_end_to_end_length_per_link(link_length: f64, link_stiffness: f64, force: f64, temperature: f64) -> f64
{
super::end_to_end_length_per_link(&link_length, &link_stiffness, &force, &temperature)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_end_to_end_length(number_of_links: u8, nondimensional_link_stiffness: f64, nondimensional_force: f64) -> f64
{
super::nondimensional_end_to_end_length(&number_of_links, &nondimensional_link_stiffness, &nondimensional_force)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_end_to_end_length_per_link(nondimensional_link_stiffness: f64, nondimensional_force: f64) -> f64
{
super::nondimensional_end_to_end_length_per_link(&nondimensional_link_stiffness, &nondimensional_force)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_gibbs_free_energy(number_of_links: u8, link_length: f64, hinge_mass: f64, link_stiffness: f64, force: f64, temperature: f64) -> f64
{
super::gibbs_free_energy(&number_of_links, &link_length, &hinge_mass, &link_stiffness, &force, &temperature)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_gibbs_free_energy_per_link(link_length: f64, hinge_mass: f64, link_stiffness: f64, force: f64, temperature: f64) -> f64
{
super::gibbs_free_energy_per_link(&link_length, &hinge_mass, &link_stiffness, &force, &temperature)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_relative_gibbs_free_energy(number_of_links: u8, link_length: f64, link_stiffness: f64, force: f64, temperature: f64) -> f64
{
super::relative_gibbs_free_energy(&number_of_links, &link_length, &link_stiffness, &force, &temperature)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_relative_gibbs_free_energy_per_link(link_length: f64, link_stiffness: f64, force: f64, temperature: f64) -> f64
{
super::relative_gibbs_free_energy_per_link(&link_length, &link_stiffness, &force, &temperature)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_gibbs_free_energy(number_of_links: u8, link_length: f64, hinge_mass: f64, nondimensional_link_stiffness: f64, nondimensional_force: f64, temperature: f64) -> f64
{
super::nondimensional_gibbs_free_energy(&number_of_links, &link_length, &hinge_mass, &nondimensional_link_stiffness, &nondimensional_force, &temperature)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_gibbs_free_energy_per_link(link_length: f64, hinge_mass: f64, nondimensional_link_stiffness: f64, nondimensional_force: f64, temperature: f64) -> f64
{
super::nondimensional_gibbs_free_energy_per_link(&link_length, &hinge_mass, &nondimensional_link_stiffness, &nondimensional_force, &temperature)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_relative_gibbs_free_energy(number_of_links: u8, nondimensional_link_stiffness: f64, nondimensional_force: f64) -> f64
{
super::nondimensional_relative_gibbs_free_energy(&number_of_links, &nondimensional_link_stiffness, &nondimensional_force)
}
#[no_mangle]
pub extern fn physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_relative_gibbs_free_energy_per_link(nondimensional_link_stiffness: f64, nondimensional_force: f64) -> f64
{
super::nondimensional_relative_gibbs_free_energy_per_link(&nondimensional_link_stiffness, &nondimensional_force)
}
|
use std::collections::HashMap;
use std::error::Error;
use std::path::Path;
use log::debug;
use uuid::Uuid;
use crate::csv::inference::ColumnInference;
use crate::db::utils::to_table_parameters;
use crate::db::{Db, Header, Rows};
use crate::parser::collector::Collector;
use crate::parser::rewriter::Rewriter;
use crate::parser::Parser;
use crate::qsv::util::{remove_extension, sanitize};
use crate::qsv::{csv_data_from_mime_type, Options};
///Executes a query, possibly returning Rows
pub fn execute_query(query: &str, options: &Options) -> Result<(Header, Rows), Box<dyn Error>> {
let mut collector = Collector::new();
let ast = Parser::parse_sql(query)?;
let mut db = Db::open_in_memory()?;
if ast.len() != 1 {
return Err("Expected exactly one SQL statement in query input".into());
}
let statement = &ast[0];
collector.collect(statement); //TODO: should we handle multiple SQL statements later?
let mut files_to_tables = HashMap::new();
for filename in collector.table_identifiers.iter() {
let maybe_load = maybe_load_file(&mut files_to_tables, filename, &mut db, options);
match maybe_load {
Ok(Some(())) => {
debug!(
"Potential filename from SQL was able to be loaded: {}",
filename
);
}
Ok(None) => {
debug!(
"Identifier in SQL could not be loaded as file, as it didn't exist: {}",
filename
);
}
Err(e) => return Err(e),
}
}
let rewritten = Rewriter::new(files_to_tables);
let mut to_rewrite = statement.clone();
rewritten.rewrite(&mut to_rewrite);
debug!("Rewritten query: {}", to_rewrite.to_string());
db.select_statement(to_rewrite.to_string().as_str())
}
fn maybe_load_file(
files_to_tables: &mut HashMap<String, String>,
filename: &str,
db: &mut Db,
options: &Options,
) -> Result<Option<()>, Box<dyn Error>> {
let path = Path::new(filename);
if !path.exists() {
return Ok(None);
}
let mime_type = tree_magic::from_filepath(path);
debug!("File '{}' has MIME type: '{}'", filename, mime_type);
let csv = csv_data_from_mime_type(filename, mime_type.as_str(), options)?;
let path = Path::new(filename);
debug!(
"Attempting to load identifier from SQL as file: {}",
filename
);
let without_extension = remove_extension(path);
let table_name = sanitize(without_extension)
.unwrap_or_else(|| String::from("t") + &Uuid::new_v4().as_u128().to_string());
let inference = if options.textonly {
ColumnInference::default_inference(&csv.headers)
} else {
ColumnInference::from_csv(&csv)
};
let table_parameters = to_table_parameters(&csv, &inference);
let table_parameters: Vec<&str> = table_parameters.iter().map(|s| s.as_str()).collect();
let table_name = table_name.as_str();
if !files_to_tables.values().any(|s| s == table_name) {
debug!(
"Attempting to create table {} for filename {}",
table_name, filename
);
db.create_table(table_name, &table_parameters)?;
let headers: Vec<&str> = csv.headers.iter().collect();
let records: Vec<Vec<&str>> = csv.records.iter().map(|r| r.iter().collect()).collect();
debug!("Inserting {} rows into {}", records.len(), table_name);
db.insert(table_name, &headers, records);
files_to_tables.insert(filename.to_string(), String::from(table_name));
} else {
debug!(
"Table already exists {} for filename {}, not creating it or inserting records",
table_name, filename
);
}
Ok(Some(()))
}
|
use std::fs;
use serde_json::json;
use websrv::{WebSrv, StatusCode, Method, Route, Request};
static ROUTES: &'static [Route] = &[
Route {path: "/hello", method: Method::GET, func: hello_world},
Route {path: "/hello_rust", method: Method::GET, func: hello_rust},
Route {path: "/forbidden", method: Method::GET, func: forbidden},
];
fn main() {
env_logger::init();
let websrv = WebSrv::new("127.0.0.1:7878", 4);
websrv.run(ROUTES);
}
fn hello_world(_: &Request) -> (StatusCode, String) {
let response = fs::read_to_string("templates/hello.html").unwrap();
(StatusCode::Ok, response)
}
fn hello_rust(request: &Request) -> (StatusCode, String) {
(StatusCode::Created, json!({
"message": "Hello from rust!",
"method": request.method,
"uri": request.uri,
"http_ver": request.http_ver
}).to_string())
}
fn forbidden(_: &Request) -> (StatusCode, String) {
let response = fs::read_to_string("templates/403.html").unwrap();
(StatusCode::Forbidden, response)
} |
use std::vec::Vec;
pub struct SHA3 {
input_bytes: Vec<u8>,
current_state: [[u64; 5]; 5],
block_size: u64,
digest_size: u64,
n_r: u64,
c: u64
}
impl SHA3 {
const OFFSET: [[u8; 5]; 5] = [
[0, 36, 3, 41, 18],
[1, 44, 10, 45, 2],
[62, 6, 43, 15, 61],
[28, 55, 25, 21, 56],
[27, 20, 39, 8, 14]
];
const ROUND_CONSTANTS: [u64; 24] = [
0x0000000000000001,
0x0000000000008082,
0x800000000000808A,
0x8000000080008000,
0x000000000000808B,
0x0000000080000001,
0x8000000080008081,
0x8000000000008009,
0x000000000000008A,
0x0000000000000088,
0x0000000080008009,
0x000000008000000A,
0x000000008000808B,
0x800000000000008B,
0x8000000000008089,
0x8000000000008003,
0x8000000000008002,
0x8000000000000080,
0x000000000000800A,
0x800000008000000A,
0x8000000080008081,
0x8000000000008080,
0x0000000080000001,
0x8000000080008008
];
fn keccak_round(a: [[u64; 5]; 5], round_constant: u64) -> [[u64; 5]; 5] {
let mut state: [[u64; 5]; 5] = a;
let mut b: [[u64; 5]; 5] = [[0; 5]; 5];
let mut c: [u64; 5] = [0; 5];
let mut d: [u64; 5] = [0; 5];
for i in 0..5 {
c[i] = state[i].iter().fold(0, |acc, x| acc ^ x);
}
for i in 0..5 {
d[i] = c[((i as i32) - 1).rem_euclid(5) as usize] ^ c[(i + 1) % 5].rotate_left(1);
}
for i in 0..5 {
for n in 0..5 {
state[i][n] ^= d[i];
}
}
for i in 0..5 {
for n in 0..5 {
b[n][(2 * i + 3 * n) % 5] = state[i][n].rotate_left(SHA3::OFFSET[i][n] as u32);
}
}
for i in 0..5 {
for n in 0..5 {
state[i][n] = b[i][n] ^ ((!b[(i + 1) % 5][n]) & b[(i + 2) % 5][n]);
}
}
state[0][0] ^= round_constant;
return state;
}
fn keccak_function(&mut self) {
for i in 0..self.n_r {
let index = i as usize;
self.current_state = Self::keccak_round(self.current_state, Self::ROUND_CONSTANTS[index]);
}
}
fn pad_vector(&mut self) {
let b = self.block_size + self.c;
let padding_bytes_required = ((self.input_bytes.len() as i64) * -1).rem_euclid((b / 8) as i64);
if padding_bytes_required > 1 {
self.input_bytes.push(0x80);
while (((self.input_bytes.len() as i64) * -1).rem_euclid((b / 8) as i64)) > 1 {
self.input_bytes.push(0x00);
}
self.input_bytes.push(0x01);
} else if padding_bytes_required == 1 {
self.input_bytes.push(0x81);
}
}
fn absorb_vector(&mut self) -> [[u64; 5]; 5] {
let mut absorbed_state: [[u64; 5]; 5] = [[0; 5]; 5];
for i in 0..5 {
for n in 0..5 {
let state_value = self.input_bytes.drain(0..8).fold(0, |acc, x| (acc << 8) | (x as u64));
absorbed_state[i][n] = state_value;
}
}
self.input_bytes.shrink_to_fit();
return absorbed_state;
}
fn update_state(&mut self) {
let b = (self.block_size + self.c) / 8;
while self.input_bytes.len() as u64 >= b {
let absorbed_state = self.absorb_vector();
for i in 0..5 {
for n in 0..5 {
self.current_state[i][n] ^= absorbed_state[i][n];
}
}
}
}
pub fn update_with_bytes(&mut self, input_bytes: &[u8]) {
self.input_bytes.append(&mut input_bytes.to_vec());
self.update_state();
}
pub fn update(&mut self, input_str: &str) {
self.update_with_bytes(input_str.as_bytes());
}
pub fn digest(&mut self) -> Vec<u8> {
self.pad_vector();
self.update_state();
let mut digest_output: Vec<u8> = Vec::new();
let digest_byte_size = (self.digest_size / 8) as usize;
while digest_output.len() < digest_byte_size {
self.keccak_function();
for i in 0..5 {
for n in 0..5 {
let state_value = self.current_state[i][n];
for x in (0..4).rev() {
digest_output.push(((state_value >> (x * 8)) & 255) as u8);
}
}
}
}
digest_output.truncate(digest_byte_size);
return digest_output;
}
pub fn hex_digest(&mut self) -> String {
return self.digest().iter().map(|b| format!("{:02x}", b)).collect();
}
pub fn sha_256(input_str: &str) -> SHA3 {
SHA3::new(
input_str,
1088,
512,
256
)
}
pub fn sha_512(input_str: &str) -> SHA3 {
SHA3::new(
input_str,
576,
1024,
512
)
}
fn new(input_str: &str, r: u64, c: u64, n: u64) -> SHA3 {
let n_r = 12 + 2 * (((r as f64 + c as f64) / 25.0).log2().floor() as u64);
SHA3 {
input_bytes: input_str.as_bytes().to_vec(),
current_state: [[0; 5]; 5],
block_size: r,
digest_size: n,
n_r: n_r,
c: c
}
}
} |
/// The writer is responsible for turning structures into bytes in a file.
use std::{
io::{self, SeekFrom},
marker::PhantomData,
};
use bitwriter::BitWriter;
use crate::{
frame::Frame,
headers::{MetadataBlock, MetadataBlockStreamInfo},
};
pub struct HeaderWriter<W, S> {
w: W,
stream_info: MetadataBlockStreamInfo,
md5: md5::Md5,
_s: PhantomData<S>,
}
impl<W: std::io::Write, S> HeaderWriter<W, S> {
pub fn new(w: W, stream_info: MetadataBlockStreamInfo) -> HeaderWriter<W, S> {
HeaderWriter {
w,
stream_info,
md5: md5::Md5::default(),
_s: PhantomData,
}
}
pub fn write_headers(
mut self,
headers: impl IntoIterator<Item = MetadataBlock>,
) -> io::Result<FrameWriter<W, S>> {
let mut writer = BitWriter::with_capacity(4096);
writer.put(32, u32::from_be_bytes(*b"fLaC"));
let mut headers = headers.into_iter().peekable();
let is_last_header = headers.peek().is_none();
self.stream_info.put_into(is_last_header, &mut writer);
while let Some(header) = headers.next() {
let is_last_header = headers.peek().is_none();
header.put_into(is_last_header, &mut writer);
}
let bytes = writer.finish();
self.w.write_all(&bytes)?;
Ok(FrameWriter {
w: self.w,
md5: self.md5,
_s: self._s,
})
}
}
pub struct FrameWriter<W, S> {
w: W,
md5: md5::Md5,
_s: PhantomData<S>,
}
// TODO: Make generic over <W, S: Sample>
impl<W: io::Write> FrameWriter<W, i16> {
pub fn write_frame(&mut self, frame: Frame<i16>) -> io::Result<()> {
let mut writer = BitWriter::with_capacity(5000);
frame.put_into(&mut writer);
let bytes = writer.finish();
self.w.write_all(&bytes)?;
Ok(())
}
}
impl<W: io::Write + io::Seek, S> FrameWriter<W, S> {
/// Call at the very end to fill in metadata about information learned by encoding the file
/// This includes the MD5 sum, seek table, etc.
pub fn finish(&mut self) -> io::Result<()> {
self.w.seek(SeekFrom::Start(26))?; // Location of MD5 hash
//let md5 = std::mem::take(&mut self.md5);
//self.w.write_all(&md5.finalize()[..])?;
Ok(())
}
}
|
// don't allow orphan method
fn main() {
// Add code here
} |
use yew::prelude::*;
use yew_router::prelude::*;
use crate::route::MyRoute;
pub struct Header {
// props: Props,
_link: ComponentLink<Self>,
}
impl Component for Header {
type Message = ();
type Properties = ();
fn create(_props: Self::Properties, _link: ComponentLink<Self>) -> Self {
Self { _link }
}
fn update(&mut self, _msg: Self::Message) -> ShouldRender {
false
}
fn change(&mut self, _props: Self::Properties) -> ShouldRender {
// Should only return "true" if new properties are different to
// previously received properties.
// This component has no properties so we will always return "false".
false
}
fn view(&self) -> Html {
html! {
<header>
<Link<MyRoute> classes=classes!("navbar-item") route=MyRoute::Home>
{ "Home" }
</Link<MyRoute>>
<Link<MyRoute> classes=classes!("navbar-item") route=MyRoute::Todo>
{ "Todo" }
</Link<MyRoute>>
<Link<MyRoute> classes=classes!("navbar-item") route=MyRoute::WebGpu>
{ "WebGPU?" }
</Link<MyRoute>>
</header>
}
}
}
|
use azuki_tac::InstId;
pub enum Value {
Int(i64),
StackPointer {
frame: u32,
value: InstId,
offset: u32,
},
HeapPointer {},
}
|
use std::any::Any;
use std::cell::RefCell;
use euclid::{Point2D, Size2D, Transform2D, Vector2D};
use glium::glutin::event::{ElementState, Event, MouseButton, MouseScrollDelta, WindowEvent};
use glium::{Display, DrawError, Frame};
use log::debug;
use crate::event_handling::{EventHandler, FnEventHandler};
use crate::geometry::{CanvasSpace, ModelSpace, PixelSpace, ScreenSpace};
use crate::graphics::programs::Programs;
// use crate::state::{CommandRequest, State};
#[derive(Debug, Clone)]
pub enum CanvasError {
DrawError(DrawError),
InvalidGenericType,
}
impl From<DrawError> for CanvasError {
fn from(err: DrawError) -> Self {
CanvasError::DrawError(err)
}
}
pub trait CanvasObject: Any + CanvasObjectExt {
fn draw<'a>(&self, ctx: &mut DrawingContext<'a>) -> Result<(), CanvasError>;
}
pub trait CanvasObjectExt: Any {
// requires same traits as Foo
fn as_any(&self) -> &dyn Any;
fn as_any_mut(&mut self) -> &mut dyn Any;
}
impl<T> CanvasObjectExt for T
where
T: CanvasObject + Sized,
{
// but it's only implemented if also Sized
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
pub struct InputState {
mouse_pos: Point2D<f32, PixelSpace>,
left_pressed_start: Option<Point2D<f32, PixelSpace>>,
right_pressed_start: Option<Point2D<f32, PixelSpace>>,
}
pub struct Canvas {
input: InputState,
zoom: f32,
translation: Vector2D<f32, CanvasSpace>,
preview_translation: Option<Vector2D<f32, CanvasSpace>>,
dimensions: Size2D<u32, PixelSpace>,
programs: Programs,
click_handler: Box<dyn FnMut(Point2D<f32, CanvasSpace>, MouseButton)>,
}
impl Canvas {
pub fn new(display: &Display) -> Canvas {
let programs = Programs::new(display).unwrap();
Canvas {
input: InputState {
mouse_pos: Point2D::new(0., 0.),
left_pressed_start: None,
right_pressed_start: None,
},
zoom: 1.0,
translation: Vector2D::new(0., 0.),
preview_translation: None,
dimensions: display.get_framebuffer_dimensions().into(),
programs,
click_handler: Box::new(|_, _| ()),
}
}
pub fn pixel_transform(&self) -> Transform2D<f32, PixelSpace, ScreenSpace> {
let w = self.dimensions.width as f32 / 2.;
let h = self.dimensions.height as f32 / 2.;
Transform2D::translation(-w, -h).then_scale(1. / w, -1. / h)
}
pub fn view_transform(&self) -> Transform2D<f32, CanvasSpace, ScreenSpace> {
let tx = self.preview_translation.unwrap_or(self.translation);
let zm = self.zoom;
Transform2D::translation(tx.x, tx.y).then_scale(
zm / self.dimensions.width as f32,
zm / self.dimensions.height as f32,
)
}
pub fn draw<T: Any + 'static>(
&self,
target: &mut Frame,
obj: &dyn CanvasObject,
generic: &T,
) -> Result<(), CanvasError> {
let view_transform = self.view_transform();
let mut ctx = DrawingContext {
generic,
programs: &self.programs,
target,
view_transform,
model_transform: Transform2D::identity(),
dimensions: self.dimensions.into(),
};
obj.draw(&mut ctx)
}
pub fn input(&mut self) -> CanvasInput<'_> {
CanvasInput(RefCell::new(self))
}
pub fn set_click_handler(&mut self, handler: Box<dyn FnMut(Point2D<f32, CanvasSpace>, MouseButton)>) {
self.click_handler = handler;
}
}
/// RefCell wrapper of canvas. This is necessary because we need to have mutable
/// access to canvas while analyzing the input from two functions. Once for
/// captured input and once for usual input.
pub struct CanvasInput<'a>(RefCell<&'a mut Canvas>);
impl<'a> CanvasInput<'a> {
pub fn capture(&'a self) -> impl EventHandler + 'a {
FnEventHandler(move |event| {
let event = if let Event::WindowEvent { event, .. } = event {
event
} else {
return false;
};
let mut canvas = self.0.borrow_mut();
if canvas.input.left_pressed_start.is_none() {
return false;
}
match event {
WindowEvent::MouseInput {
button: MouseButton::Left,
state: ElementState::Released,
..
} => {
if let Some(start) = canvas.input.left_pressed_start {
let delta = canvas.input.mouse_pos - start;
if delta.length() < 3. {
let screen = canvas.pixel_transform().transform_point(start);
let click_pos = canvas
.view_transform()
.inverse()
.unwrap()
.transform_point(screen);
debug!("Clicked at: {:?}", click_pos);
(canvas.click_handler)(click_pos, MouseButton::Left);
} else {
let screen = canvas.pixel_transform().transform_vector(delta);
let model = canvas
.view_transform()
.inverse()
.unwrap()
.transform_vector(screen);
canvas.translation += model;
}
}
canvas.input.left_pressed_start = None;
canvas.preview_translation = None;
// Don't capture this event so Imgui knows the LMB is released.
false
}
WindowEvent::CursorMoved { position, .. } => {
let position = Point2D::new(position.x as f32, position.y as f32);
canvas.input.mouse_pos = position;
if let Some(start) = canvas.input.left_pressed_start {
let delta = position - start;
canvas.preview_translation = if delta.length() < 3. {
None
} else {
let screen = canvas.pixel_transform().transform_vector(delta);
let model = canvas
.view_transform()
.inverse()
.unwrap()
.transform_vector(screen);
Some(canvas.translation + model)
};
}
true
}
_ => false,
}
})
}
pub fn usual(&'a self) -> impl EventHandler + 'a {
FnEventHandler(move |event| {
let event = if let Event::WindowEvent { event, .. } = event {
event
} else {
return false;
};
let mut canvas = self.0.borrow_mut();
match event {
WindowEvent::MouseWheel {
delta: MouseScrollDelta::LineDelta(_x, y),
..
} => {
canvas.zoom *= 1. + (y / 10.);
true
}
WindowEvent::MouseInput {
button: MouseButton::Left,
state: ElementState::Pressed,
..
} => {
canvas.input.left_pressed_start = Some(canvas.input.mouse_pos);
true
}
WindowEvent::MouseInput {
button: MouseButton::Right,
state: ElementState::Pressed,
..
} => {
canvas.input.right_pressed_start = Some(canvas.input.mouse_pos);
true
}
WindowEvent::MouseInput {
button: MouseButton::Right,
state: ElementState::Released,
..
} => {
if let Some(rps) = canvas.input.right_pressed_start.take() {
if rps.distance_to(canvas.input.mouse_pos) < 3. {
let screen = canvas.pixel_transform().transform_point(rps);
let click_pos = canvas
.view_transform()
.inverse()
.unwrap()
.transform_point(screen);
(canvas.click_handler)(click_pos, MouseButton::Right);
}
}
true
}
WindowEvent::CursorMoved { position, .. } => {
let position = Point2D::new(position.x as f32, position.y as f32);
canvas.input.mouse_pos = position;
true
}
WindowEvent::Resized(size) => {
canvas.dimensions = Size2D::new(size.width, size.height);
false
}
_ => false,
}
})
}
}
pub struct DrawingContext<'a> {
pub programs: &'a Programs,
pub target: &'a mut Frame,
pub generic: &'a (dyn Any + 'static),
pub model_transform: Transform2D<f32, ModelSpace, CanvasSpace>,
pub view_transform: Transform2D<f32, CanvasSpace, ScreenSpace>,
pub dimensions: (u32, u32),
}
impl<'a> DrawingContext<'a> {
pub fn with_model_transform<T>(
&mut self,
transform: Transform2D<f32, ModelSpace, CanvasSpace>,
f: impl FnOnce(DrawingContext) -> T,
) -> T {
let new = DrawingContext {
generic: self.generic,
model_transform: transform,
view_transform: self.view_transform,
programs: self.programs,
target: self.target,
dimensions: self.dimensions,
};
f(new)
}
pub fn with_generic<T>(&mut self, generic: &dyn Any, f: impl FnOnce(DrawingContext) -> T) -> T {
let new = DrawingContext {
generic,
model_transform: self.model_transform,
view_transform: self.view_transform,
programs: self.programs,
target: self.target,
dimensions: self.dimensions,
};
f(new)
}
pub fn get_generic<T: 'static>(&self) -> Result<&'a T, CanvasError> {
self.generic
.downcast_ref()
.ok_or(CanvasError::InvalidGenericType)
}
}
|
use super::free_variables::find_free_variables;
use crate::{ir::*, types::Type};
use std::collections::HashMap;
pub fn infer_environment(module: &Module) -> Module {
Module::new(
module.type_definitions().to_vec(),
module.foreign_declarations().to_vec(),
module.foreign_definitions().to_vec(),
module.declarations().to_vec(),
module
.definitions()
.iter()
.map(|definition| infer_in_definition(definition, &Default::default()))
.collect(),
)
}
fn infer_in_definition(definition: &Definition, variables: &HashMap<String, Type>) -> Definition {
Definition::with_options(
definition.name(),
find_free_variables(definition.body())
.iter()
.filter_map(|name| {
variables
.get(name)
.map(|type_| Argument::new(name, type_.clone()))
})
.collect(),
definition.arguments().to_vec(),
// Do not include this function itself in variables as it can be global.
infer_in_expression(
definition.body(),
&variables
.clone()
.drain()
.chain(
definition
.arguments()
.iter()
.map(|argument| (argument.name().into(), argument.type_().clone())),
)
.collect(),
),
definition.result_type().clone(),
definition.is_thunk(),
)
}
fn infer_in_expression(expression: &Expression, variables: &HashMap<String, Type>) -> Expression {
match expression {
Expression::ArithmeticOperation(operation) => {
infer_in_arithmetic_operation(operation, variables).into()
}
Expression::Case(case) => infer_in_case(case, variables).into(),
Expression::ComparisonOperation(operation) => {
infer_in_comparison_operation(operation, variables).into()
}
Expression::FunctionApplication(application) => {
infer_in_function_application(application, variables).into()
}
Expression::If(if_) => infer_in_if(if_, variables).into(),
Expression::Let(let_) => infer_in_let(let_, variables).into(),
Expression::LetRecursive(let_) => infer_in_let_recursive(let_, variables).into(),
Expression::Record(record) => infer_in_record(record, variables).into(),
Expression::RecordElement(element) => infer_in_record_element(element, variables).into(),
Expression::Variant(variant) => infer_in_variant(variant, variables).into(),
Expression::Primitive(_) | Expression::ByteString(_) | Expression::Variable(_) => {
expression.clone()
}
}
}
fn infer_in_arithmetic_operation(
operation: &ArithmeticOperation,
variables: &HashMap<String, Type>,
) -> ArithmeticOperation {
ArithmeticOperation::new(
operation.operator(),
infer_in_expression(operation.lhs(), variables),
infer_in_expression(operation.rhs(), variables),
)
}
fn infer_in_if(if_: &If, variables: &HashMap<String, Type>) -> If {
If::new(
infer_in_expression(if_.condition(), variables),
infer_in_expression(if_.then(), variables),
infer_in_expression(if_.else_(), variables),
)
}
fn infer_in_case(case: &Case, variables: &HashMap<String, Type>) -> Case {
Case::new(
infer_in_expression(case.argument(), variables),
case.alternatives()
.iter()
.map(|alternative| infer_in_alternative(alternative, variables))
.collect(),
case.default_alternative()
.map(|expression| infer_in_expression(expression, variables)),
)
}
fn infer_in_alternative(
alternative: &Alternative,
variables: &HashMap<String, Type>,
) -> Alternative {
let mut variables = variables.clone();
variables.insert(alternative.name().into(), alternative.type_().clone());
Alternative::new(
alternative.type_().clone(),
alternative.name(),
infer_in_expression(alternative.expression(), &&variables),
)
}
fn infer_in_comparison_operation(
operation: &ComparisonOperation,
variables: &HashMap<String, Type>,
) -> ComparisonOperation {
ComparisonOperation::new(
operation.operator(),
infer_in_expression(operation.lhs(), variables),
infer_in_expression(operation.rhs(), variables),
)
}
fn infer_in_function_application(
application: &FunctionApplication,
variables: &HashMap<String, Type>,
) -> FunctionApplication {
FunctionApplication::new(
infer_in_expression(application.function(), variables),
infer_in_expression(application.argument(), variables),
)
}
fn infer_in_let(let_: &Let, variables: &HashMap<String, Type>) -> Let {
Let::new(
let_.name(),
let_.type_().clone(),
infer_in_expression(let_.bound_expression(), variables),
infer_in_expression(
let_.expression(),
&variables
.clone()
.drain()
.chain(vec![(let_.name().into(), let_.type_().clone())])
.collect(),
),
)
}
fn infer_in_let_recursive(let_: &LetRecursive, variables: &HashMap<String, Type>) -> LetRecursive {
let variables = variables
.clone()
.drain()
.chain(
let_.definitions()
.iter()
.map(|definition| (definition.name().into(), definition.type_().clone().into())),
)
.collect();
LetRecursive::new(
let_.definitions()
.iter()
.map(|definition| infer_in_definition(definition, &variables))
.collect(),
infer_in_expression(let_.expression(), &variables),
)
}
fn infer_in_record(record: &Record, variables: &HashMap<String, Type>) -> Record {
Record::new(
record.type_().clone(),
record
.elements()
.iter()
.map(|element| infer_in_expression(element, variables))
.collect(),
)
}
fn infer_in_record_element(
element: &RecordElement,
variables: &HashMap<String, Type>,
) -> RecordElement {
RecordElement::new(
element.type_().clone(),
element.index(),
infer_in_expression(element.record(), variables),
)
}
fn infer_in_variant(variant: &Variant, variables: &HashMap<String, Type>) -> Variant {
Variant::new(
variant.type_().clone(),
infer_in_expression(variant.payload(), variables),
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types;
#[test]
fn infer_empty_environment() {
assert_eq!(
infer_in_definition(
&Definition::new(
"f",
vec![Argument::new("x", types::Primitive::Number)],
42.0,
types::Primitive::Number
),
&Default::default()
),
Definition::with_environment(
"f",
vec![],
vec![Argument::new("x", types::Primitive::Number)],
42.0,
types::Primitive::Number
)
);
}
#[test]
fn infer_environment() {
assert_eq!(
infer_in_definition(
&Definition::new(
"f",
vec![Argument::new("x", types::Primitive::Number)],
Variable::new("y"),
types::Primitive::Number
),
&vec![("y".into(), types::Primitive::Number.into())]
.drain(..)
.collect()
),
Definition::with_environment(
"f",
vec![Argument::new("y", types::Primitive::Number)],
vec![Argument::new("x", types::Primitive::Number)],
Variable::new("y"),
types::Primitive::Number
)
);
}
#[test]
fn infer_environment_idempotently() {
let variables = vec![("y".into(), types::Primitive::Number.into())]
.drain(..)
.collect();
assert_eq!(
infer_in_definition(
&infer_in_definition(
&Definition::new(
"f",
vec![Argument::new("x", types::Primitive::Number)],
Variable::new("y"),
types::Primitive::Number
),
&variables
),
&variables
),
Definition::with_environment(
"f",
vec![Argument::new("y", types::Primitive::Number)],
vec![Argument::new("x", types::Primitive::Number)],
Variable::new("y"),
types::Primitive::Number
)
);
}
}
|
#![allow(incomplete_features)]
#![cfg_attr(not(test), no_std)]
use pc_keyboard::{DecodedKey, KeyCode};
use pluggable_interrupt_os::vga_buffer::{BUFFER_WIDTH, BUFFER_HEIGHT};
use core::borrow::BorrowMut;
use pluggable_interrupt_os::println;
const WIDTH: usize = BUFFER_WIDTH;
const HEIGHT: usize = BUFFER_HEIGHT - 2;
const UPDATE_FREQUENCY: usize = 1;
#[derive(Copy,Clone,Eq,PartialEq,Debug)]
pub struct SpaceInvadersGame {
cells: [[Cell; WIDTH]; HEIGHT],
status: Status,
player: Player,
aliens: Aliens,
shots: [Shot; 4],
score: u64,
last_dir: Option<Dir>,
countdown: usize,
fired_shot: bool,
alien_move_frequency: usize,
alien_move_countdown: usize // delays alien movement
}
#[derive(Copy,Clone,Eq,PartialEq,Debug)]
pub enum Status {
Normal,
Over
}
#[derive(Debug,Copy,Clone,Eq,PartialEq)]
#[repr(u8)]
pub enum Cell {
Empty,
Barrier
}
#[derive(Debug,Copy,Clone,Eq,PartialEq)]
#[repr(u8)]
pub enum Dir {
N, S, E, W
}
impl Dir {
fn reverse(&self) -> Dir {
match self {
Dir::N => Dir::S,
Dir::S => Dir::N,
Dir::E => Dir::W,
Dir::W => Dir::E
}
}
fn left(&self) -> Dir {
match self {
Dir::N => Dir::W,
Dir::S => Dir::E,
Dir::E => Dir::N,
Dir::W => Dir::S
}
}
fn right(&self) -> Dir {
match self {
Dir::N => Dir::E,
Dir::S => Dir::W,
Dir::E => Dir::S,
Dir::W => Dir::N
}
}
}
#[derive(Debug,Copy,Clone,Eq,PartialEq)]
pub struct Position {
col: i16, row: i16
}
impl Position {
pub fn is_legal(&self) -> bool {
0 <= self.col && self.col < WIDTH as i16 && 0 <= self.row && self.row < HEIGHT as i16
}
pub fn row_col(&self) -> (usize, usize) {
(self.row as usize, self.col as usize)
}
pub fn neighbor(&self, d: Dir) -> Position {
match d {
Dir::N => Position {row: self.row - 1, col: self.col},
Dir::S => Position {row: self.row + 1, col: self.col},
Dir::E => Position {row: self.row, col: self.col + 1},
Dir::W => Position {row: self.row, col: self.col - 1}
}
}
}
#[derive(Copy,Clone,Eq,PartialEq,Debug)]
pub struct Shot {
pos: Position,
active: bool,
dir: Dir,
player_fired: bool // true if fired by player, false if by aliens
}
impl Shot {
fn new(pos: Position) -> Self {Shot {pos, active: false, dir: Dir::N, player_fired: false}}
fn fire(&mut self, pos: Position, direction: Dir, player: bool) {
self.pos = pos;
self.active = true;
self.dir = direction;
self.player_fired = player
}
fn deactivate(&mut self) { self.active = false;}
fn fired_by_player(&self) -> bool {self.player_fired}
fn next_pos(&self) -> Position {self.pos.neighbor(self.dir)}
pub fn icon() -> char { '|' }
}
#[derive(Copy,Clone,Eq,PartialEq,Debug)]
pub struct Player {
pos: Position,
active_shots: u8,
total_shots: u8
}
impl Player {
fn new(pos: Position) -> Self {
Player {pos, active_shots: 0, total_shots: 3}
}
fn can_fire_shot(&self) -> bool {
self.active_shots < self.total_shots
}
fn get_shot_position(&self) -> Position {
Position {row: self.pos.row - 1, col: self.pos.col}
}
pub fn icon() -> char { '^' }
}
#[derive(Debug,Copy,Clone,Eq,PartialEq)]
pub struct Alien {
pos: Position,
alive: bool
}
impl Alien {
fn new(pos: Position) -> Self {
Alien {pos, alive: true}
}
fn directly_above_player(&self, player: &Player) -> bool {
player.pos.col == self.pos.col
}
fn get_shot_pos(&self) -> Position {
let (row, col) = self.pos.row_col();
Position {row: (row + 1) as i16, col: col as i16}
}
pub fn icon() -> char {'@'}
}
#[derive(Debug,Copy,Clone,Eq,PartialEq)]
pub struct Aliens {
aliens: [[Alien; 24]; 5],
bottom_row: u32, // lowest row of aliens
active_shots: u8,
total_shots: u8,
dir: Dir,
}
impl Aliens {
fn new() -> Self {
Aliens {aliens: [[Alien::new(Position {row: 0, col: 0}); 24]; 5], bottom_row: 4, active_shots: 0, total_shots: 1, dir: Dir::E}
}
fn can_fire_shot(&self) -> bool {
self.active_shots < self.total_shots
}
fn find_alien_to_fire(&self, player: &Player) -> Option<&Alien> {
for row in self.aliens.iter() {
for alien in row.iter() {
if alien.directly_above_player(player) {
return Some(alien)
}
}
}
None
}
// fn move_aliens(&self) {
// for (row_num, row) in self.aliens.aliens.iter().enumerate() {
// for (col_num, alien) in row.iter().enumerate() {
// if alien.alive && alien.pos == p {
//
// return Some((row_num, col_num, alien))
// }
// }
// }
// }
}
const LAST_RAW : &'static i32 = &16;
const START: &'static str =
"#..............................................................................#
#..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@......#
#...@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@.....#
#....@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@....#
#...@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@.....#
#..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@..@......#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
###..###..###..###..###..###..###..###..###..###..###..###..###..###..###..##.##
###..###..###..###..###..###..###..###..###..###..###..###..###..###..###..##.##
###..###..###..###..###..###..###..###..###..###..###..###..###..###..###..##.##
#..............................................................................#
#...................................^..........................................#
#..............................................................................#";
impl SpaceInvadersGame {
pub fn new() -> Self {
let mut game = SpaceInvadersGame {
cells: [[Cell::Empty; WIDTH]; HEIGHT],
status: Status::Normal,
player: Player::new(Position {row: 0, col: 0}),
aliens: Aliens::new(),
shots: [Shot::new(Position {row: 0, col: 0}); 4],
score: 0,
last_dir: None,
countdown: 0,
fired_shot: false,
alien_move_countdown: 0,
alien_move_frequency: 3
};
game.reset();
game
}
pub fn update(&mut self) {
if self.status == Status::Normal{
self.move_player();
self.last_dir = None;
if self.fired_shot {
self.fired_shot = false;
self.player_shoot();
}
if self.alien_countdown_complete() {
self.move_aliens();
}
self.alien_shoot();
self.move_shots();
self.check_collisions();
}
}
fn alien_countdown_complete(&mut self) -> bool {
if self.alien_move_countdown <= 0 {
self.alien_move_countdown = self.alien_move_frequency;
true
} else {
self.alien_move_countdown -= 1;
false
}
}
pub fn status(&self) -> Status {
self.status
}
pub fn score(&self) -> u64 {
self.score
}
fn reset(&mut self) {
self.set_up_game();
self.score = 0;
}
// Brings new aliens while keeping score
fn next_screen(&mut self) {
self.set_up_game();
}
fn set_up_game(&mut self) {
let mut alien_col = 0;
let mut alien_row = 0;
for (row_num, row_chars) in START.split("\n").enumerate() {
for (col_num, icon) in row_chars.chars().enumerate() {
self.translate_icon(&mut alien_row, &mut alien_col, row_num, col_num, icon)
}
}
for shot in self.shots.iter_mut() {
shot.active = false;
}
self.status = Status::Normal;
self.last_dir = None;
self.fired_shot = false;
}
fn translate_icon(&mut self, alien_row: &mut usize, alien_col: &mut usize, row: usize, col: usize, icon: char) {
match icon {
'.' => self.cells[row][col] = Cell::Empty,
'#' => self.cells[row][col] = Cell::Barrier,
'^' => self.player = Player::new(Position {row: row as i16, col: col as i16}),
'@' => {
self.aliens.aliens[*alien_row][*alien_col] = Alien::new(
Position {row: row as i16, col: col as i16}
);
*alien_col += 1;
if *alien_col >= self.aliens.aliens[0].len() {
*alien_col = 0;
*alien_row += 1;
}
}
_ => panic!("Invalid char '{}'", icon)
}
}
pub fn cell(&self, p: Position) -> Cell {
self.cells[p.row as usize][p.col as usize]
}
pub fn cell_pos_iter(&self) -> RowColIter {
RowColIter { row: 0, col: 0 }
}
pub fn player_at(&self, p: Position) -> bool {
p == self.player.pos
}
pub fn alien_at(&self, p: Position) -> Option<(usize,usize,&Alien)> {
for (row_num, row) in self.aliens.aliens.iter().enumerate() {
for (col_num, alien) in row.iter().enumerate() {
if alien.alive && alien.pos == p {
return Some((row_num, col_num, alien))
}
}
}
return None
}
pub fn move_aliens(&mut self) {
let mut will_hit_wall = false;
for i in 0..self.aliens.aliens.len(){
for j in 0..self.aliens.aliens.get(0).unwrap().len(){
let mut alien1 : &mut Alien = &mut self.aliens.aliens[i][j];
let nextPos = alien1.pos.neighbor(self.aliens.dir);
let down_next = alien1.pos.neighbor(Dir::S);
let(row, col) = nextPos.row_col();
if !nextPos.is_legal(){
will_hit_wall = true;
}
}
}
if will_hit_wall {
self.aliens.dir = self.aliens.dir.reverse();
}
for i in 0..self.aliens.aliens.len(){
for j in 0..self.aliens.aliens.get(0).unwrap().len(){
let mut alien1 : &mut Alien = &mut self.aliens.aliens[i][j];
let nextPos = alien1.pos.neighbor(self.aliens.dir);
let down_next = alien1.pos.neighbor(Dir::S);
let(row, col) = nextPos.row_col();
if row as i32 == *LAST_RAW {
self.status = Status::Over;
}else{
if will_hit_wall{
alien1.pos = down_next ;
}else{
alien1.pos = nextPos;
}
}
}
}
}
pub fn shot_at(&self, p: Position) -> bool {
for shot in self.shots.iter() {
if shot.active && shot.pos == p {
return true
}
}
return false
}
fn move_player(&mut self) {
if let Some(dir) = self.last_dir {
let neighbor = self.player.pos.neighbor(dir);
if neighbor.is_legal() {
let (row, col) = neighbor.row_col();
if self.cells[row][col] != Cell::Barrier {
self.player.pos = neighbor;
}
}
}
}
fn move_shots(&mut self) {
for shot in self.shots.iter_mut() {
if shot.active {
let new_pos = shot.next_pos();
if new_pos.is_legal() {
shot.pos = new_pos;
} else {
shot.deactivate();
if shot.player_fired {
self.player.active_shots -= 1;
} else {
self.aliens.active_shots -= 1;
}
}
}
}
}
fn check_collisions(&mut self) {
for i in 0..self.shots.len() {
if self.shots.get(i).unwrap().active {
if self.check_shot_collision(i) {
self.shots.get_mut(i).unwrap().deactivate();
if self.shots.get(i).unwrap().fired_by_player() {
self.player.active_shots -= 1;
} else {
self.aliens.active_shots -= 1;
}
}
}
}
}
fn check_shot_collision(&mut self, shot_index: usize) -> bool {
let shot_pos = self.shots.get(shot_index).unwrap().pos;
let fired_by_player = self.shots.get(shot_index).unwrap().fired_by_player();
if self.cell(shot_pos) == Cell::Barrier {
let (row, col) = shot_pos.row_col();
self.cells[row][col] = Cell::Empty;
return true
} else if self.player_at(shot_pos) && !fired_by_player {
self.status = Status::Over;
return true
} else if fired_by_player {
match self.alien_at(shot_pos) {
Some((row, col, alien)) => {
let alien = self.aliens.aliens.get_mut(row).unwrap().get_mut(col).unwrap();
alien.alive = false;
self.score += 1;
return true
},
_ => {}
}
}
false
}
fn find_usable_shot(&self) -> Option<usize> {
for i in 0..self.shots.len() {
if !self.shots.get(i).unwrap().active {
return Some(i)
}
}
None
}
fn find_shot_for_player(&self) -> Option<usize> {
if self.player.can_fire_shot() {
return self.find_usable_shot()
}
return None
}
fn player_shoot(&mut self) {
let fireable_shot = self.find_shot_for_player();
match fireable_shot {
Some(i) => {
let pos = self.player.get_shot_position();
let shot: &mut Shot = self.shots.get_mut(i).unwrap();
shot.fire(pos, Dir::N, true);
self.player.active_shots += 1;
},
None => {}
}
}
fn find_shot_for_aliens(&self) -> Option<usize> {
if self.aliens.can_fire_shot() {
return self.find_usable_shot()
}
None
}
fn alien_shoot(&mut self) {
let fireable_shot = self.find_shot_for_aliens();
match fireable_shot {
Some(i) => {
let alien_to_shoot = self.aliens.find_alien_to_fire(&self.player);
match alien_to_shoot {
Some(alien) => {
let pos = alien.get_shot_pos();
let shot: &mut Shot = self.shots.get_mut(i).unwrap();
shot.fire(pos, Dir::S, false);
self.aliens.active_shots += 1;
},
None => {}
}
}
None => {}
}
}
pub fn key(&mut self, key: DecodedKey) {
match self.status {
Status::Over => {
match key {
DecodedKey::RawKey(KeyCode::S) | DecodedKey::Unicode('s') => self.reset(),
_ => {}
}
}
Status::Normal => {
match key {
DecodedKey::RawKey(KeyCode::Spacebar) | DecodedKey::Unicode(' ')=> {self.fired_shot = true},
DecodedKey::RawKey(k) => match k {
KeyCode::ArrowLeft => {
self.last_dir = Some(Dir::W);
},
KeyCode::ArrowRight => {self.last_dir = Some(Dir::E)},
_ => {}
},
_ => {}
}
}
}
}
pub fn countdown_complete(&mut self) -> bool {
if self.countdown == 0 {
self.countdown = UPDATE_FREQUENCY;
true
} else {
self.countdown -= 1;
false
}
}
}
fn check_valid_key(key: DecodedKey) -> Option<KeyCode> {
match key {
DecodedKey::RawKey(k) => match k {
KeyCode::ArrowLeft => Some(k),
KeyCode::ArrowRight => Some(k),
KeyCode::Spacebar => Some(k),
_ => None
},
_ => None
}
}
pub struct RowColIter {
row: usize, col: usize
}
impl Iterator for RowColIter {
type Item = Position;
fn next(&mut self) -> Option<Self::Item> {
if self.row < HEIGHT {
let result = Some(Position {row: self.row as i16, col: self.col as i16});
self.col += 1;
if self.col == WIDTH {
self.col = 0;
self.row += 1;
}
result
} else {
None
}
}
}
|
use clap::{App, Arg};
mod csv;
mod text;
fn main() -> Result<(), ()> {
let matches = App::new("HyperLogLog CLI")
.version("0.1")
.author("Adam Shirey <adam@shirey.ch>")
.about("Efficiently approximates distinct count of input values.")
.arg(
Arg::with_name("error-rate")
.short("e")
.long("error-rate")
.value_name("ERROR_RATE")
.default_value("0.01")
.help("The approximate allowable error rate")
.takes_value(true),
)
.arg(
Arg::with_name("format")
.short("f")
.long("format")
.default_value("text")
.help("Input file format. Omit for line-based text.")
.long_help(
r#"Input file format. Use 'csv' to split the input text into columns, counting
each column independently. You may also use "#,
)
.required(false),
)
.arg(
Arg::with_name("header")
.short("h")
.long("header")
.multiple(false)
.takes_value(false)
.help("Indicates the input has a header. This flag is implicitly set. Use -H to disable header."),
)
.arg(
Arg::with_name("no-header")
.short("H")
.long("no-header")
.multiple(false)
.takes_value(false)
.help("Indicates the input does not have a header"),
)
.arg(
Arg::with_name("delimiter")
.short("d")
.long("delimiter")
.default_value(",")
.multiple(false)
.help("The column delimiter. Default is ','")
)
.arg(
Arg::with_name("columns")
.short("c")
.long("columns")
.multiple(false)
.help("A list of column names, numbers, or number ranges")
)
.arg(
Arg::with_name("input")
.help("Specifies the input source. If omitted or '-', stdin is used.")
.default_value("-")
.multiple(true),
)
.get_matches();
let error_rate = matches
.value_of("error-rate")
.unwrap()
.parse::<f64>()
.map_err(|e| {
println!("Failed to parse the error rate argument: {}", e);
})?;
if error_rate <= 0.0 || error_rate >= 1.0 {
println!("Error rate must be between 0 and 1, inclusive.");
return Err(());
}
let inputs = match matches.values_of("input") {
Some(values) => values,
None => {
println!("No input files specified");
return Err(());
}
};
let inputs: Vec<&str> = inputs.collect();
match matches.value_of("format").unwrap() {
"csv" => csv::process_csv(&inputs, error_rate, &matches)?,
"json" => todo!("json formatted input"),
"parquet" => todo!("parquet formatted input"),
_ => text::process_text(&inputs, error_rate)?
}
Ok(())
}
|
/// Errors for translators. These are separate so new translators can easily be created in a modular fashion.
pub mod errors;
// We export each translator by name
#[cfg(feature = "translator-fluent")]
mod fluent;
#[cfg(feature = "translator-fluent")]
pub use fluent::{FluentTranslator, FLUENT_TRANSLATOR_FILE_EXT};
// And then we export defaults using feature gates
#[cfg(feature = "translator-dflt-fluent")]
pub use FluentTranslator as Translator;
#[cfg(feature = "translator-dflt-fluent")]
pub use FLUENT_TRANSLATOR_FILE_EXT as TRANSLATOR_FILE_EXT;
/// Translates the given ID conveniently, taking arguments for interpolation as required.
#[macro_export]
macro_rules! t {
// When there are no arguments to interpolate
($id:expr) => {
{
let render_ctx = ::sycamore::context::use_context::<::perseus::template::RenderCtx>();
let translator = render_ctx.translator;
translator.translate($id, ::std::option::Option::None)
}
};
// When there are arguments to interpolate
($id:expr, {
$($key:literal: $value:expr),+
}) => {
{
let render_ctx = ::sycamore::context::use_context::<::perseus::template::RenderCtx>();
let translator = render_ctx.translator;
let mut args = ::fluent_bundle::FluentArgs::new();
$(
args.set($key, $value);
)+
translator.translate($id, ::std::option::Option::Some(args))
}
};
}
/// Gets the link to the given resource in internationalized form conveniently.
#[macro_export]
macro_rules! link {
($url:expr) => {{
let render_ctx = ::sycamore::context::use_context::<::perseus::template::RenderCtx>();
let translator = render_ctx.translator;
translator.url($url)
}};
}
|
pub mod transaction;
pub mod verifier;
pub use tockb_types as types;
pub use tockb_types::config;
|
use exonum::crypto::{Hash, PublicKey};
use super::proto;
/// Wallet information stored in the database.
#[derive(Clone, Debug, ProtobufConvert)]
#[exonum(pb = "proto::Queue", serde_pb_convert)]
pub struct Queue {
/// `PublicKey` of the queue.
pub key: PublicKey,
/// Name of the queue.
pub name: String,
}
impl Queue {
/// Create new queue.
pub fn new(
&key: &PublicKey,
name: &String,
) -> Self {
Self {
key,
name: name.to_owned(),
}
}
}
|
use std::{fs::File, path::PathBuf, time::Instant};
use assembly_fdb::{mem::Database, sqlite::try_export_db};
use color_eyre::eyre::WrapErr;
use mapr::Mmap;
use rusqlite::Connection;
use structopt::StructOpt;
#[derive(StructOpt)]
/// Turns an FDB file into an equivalent SQLite file
struct Options {
/// The FD source file
src: PathBuf,
/// The SQLite destination file
dest: PathBuf,
}
fn main() -> color_eyre::Result<()> {
color_eyre::install()?;
let opts = Options::from_args();
let start = Instant::now();
let src_file = File::open(&opts.src)
.wrap_err_with(|| format!("Failed to open input file '{}'", opts.src.display()))?;
let mmap = unsafe { Mmap::map(&src_file)? };
let buffer: &[u8] = &mmap;
println!("Copying data, this may take a few seconds...");
let db = Database::new(buffer);
let mut conn = Connection::open(opts.dest)?;
try_export_db(&mut conn, db).wrap_err("Failed to export database to sqlite")?;
let duration = start.elapsed();
println!(
"Finished in {}.{}s",
duration.as_secs(),
duration.subsec_millis()
);
Ok(())
}
|
use std::borrow::Borrow;
use std::io::BufRead;
/// The indices of each column in the VCF data lines
enum VCFColumn {
CHROMOSOME = 0,
POS = 1,
ID = 2,
REF = 3,
ALT = 4,
QUAL = 5,
FILTER = 6,
INFO = 7,
FORMAT = 8,
}
static FIRST_DATA_COLUMN: usize = VCFColumn::FORMAT as usize + 1;
/// A VCF data line
pub struct VCFData {
line: String,
ranges: Vec<(usize, usize)>,
}
impl VCFData {
fn new(line: String, ranges: Vec<(usize, usize)>) -> VCFData {
VCFData { line, ranges }
}
fn field(&self, index: usize) -> &str {
let (start, end) = self.ranges[index];
&self.line[start..end]
}
pub fn chromosome(&self) -> &str {
self.field(VCFColumn::CHROMOSOME as usize)
}
pub fn position(&self) -> &str {
self.field(VCFColumn::POS as usize)
}
pub fn identifier(&self) -> &str {
self.field(VCFColumn::ID as usize)
}
pub fn reference(&self) -> &str {
self.field(VCFColumn::REF as usize)
}
pub fn alternatives(&self) -> Vec<&str> {
self.field(VCFColumn::ALT as usize).split(',').collect()
}
pub fn quality(&self) -> &str {
self.field(VCFColumn::QUAL as usize)
}
pub fn filter(&self) -> &str {
self.field(VCFColumn::FILTER as usize)
}
pub fn info(&self) -> &str {
self.field(VCFColumn::INFO as usize)
}
pub fn format(&self) -> &str {
self.field(VCFColumn::FORMAT as usize)
}
pub fn genotype(&self, index: usize) -> &str {
self.field(FIRST_DATA_COLUMN + index)
}
pub fn genotypes(&self) -> impl Iterator<Item = &str> {
let range = FIRST_DATA_COLUMN..self.ranges.len();
range.map(move |idx| self.field(idx))
}
pub(crate) fn keep<I, T>(self, indices: I) -> VCFData
where
T: Borrow<usize>,
I: Iterator<Item = T>,
{
let mut ranges: Vec<_> = self.ranges[..FIRST_DATA_COLUMN].into();
ranges.extend(
indices
.into_iter()
.map(|i| self.ranges[i.borrow() + FIRST_DATA_COLUMN]),
);
VCFData {
line: self.line,
ranges,
}
}
pub(crate) fn debug(&self) {
for (idx, (start, end)) in self.ranges.iter().enumerate() {
let slice = self.line.get(*start..*end);
println!("{}: {}-{}\t{:?}", idx, start, end, slice);
}
}
}
pub struct StreamUnfolded<S: DataStream> {
pub metadata: Vec<(String, String)>,
pub individuals: Vec<String>,
pub stream: S,
}
pub trait MetadataReader {
type Next: IndividualsReader;
fn read_metadata(
self,
metadata: &mut Vec<(String, String)>,
) -> Result<Self::Next, &'static str>;
fn unfold(self) -> Result<StreamUnfolded<<Self::Next as IndividualsReader>::Next>, &'static str>
where
Self: Sized,
{
let mut metadata = Vec::new();
let mut individuals = Vec::new();
let stream = self.read_metadata(&mut metadata)?;
let stream = stream.read_individuals(&mut individuals)?;
Ok(StreamUnfolded {
metadata,
individuals,
stream,
})
}
}
pub trait IndividualsReader {
type Next: DataStream;
fn read_individuals(self, list: &mut Vec<String>) -> Result<Self::Next, &'static str>;
}
pub trait DataStream: Iterator<Item = VCFData> {}
pub fn from_text_stream<R: BufRead>(text_stream: R) -> impl MetadataReader {
MetadataReaderFromTextStream::new(text_stream)
}
struct MetadataReaderFromTextStream<R: BufRead> {
reader: R,
}
impl<R: BufRead> MetadataReaderFromTextStream<R> {
fn new(text_stream: R) -> MetadataReaderFromTextStream<R> {
MetadataReaderFromTextStream {
reader: text_stream,
}
}
}
impl<R: BufRead> MetadataReader for MetadataReaderFromTextStream<R> {
type Next = IndividualsReaderFromTextStream<R>;
fn read_metadata(
mut self,
map: &mut Vec<(String, String)>,
) -> Result<Self::Next, &'static str> {
let mut line = String::new();
let mut count = 0;
loop {
line.clear();
let line = match self.reader.read_line(&mut line) {
Err(_) => return Err("Error reading the text stream"),
Ok(len) if len == 0 && count == 0 => return Err("VCF file is empty"),
Ok(len) if len == 0 => return Err("VCF file contains only metadata"),
Ok(_) => &line,
};
count += 1;
let line = line.trim_right_matches("\n");
if line.starts_with("##") {
let fields = line[2..].splitn(2, "=").collect::<Vec<_>>();
map.push((fields[0].to_string(), fields[1].to_string()));
} else {
return Ok(IndividualsReaderFromTextStream {
reader: self.reader,
line: line.to_string(),
});
}
}
}
}
struct IndividualsReaderFromTextStream<R: BufRead> {
reader: R,
line: String,
}
impl<R: BufRead> IndividualsReader for IndividualsReaderFromTextStream<R> {
type Next = DataStreamFromTextStream<R>;
fn read_individuals(self, list: &mut Vec<String>) -> Result<Self::Next, &'static str> {
let start_len = list.len();
let fields = self.line.split("\t").collect::<Vec<_>>();
let genotype = fields[VCFColumn::FORMAT as usize] == "FORMAT";
let start_index = if genotype {
VCFColumn::FORMAT as usize + 1
} else {
VCFColumn::FORMAT as usize
};
list.extend(fields[start_index..].iter().map(|&s| s.to_string()));
if list.len() == start_len {
Err("Line does not contain any individuals")
} else {
Ok(DataStreamFromTextStream {
reader: self.reader,
genotype,
})
}
}
}
struct DataStreamFromTextStream<R: BufRead> {
reader: R,
genotype: bool,
}
impl<R: BufRead> Iterator for DataStreamFromTextStream<R> {
type Item = VCFData;
fn next(&mut self) -> Option<VCFData> {
let mut line = String::new();
if self.reader.read_line(&mut line).is_err() || line.len() == 0 {
return None;
}
if line.ends_with('\n') {
line.pop();
}
let mut tabs = line
.chars()
.enumerate()
.filter(|(_, c)| *c == '\t')
.map(|(idx, _)| idx)
.collect::<Vec<_>>();
if !self.genotype {
let idx = VCFColumn::FORMAT as usize - 1;
let last_tab = tabs[idx];
tabs.insert(idx, last_tab);
}
let starts = vec![0]
.into_iter()
.chain(tabs.iter().cloned().map(|idx| idx + 1));
let ends = tabs.iter().cloned().chain(vec![line.len()].into_iter());
let ranges = starts.zip(ends).collect();
Some(VCFData::new(line, ranges))
}
}
impl<R: BufRead> DataStream for DataStreamFromTextStream<R> {}
mod test {
use std::io;
use super::*;
fn main() -> Result<(), &'static str> {
let mut metadata = Vec::new();
let mut individuals = Vec::new();
let stdin = io::stdin();
let handle = stdin.lock();
let s = from_text_stream(handle);
let s = s.read_metadata(&mut metadata)?;
let s = s.read_individuals(&mut individuals)?;
for _polymorphism in s {
break;
}
Ok(())
}
}
|
mod bytes_ext;
mod codec;
mod mctypes;
mod packet;
pub mod packets;
pub use codec::{Error, MinecraftCodec};
pub use packet::{Packet, PacketBuilder, PacketDirection, PacketId, PacketStage, PacketType};
pub fn cast_packet<P: packet::Packet + 'static + Send>(packet: Box<dyn Packet>) -> P {
*packet.into_any().downcast().unwrap()
}
|
use super::{
options::{ApplyContract, DoNotApplyContracts, DoNotUseCallback, UseCallback},
primitives::{embed_primitives, embed_primitives_without_io, CONSTANTS},
vm::VirtualMachineCore,
};
use crate::{
compiler::{compiler::Compiler, constants::ConstantMap, program::Program},
core::instructions::DenseInstruction,
parser::ast::ExprKind,
parser::parser::{ParseError, Parser},
rerrs::{ErrorKind, SteelErr},
rvals::{FromSteelVal, IntoSteelVal, Result, SteelVal},
stop, throw,
};
use std::{
collections::HashMap,
io::Read,
path::{Path, PathBuf},
rc::Rc,
};
use im_rc::HashMap as ImmutableHashMap;
use itertools::Itertools;
pub struct Engine {
virtual_machine: VirtualMachineCore,
compiler: Compiler,
constants: Option<ImmutableHashMap<String, SteelVal>>,
}
impl Engine {
/// Instantiates a raw engine instance. Includes no primitives or prelude.
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// let mut vm = Engine::new_raw();
/// assert!(vm.run("(+ 1 2 3").is_err()); // + is a free identifier
/// ```
pub fn new_raw() -> Self {
Engine {
virtual_machine: VirtualMachineCore::new(),
compiler: Compiler::default(),
constants: None,
}
}
/// Instantiates a new engine instance with all primitive functions enabled.
/// This excludes the prelude and contract files.
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// let mut vm = Engine::new_base();
/// // map is found in the prelude, so this will fail
/// assert!(vm.run(r#"(map (lambda (x) 10) (list 1 2 3 4 5))"#).is_err());
/// ```
#[inline]
pub fn new_base() -> Self {
let mut vm = Engine::new_raw();
// Embed any primitives that we want to use
embed_primitives(&mut vm);
vm
}
#[inline]
pub fn new_sandboxed() -> Self {
let mut vm = Engine::new_raw();
embed_primitives_without_io(&mut vm);
let core_libraries = [crate::stdlib::PRELUDE, crate::stdlib::CONTRACTS];
for core in std::array::IntoIter::new(core_libraries) {
vm.parse_and_execute_without_optimizations(core).unwrap();
}
vm
}
/// Instantiates a new engine instance with all the primitive functions enabled.
/// This is the most general engine entry point, and includes both the contract and
/// prelude files in the root.
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// let mut vm = Engine::new();
/// vm.run(r#"(+ 1 2 3)"#).unwrap();
/// ```
pub fn new() -> Self {
let mut vm = Engine::new_base();
let core_libraries = [
crate::stdlib::PRELUDE,
crate::stdlib::DISPLAY,
crate::stdlib::CONTRACTS,
];
for core in std::array::IntoIter::new(core_libraries) {
vm.parse_and_execute_without_optimizations(core).unwrap();
}
vm
}
/// Consumes the current `Engine` and emits a new `Engine` with the prelude added
/// to the environment. The prelude won't work unless the primitives are also enabled.
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// let mut vm = Engine::new_base().with_prelude().unwrap();
/// vm.run("(+ 1 2 3)").unwrap();
/// ```
pub fn with_prelude(mut self) -> Result<Self> {
let core_libraries = &[
crate::stdlib::PRELUDE,
crate::stdlib::DISPLAY,
crate::stdlib::CONTRACTS,
];
for core in core_libraries {
self.parse_and_execute_without_optimizations(core)?;
}
Ok(self)
}
/// Registers the prelude to the environment of the given Engine.
/// The prelude won't work unless the primitives are also enabled.
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// let mut vm = Engine::new_base();
/// vm.register_prelude().unwrap();
/// vm.run("(+ 1 2 3)").unwrap();
/// ```
pub fn register_prelude(&mut self) -> Result<&mut Self> {
let core_libraries = &[
crate::stdlib::PRELUDE,
crate::stdlib::DISPLAY,
crate::stdlib::CONTRACTS,
];
for core in core_libraries {
self.parse_and_execute_without_optimizations(core)?;
}
Ok(self)
}
/// Emits a program with path information embedded for error messaging.
pub fn emit_program_with_path(&mut self, expr: &str, path: PathBuf) -> Result<Program> {
let constants = self.constants();
self.compiler.compile_program(expr, Some(path), constants)
}
/// Emits a program for a given `expr` directly without providing any error messaging for the path.
pub fn emit_program(&mut self, expr: &str) -> Result<Program> {
let constants = self.constants();
self.compiler.compile_program(expr, None, constants)
}
// Attempts to disassemble the given expression into a series of bytecode dumps
pub fn disassemble(&mut self, expr: &str) -> Result<String> {
let constants = self.constants();
self.compiler
.emit_debug_instructions(expr, constants)
.map(|x| {
x.into_iter()
.map(|i| crate::core::instructions::disassemble(&i))
.join("\n\n")
})
}
/// Execute bytecode with a constant map directly.
pub fn execute(
&mut self,
bytecode: Rc<[DenseInstruction]>,
constant_map: &ConstantMap,
) -> Result<SteelVal> {
self.virtual_machine
.execute(bytecode, constant_map, UseCallback, ApplyContract)
}
/// Emit the bytecode directly, with a path provided.
pub fn emit_instructions_with_path(
&mut self,
exprs: &str,
path: PathBuf,
) -> Result<Vec<Vec<DenseInstruction>>> {
let constants = self.constants();
self.compiler
.emit_instructions(exprs, Some(path), constants)
}
/// Emit instructions directly, without a path for error messaging.
pub fn emit_instructions(&mut self, exprs: &str) -> Result<Vec<Vec<DenseInstruction>>> {
let constants = self.constants();
self.compiler.emit_instructions(exprs, None, constants)
}
/// Execute a program directly, returns a vector of `SteelVal`s corresponding to each expr in the `Program`.
pub fn execute_program(&mut self, program: Program) -> Result<Vec<SteelVal>> {
self.virtual_machine
.execute_program(program, UseCallback, ApplyContract)
}
/// Emit the unexpanded AST
pub fn emit_ast_to_string(expr: &str) -> Result<String> {
let mut intern = HashMap::new();
let parsed: std::result::Result<Vec<ExprKind>, ParseError> =
Parser::new(expr, &mut intern).collect();
let parsed = parsed?;
Ok(parsed.into_iter().map(|x| x.to_pretty(60)).join("\n\n"))
}
/// Emit the fully expanded AST
pub fn emit_fully_expanded_ast_to_string(&mut self, expr: &str) -> Result<String> {
let constants = self.constants();
Ok(self
.compiler
.emit_expanded_ast(expr, constants)?
.into_iter()
.map(|x| x.to_pretty(60))
.join("\n\n"))
}
/// Registers an external value of any type as long as it implements [`FromSteelVal`](crate::rvals::FromSteelVal) and
/// [`IntoSteelVal`](crate::rvals::IntoSteelVal). This method does the coercion to embed the type into the `Engine`'s
/// environment with the name `name`. This function can fail only if the conversion from `T` to [`SteelVal`](crate::rvals::SteelVal) fails.
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// let mut vm = Engine::new();
/// let external_value = "hello-world".to_string();
/// vm.register_external_value("hello-world", external_value).unwrap();
/// vm.run("hello-world").unwrap(); // Will return the string
/// ```
pub fn register_external_value<T: FromSteelVal + IntoSteelVal>(
&mut self,
name: &str,
value: T,
) -> Result<&mut Self> {
let converted = value.into_steelval()?;
Ok(self.register_value(name, converted))
}
/// Registers a [`SteelVal`](crate::rvals::SteelVal) under the name `name` in the `Engine`'s internal environment.
///
/// # Examples
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// use steel::rvals::SteelVal;
///
/// let mut vm = Engine::new();
/// let external_value = SteelVal::StringV("hello-world".to_string().into());
/// vm.register_value("hello-world", external_value);
/// vm.run("hello-world").unwrap(); // Will return the string
/// ```
pub fn register_value(&mut self, name: &str, value: SteelVal) -> &mut Self {
let idx = self.compiler.register(name);
self.virtual_machine.insert_binding(idx, value);
self
}
/// Registers multiple values at once
pub fn register_values(
&mut self,
values: impl Iterator<Item = (String, SteelVal)>,
) -> &mut Self {
for (name, value) in values {
self.register_value(name.as_str(), value);
}
self
}
/// Registers a predicate for a given type. When embedding external values, it is convenient
/// to be able to have a predicate to test if the given value is the specified type.
/// In order to be registered, a type must implement [`FromSteelVal`](crate::rvals::FromSteelVal)
/// and [`IntoSteelVal`](crate::rvals::IntoSteelVal)
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// use steel::steel_vm::register_fn::RegisterFn;
/// fn foo() -> usize {
/// 10
/// }
///
/// let mut vm = Engine::new();
/// vm.register_fn("foo", foo);
///
/// vm.run(r#"(foo)"#).unwrap(); // Returns vec![10]
/// ```
pub fn register_type<T: FromSteelVal + IntoSteelVal>(
&mut self,
predicate_name: &'static str,
) -> &mut Self {
let f = move |args: &[SteelVal]| -> Result<SteelVal> {
if args.len() != 1 {
stop!(ArityMismatch => format!("{} expected 1 argument, got {}", predicate_name, args.len()));
}
Ok(SteelVal::BoolV(T::from_steelval(args[0].clone()).is_ok()))
};
self.register_value(predicate_name, SteelVal::BoxedFunction(Rc::new(f)))
}
/// Registers a callback function. If registered, this callback will be called on every instruction
/// Allows for the introspection of the currently running process. The callback here takes as an argument the current instruction number.
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// let mut vm = Engine::new();
/// vm.on_progress(|count| {
/// // parameter is 'usize' - number of instructions performed up to this point
/// if count % 1000 == 0 {
/// // print out a progress log every 1000 operations
/// println!("Number of instructions up to this point: {}", count);
/// // Returning false here would quit the evaluation of the function
/// return true;
/// }
/// true
/// });
/// // This should end with "Number of instructions up to this point: 12000"
/// vm.run(
/// r#"
/// (define (loop x)
/// (if (equal? x 1000)
/// x
/// (loop (+ x 1))))
/// (loop 0)
/// "#,
/// )
/// .unwrap();
/// ```
pub fn on_progress<FN: Fn(usize) -> bool + 'static>(&mut self, callback: FN) -> &mut Self {
self.virtual_machine.on_progress(callback);
self
}
/// Extracts a value with the given identifier `name` from the internal environment.
/// If a script calculated some series of bound values, then it can be extracted this way.
/// This will return the [`SteelVal`](crate::rvals::SteelVal), not the underlying data.
/// To unwrap the value, use the [`extract`](crate::steel_vm::engine::Engine::extract) method and pass the type parameter.
///
/// The function will return an error if the `name` is not currently bound in the `Engine`'s internal environment.
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// use steel::rvals::SteelVal;
/// let mut vm = Engine::new();
/// vm.run("(define a 10)").unwrap();
/// assert_eq!(vm.extract_value("a").unwrap(), SteelVal::IntV(10));
/// ```
pub fn extract_value(&self, name: &str) -> Result<SteelVal> {
let idx = self.compiler.get_idx(name).ok_or_else(throw!(
Generic => format!("free identifier: {} - identifier given cannot be found in the global environment", name)
))?;
self.virtual_machine.extract_value(idx)
.ok_or_else(throw!(
Generic => format!("free identifier: {} - identifier given cannot be found in the global environment", name)
))
}
/// Extracts a value with the given identifier `name` from the internal environment, and attempts to coerce it to the
/// given type. This will return an error if the `name` is not currently bound in the `Engine`'s internal environment, or
/// if the type passed in does not match the value (and thus the coercion using [`FromSteelVal`](crate::rvals::FromSteelVal) fails)
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// let mut vm = Engine::new();
/// vm.run("(define a 10)").unwrap();
/// assert_eq!(vm.extract::<usize>("a").unwrap(), 10);
/// ```
pub fn extract<T: FromSteelVal>(&self, name: &str) -> Result<T> {
T::from_steelval(self.extract_value(name)?)
}
/// Execute a program given as the `expr`, and computes a `Vec<SteelVal>` corresponding to the output of each expression given.
/// This method contains no path information used for error reporting, and simply runs the expression as is. Modules will be
/// imported with the root directory as wherever the executable was started.
/// Any parsing, compilation, or runtime error will be reflected here, ideally with span information as well. The error will not
/// be reported automatically.
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// use steel::rvals::SteelVal;
/// let mut vm = Engine::new();
/// let output = vm.run("(+ 1 2) (* 5 5) (- 10 5)").unwrap();
/// assert_eq!(output, vec![SteelVal::IntV(3), SteelVal::IntV(25), SteelVal::IntV(5)]);
/// ```
pub fn run(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
let constants = self.constants();
let program = self.compiler.compile_program(expr, None, constants)?;
self.virtual_machine
.execute_program(program, UseCallback, ApplyContract)
}
/// Execute a program, however do not run any callbacks as registered with `on_progress`.
pub fn run_without_callbacks(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
let constants = self.constants();
let program = self.compiler.compile_program(expr, None, constants)?;
self.virtual_machine
.execute_program(program, DoNotUseCallback, ApplyContract)
}
/// Execute a program (as per [`run`](crate::steel_vm::engine::Engine::run)), however do not enforce any contracts. Any contracts that are added are not
/// enforced.
///
/// # Examples
///
/// ```
/// # extern crate steel;
/// # use steel::steel_vm::engine::Engine;
/// use steel::rvals::SteelVal;
/// let mut vm = Engine::new();
/// let output = vm.run_without_contracts(r#"
/// (define/contract (foo x)
/// (->/c integer? any/c)
/// "hello world")
///
/// (foo "bad-input")
/// "#).unwrap();
/// ```
pub fn run_without_contracts(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
let constants = self.constants();
let program = self.compiler.compile_program(expr, None, constants)?;
self.virtual_machine
.execute_program(program, UseCallback, DoNotApplyContracts)
}
/// Execute a program without invoking any callbacks, or enforcing any contract checking
pub fn run_without_callbacks_or_contracts(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
let constants = self.constants();
let program = self.compiler.compile_program(expr, None, constants)?;
self.virtual_machine
.execute_program(program, DoNotUseCallback, DoNotApplyContracts)
}
/// Similar to [`run`](crate::steel_vm::engine::Engine::run), however it includes path information
/// for error reporting purposes.
pub fn run_with_path(&mut self, expr: &str, path: PathBuf) -> Result<Vec<SteelVal>> {
let constants = self.constants();
let program = self.compiler.compile_program(expr, Some(path), constants)?;
self.virtual_machine
.execute_program(program, UseCallback, ApplyContract)
}
pub fn parse_and_execute_without_optimizations(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
let constants = self.constants();
let program = self.compiler.compile_program(expr, None, constants)?;
self.virtual_machine
.execute_program(program, UseCallback, ApplyContract)
}
pub fn parse_and_execute(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
self.parse_and_execute_without_optimizations(expr)
}
// Read in the file from the given path and execute accordingly
// Loads all the functions in from the given env
// pub fn parse_and_execute_from_path<P: AsRef<Path>>(
// &mut self,
// path: P,
// ) -> Result<Vec<SteelVal>> {
// let mut file = std::fs::File::open(path)?;
// let mut exprs = String::new();
// file.read_to_string(&mut exprs)?;
// self.parse_and_execute(exprs.as_str(), )
// }
pub fn parse_and_execute_from_path<P: AsRef<Path>>(
&mut self,
path: P,
) -> Result<Vec<SteelVal>> {
let path_buf = PathBuf::from(path.as_ref());
let mut file = std::fs::File::open(path)?;
let mut exprs = String::new();
file.read_to_string(&mut exprs)?;
self.run_with_path(exprs.as_str(), path_buf)
}
// TODO this does not take into account the issues with
// people registering new functions that shadow the original one
fn constants(&mut self) -> ImmutableHashMap<String, SteelVal> {
if let Some(hm) = self.constants.clone() {
hm
} else {
let mut hm = ImmutableHashMap::new();
for constant in CONSTANTS {
if let Ok(v) = self.extract_value(constant) {
hm.insert(constant.to_string(), v);
}
}
self.constants = Some(hm.clone());
hm
}
}
}
#[cfg(test)]
mod on_progress_tests {
use super::*;
use std::cell::Cell;
use std::rc::Rc;
#[test]
fn count_every_thousand() {
let mut vm = Engine::new();
let external_count = Rc::new(Cell::new(0));
let embedded_count = Rc::clone(&external_count);
vm.on_progress(move |count| {
// parameter is 'usize' - number of instructions performed up to this point
if count % 1000 == 0 {
// print out a progress log every 1000 operations
println!("Number of instructions up to this point: {}", count);
embedded_count.set(embedded_count.get() + 1);
// Returning false here would quit the evaluation of the function
return true;
}
true
});
// This should end with "Number of instructions up to this point: 4000"
vm.run(
r#"
(define (loop x)
(if (equal? x 1000)
x
(loop (+ x 1))))
(displayln (loop 0))
"#,
)
.unwrap();
assert_eq!(external_count.get(), 4);
}
}
|
use crate::config;
use crate::mcc::agent::speciated_agent_queue::SpeciatedAgentQueue;
use crate::mcc::maze::speciated_maze_queue::SpeciatedMazeQueue;
pub struct VariedSizeController {
//pub(crate) agent_entries: Vec<VariedSizeEntry>,
//pub(crate) maze_entries: Vec<VariedSizeEntry>,
}
impl VariedSizeController {
fn update_agents(&mut self, agents: &mut SpeciatedAgentQueue) {
let mut clone = agents.species.clone();
clone.sort_by(|a, b| {
(a.statistics.get_overall_average_increase())
.partial_cmp(&b.statistics.get_overall_average_increase())
.unwrap()
});
let length = agents.species.len();
let (worst, best) = clone.split_at(length / 2);
for (w, b) in worst.iter().zip(best) {
let mut valid_to = true;
let mut valid_from = true;
let from_species_check = agents.iter_species_mut().find(|m| m.id == w.id);
if from_species_check.is_some() {
if from_species_check.unwrap().agent_queue.max_items_limit <= config::MCC.varied_size_agent_default_borrow_amount {
continue;
}
}
{
let to_species = agents.iter_species_mut().find(|m| m.id == b.id);
if to_species.is_some() {
to_species.unwrap().agent_queue.max_items_limit +=
config::MCC.varied_size_agent_default_borrow_amount;
} else {
valid_to = false;
}
}
{
let from_species = agents.iter_species_mut().find(|m| m.id == w.id);
if from_species.is_some() && valid_to {
from_species.unwrap().agent_queue.max_items_limit -=
config::MCC.varied_size_agent_default_borrow_amount;
} else {
valid_from = false;
}
}
if valid_to && !valid_from {
let to_species = agents.iter_species_mut().find(|m| m.id == b.id);
if to_species.is_some() {
to_species.unwrap().agent_queue.max_items_limit -=
config::MCC.varied_size_agent_default_borrow_amount;
}
}
}
}
fn update_mazes(&mut self, mazes: &mut SpeciatedMazeQueue) {
let mut clone = mazes.species.clone();
clone.sort_by(|a, b| {
(a.statistics.get_overall_score())
.partial_cmp(&b.statistics.get_overall_score())
.unwrap()
});
let length = mazes.species.len();
let (worst, best) = clone.split_at(length / 2);
for (w, b) in worst.iter().zip(best) {
let mut valid_to = true;
let mut valid_from = true;
let from_species_check = mazes.iter_species_mut().find(|m| m.id == w.id);
if from_species_check.is_some() {
if from_species_check.unwrap().maze_queue.max_items_limit <= config::MCC.varied_size_maze_default_borrow_amount {
continue;
}
}
{
let to_species = mazes.iter_species_mut().find(|m| m.id == b.id);
if to_species.is_some() {
to_species.unwrap().maze_queue.max_items_limit +=
config::MCC.varied_size_maze_default_borrow_amount;
} else {
valid_to = false;
}
}
{
let from_species = mazes.iter_species_mut().find(|m| m.id == w.id);
if from_species.is_some() && valid_to {
from_species.unwrap().maze_queue.max_items_limit -=
config::MCC.varied_size_maze_default_borrow_amount;
} else {
valid_from = false;
}
}
if valid_to && !valid_from {
let to_species = mazes.iter_species_mut().find(|m| m.id == b.id);
if to_species.is_some() {
to_species.unwrap().maze_queue.max_items_limit -=
config::MCC.varied_size_maze_default_borrow_amount;
}
}
}
}
pub fn update_population_properties(
&mut self,
agents: &mut SpeciatedAgentQueue,
mazes: &mut SpeciatedMazeQueue,
) {
self.update_agents(agents);
self.update_mazes(mazes);
}
}
|
extern crate image;
extern crate imageproc;
extern crate rusttype;
extern crate conv;
use decoder::*;
use decoder_class::*;
use decoder_usecase::*;
use image::{GenericImage, ImageBuffer, Pixel};
use imageproc::definitions::{Clamp, Image};
use conv::ValueInto;
use std::f32;
use std::i32;
use std;
use imageproc::pixelops::weighted_sum;
use imageproc::drawing::*;
use imageproc::rect::Rect;
use imageproc::rect::Region;
use rusttype::{Font, Scale, point, PositionedGlyph};
use std::path::Path;
use std::env;
use std::fs::File;
use std::io::*;
use std::collections::HashMap;
use std::ops::Mul;
use image::{Rgb,RgbImage};
use rusttype::{FontCollection};
use image::GenericImageView;
use visuals::draw_text_mut;
pub fn create_system_and_akteur(path: &std::path::Path, image: image::ImageBuffer<Rgb<u8>, Vec<u8>>,systemname:&str,vec_akteure: &Vec<Actor>) -> (image::ImageBuffer<Rgb<u8>, Vec<u8>>) {
let mut image=image;
let mut systemname=systemname;
let mut done_create=false;
let mut vec_stelle=0;
let mut anzahl=0;
image=draw_systemborder(image,systemname);
for vec_stelle in 0..vec_akteure.len(){
let mut position = vec_akteure[vec_stelle].id;
image = draw_akteur(image, 0, position,"l");//0 muss da bleiben
image = name_akteur(image, position, &vec_akteure[vec_stelle].name,"l");
let mut relation = vec_akteure[vec_stelle].extends_from;
match relation {
Some(relation) => image = draw_relationship_akteur(image, position,relation, "l"),
None => (),
}
for id in &vec_akteure[vec_stelle].has_use_case{
image=draw_case_with_assoziation(image,*id,position,"","","l");
}
}
let _ = image.save(path).unwrap();
return(image);
}
pub fn create_cases(path: &std::path::Path, image: image::ImageBuffer<Rgb<u8>, Vec<u8>>,vec_cases: &Vec<UseCase>)-> (image::ImageBuffer<Rgb<u8>, Vec<u8>>) {
let mut image=image;
let mut done_create=false;
let mut vec_stelle=0;
let mut name="";
while !done_create {
let mut place = vec_cases[vec_stelle].id;
let mut extend = vec_cases[vec_stelle].is_extension_point;
name= &vec_cases[vec_stelle].name;
if extend==true{
image=draw_case_extend(image,place)
}
image = draw_case(image, place);
image=name_case(image,place,name);
vec_stelle=vec_stelle+1;
if vec_stelle==vec_cases.iter().len(){
done_create=true;
}
}
let _ = image.save(path).unwrap();
return(image);
}
pub fn create_relations(path: &std::path::Path, image: image::ImageBuffer<Rgb<u8>, Vec<u8>>,vec: &Vec<UseCaseRelation>)->(image::ImageBuffer<Rgb<u8>, Vec<u8>>){
let mut image=image;
let mut done_create=false;
let mut vec_stelle=0;
let mut anzahl=0;
let mut tuple=draw_arrow(image,0,0,"");
let mut vor_x=tuple.1;
let mut vor_y=tuple.2;
for rel in vec{
if let UseCaseRelationType::Include = rel.relation_type {
tuple=draw_arrow(tuple.0,rel.from,rel.to,"<<include>>");
}
else{
tuple=draw_arrow(tuple.0,rel.from,rel.to,"<<extend>>");
anzahl=anzahl+1;
image=tuple.0;
image = draw_extend_reason(image, anzahl, &rel.note, tuple.1, tuple.2);
tuple.0 = image;
}
}
let _ = tuple.0.save(path).unwrap();
return(tuple.0);
}
fn draw_systemborder(image: image::ImageBuffer<Rgb<u8>, Vec<u8>>, name: &str) -> (image::ImageBuffer<Rgb<u8>, Vec<u8>>) {
let font = Vec::from(include_bytes!("../res/fonts/DejaVuSans-Bold.ttf") as &[u8]);
let font = FontCollection::from_bytes(font).unwrap().into_font().unwrap();
let schrift = Scale { x: 20.0, y: 20.0 };
let draw_color = Rgb([0u8, 0u8, 0u8]);
let rect = Rect::at(200, 10).of_size(780,990);
let mut image = image;
let mut name = name;
draw_hollow_rect_mut(&mut image, rect, draw_color);
draw_text_mut(&mut image, Rgb([0u8, 0u8, 0u8]), 400, 20, schrift, &font, name);
return (image);
}
fn draw_akteur(image: image::ImageBuffer<Rgb<u8>, Vec<u8>>, ist_anzahl_guys: i32, soll_anzahl_guys: i32,side: &str) -> (image::ImageBuffer<Rgb<u8>, Vec<u8>>) {
let draw_color = Rgb([0u8, 0u8, 0u8]);
let mut image = image;
let mut ist_anzahl_guys = ist_anzahl_guys;
let mut soll_anzahl_guys = soll_anzahl_guys;
let mut side=side;
let mut fertig = false;
let mut x_anfang = 80;
let mut head_anfang = 50;
let mut body_anfang = 60;
let mut arm_anfang = 70;
let mut bein_anfang = 90;
let mut bein_ende = 110;
if side=="l" {
while !fertig {
if soll_anzahl_guys-1==ist_anzahl_guys {
draw_hollow_circle_mut(&mut image, (x_anfang as i32, head_anfang as i32), 10 as i32, draw_color);
draw_line_segment_mut(&mut image, (x_anfang as f32, body_anfang as f32), (x_anfang as f32, bein_anfang as f32), draw_color);
draw_line_segment_mut(&mut image, (x_anfang as f32, arm_anfang as f32), ((90 as f32), (body_anfang as f32)), draw_color);
draw_line_segment_mut(&mut image, (x_anfang as f32, arm_anfang as f32), ((70 as f32), (body_anfang as f32)), draw_color);
draw_line_segment_mut(&mut image, (x_anfang as f32, bein_anfang as f32), ((90 as f32), (bein_ende as f32)), draw_color);
draw_line_segment_mut(&mut image, (x_anfang as f32, bein_anfang as f32), ((70 as f32), (bein_ende as f32)), draw_color);
}
head_anfang = head_anfang + 130;
body_anfang = body_anfang + 130;
arm_anfang = arm_anfang + 130;
bein_anfang = bein_anfang + 130;
bein_ende = bein_ende + 130;
ist_anzahl_guys = ist_anzahl_guys + 1;
if ist_anzahl_guys == 10 {
fertig = true;
}
}
}else if side=="r"{
x_anfang = 920;
while !fertig {
if soll_anzahl_guys-1==ist_anzahl_guys {
draw_hollow_circle_mut(&mut image, (x_anfang as i32, head_anfang as i32), 10 as i32, draw_color);
draw_line_segment_mut(&mut image, (x_anfang as f32, body_anfang as f32), (x_anfang as f32, bein_anfang as f32), draw_color);
draw_line_segment_mut(&mut image, (x_anfang as f32, arm_anfang as f32), ((910 as f32), (body_anfang as f32)), draw_color);
draw_line_segment_mut(&mut image, (x_anfang as f32, arm_anfang as f32), ((930 as f32), (body_anfang as f32)), draw_color);
draw_line_segment_mut(&mut image, (x_anfang as f32, bein_anfang as f32), ((910 as f32), (bein_ende as f32)), draw_color);
draw_line_segment_mut(&mut image, (x_anfang as f32, bein_anfang as f32), ((930 as f32), (bein_ende as f32)), draw_color);
}
head_anfang = head_anfang + 130;
body_anfang = body_anfang + 130;
arm_anfang = arm_anfang + 130;
bein_anfang = bein_anfang + 130;
bein_ende = bein_ende + 130;
ist_anzahl_guys = ist_anzahl_guys + 1;
if ist_anzahl_guys == 10 {
fertig = true;
}
}
}
return (image);
}
fn name_akteur(image: image::ImageBuffer<Rgb<u8>, Vec<u8>>, person: i32, name: &str,side: &str) -> (image::ImageBuffer<Rgb<u8>, Vec<u8>>) {
let font = Vec::from(include_bytes!("../res/fonts/DejaVuSans.ttf") as &[u8]);
let font = FontCollection::from_bytes(font).unwrap().into_font().unwrap();
let schrift = Scale { x: 10.0, y: 10.0 };
let mut image = image;
let mut bein_ende = 110;
let mut person = person - 1;
let mut name = name;
let mut side=side;
bein_ende = bein_ende + (130 * person);
if side=="l" {
draw_text_mut(&mut image, Rgb([0u8, 0u8, 0u8]), 70, (bein_ende + 10) as u32, schrift, &font, name);
}if side=="r"{
draw_text_mut(&mut image, Rgb([0u8, 0u8, 0u8]), 910, (bein_ende + 10) as u32, schrift, &font, name);
}
return (image);
}
fn draw_case(image: image::ImageBuffer<Rgb<u8>, Vec<u8>>,stelle: i32) -> (image::ImageBuffer<Rgb<u8>, Vec<u8>>) {
let draw_color = Rgb([0u8, 0u8, 0u8]);
let mut image = image;
let mut stelle=stelle;
let mut tuple = get_case_koordinaten(stelle);
let mut y_ellipse = tuple.1;
let mut x_ellipse = tuple.0;
draw_hollow_ellipse_mut(&mut image, (x_ellipse as i32, y_ellipse as i32), 50 as i32, 25 as i32, draw_color);
return (image);
}
fn draw_case_with_assoziation(image: image::ImageBuffer<Rgb<u8>, Vec<u8>>,stelle: i32, person: i32, von: &str, nach: &str,side: &str) -> (image::ImageBuffer<Rgb<u8>, Vec<u8>>) {
let draw_color = Rgb([0u8, 0u8, 0u8]);
let mut image = image;
let font = Vec::from(include_bytes!("../res/fonts/DejaVuSans.ttf") as &[u8]);
let font = FontCollection::from_bytes(font).unwrap().into_font().unwrap();
let schrift = Scale { x: 10.0, y: 10.0 };
let mut stelle = stelle;
let mut tuple = get_case_koordinaten(stelle);
let mut x_anfang = 80;
let mut y_ellipse = tuple.1;
let mut x_ellipse = tuple.0;
let mut person = person - 1;
let mut anfang = 75;
anfang = anfang + (130 * person);
if side == "l" {
draw_line_segment_mut(&mut image, (x_anfang as f32, anfang as f32), ((x_ellipse - 50) as f32, y_ellipse as f32), draw_color);
} else if side == "r" {
x_anfang = 920;
draw_line_segment_mut(&mut image, (x_anfang as f32, anfang as f32), ((x_ellipse + 50) as f32, y_ellipse as f32), draw_color);
}
return (image);
}
fn draw_relationship_akteur(image: image::ImageBuffer<Rgb<u8>, Vec<u8>>, person_von: i32, person_nach: i32,side:&str) -> (image::ImageBuffer<Rgb<u8>, Vec<u8>>) {
let draw_color = Rgb([0u8, 0u8, 0u8]);
let mut image = image;
let mut person_von = person_von - 1;
let mut person_nach = person_nach - 1;
let mut kopf_oben_x = 80;
let mut kopf_oben_y = 50 - 10;
let mut side=side;
if side=="r" {kopf_oben_x = 920;}
kopf_oben_y = kopf_oben_y + (130 * person_von);
draw_line_segment_mut(&mut image, ((kopf_oben_x) as f32, (kopf_oben_y) as f32), ((kopf_oben_x) as f32, (kopf_oben_y - 30) as f32), draw_color);
draw_line_segment_mut(&mut image, (kopf_oben_x as f32, (kopf_oben_y - 50) as f32), ((kopf_oben_x - 10) as f32, (kopf_oben_y - 30) as f32), draw_color);
draw_line_segment_mut(&mut image, (kopf_oben_x as f32, (kopf_oben_y - 50) as f32), ((kopf_oben_x + 10) as f32, (kopf_oben_y - 30) as f32), draw_color);
draw_line_segment_mut(&mut image, ((kopf_oben_x - 10) as f32, (kopf_oben_y - 30) as f32), ((kopf_oben_x + 10) as f32, (kopf_oben_y - 30) as f32), draw_color);
return (image);
}
fn draw_case_extend(image: image::ImageBuffer<Rgb<u8>, Vec<u8>>, stelle: i32) -> (image::ImageBuffer<Rgb<u8>, Vec<u8>>) {
let draw_color = Rgb([0u8, 0u8, 0u8]);
let mut image = image;
let mut stelle=stelle;
let mut tuple = get_case_koordinaten(stelle);
let mut y_ellipse = tuple.1;
let mut x_ellipse = tuple.0;
draw_hollow_ellipse_mut(&mut image, (x_ellipse as i32, y_ellipse as i32), 50 as i32, 25 as i32, draw_color);
draw_line_segment_mut(&mut image, ((x_ellipse-30) as f32, (y_ellipse-20) as f32), ((x_ellipse+30) as f32, (y_ellipse-20) as f32), draw_color);
return (image);
}
fn get_case_koordinaten(ende: i32) -> (i32,i32,i32,i32) {
let draw_color = Rgb([0u8, 0u8, 0u8]);
let mut fertig=false;
let mut y_ellipse = 70;
let mut x_ellipse = 250;
let mut reihe=1;
let mut anzahl=1;
let mut ende=ende;
let mut spalte=1;
if ende==1{
y_ellipse = 70;
x_ellipse = 250;
}
else {
while !fertig {
x_ellipse = x_ellipse + 200;
if spalte == 3 {
y_ellipse = y_ellipse + 70;
x_ellipse = 250;
spalte = 0;
reihe=reihe+1;
}
anzahl = anzahl + 1;
spalte = spalte + 1;
if anzahl == ende {
fertig = true;
}
}
}
return (x_ellipse,y_ellipse,spalte,reihe);
}
fn draw_arrow(image: image::ImageBuffer<Rgb<u8>, Vec<u8>>, von: i32,nach: i32,beschriftung: &str)->(image::ImageBuffer<Rgb<u8>, Vec<u8>>,i32,i32) {
let draw_color = Rgb([0u8, 0u8, 0u8]);
let draw_white = Rgb([255u8, 255u8, 255u8]);
let font = Vec::from(include_bytes!("../res/fonts/DejaVuSans.ttf") as &[u8]);
let font = FontCollection::from_bytes(font).unwrap().into_font().unwrap();
let schrift = Scale { x: 13.0, y: 13.0 };
let mut beschriftung=beschriftung;
let mut image=image;
let mut von_k=von;
let mut nach_k=nach;
let mut kreis_x=0;
let mut kreis_y=0;
if von_k >0 && nach_k > 0 {
let mut von = get_case_koordinaten(von);
let mut nach = get_case_koordinaten(nach);
let mut start_x = von.0;
let mut ende_x = nach.0;
let mut start_y = von.1;
let mut ende_y = nach.1;
let mut spalte_von = von.2;
let mut spalte_nach = nach.2;
let mut reihe_von = von.3;
let mut reihe_nach = nach.3;
let mut dazu = 10;
let mut dazu_y = 10;
let mut anderes = 10;
let mut richtung_h = "";
let mut richtung_w = "";
let mut richtung_pfeil = "";
if reihe_von == reihe_nach && spalte_von <= spalte_nach {
start_x = start_x + 50;
ende_x = ende_x - 50;
dazu = 10;
kreis_x = ende_x - 30;
kreis_y = ende_y;
richtung_pfeil = "rechts";
} else if reihe_von == reihe_nach && spalte_von >= spalte_nach {
start_x = start_x - 50;
ende_x = ende_x + 50;
dazu = -10;
kreis_x = ende_x + 30;
kreis_y = ende_y;
richtung_pfeil = "links";
} else if spalte_von == spalte_nach && reihe_von <= reihe_nach {
start_y = start_y + 25;
ende_y = ende_y - 25;
dazu = 10;
kreis_x = ende_x;
kreis_y = ende_y - 30;
richtung_pfeil = "unten";
} else if spalte_von == spalte_nach && reihe_von >= reihe_nach {
start_y = start_y - 25;
ende_y = ende_y + 25;
dazu = -10;
kreis_x = ende_x;
kreis_y = ende_y + 30;
richtung_pfeil = "oben";
} else if spalte_von < spalte_nach && reihe_von < reihe_nach {
start_x = start_x + 50;
ende_x = ende_x - 50;
dazu = 10;
dazu_y = 10;
anderes = -10;
kreis_x = ende_x - 30;
kreis_y = ende_y - 10;
richtung_h = "unten";
richtung_w = "rechts";
richtung_pfeil = "rechts";
} else if spalte_von < spalte_nach && reihe_von > reihe_nach {
start_x = start_x + 50;
ende_x = ende_x - 50;
dazu = 10;
dazu_y = -10;
anderes = 10;
kreis_x = ende_x - 30;
kreis_y = ende_y + 10;
richtung_h = "oben";
richtung_w = "rechts";
richtung_pfeil = "rechts";
} else if spalte_von > spalte_nach && reihe_von < reihe_nach {
start_x = start_x - 50;
ende_x = ende_x + 50;
dazu = 10;
dazu_y = 10;
anderes = -10;
kreis_x = ende_x + 30;
kreis_y = ende_y - 10;
richtung_h = "unten";
richtung_w = "links";
richtung_pfeil = "links";
} else if spalte_von > spalte_nach && reihe_von > reihe_nach {
start_x = start_x - 50;
ende_x = ende_x + 50;
dazu = 10;
dazu_y = -10;
anderes = 10;
kreis_x = ende_x + 30;
kreis_y = ende_y + 10;
richtung_h = "oben";
richtung_w = "links";
richtung_pfeil = "links";
}
let mut zwischen_x = start_x;
let mut zwischen_y = start_y;
let mut fertig = false;
while fertig == false {
draw_line_segment_mut(&mut image, ((start_x) as f32, (start_y) as f32), ((zwischen_x) as f32, (zwischen_y) as f32), draw_color);
if start_y == ende_y {
start_x = zwischen_x;
zwischen_x = zwischen_x + dazu;
if spalte_von > spalte_nach {
if zwischen_x <= ende_x {
fertig = true;
}
} else {
if zwischen_x >= ende_x {
fertig = true;
}
}
start_x = zwischen_x;
zwischen_x = zwischen_x + dazu;
} else if start_x == ende_x {
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu;
if reihe_von > reihe_nach {
if zwischen_y <= ende_y {
fertig = true;
}
} else {
if zwischen_y >= ende_y {
fertig = true;
}
}
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu;
} else {
let mut tuple = zeiche_pfeil_richtung_eins(start_x, start_y, ende_x, ende_y, zwischen_x, zwischen_y, dazu, dazu_y, richtung_h, richtung_w);
start_x = tuple.0;
start_y = tuple.1;
ende_x = tuple.2;
ende_y = tuple.3;
zwischen_x = tuple.4;
zwischen_y = tuple.5;
if zwischen_y >= ende_y && richtung_pfeil == "rechts" {
if zwischen_x >= ende_x {
fertig = true;
}
} else if zwischen_y >= ende_y && richtung_pfeil == "links" {
if zwischen_x <= ende_x {
fertig = true;
}
}
let mut tuple = zeiche_pfeil_richtung_zwei(start_x, start_y, ende_x, ende_y, zwischen_x, zwischen_y, dazu, dazu_y, anderes, richtung_h, richtung_w);
start_x = tuple.0;
start_y = tuple.1;
ende_x = tuple.2;
ende_y = tuple.3;
zwischen_x = tuple.4;
zwischen_y = tuple.5;
}
}
if richtung_pfeil == "links" {
draw_line_segment_mut(&mut image, ((ende_x) as f32, (zwischen_y) as f32), ((ende_x + 20) as f32, (zwischen_y - 10) as f32), draw_color);
draw_line_segment_mut(&mut image, ((ende_x) as f32, (zwischen_y) as f32), ((ende_x + 20) as f32, (zwischen_y + 10) as f32), draw_color);
draw_text_mut(&mut image, Rgb([0u8, 0u8, 0u8]), (kreis_x + 10) as u32, (kreis_y-5) as u32, schrift, &font, beschriftung);
} else if richtung_pfeil == "rechts" {
draw_line_segment_mut(&mut image, ((ende_x) as f32, (zwischen_y) as f32), ((ende_x - 20) as f32, (zwischen_y - 10) as f32), draw_color);
draw_line_segment_mut(&mut image, ((ende_x) as f32, (zwischen_y) as f32), ((ende_x - 20) as f32, (zwischen_y + 10) as f32), draw_color);
draw_text_mut(&mut image, Rgb([0u8, 0u8, 0u8]), (kreis_x - 60) as u32, (kreis_y -5) as u32, schrift, &font, beschriftung);
} else if richtung_pfeil == "oben" {
draw_line_segment_mut(&mut image, ((ende_x) as f32, (ende_y) as f32), ((ende_x + 10) as f32, (ende_y + 10) as f32), draw_color);
draw_line_segment_mut(&mut image, ((ende_x) as f32, (ende_y) as f32), ((ende_x - 10) as f32, (ende_y + 10) as f32), draw_color);
draw_text_mut(&mut image, Rgb([0u8, 0u8, 0u8]), (ende_x + 8) as u32, (ende_y + 10) as u32, schrift, &font, beschriftung);
} else if richtung_pfeil == "unten" {
draw_line_segment_mut(&mut image, ((ende_x) as f32, (ende_y) as f32), ((ende_x + 10) as f32, (ende_y - 10) as f32), draw_color);
draw_line_segment_mut(&mut image, ((ende_x) as f32, (ende_y) as f32), ((ende_x - 10) as f32, (ende_y - 10) as f32), draw_color);
draw_text_mut(&mut image, Rgb([0u8, 0u8, 0u8]), (ende_x + 8) as u32, (ende_y - 20) as u32, schrift, &font, beschriftung);
}
if beschriftung=="<<extend>>" {
draw_hollow_ellipse_mut(&mut image, (kreis_x as i32, kreis_y as i32), 5 as i32, 5 as i32, draw_color);
}
}
else {
kreis_x=0;
kreis_y=0;
}
return(image,kreis_x,kreis_y);
}
fn name_case(image: image::ImageBuffer<Rgb<u8>, Vec<u8>>,stelle: i32,text: &str)->(image::ImageBuffer<Rgb<u8>, Vec<u8>>){
let mut image=image;
let font = Vec::from(include_bytes!("../res/fonts/DejaVuSans.ttf") as &[u8]);
let font = FontCollection::from_bytes(font).unwrap().into_font().unwrap();
let schrift = Scale { x: 13.0, y: 13.0 };
let mut stelle=stelle;
let mut text=text;
let mut tuple = get_case_koordinaten(stelle);
draw_text_mut(&mut image, Rgb([0u8, 0u8, 0u8]),(tuple.0-45)as u32 , (tuple.1-5) as u32, schrift, &font, text);
return(image);
}
fn zeiche_pfeil_richtung_eins(start_x: i32,start_y: i32,ende_x: i32,ende_y: i32,zwischen_x: i32,zwischen_y: i32,dazu: i32,dazu_y: i32,richtung_h: &str,richtung_w: &str)
->(i32,i32,i32,i32,i32,i32){
let mut start_x=start_x;
let mut start_y=start_y;
let mut ende_x=ende_x;
let mut ende_y=ende_y;
let mut zwischen_x=zwischen_x;
let mut zwischen_y=zwischen_y;
let mut dazu=dazu;
let mut dazu_y=dazu_y;
let mut richtung_h=richtung_h;
let mut richtung_w=richtung_w;
//rechts oben
if richtung_h=="oben" && richtung_w=="rechts"{
if zwischen_y <= ende_y {
zwischen_y = zwischen_y + dazu;
start_x = zwischen_x;
zwischen_x = zwischen_x + dazu;
} else if zwischen_x >= ende_x {
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
} else {
start_x = zwischen_x;
zwischen_x = zwischen_x + dazu;
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
}
//rechts unten
else if richtung_h=="unten" && richtung_w=="rechts"{
if zwischen_y >= ende_y {
zwischen_y = zwischen_y + dazu;
start_x = zwischen_x;
zwischen_x = zwischen_x + dazu;
} else if zwischen_x >= ende_x {
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
} else {
start_x = zwischen_x;
zwischen_x = zwischen_x + dazu;
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
}
//links unten
else if richtung_h=="unten" && richtung_w=="links"{
if zwischen_y >= ende_y {
zwischen_y = zwischen_y + dazu;
start_x = zwischen_x;
zwischen_x = zwischen_x - dazu;
} else if zwischen_x <= ende_x {
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
} else {
start_x = zwischen_x;
zwischen_x = zwischen_x - dazu;
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
}
//links oben
else if richtung_h=="oben" && richtung_w=="links"{
if zwischen_y <= ende_y {
zwischen_y = zwischen_y + dazu;
start_x = zwischen_x;
zwischen_x = zwischen_x - dazu;
} else if zwischen_x <= ende_x {
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
} else {
start_x = zwischen_x;
zwischen_x = zwischen_x - dazu;
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
}
return(start_x,start_y,ende_x,ende_y,zwischen_x,zwischen_y)
}
fn zeiche_pfeil_richtung_zwei(start_x: i32,start_y: i32,ende_x: i32,ende_y: i32,zwischen_x: i32,zwischen_y: i32,dazu: i32,dazu_y: i32,anderes: i32,richtung_h: &str,richtung_w: &str)
->(i32,i32,i32,i32,i32,i32){
let mut start_x=start_x;
let mut start_y=start_y;
let mut ende_x=ende_x;
let mut ende_y=ende_y;
let mut zwischen_x=zwischen_x;
let mut zwischen_y=zwischen_y;
let mut dazu=dazu;
let mut dazu_y=dazu_y;
let mut anderes=anderes;
let mut richtung_h=richtung_h;
let mut richtung_w=richtung_w;
//rechts oben
if richtung_h=="oben" && richtung_w=="rechts"{
if zwischen_y <= ende_y {
zwischen_y = zwischen_y + anderes;
start_x = zwischen_x;
zwischen_x = zwischen_x + dazu;
}
else if zwischen_x >= ende_x {
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
else {
start_x=zwischen_x;
zwischen_x=zwischen_x+dazu;
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
}
//rechts unten
else if richtung_h=="unten" && richtung_w=="rechts"{
if zwischen_y >= ende_y {
zwischen_y = zwischen_y + anderes;
start_x = zwischen_x;
zwischen_x = zwischen_x + dazu;
}
else if zwischen_x >= ende_x {
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
else {
start_x=zwischen_x;
zwischen_x=zwischen_x+dazu;
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
}
//links unten
else if richtung_h=="unten" && richtung_w=="links"{
if zwischen_y >= ende_y {
zwischen_y = zwischen_y + anderes;
start_x = zwischen_x;
zwischen_x = zwischen_x - dazu;
}
else if zwischen_x <= ende_x {
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
else {
start_x=zwischen_x;
zwischen_x=zwischen_x-dazu;
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
}
//oben links
else if richtung_h=="oben" && richtung_w=="links"{
if zwischen_y <= ende_y {
zwischen_y = zwischen_y + anderes;
start_x = zwischen_x;
zwischen_x = zwischen_x - dazu;
}
else if zwischen_x <= ende_x {
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
else {
start_x=zwischen_x;
zwischen_x=zwischen_x-dazu;
start_y = zwischen_y;
zwischen_y = zwischen_y + dazu_y;
}
}
return(start_x,start_y,ende_x,ende_y,zwischen_x,zwischen_y)
}
fn draw_extend_reason(image: image::ImageBuffer<Rgb<u8>, Vec<u8>>,anzahl: i32,text: &str,kreis_x: i32, kreis_y: i32)-> (image::ImageBuffer<Rgb<u8>, Vec<u8>>){
let mut image=image;
let mut anzahl=anzahl;
let mut text=text;
let mut kreis_x=kreis_x;
let mut kreis_y=kreis_y;
let font = Vec::from(include_bytes!("../res/fonts/DejaVuSans.ttf") as &[u8]);
let font = FontCollection::from_bytes(font).unwrap().into_font().unwrap();
let schrift = Scale { x: 13.0, y: 13.0 };
let mut yo= 50;
let mut yu= 100;
let mut yh= 70;
let mut xl= 960 as f32;
let mut xm= 940 as f32;
let mut xk= 760;
let mut done_create=false;
let mut dauer=0;
let mut gezeichnet=false;
for dauer in 0..anzahl{
if dauer>=1 {
yo = yo + 60;
yu = yu + 60;
yh = yh + 60;
}
draw_line_segment_mut(&mut image,(xk as f32,yo as f32),(xm,yo as f32), Rgb([0u8, 0u8, 0u8]));
draw_line_segment_mut(&mut image,(xk as f32,yu as f32),(xl,yu as f32), Rgb([0u8, 0u8, 0u8]));
draw_line_segment_mut(&mut image,(xk as f32,yo as f32),(xk as f32,yu as f32), Rgb([0u8, 0u8, 0u8]));
draw_line_segment_mut(&mut image,(xl,yu as f32),(xl,yh as f32), Rgb([0u8, 0u8, 0u8]));
draw_line_segment_mut(&mut image,(xl,yh as f32),(xm,yo as f32), Rgb([0u8, 0u8, 0u8]));
draw_line_segment_mut(&mut image,(xm,yo as f32),(xm,yh as f32), Rgb([0u8, 0u8, 0u8]));
draw_line_segment_mut(&mut image,(xm,yh as f32),(xl,yh as f32), Rgb([0u8, 0u8, 0u8]));
}
draw_text_mut(&mut image, Rgb([0u8, 0u8, 0u8]),(xk+10)as u32 , (yo+10) as u32, schrift, &font, text);
draw_line_segment_mut(&mut image,(kreis_x as f32 ,kreis_y as f32),(xk as f32,((yo+yu)/2) as f32), Rgb([0u8, 0u8, 0u8]));
return(image);
} |
use super::{Fid, FidIter};
impl<'iter> Fid {
/// Creates an iterator over FID's bit vector.
///
/// # Examples
/// ```
/// use fid_rs::Fid;
///
/// let fid = Fid::from("1010_1010");
/// for (i, bit) in fid.iter().enumerate() {
/// assert_eq!(bit, fid[i as u64]);
/// }
/// ```
pub fn iter(&'iter self) -> FidIter<'iter> {
FidIter { fid: self, i: 0 }
}
}
impl<'iter> Iterator for FidIter<'iter> {
type Item = bool;
fn next(&mut self) -> Option<Self::Item> {
if self.i >= self.fid.len() {
None
} else {
self.i += 1;
Some(self.fid[self.i - 1])
}
}
}
#[cfg(test)]
mod iter_success_tests {
use crate::Fid;
#[test]
fn iter() {
let fid = Fid::from("1010_1010");
for (i, bit) in fid.iter().enumerate() {
assert_eq!(bit, fid[i as u64]);
}
}
}
#[cfg(test)]
mod iter_failure_tests {
// Nothing to test
}
|
use clang::*;
use std::io::Write;
use super::gen_context::GenContext;
use super::symbol_status::SymbolStatus;
use super::compile_entity_children;
use super::CType;
pub fn gen(gen_context: &mut GenContext, entity: Entity) {
if let Some(mut entity_name) = entity.get_name() {
// Check if available
match entity.get_availability() {
Availability::Inaccessible |
Availability::Unavailable => {
return
}
_ => {}
}
// Check if a function or property
if entity_name.ends_with(":") {
// Remove the trailing `:`
entity_name.pop();
}
// Get parent function name
let parent_class = unwrap_or_exit!(entity.get_semantic_parent(), "Could not locate pos {}", entity_name);
let parent_ty = unwrap_or_exit!(parent_class.get_type().map(|t| t.get_display_name()), "Could not locate parent ty {}", entity_name);
// Handle initializers seperately
if entity_name.starts_with("init") {
// We are an initializer
let initializer_name = entity_name.replacen("init", "", 1);
return
}
// Also split it into the components
let mut method_args_iter = entity_name.split(":");
let fn_name = unwrap_or_exit!(method_args_iter.next(), "Could not find function name for {}", entity_name);
// Get return type
let ret_ty = entity.get_result_type().map(|t| t.get_canonical_type());
let ret_ty_cstr = ty_to_cstr!(ret_ty, entity);
// Get arguments
let fn_args = unwrap_or_exit!(entity.get_arguments(), "Could not get function args {}", entity_name);
// Get public & private arg names
let fn_public_arg_names = method_args_iter.collect::<Vec<&str>>();
let fn_private_arg_names = fn_args
.iter()
.map(|arg|
unwrap_or_exit!(
arg.get_name(),
"Could not get private fn arg name for {}", entity_name))
.collect::<Vec<String>>();
// Get argument types
let fn_arg_types = fn_args.iter().map(|arg| arg.get_type()).collect::<Vec<Option<Type>>>();
let fn_arg_cstrs = fn_arg_types
.iter()
.map(|arg_ty| ty_to_cstr!(arg_ty, entity))
.collect::<Vec<String>>()
.join(", ");
// This this context, instance type is likely
gen_fmt!(gen_context, get_vtable, " {}(*{})({});\n", ret_ty_cstr, fn_name, fn_arg_cstrs);
// Generate the fn proto
let mut pub_names = fn_public_arg_names.clone();
pub_names.insert(0, fn_name);
let proto = if fn_private_arg_names.len() == 0 {
fn_name.clone().to_string()
} else {
fn_private_arg_names
.iter()
.zip(pub_names.iter())
.zip(fn_arg_types.iter())
.map(|((priv_name, pub_name), ty)| format!("{}:({}){}", pub_name, ty_to_cstr!(ty, entity), priv_name))
.collect::<Vec<String>>()
.join(" ")
};
// Add the vtable call
gen_fmt!(gen_context, get_impl, "- ({}){} {{\n ", ret_ty_cstr, proto);
// The local argument names
let arg_names = fn_private_arg_names.join(", ");
// Generates the call
let super_call = if fn_private_arg_names.len() == 0 {
fn_name.clone().to_string()
} else {
fn_private_arg_names
.iter()
.enumerate()
.map(|(index, priv_arg)| format!("{}: {}", pub_names[index], priv_arg))
.collect::<Vec<String>>()
.join(" ")
};
gen_fmt!(gen_context, get_impl, "[super {}];\n ", super_call);
// Determine if to return.
let does_return = ret_ty.map(|t| t.get_kind()).unwrap_or(TypeKind::Void) != TypeKind::Void;
if does_return {
gen_all!(gen_context, get_impl, b"return ");
}
gen_fmt!(gen_context, get_impl, "vtable->{}({});\n", fn_name, arg_names);
gen_all!(gen_context, get_impl, b"}\n\n");
// Write the ABI
let mangled_name = GenContext::mangle_entity(&entity);
gen_fmt!(gen_context, get_abi, "// {}\n", entity_name);
if fn_private_arg_names.len() == 0 {
gen_fmt!(gen_context, get_abi, "inline {} {}({}* __vsl_ocpp_self) {{\n ", ret_ty_cstr, mangled_name, parent_ty);
} else {
let mangled_args = fn_private_arg_names
.iter()
.zip(fn_arg_types.iter())
.map(|(name, ty)| {
let ty_string = ty_to_cstr!(ty, entity);
if ty_string == "void (^)()" {
format!("void (^{})()", name)
} else {
format!("{} {}", ty_string, name)
}
})
.collect::<Vec<String>>()
.join(", ");
gen_fmt!(gen_context, get_abi, "inline {} {}({}* __vsl_ocpp_self, {}) {{\n ", ret_ty_cstr, mangled_name, parent_ty, mangled_args);
}
if does_return {
gen_all!(gen_context, get_abi, b"return ")
}
// If no args then we won't use formatting
if fn_private_arg_names.len() == 0 {
gen_fmt!(gen_context, get_abi, "[__vsl_ocpp_self {} /* (void) */];\n", fn_name);
} else {
let pub_name_mappings = pub_names
.iter()
.zip(fn_private_arg_names)
.map(|(pub_name, priv_name)| format!("{}:{}", pub_name, priv_name))
.collect::<Vec<String>>()
.join(" ");
gen_fmt!(gen_context, get_abi, "[__vsl_ocpp_self {}];\n", pub_name_mappings);
}
gen_all!(gen_context, get_abi, b"}\n\n");
} else {
warn!("Could not get name for target resolution entity.");
}
}
|
use crate::{directory::Directory, persistence::vec_to_bytes};
use super::{super::*, *};
use std::{self, io, u32};
/// This data structure assumes that a set is only called once for a id, and ids are set in order.
#[derive(Debug, Clone)]
pub(crate) struct IndexIdToOneParentFlushing {
pub(crate) cache: Vec<u32>,
pub(crate) current_id_offset: u32,
directory: Box<dyn Directory>,
pub(crate) path: PathBuf,
pub(crate) metadata: IndexValuesMetadata,
}
impl IndexIdToOneParentFlushing {
pub(crate) fn new(directory: Box<dyn Directory>, path: PathBuf, max_value_id: u32) -> IndexIdToOneParentFlushing {
IndexIdToOneParentFlushing {
directory,
path,
metadata: IndexValuesMetadata {
max_value_id,
..Default::default()
},
cache: Default::default(),
current_id_offset: 0,
}
}
pub(crate) fn into_im_store(self) -> SingleArrayPacked<u32> {
let mut metadata = IndexValuesMetadata::default();
metadata.max_value_id = u32::MAX / 2; // only so that packed reads u32 bits TODO FIXME
metadata.avg_join_size = calc_avg_join_size(self.metadata.num_values, self.cache.len() as u32);
//load data with MMap
SingleArrayPacked::from_vec(vec_to_bytes(&self.cache), metadata)
}
#[inline]
pub(crate) fn add(&mut self, id: u32, val: u32) -> Result<(), io::Error> {
self.metadata.num_values += 1;
let id_pos = (id - self.current_id_offset) as usize;
if self.cache.len() <= id_pos {
//TODO this could become very big, check memory consumption upfront, and flush directly to disk, when a resize would step over a certain threshold @Memory
self.cache.resize(id_pos + 1, EMPTY_BUCKET);
}
self.cache[id_pos] = val + 1; //+1 because EMPTY_BUCKET = 0 is already reserved
if self.cache.len() * 4 >= 4_000_000 {
self.flush()?;
}
Ok(())
}
#[inline]
pub(crate) fn is_in_memory(&self) -> bool {
self.current_id_offset == 0
}
#[inline]
pub(crate) fn is_empty(&self) -> bool {
self.cache.is_empty() && self.current_id_offset == 0
}
pub(crate) fn flush(&mut self) -> Result<(), io::Error> {
if self.cache.is_empty() {
return Ok(());
}
self.current_id_offset += self.cache.len() as u32;
let bytes_required = get_bytes_required(self.metadata.max_value_id);
let mut bytes = Vec::new();
encode_vals(&self.cache, bytes_required, &mut bytes)?;
self.directory.append(&self.path, &bytes)?;
self.metadata.avg_join_size = calc_avg_join_size(self.metadata.num_values, self.current_id_offset + self.cache.len() as u32);
self.cache.clear();
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::persistence::*;
fn get_test_data_1_to_1() -> Vec<u32> {
vec![5, 6, 9, 9, 9, 50000]
}
fn check_test_data_1_to_1<T: IndexIdToParentData>(store: &dyn IndexIdToParent<Output = T>) {
// assert_eq!(store.get_keys().iter().map(|el| el.to_u32().unwrap()).collect::<Vec<_>>(), vec![0, 1, 2, 3, 4, 5]);
assert_eq!(store.get_value(0).unwrap().to_u32().unwrap(), 5);
assert_eq!(store.get_value(1).unwrap().to_u32().unwrap(), 6);
assert_eq!(store.get_value(2).unwrap().to_u32().unwrap(), 9);
assert_eq!(store.get_value(3).unwrap().to_u32().unwrap(), 9);
assert_eq!(store.get_value(4).unwrap().to_u32().unwrap(), 9);
assert_eq!(store.get_value(5).unwrap().to_u32().unwrap(), 50000);
assert_eq!(store.get_value(6), None);
let empty_vec: Vec<u32> = vec![];
assert_eq!(store.get_values_iter(0).collect::<Vec<u32>>(), vec![5]);
assert_eq!(store.get_values_iter(1).collect::<Vec<u32>>(), vec![6]);
assert_eq!(store.get_values_iter(2).collect::<Vec<u32>>(), vec![9]);
assert_eq!(store.get_values_iter(3).collect::<Vec<u32>>(), vec![9]);
assert_eq!(store.get_values_iter(4).collect::<Vec<u32>>(), vec![9]);
assert_eq!(store.get_values_iter(5).collect::<Vec<u32>>(), vec![50000]);
assert_eq!(store.get_values_iter(6).collect::<Vec<u32>>(), empty_vec);
assert_eq!(store.get_values_iter(11).collect::<Vec<u32>>(), empty_vec);
}
mod test_direct_1_to_1 {
use crate::directory::RamDirectory;
use super::*;
#[test]
fn test_index_id_to_parent_flushing() {
let directory: Box<dyn Directory> = Box::<RamDirectory>::default();
let path = Path::new("data");
let mut ind = IndexIdToOneParentFlushing::new(directory.box_clone(), path.to_owned(), *get_test_data_1_to_1().iter().max().unwrap());
for (key, val) in get_test_data_1_to_1().iter().enumerate() {
ind.add(key as u32, *val).unwrap();
ind.flush().unwrap();
}
let data = directory.get_file_bytes(path).unwrap();
let store = SingleArrayPacked::<u32>::from_data(data, ind.metadata);
check_test_data_1_to_1(&store);
}
#[test]
fn test_index_id_to_parent_im() {
let directory: Box<dyn Directory> = Box::<RamDirectory>::default();
let mut ind = IndexIdToOneParentFlushing::new(directory, Path::new("data").to_owned(), *get_test_data_1_to_1().iter().max().unwrap());
for (key, val) in get_test_data_1_to_1().iter().enumerate() {
ind.add(key as u32, *val).unwrap();
}
check_test_data_1_to_1(&ind.into_im_store());
}
}
mod test_indirect {
// use super::*;
// use rand::Rng;
// pub(crate) fn bench_fnvhashmap_group_by(num_entries: u32, max_val: u32) -> FnvHashMap<u32, u32> {
// let mut hits: FnvHashMap<u32, u32> = FnvHashMap::default();
// hits.reserve(num_entries as usize);
// let mut rng = rand::thread_rng();
// for _x in 0..num_entries {
// let stat = hits.entry(rng.gen_range(0, max_val)).or_insert(0);
// *stat += 1;
// }
// hits
// }
// pub(crate) fn bench_vec_group_by_direct(num_entries: u32, max_val: u32, hits: &mut Vec<u32>) -> &mut Vec<u32> {
// hits.resize(max_val as usize + 1, 0);
// let mut rng = rand::thread_rng();
// for _x in 0..num_entries {
// hits[rng.gen_range(0, max_val as usize)] += 1;
// }
// hits
// }
// pub(crate) fn bench_vec_group_by_direct_u8(num_entries: u32, max_val: u32, hits: &mut Vec<u8>) -> &mut Vec<u8> {
// hits.resize(max_val as usize + 1, 0);
// let mut rng = rand::thread_rng();
// for _x in 0..num_entries {
// hits[rng.gen_range(0, max_val as usize)] += 1;
// }
// hits
// }
// pub(crate) fn bench_vec_group_by_flex(num_entries: u32, max_val: u32) -> Vec<u32> {
// let mut hits: Vec<u32> = vec![];
// let mut rng = rand::thread_rng();
// for _x in 0..num_entries {
// let id = rng.gen_range(0, max_val as usize);
// if hits.len() <= id {
// hits.resize(id + 1, 0);
// }
// hits[id] += 1;
// }
// hits
// }
//20x break even ?
// #[bench]
// fn bench_group_by_fnvhashmap_0(b: &mut test::Bencher) {
// b.iter(|| {
// bench_fnvhashmap_group_by(700_000, 5_000_000);
// })
// }
// #[bench]
// fn bench_group_by_vec_direct_0(b: &mut test::Bencher) {
// b.iter(|| {
// bench_vec_group_by_direct(700_000, 5_000_000, &mut vec![]);
// })
// }
// #[bench]
// fn bench_group_by_vec_direct_u16_0(b: &mut test::Bencher) {
// b.iter(|| {
// bench_vec_group_by_direct_u8(700_000, 5_000_000, &mut vec![]);
// })
// }
// #[bench]
// fn bench_group_by_vec_direct_0_pre_alloc(b: &mut test::Bencher) {
// let mut dat = vec![];
// b.iter(|| {
// bench_vec_group_by_direct(700_000, 5_000_000, &mut dat);
// })
// }
// #[bench]
// fn bench_group_by_vec_flex_0(b: &mut test::Bencher) {
// b.iter(|| {
// bench_vec_group_by_flex(700_000, 5_000_000);
// })
// }
// #[bench]
// fn bench_group_by_rand_0(b: &mut test::Bencher) {
// b.iter(|| {
// bench_vec_group_by_rand(700_000, 50_000);
// })
// }
// #[bench]
// fn indirect_pointing_uncompressed_im(b: &mut test::Bencher) {
// let mut rng = rand::thread_rng();
// let between = Range::new(0, 40_000);
// let store = get_test_data_large(40_000, 15);
// let mayda = IndexIdToMultipleParent::<u32>::new(&store);
// b.iter(|| mayda.get_values(between.ind_sample(&mut rng)))
// }
}
}
|
use std::collections::HashMap;
fn process_group_union(group : &str) -> usize {
let mut total : Vec<char> =
group.chars()
.filter(|c| c.is_ascii_alphabetic())
.collect();
total.sort();
total.dedup();
total.len()
}
fn process_group_intersection(group : &str) -> usize {
let map : HashMap<char, usize> = HashMap::new();
let map =
group.chars()
.filter(|c| c.is_ascii_alphabetic())
.fold(map, |mut map, c| {
map.entry(c)
.and_modify(|x| *x += 1)
.or_insert(1);
map
} );
let lines : usize = group.lines().map(|_| 1).sum();
map.iter()
.map(|(_, &i)| if i == lines { 1 } else { 0 })
.sum()
}
fn process_all_groups_union(groups: &str) -> usize {
groups.split("\n\n")
.map(|group| process_group_union(group))
.sum()
}
fn process_all_groups_intersection(groups: &str) -> usize {
groups.split("\n\n")
.map(|group| process_group_intersection(group))
.sum()
}
fn main() {
let test_input = "\
abc
a
b
c
ab
ac
a
a
a
a
b";
println!("test groups val is {:?}", process_all_groups_union(test_input));
let real_input = include_str!("day6.txt");
println!("real groups val is {:?}", process_all_groups_union(real_input));
println!("test groups intersection is {:?}", process_all_groups_intersection(test_input));
println!("real groups intersection is {:?}", process_all_groups_intersection(real_input));
} |
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc;
use std::{thread, time};
use sharedlock_rs::SharedLock;
#[test]
fn test_dead_lock() {
let lock = SharedLock::new(0);
let guard1 = lock.write();
assert!(guard1.is_ok());
let guard2 = lock.write();
assert!(guard2.is_err());
}
#[test]
fn test_lock_busy() {
let lock = SharedLock::new(0);
let wg = lock.write();
assert!(wg.is_ok());
let rg = lock.read();
assert!(rg.is_err());
}
#[test]
fn test_common() {
let lock = SharedLock::new(5);
{
let r1 = lock.read().unwrap();
let r2 = lock.read().unwrap();
assert_eq!(*r1, 5);
assert_eq!(*r2, 5);
}
{
let mut w = lock.write().unwrap();
*w += 1;
assert_eq!(*w, 6);
}
}
#[test]
fn test_validity() {
const NUM_READERS: u32 = 8;
const NUM_WRITERS: u32 = 2;
const SLEEP_TIME_SEC: time::Duration = time::Duration::from_secs(6);
let lock = Arc::new(SharedLock::new(0));
let count = Arc::new(AtomicU64::new(0));
let shutdown = Arc::new(AtomicBool::new(false));
let mut handles = Vec::new();
for _ in 0..NUM_WRITERS {
let lock_clone = lock.clone();
let count_clone = count.clone();
let shutdown_clone = shutdown.clone();
handles.push(thread::spawn(move || {
while !shutdown_clone.load(Ordering::Acquire) {
let mut guard = lock_clone.write().unwrap();
*guard += 1;
count_clone.fetch_add(1, Ordering::SeqCst);
drop(guard);
}
}));
}
for _ in 0..NUM_READERS {
let lock_clone = lock.clone();
let count_clone = count.clone();
let shutdown_clone = shutdown.clone();
handles.push(thread::spawn(move || {
while !shutdown_clone.load(Ordering::Acquire) {
let guard = lock_clone.read().unwrap();
assert_eq!(*guard, count_clone.load(Ordering::SeqCst));
}
}));
}
thread::sleep(SLEEP_TIME_SEC);
shutdown.store(true, Ordering::Release);
for handle in handles {
handle.join().unwrap();
}
assert_eq!(count.load(Ordering::Acquire), *lock.write().unwrap());
}
|
use super::appsdb::AppDataBase;
pub fn backup() {
let mut database = AppDataBase::new();
let apps = database.get_apps();
for app in apps {
app.backup();
}
} |
pub fn simple_borrow_test() {
println!("{}", "-------------------------------");
let s1 = String::from("hello");
let s2 = s1;
// If we use s1,it will report a error;
// println!("{} has moved to s2",s1);
// error type: value used here after move
println!("{} has moved to s2", s2);
let mut s3 = String::from("hello");
let _test = "test";
//test is a &str type
//String::from create a String type
//&String is reference of String type
//slice is &str type
{
let s4 = &s3; // &s3 是一个不可变引用
// &s3 is immutable, we can't change s3 value by s4.
// although s4 is mutable, it mean s4 could point to another &str,i.e:&s8
println!("s3 value:{}", s3);
println!("s4 value:{}", s4);
}
{
let s4 = &mut s3; // &mut s3 是一个可变引用
// &mut s3 is mutable, we could change s3 value by s4.
// s4 is mutable, it mean s4 could point to another &str,i.e:&s8
s4.push_str("_ownership");
println!("s4 value:{}", s4);
// we can't use it because s3 has been borrowed as mutable
// println!("s3 value:{}",s3);
}
//borrow will return
println!("s3 value:{}", s3);
{
let mut s4 = s3;
s4.push_str("_ownership");
// println!("s3 value:{}", s3); s3 has been borrowed
// let s5 = s3; (value used here after move,s3 has been borrowed)
println!("s4 value:{}", s4);
}
let mut a = [1, 2, 3, 4, 5];
{
let slice = &mut a[1..3];
slice[0] = 100;
}
println!("a[1] value: {}", a[1]);
println!("{}", "-------------------------------");
}
pub fn clone_copy_test() {
//Cloning is an explicit action, x.clone().
println!("{}", "-------------------------------");
let s1 = String::from("hello");
let s2 = s1.clone();
println!("{} ,{} test clone", s1, s2);
//Copies happen implicitly, for example as part of an assignment y = x
let mut x = 5;
let mut y = x;
println!("x value is:{}", x);
println!("y value is:{}", y);
x = 3;
y = 2;
println!("x value is:{}", x);
println!("y value is:{}", y);
println!("{}", "-------------------------------");
//Clone is a supertrait of Copy, so everything which is Copy must also implement Clone
}
pub fn move_test() {
println!("{}", "---------------move_test start----------------");
let s3 = String::from("hello");
{
let mut s4 = s3;
s4.push_str("_ownership")
}
// It will return error: value used here after move
// println!("s3 value:{}", s3);
// move will not return
println!("{}", "---------------move_test end ----------------");
}
|
use super::WidgetDimensions;
#[derive(Clone, Copy)]
pub struct LayoutHacks {
pub expand_horizontally: bool,
pub expand_vertically: bool,
// NYEO NOTE: It's completely OK for these to be settable to arbitrary values because the min/max constraints will be handled in tailor()
pub preferred_width: Option<usize>,
pub preferred_height: Option<usize>,
}
impl LayoutHacks {
pub fn new() -> LayoutHacks {
LayoutHacks {
expand_horizontally: false,
expand_vertically: false,
preferred_width: None,
preferred_height: None,
}
}
pub fn apply(&self, mut wd: WidgetDimensions) -> WidgetDimensions {
if self.expand_horizontally {
wd.horizontal_spacer_count = wd.horizontal_spacer_count.max(1);
};
if self.expand_vertically {
wd.vertical_spacer_count = wd.vertical_spacer_count.max(1);
};
if let Some(w) = self.preferred_width {
wd.preferred.width = w as isize;
wd.min.width = wd.min.width.min(w as isize);
}
if let Some(h) = self.preferred_height {
wd.preferred.height = h as isize;
wd.min.height = wd.min.height.min(h as isize);
}
wd
}
} |
// This file is part of Substrate.
// Copyright (C) 2018-2020 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// 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 sp_std::collections::btree_map::BTreeMap;
use sp_std::fmt;
use wasmi::{
Externals, FuncInstance, FuncRef, GlobalDescriptor, GlobalRef, ImportResolver,
MemoryDescriptor, MemoryInstance, MemoryRef, Module, ModuleInstance, ModuleRef,
RuntimeArgs, RuntimeValue, Signature, TableDescriptor, TableRef, Trap, TrapKind
};
use wasmi::memory_units::Pages;
use super::{Error, Value, ReturnValue, HostFuncType, HostError};
#[derive(Clone)]
pub struct Memory {
memref: MemoryRef,
}
impl Memory {
pub fn new(initial: u32, maximum: Option<u32>) -> Result<Memory, Error> {
Ok(Memory {
memref: MemoryInstance::alloc(
Pages(initial as usize),
maximum.map(|m| Pages(m as usize)),
).map_err(|_| Error::Module)?,
})
}
pub fn get(&self, ptr: u32, buf: &mut [u8]) -> Result<(), Error> {
self.memref.get_into(ptr, buf).map_err(|_| Error::OutOfBounds)?;
Ok(())
}
pub fn set(&self, ptr: u32, value: &[u8]) -> Result<(), Error> {
self.memref.set(ptr, value).map_err(|_| Error::OutOfBounds)?;
Ok(())
}
}
struct HostFuncIndex(usize);
struct DefinedHostFunctions<T> {
funcs: Vec<HostFuncType<T>>,
}
impl<T> Clone for DefinedHostFunctions<T> {
fn clone(&self) -> DefinedHostFunctions<T> {
DefinedHostFunctions {
funcs: self.funcs.clone(),
}
}
}
impl<T> DefinedHostFunctions<T> {
fn new() -> DefinedHostFunctions<T> {
DefinedHostFunctions {
funcs: Vec::new(),
}
}
fn define(&mut self, f: HostFuncType<T>) -> HostFuncIndex {
let idx = self.funcs.len();
self.funcs.push(f);
HostFuncIndex(idx)
}
}
#[derive(Debug)]
struct DummyHostError;
impl fmt::Display for DummyHostError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "DummyHostError")
}
}
impl wasmi::HostError for DummyHostError {}
struct GuestExternals<'a, T: 'a> {
state: &'a mut T,
defined_host_functions: &'a DefinedHostFunctions<T>,
}
impl<'a, T> Externals for GuestExternals<'a, T> {
fn invoke_index(
&mut self,
index: usize,
args: RuntimeArgs,
) -> Result<Option<RuntimeValue>, Trap> {
let args = args.as_ref()
.iter()
.cloned()
.map(Into::into)
.collect::<Vec<_>>();
let result = (self.defined_host_functions.funcs[index])(self.state, &args);
match result {
Ok(value) => Ok(match value {
ReturnValue::Value(v) => Some(v.into()),
ReturnValue::Unit => None,
}),
Err(HostError) => Err(TrapKind::Host(Box::new(DummyHostError)).into()),
}
}
}
enum ExternVal {
HostFunc(HostFuncIndex),
Memory(Memory),
}
pub struct EnvironmentDefinitionBuilder<T> {
map: BTreeMap<(Vec<u8>, Vec<u8>), ExternVal>,
defined_host_functions: DefinedHostFunctions<T>,
}
impl<T> EnvironmentDefinitionBuilder<T> {
pub fn new() -> EnvironmentDefinitionBuilder<T> {
EnvironmentDefinitionBuilder {
map: BTreeMap::new(),
defined_host_functions: DefinedHostFunctions::new(),
}
}
pub fn add_host_func<N1, N2>(&mut self, module: N1, field: N2, f: HostFuncType<T>)
where
N1: Into<Vec<u8>>,
N2: Into<Vec<u8>>,
{
let idx = self.defined_host_functions.define(f);
self.map
.insert((module.into(), field.into()), ExternVal::HostFunc(idx));
}
pub fn add_memory<N1, N2>(&mut self, module: N1, field: N2, mem: Memory)
where
N1: Into<Vec<u8>>,
N2: Into<Vec<u8>>,
{
self.map
.insert((module.into(), field.into()), ExternVal::Memory(mem));
}
}
impl<T> ImportResolver for EnvironmentDefinitionBuilder<T> {
fn resolve_func(
&self,
module_name: &str,
field_name: &str,
signature: &Signature,
) -> Result<FuncRef, wasmi::Error> {
let key = (
module_name.as_bytes().to_owned(),
field_name.as_bytes().to_owned(),
);
let externval = self.map.get(&key).ok_or_else(|| {
wasmi::Error::Instantiation(format!("Export {}:{} not found", module_name, field_name))
})?;
let host_func_idx = match *externval {
ExternVal::HostFunc(ref idx) => idx,
_ => {
return Err(wasmi::Error::Instantiation(format!(
"Export {}:{} is not a host func",
module_name, field_name
)))
}
};
Ok(FuncInstance::alloc_host(signature.clone(), host_func_idx.0))
}
fn resolve_global(
&self,
_module_name: &str,
_field_name: &str,
_global_type: &GlobalDescriptor,
) -> Result<GlobalRef, wasmi::Error> {
Err(wasmi::Error::Instantiation(format!(
"Importing globals is not supported yet"
)))
}
fn resolve_memory(
&self,
module_name: &str,
field_name: &str,
_memory_type: &MemoryDescriptor,
) -> Result<MemoryRef, wasmi::Error> {
let key = (
module_name.as_bytes().to_owned(),
field_name.as_bytes().to_owned(),
);
let externval = self.map.get(&key).ok_or_else(|| {
wasmi::Error::Instantiation(format!("Export {}:{} not found", module_name, field_name))
})?;
let memory = match *externval {
ExternVal::Memory(ref m) => m,
_ => {
return Err(wasmi::Error::Instantiation(format!(
"Export {}:{} is not a memory",
module_name, field_name
)))
}
};
Ok(memory.memref.clone())
}
fn resolve_table(
&self,
_module_name: &str,
_field_name: &str,
_table_type: &TableDescriptor,
) -> Result<TableRef, wasmi::Error> {
Err(wasmi::Error::Instantiation(format!(
"Importing tables is not supported yet"
)))
}
}
pub struct Instance<T> {
instance: ModuleRef,
defined_host_functions: DefinedHostFunctions<T>,
_marker: std::marker::PhantomData<T>,
}
impl<T> Instance<T> {
pub fn new(
code: &[u8],
env_def_builder: &EnvironmentDefinitionBuilder<T>,
state: &mut T,
) -> Result<Instance<T>, Error> {
let module = Module::from_buffer(code).map_err(|_| Error::Module)?;
let not_started_instance = ModuleInstance::new(&module, env_def_builder)
.map_err(|_| Error::Module)?;
let defined_host_functions = env_def_builder.defined_host_functions.clone();
let instance = {
let mut externals = GuestExternals {
state,
defined_host_functions: &defined_host_functions,
};
let instance = not_started_instance.run_start(&mut externals)
.map_err(|_| Error::Execution)?;
instance
};
Ok(Instance {
instance,
defined_host_functions,
_marker: std::marker::PhantomData::<T>,
})
}
pub fn invoke(
&mut self,
name: &str,
args: &[Value],
state: &mut T,
) -> Result<ReturnValue, Error> {
let args = args.iter().cloned().map(Into::into).collect::<Vec<_>>();
let mut externals = GuestExternals {
state,
defined_host_functions: &self.defined_host_functions,
};
let result = self.instance
.invoke_export(&name, &args, &mut externals);
match result {
Ok(None) => Ok(ReturnValue::Unit),
Ok(Some(val)) => Ok(ReturnValue::Value(val.into())),
Err(_err) => Err(Error::Execution),
}
}
pub fn get_global_val(&self, name: &str) -> Option<Value> {
let global = self.instance
.export_by_name(name)?
.as_global()?
.get();
Some(global.into())
}
}
#[cfg(test)]
mod tests {
use crate::{Error, Value, ReturnValue, HostError, EnvironmentDefinitionBuilder, Instance};
use assert_matches::assert_matches;
fn execute_sandboxed(code: &[u8], args: &[Value]) -> Result<ReturnValue, HostError> {
struct State {
counter: u32,
}
fn env_assert(_e: &mut State, args: &[Value]) -> Result<ReturnValue, HostError> {
if args.len() != 1 {
return Err(HostError);
}
let condition = args[0].as_i32().ok_or_else(|| HostError)?;
if condition != 0 {
Ok(ReturnValue::Unit)
} else {
Err(HostError)
}
}
fn env_inc_counter(e: &mut State, args: &[Value]) -> Result<ReturnValue, HostError> {
if args.len() != 1 {
return Err(HostError);
}
let inc_by = args[0].as_i32().ok_or_else(|| HostError)?;
e.counter += inc_by as u32;
Ok(ReturnValue::Value(Value::I32(e.counter as i32)))
}
/// Function that takes one argument of any type and returns that value.
fn env_polymorphic_id(_e: &mut State, args: &[Value]) -> Result<ReturnValue, HostError> {
if args.len() != 1 {
return Err(HostError);
}
Ok(ReturnValue::Value(args[0]))
}
let mut state = State { counter: 0 };
let mut env_builder = EnvironmentDefinitionBuilder::new();
env_builder.add_host_func("env", "assert", env_assert);
env_builder.add_host_func("env", "inc_counter", env_inc_counter);
env_builder.add_host_func("env", "polymorphic_id", env_polymorphic_id);
let mut instance = Instance::new(code, &env_builder, &mut state)?;
let result = instance.invoke("call", args, &mut state);
result.map_err(|_| HostError)
}
#[test]
fn invoke_args() {
let code = wat::parse_str(r#"
(module
(import "env" "assert" (func $assert (param i32)))
(func (export "call") (param $x i32) (param $y i64)
;; assert that $x = 0x12345678
(call $assert
(i32.eq
(get_local $x)
(i32.const 0x12345678)
)
)
(call $assert
(i64.eq
(get_local $y)
(i64.const 0x1234567887654321)
)
)
)
)
"#).unwrap();
let result = execute_sandboxed(
&code,
&[
Value::I32(0x12345678),
Value::I64(0x1234567887654321),
]
);
assert!(result.is_ok());
}
#[test]
fn return_value() {
let code = wat::parse_str(r#"
(module
(func (export "call") (param $x i32) (result i32)
(i32.add
(get_local $x)
(i32.const 1)
)
)
)
"#).unwrap();
let return_val = execute_sandboxed(
&code,
&[
Value::I32(0x1336),
]
).unwrap();
assert_eq!(return_val, ReturnValue::Value(Value::I32(0x1337)));
}
#[test]
fn signatures_dont_matter() {
let code = wat::parse_str(r#"
(module
(import "env" "polymorphic_id" (func $id_i32 (param i32) (result i32)))
(import "env" "polymorphic_id" (func $id_i64 (param i64) (result i64)))
(import "env" "assert" (func $assert (param i32)))
(func (export "call")
;; assert that we can actually call the "same" function with different
;; signatures.
(call $assert
(i32.eq
(call $id_i32
(i32.const 0x012345678)
)
(i32.const 0x012345678)
)
)
(call $assert
(i64.eq
(call $id_i64
(i64.const 0x0123456789abcdef)
)
(i64.const 0x0123456789abcdef)
)
)
)
)
"#).unwrap();
let return_val = execute_sandboxed(&code, &[]).unwrap();
assert_eq!(return_val, ReturnValue::Unit);
}
#[test]
fn cant_return_unmatching_type() {
fn env_returns_i32(_e: &mut (), _args: &[Value]) -> Result<ReturnValue, HostError> {
Ok(ReturnValue::Value(Value::I32(42)))
}
let mut env_builder = EnvironmentDefinitionBuilder::new();
env_builder.add_host_func("env", "returns_i32", env_returns_i32);
let code = wat::parse_str(r#"
(module
;; It's actually returns i32, but imported as if it returned i64
(import "env" "returns_i32" (func $returns_i32 (result i64)))
(func (export "call")
(drop
(call $returns_i32)
)
)
)
"#).unwrap();
// It succeeds since we are able to import functions with types we want.
let mut instance = Instance::new(&code, &env_builder, &mut ()).unwrap();
// But this fails since we imported a function that returns i32 as if it returned i64.
assert_matches!(
instance.invoke("call", &[], &mut ()),
Err(Error::Execution)
);
}
}
|
use crate::arena::{block, resource, BlockMut, BlockRef};
use crate::libs::random_id::U128Id;
use std::rc::Rc;
#[derive(Clone)]
pub enum TableTool {
Selecter(Rc<Selecter>),
Craftboard(Rc<Craftboard>),
Pen(Rc<Pen>),
Eraser(Rc<Eraser>),
Character(Rc<Character>),
Boxblock(Rc<Boxblock>),
TerranBlock(Rc<TerranBlock>),
Textboard(Rc<Textboard>),
ComponentAllocater(Rc<ComponentAllocater>),
}
#[derive(Clone)]
pub enum Selecter {
Point,
Range,
}
#[derive(Clone)]
pub struct Craftboard {
pub size: [f64; 3],
}
#[derive(Clone)]
pub struct Pen {
pub color: crate::libs::color::Pallet,
pub width: f64,
}
#[derive(Clone)]
pub struct Eraser {
pub width: f64,
}
#[derive(Clone)]
pub struct Character {
pub size: f64,
pub tex_size: f64,
pub color: crate::libs::color::Pallet,
pub texture: Option<BlockRef<resource::ImageData>>,
}
#[derive(Clone)]
pub struct Boxblock {
pub color: crate::libs::color::Pallet,
pub size: [f64; 3],
pub texture: Option<BlockRef<resource::BlockTexture>>,
pub shape: block::boxblock::Shape,
}
#[derive(Clone)]
pub struct TerranBlock {
pub kind: TerranBlockKind,
pub texture: Option<BlockMut<block::TerranTexture>>,
pub allocater_state: TerranBlockAllocater,
}
#[derive(Clone, PartialEq, Eq)]
pub enum TerranBlockKind {
Allocater,
Eraser,
}
#[derive(Clone)]
pub struct TerranBlockAllocater {
pub tex_idx: u32,
}
#[derive(Clone)]
pub struct Textboard {}
#[derive(Clone)]
pub struct ComponentAllocater {
pub component: U128Id,
}
|
//! Acquisition functions
use nalgebra::DVector;
use statrs::distribution::{Continuous, Normal, Univariate};
/// Expected improvement utility function.
#[derive(Debug)]
pub struct ExpectedImprovement {
/// Exploitation-exploration trade-off parameter
pub xi: f64,
}
impl Default for ExpectedImprovement {
fn default() -> Self {
ExpectedImprovement { xi: 0f64 }
}
}
impl ExpectedImprovement {
pub fn apply(
&self,
y_mean: DVector<f64>,
std: DVector<f64>,
y_max: f64,
distribution: &Normal,
) -> DVector<f64> {
let n = y_mean.len();
let y = y_mean.add_scalar(-y_max - self.xi);
let z = y.component_div(&std);
let cdf = DVector::from_iterator(n, z.iter().map(|&o| distribution.cdf(o)));
let pdf = DVector::from_iterator(n, z.iter().map(|&o| distribution.pdf(o)));
(y.component_mul(&cdf)) + (std.component_mul(&pdf))
}
}
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_abs_diff_eq;
#[test]
fn expected_improvement_test() {
let distribution = Normal::new(0.0, 1.0).unwrap();
let ei = ExpectedImprovement::default();
let y_mean = DVector::from_vec(vec![0.5]);
let std = DVector::from_vec(vec![0.15]);
let res = ei.apply(y_mean, std, 0.56, &distribution);
let expected = DVector::from_vec(vec![0.034]);
assert_abs_diff_eq!(res, expected, epsilon = 0.01);
}
}
|
#![no_std]
pub use embedded_hal as ehal;
pub use esp8266 as target;
pub use esp8266_hal_proc_macros::{interrupt, ram};
#[cfg(feature = "rt")]
pub use xtensa_lx_rt::{entry, exception};
#[cfg(all(feature = "rt", feature = "interrupt"))]
#[macro_use]
pub mod interrupt;
pub mod efuse;
pub mod flash;
pub mod gpio;
pub mod prelude;
pub mod rng;
pub mod rtccntl;
pub mod spi;
pub mod time;
pub mod timer;
pub mod uart;
pub mod watchdog;
/// Function handling ESP8266 specific initialization
/// then calls original Reset function
///
/// ENTRY point is defined in memory.x
/// *Note: the pre_init function is called in the original reset handler
/// after the initializations done in this function*
#[cfg(feature = "rt")]
#[doc(hidden)]
#[no_mangle]
#[ram]
pub unsafe extern "C" fn ESP8266Reset() -> ! {
// These symbols come from `memory.x`
extern "C" {
static mut _rtc_bss_start: u32;
static mut _rtc_bss_end: u32;
}
// configure the pll for the most common crystal frequency
use esp8266::Peripherals;
use rtccntl::{CrystalFrequency, RtcControlExt};
let mut dp = Peripherals::steal();
flash::cache_enable(&mut dp.SPI0, 0);
dp.RTCCNTL
.rtc_control()
.set_crystal_frequency(CrystalFrequency::Crystal26MHz);
// Initialize RTC RAM
xtensa_lx_rt::zero_bss(&mut _rtc_bss_start, &mut _rtc_bss_end);
// continue with default reset handler
xtensa_lx_rt::Reset();
}
|
#![cfg_attr(feature = "clippy", feature(plugin))]
#![cfg_attr(feature = "clippy", plugin(clippy))]
/*
Copyright 2017 Takashi Ogura
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.
*/
extern crate kiss3d;
extern crate nalgebra as na;
extern crate ncollide;
extern crate rand;
extern crate rrt;
use kiss3d::window::Window;
use kiss3d::light::Light;
use na::{Isometry3, Vector3};
use ncollide::shape::{Ball, Cuboid};
use ncollide::query;
use ncollide::ncollide_geometry::query::Proximity;
use rand::distributions::{IndependentSample, Range};
struct CollisionProblem {
obstacle: Cuboid<na::Vector3<f32>>,
ball: Ball<f32>,
}
impl CollisionProblem {
fn is_feasible(&self, point: &[f64]) -> bool {
let cuboid_pos = Isometry3::new(Vector3::new(0.0f32, 0.0, 0.0), na::zero());
let ball_pos = Isometry3::new(
Vector3::new(point[0] as f32, point[1] as f32, point[2] as f32),
na::zero(),
);
let prediction = 0.1;
let ctct = query::proximity(
&ball_pos,
&self.ball,
&cuboid_pos,
&self.obstacle,
prediction,
);
ctct == Proximity::Disjoint
}
fn random_sample(&self) -> Vec<f64> {
let between = Range::new(-4.0, 4.0);
let mut rng = rand::thread_rng();
vec![
between.ind_sample(&mut rng),
between.ind_sample(&mut rng),
between.ind_sample(&mut rng),
]
}
}
fn main() {
let mut window = Window::new("rrt test");
window.set_light(Light::StickToCamera);
let p = CollisionProblem {
obstacle: Cuboid::new(Vector3::new(0.05f32, 0.25, 0.15)),
ball: Ball::new(0.05f32),
};
let mut c1 = window.add_cube(
p.obstacle.half_extents()[0] * 2.0,
p.obstacle.half_extents()[1] * 2.0,
p.obstacle.half_extents()[2] * 2.0,
);
c1.set_color(1.0, 0.0, 0.0);
let mut cs = window.add_cube(0.05, 0.05, 0.05);
cs.set_color(0.0, 0.0, 1.0);
let mut cg = window.add_cube(0.05, 0.05, 0.05);
cg.set_color(0.0, 1.0, 0.0);
let mut c2 = window.add_sphere(p.ball.radius());
c2.set_color(0.0, 1.0, 1.0);
let start = [0.2f64, 0.2, 0.2];
let goal = [-0.2f64, -0.2, -0.2];
let poss = Isometry3::new(
Vector3::new(start[0] as f32, start[1] as f32, start[2] as f32),
na::zero(),
);
let posg = Isometry3::new(
Vector3::new(goal[0] as f32, goal[1] as f32, goal[2] as f32),
na::zero(),
);
cs.set_local_transformation(poss);
cg.set_local_transformation(posg);
let mut path = vec![];
let mut index = 0;
while window.render() {
if index == path.len() {
path = rrt::dual_rrt_connect(
&start,
&goal,
|x: &[f64]| p.is_feasible(x),
|| p.random_sample(),
0.05,
1000,
).unwrap();
rrt::smooth_path(&mut path, |x: &[f64]| p.is_feasible(x), 0.05, 100);
index = 0;
}
let point = &path[index % path.len()];
let pos = Isometry3::new(
Vector3::new(point[0] as f32, point[1] as f32, point[2] as f32),
na::zero(),
);
c2.set_local_transformation(pos);
index += 1;
}
}
|
use crate::directory::Directory;
use crate::error::Error;
use crate::inherit::InheritEdition;
use crate::manifest::Edition;
use serde::de::value::MapAccessDeserializer;
use serde::de::value::StrDeserializer;
use serde::de::{self, Deserialize, Deserializer, Visitor};
use serde::ser::{Serialize, Serializer};
use serde_derive::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::BTreeMap as Map;
use std::fmt;
use std::fs;
use std::path::PathBuf;
pub fn get_manifest(manifest_dir: &Directory) -> Result<Manifest, Error> {
let cargo_toml_path = manifest_dir.join("Cargo.toml");
let mut manifest = (|| {
let manifest_str = fs::read_to_string(&cargo_toml_path)?;
let manifest: Manifest = basic_toml::from_str(&manifest_str)?;
Ok(manifest)
})()
.map_err(|err| Error::GetManifest(cargo_toml_path, Box::new(err)))?;
fix_dependencies(&mut manifest.dependencies, manifest_dir);
fix_dependencies(&mut manifest.dev_dependencies, manifest_dir);
for target in manifest.target.values_mut() {
fix_dependencies(&mut target.dependencies, manifest_dir);
fix_dependencies(&mut target.dev_dependencies, manifest_dir);
}
Ok(manifest)
}
pub fn get_workspace_manifest(manifest_dir: &Directory) -> WorkspaceManifest {
try_get_workspace_manifest(manifest_dir).unwrap_or_default()
}
pub fn try_get_workspace_manifest(manifest_dir: &Directory) -> Result<WorkspaceManifest, Error> {
let cargo_toml_path = manifest_dir.join("Cargo.toml");
let manifest_str = fs::read_to_string(cargo_toml_path)?;
let mut manifest: WorkspaceManifest = basic_toml::from_str(&manifest_str)?;
fix_dependencies(&mut manifest.workspace.dependencies, manifest_dir);
fix_patches(&mut manifest.patch, manifest_dir);
fix_replacements(&mut manifest.replace, manifest_dir);
Ok(manifest)
}
fn fix_dependencies(dependencies: &mut Map<String, Dependency>, dir: &Directory) {
dependencies.remove("trybuild");
for dep in dependencies.values_mut() {
dep.path = dep.path.as_ref().map(|path| Directory::new(dir.join(path)));
}
}
fn fix_patches(patches: &mut Map<String, RegistryPatch>, dir: &Directory) {
for registry in patches.values_mut() {
registry.crates.remove("trybuild");
for patch in registry.crates.values_mut() {
patch.path = patch.path.as_ref().map(|path| dir.join(path));
}
}
}
fn fix_replacements(replacements: &mut Map<String, Patch>, dir: &Directory) {
replacements.remove("trybuild");
for replacement in replacements.values_mut() {
replacement.path = replacement.path.as_ref().map(|path| dir.join(path));
}
}
#[derive(Deserialize, Default, Debug)]
pub struct WorkspaceManifest {
#[serde(default)]
pub workspace: WorkspaceWorkspace,
#[serde(default)]
pub patch: Map<String, RegistryPatch>,
#[serde(default)]
pub replace: Map<String, Patch>,
}
#[derive(Deserialize, Default, Debug)]
pub struct WorkspaceWorkspace {
#[serde(default)]
pub package: WorkspacePackage,
#[serde(default)]
pub dependencies: Map<String, Dependency>,
}
#[derive(Deserialize, Default, Debug)]
pub struct WorkspacePackage {
pub edition: Option<Edition>,
}
#[derive(Deserialize, Default, Debug)]
pub struct Manifest {
#[serde(default)]
pub package: Package,
#[serde(default)]
pub features: Map<String, Vec<String>>,
#[serde(default)]
pub dependencies: Map<String, Dependency>,
#[serde(default, alias = "dev-dependencies")]
pub dev_dependencies: Map<String, Dependency>,
#[serde(default)]
pub target: Map<String, TargetDependencies>,
}
#[derive(Deserialize, Default, Debug)]
pub struct Package {
pub name: String,
#[serde(default)]
pub edition: EditionOrInherit,
pub resolver: Option<String>,
}
#[derive(Debug)]
pub enum EditionOrInherit {
Edition(Edition),
Inherit,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(remote = "Self")]
pub struct Dependency {
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<Directory>,
#[serde(default, skip_serializing_if = "is_false")]
pub optional: bool,
#[serde(
rename = "default-features",
default = "get_true",
skip_serializing_if = "is_true"
)]
pub default_features: bool,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub features: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub git: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub branch: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tag: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rev: Option<String>,
#[serde(default, skip_serializing_if = "is_false")]
pub workspace: bool,
#[serde(flatten)]
pub rest: Map<String, Value>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct TargetDependencies {
#[serde(default, skip_serializing_if = "Map::is_empty")]
pub dependencies: Map<String, Dependency>,
#[serde(
default,
alias = "dev-dependencies",
skip_serializing_if = "Map::is_empty"
)]
pub dev_dependencies: Map<String, Dependency>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(transparent)]
pub struct RegistryPatch {
pub crates: Map<String, Patch>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct Patch {
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<PathBuf>,
#[serde(skip_serializing_if = "Option::is_none")]
pub git: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub branch: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tag: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rev: Option<String>,
#[serde(flatten)]
pub rest: Map<String, Value>,
}
fn get_true() -> bool {
true
}
fn is_true(boolean: &bool) -> bool {
*boolean
}
fn is_false(boolean: &bool) -> bool {
!*boolean
}
impl Default for EditionOrInherit {
fn default() -> Self {
EditionOrInherit::Edition(Edition::default())
}
}
impl<'de> Deserialize<'de> for EditionOrInherit {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct EditionOrInheritVisitor;
impl<'de> Visitor<'de> for EditionOrInheritVisitor {
type Value = EditionOrInherit;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("edition")
}
fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
Edition::deserialize(StrDeserializer::new(s)).map(EditionOrInherit::Edition)
}
fn visit_map<M>(self, map: M) -> Result<Self::Value, M::Error>
where
M: de::MapAccess<'de>,
{
InheritEdition::deserialize(MapAccessDeserializer::new(map))?;
Ok(EditionOrInherit::Inherit)
}
}
deserializer.deserialize_any(EditionOrInheritVisitor)
}
}
impl Serialize for Dependency {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
Dependency::serialize(self, serializer)
}
}
impl<'de> Deserialize<'de> for Dependency {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct DependencyVisitor;
impl<'de> Visitor<'de> for DependencyVisitor {
type Value = Dependency;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str(
"a version string like \"0.9.8\" or a \
dependency like { version = \"0.9.8\" }",
)
}
fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Dependency {
version: Some(s.to_owned()),
path: None,
optional: false,
default_features: true,
features: Vec::new(),
git: None,
branch: None,
tag: None,
rev: None,
workspace: false,
rest: Map::new(),
})
}
fn visit_map<M>(self, map: M) -> Result<Self::Value, M::Error>
where
M: de::MapAccess<'de>,
{
Dependency::deserialize(MapAccessDeserializer::new(map))
}
}
deserializer.deserialize_any(DependencyVisitor)
}
}
|
use crate::util::lines_from_file;
pub fn day20() {
println!("== Day 20 ==");
let input = lines_from_file("src/day20/input.txt");
let a = part_a(&input);
println!("Part A: {}", a);
let b = part_b(&input);
println!("Part B: {}", b);
}
fn part_a(input: &Vec<String>) -> usize {
solve(input, 2)
}
fn part_b(input: &Vec<String>) -> usize {
solve(input, 50)
}
fn solve(input: &Vec<String>, iterations: u32) -> usize {
let algorithm = input.get(0).unwrap().chars().collect::<Vec<char>>();
let image: Vec<Vec<char>> = input.iter()
.skip(2)
.map(|l| l.chars().collect::<Vec<char>>())
.collect();
// println!("{:?}", algorithm);
// println!("{:?}", image);
// print_image(&image);
// println!();
let mut img = image.clone();
for i in 0..iterations {
// println!("{} {}", i, i % 2);
img = enhance(&algorithm, &img, i);
// print_image(&img);
// println!();
}
img.iter()
.flatten()
.filter(|c| **c == '#')
.count()
}
#[allow(dead_code)]
fn print_image(image: &Vec<Vec<char>>) {
for row in image.iter() {
let string = row.iter().collect::<String>();
println!("{}", string);
}
}
fn enhance(algorithm: &Vec<char>, image: &Vec<Vec<char>>, iteration: u32) -> Vec<Vec<char>> {
let rd = [-1, -1, -1, 0, 0, 0, 1, 1, 1];
let cd = [-1, 0, 1, -1, 0, 1, -1, 0, 1];
let rows = image.len();
let cols = image.get(0).unwrap().len();
let border = 1;
let scan_rows = (rows + border) as i32;
let scan_cols = (cols + border) as i32;
let scan_start = border as i32 * -1;
// println!("({},{}) :: ({},{})", rows, cols, scan_rows,scan_cols);
let mut new_image_info = Vec::new();
for r_index in scan_start..scan_rows {
// In input image
let mut new_row = Vec::new();
for c_index in scan_start..scan_cols {
let mut pixels = Vec::new();
for i in 0..rd.len() {
let rr = r_index as i32 + rd[i];
let cc = c_index as i32 + cd[i];
if rr < 0 || cc < 0 || rr >= rows as i32 || cc >= cols as i32 {
// So a ['.'; 9] maps to algorithm[0], what does [algorithm[0]; 9] produce
// on the next iteration?
// The world flickers for each step. The test data does not show this as
// algorithm[0] in that case is a '.', but our data that is '#' which means
// the next iteration we have 512 as the read value (happens to be a '.' in our
// case, but a '#' in the test data)
if iteration % 2 == 0 {
pixels.push('.');
} else {
pixels.push(algorithm[0]);
}
} else {
pixels.push(image[rr as usize][cc as usize]);
}
}
let pixel_string = pixels.iter()
.map(|c| {
match c {
'.' => '0',
'#' => '1',
_ => unreachable!()
}
}).collect::<String>();
let result = u32::from_str_radix(pixel_string.as_str(), 2).unwrap();
new_row.push(result);
}
new_image_info.push(new_row);
}
// for r in new_image_info.iter() {
// println!("{:?}", r);
// }
// println!("{:?}", new_image_info);
let vec = new_image_info.iter()
.map(|r| r.iter()
.map(|c| *algorithm.get(*c as usize).unwrap())
.collect::<Vec<char>>()
).collect::<Vec<Vec<char>>>();
// println!("{:?}", vec);
vec
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn part_a_test_input() {
let filename = "src/day20/test-input.txt";
let input = lines_from_file(filename);
let result = part_a(&input);
assert_eq!(35, result)
}
#[test]
fn part_a_real() {
let filename = "src/day20/input.txt";
let input = lines_from_file(filename);
let result = part_a(&input);
assert_eq!(true, 5413 > result);
assert_ne!(5352, result);
assert_eq!(5400, result);
}
#[test]
fn part_b_test_input() {
let filename = "src/day20/test-input.txt";
let input = lines_from_file(filename);
let result = part_b(&input);
assert_eq!(3351, result)
}
#[test]
fn part_b_real() {
let filename = "src/day20/input.txt";
let input = lines_from_file(filename);
let result = part_b(&input);
assert_eq!(18989, result);
}
}
|
use std::collections::HashMap;
use itertools::Itertools;
fn find_house(n: u64) -> u64 {
let mut houses: HashMap<u64, u64> = HashMap::new();
for i in 1..=(n / 10) {
for j in (i..=(n / 10)).step_by(i as usize) {
*houses.entry(j).or_insert(0) += i * 10;
}
}
houses.into_iter()
.filter_map(|(k, v)| if v >= n { Some(k)} else {None})
.sorted()
.collect::<Vec<_>>()[0]
.to_owned()
}
fn find_house_lazy_elves(n: u64) -> u64 {
let mut houses: HashMap<u64, u64> = HashMap::new();
for i in 1..=(n / 10) {
for j in (i..=(n / 10)).step_by(i as usize).take(50) {
*houses.entry(j).or_insert(0) += i * 11;
}
}
houses.into_iter()
.filter_map(|(k, v)| if v >= n { Some(k)} else {None})
.sorted()
.collect::<Vec<_>>()[0]
.to_owned()
}
pub fn run() -> String {
find_house(34_000_000).to_string()
}
pub fn run_pt2() -> String {
find_house_lazy_elves(34_000_000).to_string()
}
#[test]
fn test_get_house_presents() {
assert_eq!(find_house(1), 10);
assert_eq!(find_house(2), 30);
assert_eq!(find_house(9), 130);
}
|
/// Variable argument version of `syscall`
#[macro_export]
macro_rules! syscall {
($nr:ident) => {
$crate::syscall1($crate::nr::$nr, 0)
};
($nr:ident, $a1:expr) => {
$crate::syscall($crate::nr::$nr, &[$a1 as usize])
};
($nr:ident, $a1:expr, $a2:expr) => {
$crate::syscall($crate::nr::$nr, &[$a1 as usize, $a2 as usize])
};
($nr:ident, $a1:expr, $a2:expr, $a3:expr) => {
$crate::syscall($crate::nr::$nr, &[$a1 as usize, $a2 as usize,
$a3 as usize])
};
($nr:ident, $a1:expr, $a2:expr, $a3:expr, $a4:expr) => {
$crate::syscall($crate::nr::$nr, &[$a1 as usize, $a2 as usize,
$a3 as usize, $a4 as usize])
};
}
/// Macro version of `syscall1`
#[macro_export]
macro_rules! syscall1 {
($nr:ident, $a1:expr) => {
$crate::syscall1($crate::nr::$nr, $a1 as usize)
};
}
/// Macro for printing to the **host's** standard stderr
#[macro_export]
macro_rules! ehprint {
($s:expr) => ($crate::io::ewrite_str($s));
($($arg:tt)*) => ($crate::io::ewrite_fmt(format_args!($($arg)*)));
}
/// Macro for printing to the **host's** standard error, with a newline.
#[macro_export]
macro_rules! ehprintln {
() => (ehprint!("\n"));
($fmt:expr) => (ehprint!(concat!($fmt, "\n")));
($fmt:expr, $($arg:tt)*) => (ehprint!(concat!($fmt, "\n"), $($arg)*));
}
/// Macro for printing to the **host's** standard output
#[macro_export]
macro_rules! hprint {
($s:expr) => ($crate::io::write_str($s));
($($arg:tt)*) => ($crate::io::write_fmt(format_args!($($arg)*)));
}
/// Macro for printing to the **host's** standard output, with a newline.
#[macro_export]
macro_rules! hprintln {
() => (hprint!("\n"));
($fmt:expr) => (hprint!(concat!($fmt, "\n")));
($fmt:expr, $($arg:tt)*) => (hprint!(concat!($fmt, "\n"), $($arg)*));
}
|
use crate::{
table::table_name::TableName,
test_support::test_models::{Body, ModelsMock, People, Pet},
test_support::MockWithTxMethods,
RowProjectionQuery, Rows,
};
use futures::FutureExt;
#[derive(Clone, PartialEq, Debug)]
struct MockDatum {
tables: Vec<MockRows>,
}
impl From<ModelsMock> for MockDatum {
fn from(models: ModelsMock) -> Self {
MockDatum {
tables: vec![
MockRows {
table_name: People::table_name(),
rows: Rows::new(People::schema(), models.people),
},
MockRows {
table_name: Body::table_name(),
rows: Rows::new(Body::schema(), models.body),
},
MockRows {
table_name: Pet::table_name(),
rows: Rows::new(Pet::schema(), models.pet),
},
],
}
}
}
#[derive(Clone, PartialEq, Debug)]
struct MockRows {
table_name: TableName,
rows: Rows,
}
pub fn mock_select(with_tx: &mut MockWithTxMethods, models: ModelsMock) {
with_tx
.expect_select()
.returning(move |session, table_name, projection, selection| {
let models = models.clone();
let datum = MockDatum::from(models);
let table = datum
.tables
.iter()
.find(|table| table.table_name == table_name)
.unwrap_or_else(|| panic!("table `{:?}` is undefined in ModelsMock", table_name));
let rows = table.rows.clone();
let rows = rows.selection(&selection);
let rows = match projection {
RowProjectionQuery::All => rows,
RowProjectionQuery::ColumnIndexes(indexes) => rows.projection(&indexes).unwrap(),
};
async move { Ok((rows, session)) }.boxed_local()
});
}
|
//! signal implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/signal.h.html
#![no_std]
#![feature(asm, const_fn, core_intrinsics, global_asm)]
extern crate errno;
extern crate platform;
#[cfg(target_os = "linux")]
#[path = "linux.rs"]
pub mod sys;
#[cfg(target_os = "redox")]
#[path = "redox.rs"]
pub mod sys;
pub use sys::*;
use core::{mem, ptr};
use platform::types::*;
const SIG_ERR: usize = !0;
pub const SIG_BLOCK: c_int = 0;
pub const SIG_UNBLOCK: c_int = 1;
pub const SIG_SETMASK: c_int = 2;
// Need both here and in platform because cbindgen :(
#[repr(C)]
#[derive(Clone)]
pub struct sigaction {
pub sa_handler: extern "C" fn(c_int),
pub sa_flags: c_ulong,
pub sa_restorer: unsafe extern "C" fn(),
pub sa_mask: sigset_t,
}
pub const NSIG: usize = 64;
pub type sigset_t = c_ulong;
#[no_mangle]
pub extern "C" fn kill(pid: pid_t, sig: c_int) -> c_int {
platform::kill(pid, sig)
}
#[no_mangle]
pub extern "C" fn killpg(pgrp: pid_t, sig: c_int) -> c_int {
platform::killpg(pgrp, sig)
}
#[no_mangle]
pub extern "C" fn raise(sig: c_int) -> c_int {
platform::raise(sig)
}
#[no_mangle]
pub unsafe extern "C" fn sigaction(
sig: c_int,
act: *const sigaction,
oact: *mut sigaction,
) -> c_int {
let mut _sigaction = None;
let ptr = if !act.is_null() {
_sigaction = Some((*act).clone());
_sigaction.as_mut().unwrap().sa_flags |= SA_RESTORER as c_ulong;
_sigaction.as_mut().unwrap() as *mut _ as *mut platform::types::sigaction
} else {
ptr::null_mut()
};
platform::sigaction(sig, ptr, oact as *mut platform::types::sigaction)
}
#[no_mangle]
pub extern "C" fn sigaddset(set: *mut sigset_t, mut signo: c_int) -> c_int {
if signo <= 0 || signo as usize > NSIG {
unsafe {
platform::errno = errno::EINVAL;
}
return -1;
}
let signo = signo as usize - 1; // 0-indexed usize, please!
unsafe {
*set |= 1 << (signo & (8 * mem::size_of::<sigset_t>() - 1));
}
0
}
// #[no_mangle]
pub extern "C" fn sigdelset(set: *mut sigset_t, signo: c_int) -> c_int {
unimplemented!();
}
#[no_mangle]
pub extern "C" fn sigemptyset(set: *mut sigset_t) -> c_int {
unsafe {
*set = 0;
}
0
}
#[no_mangle]
pub extern "C" fn sigfillset(set: *mut sigset_t) -> c_int {
unsafe {
*set = c_ulong::max_value();
}
0
}
// #[no_mangle]
pub extern "C" fn sighold(sig: c_int) -> c_int {
unimplemented!();
}
// #[no_mangle]
pub extern "C" fn sigignore(sig: c_int) -> c_int {
unimplemented!();
}
// #[no_mangle]
pub extern "C" fn siginterrupt(sig: c_int, flag: c_int) -> c_int {
unimplemented!();
}
// #[no_mangle]
pub extern "C" fn sigismember(set: *const sigset_t, signo: c_int) -> c_int {
unimplemented!();
}
extern "C" {
// Defined in assembly inside platform/x/mod.rs
fn __restore_rt();
}
#[no_mangle]
pub extern "C" fn signal(sig: c_int, func: extern "C" fn(c_int)) -> extern "C" fn(c_int) {
let sa = sigaction {
sa_handler: func,
sa_flags: SA_RESTART as c_ulong,
sa_restorer: __restore_rt,
sa_mask: sigset_t::default(),
};
let mut old_sa = unsafe { mem::uninitialized() };
if unsafe { sigaction(sig, &sa, &mut old_sa) } < 0 {
mem::forget(old_sa);
return unsafe { mem::transmute(SIG_ERR) };
}
old_sa.sa_handler
}
// #[no_mangle]
pub extern "C" fn sigpause(sig: c_int) -> c_int {
unimplemented!();
}
// #[no_mangle]
pub extern "C" fn sigpending(set: *mut sigset_t) -> c_int {
unimplemented!();
}
#[no_mangle]
pub extern "C" fn sigprocmask(how: c_int, set: *const sigset_t, oset: *mut sigset_t) -> c_int {
platform::sigprocmask(how, set, oset)
}
// #[no_mangle]
pub extern "C" fn sigrelse(sig: c_int) -> c_int {
unimplemented!();
}
// #[no_mangle]
pub extern "C" fn sigset(sig: c_int, func: fn(c_int)) -> fn(c_int) {
unimplemented!();
}
// #[no_mangle]
pub extern "C" fn sigsuspend(sigmask: *const sigset_t) -> c_int {
unimplemented!();
}
// #[no_mangle]
pub extern "C" fn sigwait(set: *const sigset_t, sig: *mut c_int) -> c_int {
unimplemented!();
}
|
use crate::{properties, util};
use serde::Deserialize;
#[derive(Debug, Deserialize)]
pub struct Ellipse {
#[serde(rename = "mn")]
pub match_name: String,
#[serde(rename = "nm")]
pub name: String,
#[serde(rename = "d", default = "util::one_please")]
pub direction: f64,
#[serde(rename = "p")]
pub position: properties::EitherMultiDimensional,
#[serde(rename = "s")]
pub size: properties::EitherMultiDimensional,
}
|
tonic::include_proto!("ns/ns");
|
use boxer::array::BoxerArrayF32;
use boxer::{ValueBox, ValueBoxPointer};
use gleam::gl::*;
use std::rc::Rc;
#[no_mangle]
fn gleam_uniform_2f(_ptr_gl: *mut ValueBox<Rc<dyn Gl>>, location: GLint, v0: GLfloat, v1: GLfloat) {
_ptr_gl.with_not_null(|gl| gl.uniform_2f(location, v0, v1));
}
#[no_mangle]
fn gleam_uniform_matrix_4fv(
_ptr_gl: *mut ValueBox<Rc<dyn Gl>>,
location: GLint,
transpose: bool,
_value_ptr: *mut ValueBox<BoxerArrayF32>,
) {
_ptr_gl.with_not_null(|gl| {
_value_ptr
.with_not_null(|values| gl.uniform_matrix_4fv(location, transpose, values.to_slice()))
});
}
|
use anyhow::Result;
use crate::error::*;
use std::collections::BTreeMap;
#[derive(Clone)]
pub struct Client {
api_token: String,
host: String,
}
impl Client {
pub fn new(api_token: Option<String>, host: String) -> Self {
Client {
api_token: api_token.unwrap_or_else(|| "".into()),
host,
}
}
pub async fn get(&self, endpoint: &str, request: &str) -> Result<String> {
let response: String = surf::get(self.get_url(endpoint, request))
.set_header("Accept", "application/json")
.recv_string()
.await
.map_err(|err| FenrirError {
code: 1001,
message: format!("{}", err),
})?;
Ok(response)
}
pub async fn get_auth(&self, endpoint: &str, request: &str) -> Result<String> {
let response: String = surf::get(self.get_url(endpoint, request))
.set_header("Accept", "application/json")
.set_header("Authorization", format!("{} {}", "Basic", self.api_token.as_str()))
.recv_string()
.await
.map_err(|err| FenrirError {
code: 1002,
message: format!("{}", err),
})?;
Ok(response)
}
pub fn build_request(&self, parameters: &BTreeMap<String, String>) -> String {
let mut request = String::new();
for (key, value) in parameters {
let param = format!("{}={}&", key, value);
request.push_str(param.as_ref());
}
request.pop(); // remove last &
request
}
fn get_url(&self, endpoint: &str, request: &str) -> String {
let mut url: String = format!("{}{}", self.host, endpoint);
if !request.is_empty() {
url.push_str(format!("?{}", request).as_str());
}
url
}
}
|
#[macro_use]
extern crate postgres_derive;
#[macro_use]
extern crate postgres;
use postgres::{Connection, TlsMode};
use postgres::types::WrongType;
mod util;
#[test]
fn defaults() {
#[derive(Debug, ToSql, FromSql, PartialEq)]
enum Foo {
Bar,
Baz,
}
let conn = Connection::connect("postgres://postgres:password@localhost", TlsMode::None)
.unwrap();
conn.execute("CREATE TYPE pg_temp.\"Foo\" AS ENUM ('Bar', 'Baz')", &[])
.unwrap();
util::test_type(
&conn,
"\"Foo\"",
&[(Foo::Bar, "'Bar'"), (Foo::Baz, "'Baz'")],
);
}
#[test]
fn name_overrides() {
#[derive(Debug, ToSql, FromSql, PartialEq)]
#[postgres(name = "mood")]
enum Mood {
#[postgres(name = "sad")]
Sad,
#[postgres(name = "ok")]
Ok,
#[postgres(name = "happy")]
Happy,
}
let conn = Connection::connect("postgres://postgres:password@localhost", TlsMode::None)
.unwrap();
conn.execute(
"CREATE TYPE pg_temp.mood AS ENUM ('sad', 'ok', 'happy')",
&[],
).unwrap();
util::test_type(
&conn,
"mood",
&[
(Mood::Sad, "'sad'"),
(Mood::Ok, "'ok'"),
(Mood::Happy, "'happy'"),
],
);
}
#[test]
fn wrong_name() {
#[derive(Debug, ToSql, FromSql, PartialEq)]
enum Foo {
Bar,
Baz,
}
let conn = Connection::connect("postgres://postgres:password@localhost", TlsMode::None)
.unwrap();
conn.execute("CREATE TYPE pg_temp.foo AS ENUM ('Bar', 'Baz')", &[])
.unwrap();
let err = conn.execute("SELECT $1::foo", &[&Foo::Bar]).unwrap_err();
assert!(err.as_conversion().unwrap().is::<WrongType>());
}
#[test]
fn extra_variant() {
#[derive(Debug, ToSql, FromSql, PartialEq)]
#[postgres(name = "foo")]
enum Foo {
Bar,
Baz,
Buz,
}
let conn = Connection::connect("postgres://postgres:password@localhost", TlsMode::None)
.unwrap();
conn.execute("CREATE TYPE pg_temp.foo AS ENUM ('Bar', 'Baz')", &[])
.unwrap();
let err = conn.execute("SELECT $1::foo", &[&Foo::Bar]).unwrap_err();
assert!(err.as_conversion().unwrap().is::<WrongType>());
}
#[test]
fn missing_variant() {
#[derive(Debug, ToSql, FromSql, PartialEq)]
#[postgres(name = "foo")]
enum Foo {
Bar,
}
let conn = Connection::connect("postgres://postgres:password@localhost", TlsMode::None)
.unwrap();
conn.execute("CREATE TYPE pg_temp.foo AS ENUM ('Bar', 'Baz')", &[])
.unwrap();
let err = conn.execute("SELECT $1::foo", &[&Foo::Bar]).unwrap_err();
assert!(err.as_conversion().unwrap().is::<WrongType>());
}
|
#[doc = "Reader of register RANGE_COND"]
pub type R = crate::R<u32, super::RANGE_COND>;
#[doc = "Writer for register RANGE_COND"]
pub type W = crate::W<u32, super::RANGE_COND>;
#[doc = "Register RANGE_COND `reset()`'s with value 0"]
impl crate::ResetValue for super::RANGE_COND {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Range condition select.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RANGE_COND_A {
#[doc = "0: result < RANGE_LOW"]
BELOW,
#[doc = "1: RANGE_LOW <= result < RANGE_HIGH"]
INSIDE,
#[doc = "2: RANGE_HIGH <= result"]
ABOVE,
#[doc = "3: result < RANGE_LOW || RANGE_HIGH <= result"]
OUTSIDE,
}
impl From<RANGE_COND_A> for u8 {
#[inline(always)]
fn from(variant: RANGE_COND_A) -> Self {
match variant {
RANGE_COND_A::BELOW => 0,
RANGE_COND_A::INSIDE => 1,
RANGE_COND_A::ABOVE => 2,
RANGE_COND_A::OUTSIDE => 3,
}
}
}
#[doc = "Reader of field `RANGE_COND`"]
pub type RANGE_COND_R = crate::R<u8, RANGE_COND_A>;
impl RANGE_COND_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> RANGE_COND_A {
match self.bits {
0 => RANGE_COND_A::BELOW,
1 => RANGE_COND_A::INSIDE,
2 => RANGE_COND_A::ABOVE,
3 => RANGE_COND_A::OUTSIDE,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `BELOW`"]
#[inline(always)]
pub fn is_below(&self) -> bool {
*self == RANGE_COND_A::BELOW
}
#[doc = "Checks if the value of the field is `INSIDE`"]
#[inline(always)]
pub fn is_inside(&self) -> bool {
*self == RANGE_COND_A::INSIDE
}
#[doc = "Checks if the value of the field is `ABOVE`"]
#[inline(always)]
pub fn is_above(&self) -> bool {
*self == RANGE_COND_A::ABOVE
}
#[doc = "Checks if the value of the field is `OUTSIDE`"]
#[inline(always)]
pub fn is_outside(&self) -> bool {
*self == RANGE_COND_A::OUTSIDE
}
}
#[doc = "Write proxy for field `RANGE_COND`"]
pub struct RANGE_COND_W<'a> {
w: &'a mut W,
}
impl<'a> RANGE_COND_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: RANGE_COND_A) -> &'a mut W {
{
self.bits(variant.into())
}
}
#[doc = "result < RANGE_LOW"]
#[inline(always)]
pub fn below(self) -> &'a mut W {
self.variant(RANGE_COND_A::BELOW)
}
#[doc = "RANGE_LOW <= result < RANGE_HIGH"]
#[inline(always)]
pub fn inside(self) -> &'a mut W {
self.variant(RANGE_COND_A::INSIDE)
}
#[doc = "RANGE_HIGH <= result"]
#[inline(always)]
pub fn above(self) -> &'a mut W {
self.variant(RANGE_COND_A::ABOVE)
}
#[doc = "result < RANGE_LOW || RANGE_HIGH <= result"]
#[inline(always)]
pub fn outside(self) -> &'a mut W {
self.variant(RANGE_COND_A::OUTSIDE)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 30)) | (((value as u32) & 0x03) << 30);
self.w
}
}
impl R {
#[doc = "Bits 30:31 - Range condition select."]
#[inline(always)]
pub fn range_cond(&self) -> RANGE_COND_R {
RANGE_COND_R::new(((self.bits >> 30) & 0x03) as u8)
}
}
impl W {
#[doc = "Bits 30:31 - Range condition select."]
#[inline(always)]
pub fn range_cond(&mut self) -> RANGE_COND_W {
RANGE_COND_W { w: self }
}
}
|
mod bitvec_const;
mod neg;
mod add;
mod sub;
mod mul;
mod smod;
mod sdiv;
mod udiv;
mod urem;
mod srem;
pub mod prelude {
pub use super::{
BitvecConst,
Neg,
Add,
Mul,
Sub,
UnsignedDiv,
SignedDiv,
SignedModulo,
UnsignedRemainder,
SignedRemainder
};
}
pub use self::bitvec_const::prelude::*;
pub use self::neg::prelude::*;
pub use self::add::prelude::*;
pub use self::sub::prelude::*;
pub use self::mul::prelude::*;
pub use self::sdiv::prelude::*;
pub use self::udiv::prelude::*;
pub use self::smod::prelude::*;
pub use self::urem::prelude::*;
pub use self::srem::prelude::*;
|
extern crate ssh;
use std::fs::File;
use ssh::public_key;
pub fn main() {
let keypair = (public_key::ED25519.generate_key_pair)(None);
let mut buffer = File::create("server.key").unwrap();
keypair.export(&mut buffer);
}
|
use std::fs::File;
use std::io::{self, Cursor, Read, Write};
use std::path::Path;
use anyhow::Result;
use libosu::{
data::{Mode, Mods},
replay::{Buttons, Replay, ReplayActionData},
timing::Millis,
};
#[cfg(feature = "replay-data")]
fn compare_action_data(replay: &Replay, replay2: &Replay) -> Result<()> {
let action_data = replay.parse_action_data()?;
let action_data2 = replay2.parse_action_data()?;
assert_eq!(action_data.frames.len(), action_data2.frames.len());
assert_eq!(action_data.rng_seed, action_data2.rng_seed);
for (a, b) in action_data.frames.iter().zip(action_data2.frames.iter()) {
assert_eq!(a.time, b.time);
assert!((a.x - b.x).abs() < 0.001);
assert!((a.y - b.y).abs() < 0.001);
assert_eq!(a.buttons, b.buttons);
}
Ok(())
}
#[test]
fn test_replay_writer() -> Result<()> {
test_replay_writer_with("tests/files/replay-osu_2058788_3017707256.osr")?;
test_replay_writer_with("tests/files/replay_with_life.osr")?;
Ok(())
}
fn test_replay_writer_with(path: impl AsRef<Path>) -> Result<()> {
let mut osr = File::open(path.as_ref())?;
let mut contents = Vec::new();
osr.read_to_end(&mut contents)?;
let mut curs = Cursor::new(&contents);
let replay = Replay::parse(&mut curs)?;
// lzma encoded data will be different, so we'll just re-parse and check contents
// not the most ideal since this assumes the parsing is correct
let mut contents2 = Vec::new();
replay.write(&mut contents2)?;
let mut curs2 = Cursor::new(&contents2);
let replay2 = Replay::parse(&mut curs2)?;
assert_eq!(replay.count_300, replay2.count_300);
assert_eq!(replay.count_100, replay2.count_100);
assert_eq!(replay.count_50, replay2.count_50);
assert_eq!(replay.count_geki, replay2.count_geki);
assert_eq!(replay.life_graph, replay2.life_graph);
#[cfg(feature = "replay-data")]
compare_action_data(&replay, &replay2)?;
Ok(())
}
#[cfg(feature = "replay-data")]
#[test]
fn test_replay_action_update() -> Result<()> {
let mut osr = File::open("tests/files/replay-osu_2058788_3017707256.osr")?;
let replay = Replay::parse(&mut osr)?;
let actions = replay.parse_action_data()?;
let mut replay2 = replay.clone();
replay2.update_action_data(&actions)?;
compare_action_data(&replay, &replay2)?;
Ok(())
}
#[test]
fn test_replay_parse_header() -> Result<()> {
let mut osr = File::open("tests/files/replay-osu_2058788_3017707256.osr")?;
let header = Replay::parse(&mut osr)?;
assert_eq!(header.mode, Mode::Osu);
assert_eq!(header.version, 20200304);
assert_eq!(
header.beatmap_hash,
"4190b795c2847f9eae06a0651493d6e2".to_string()
);
assert_eq!(header.player_username, "FGSky".to_string());
assert_eq!(
header.replay_hash,
"e8983dbdb53360e5d19cbe5de5de49a7".to_string()
);
assert_eq!(header.count_300, 330);
assert_eq!(header.count_100, 24);
assert_eq!(header.count_50, 0);
assert_eq!(header.count_geki, 87);
assert_eq!(header.count_katu, 21);
assert_eq!(header.count_miss, 2);
assert_eq!(header.score, 7756117);
assert_eq!(header.max_combo, 527);
assert_eq!(header.perfect, false);
assert_eq!(
header.mods,
Mods::Flashlight | Mods::Hidden | Mods::DoubleTime | Mods::HardRock
);
Ok(())
}
#[cfg(feature = "replay-data")]
#[test]
fn test_seed() -> Result<()> {
let mut osr = io::BufReader::new(File::open("tests/files/replay-osu_2058788_3017707256.osr")?);
let replay = Replay::parse(&mut osr)?;
let actions = replay.parse_action_data()?;
assert_eq!(actions.rng_seed, Some(16516643));
Ok(())
}
#[test]
fn test_parse_after_actions() -> Result<()> {
{
let mut osr =
File::open("tests/files/ - nekodex - new beginnings [tutorial] (2020-12-16) Osu.osr")?;
let replay = Replay::parse(&mut osr)?;
assert_eq!(replay.score_id, None);
assert_eq!(replay.target_practice_total_accuracy, None);
}
{
let mut osr = File::open("tests/files/replay-osu_2058788_3017707256.osr")?;
let replay = Replay::parse(&mut osr)?;
assert_eq!(replay.score_id, Some(3017707256));
assert_eq!(replay.target_practice_total_accuracy, None);
}
Ok(())
}
#[cfg(feature = "replay-data-xz2")]
fn lzma_encode(data: &[u8]) -> Result<Vec<u8>> {
use xz2::{
stream::{LzmaOptions, Stream},
write::XzEncoder,
};
let mut buf = Vec::new();
let opts = LzmaOptions::new_preset(0)?;
let stream = Stream::new_lzma_encoder(&opts)?;
{
let mut xz = XzEncoder::new_stream(&mut buf, stream);
xz.write_all(data)?;
}
Ok(buf)
}
#[cfg(feature = "replay-data")]
fn lzma_encode(mut data: &[u8]) -> Result<Vec<u8>> {
let mut data_out = Vec::new();
lzma_rs::lzma_compress(&mut data, &mut data_out)?;
Ok(data_out)
}
#[cfg(feature = "replay-data")]
#[test]
fn test_replay_action_parser() -> Result<()> {
let actions_text = "1|32.1|300.734|0,32|500.5123|0|10,-12345|0|0|734243";
let data = lzma_encode(actions_text.as_bytes())?;
let actions_reader = Cursor::new(data);
let action_data = ReplayActionData::parse(actions_reader)?;
let actions = &action_data.frames;
assert_eq!(actions.len(), 2);
assert_eq!(actions[0].time, Millis(1));
assert_eq!(actions[0].x, 32.1);
assert_eq!(actions[0].y, 300.734);
assert_eq!(actions[0].buttons, Buttons::empty());
assert_eq!(actions[1].time, Millis(32));
assert_eq!(actions[1].x, 500.5123);
assert_eq!(actions[1].y, 0.0);
assert_eq!(actions[1].buttons, Buttons::K2 | Buttons::M2);
assert_eq!(action_data.rng_seed, Some(734243));
Ok(())
}
#[test]
fn test_replay_parse() -> Result<()> {
let mut osr = File::open("tests/files/replay-osu_1816113_2892542031.osr")?;
let replay = Replay::parse(&mut osr)?;
assert_eq!(replay.mode, Mode::Osu);
assert_eq!(replay.version, 20190906);
assert_eq!(
replay.beatmap_hash,
"edd35ab673c5f73029cc8eda6faefe00".to_string()
);
assert_eq!(replay.player_username, "Vaxei".to_string());
assert_eq!(
replay.replay_hash,
"139c99f18fc78555cd8f30a963aadf0a".to_string()
);
assert_eq!(replay.count_300, 2977);
assert_eq!(replay.count_100, 38);
assert_eq!(replay.count_50, 0);
assert_eq!(replay.count_geki, 605);
assert_eq!(replay.count_katu, 30);
assert_eq!(replay.count_miss, 0);
assert_eq!(replay.score, 364_865_850);
assert_eq!(replay.max_combo, 4078);
assert_eq!(replay.perfect, false);
assert_eq!(replay.mods, Mods::None);
#[cfg(feature = "replay-data")]
{
let action_data = replay.parse_action_data()?;
assert_eq!(action_data.rng_seed, Some(7364804));
}
assert_eq!(replay.score_id, Some(2892542031));
assert_eq!(replay.target_practice_total_accuracy, None);
Ok(())
}
|
pub use super::number::types::Type;
pub use super::number::classes::Class;
pub use super::number::rcodes::RCode;
pub use super::number::opcodes::OpCode;
pub use super::number::errors::IdentifierError;
pub use super::name::{Name,DNSNameReader};
pub use super::number::DNSNumberReader;
use self::record::{Question,ResourceRecord,DNSResourceRecordReader,DNSQuestionReader};
use std::io;
use std::collections::hash_map::HashMap;
pub mod record;
pub mod recordtypes;
#[deriving(Show,Clone)]
pub struct Message {
pub id: u16,
pub flags: u16,
pub questions: Vec<Question>,
pub answers: Vec<ResourceRecord>,
pub nameservers: Vec<ResourceRecord>,
pub additionals: Vec<ResourceRecord>,
}
static HFLAG_MASK_QR: u16 = 0x8000;
static HFLAG_MASK_AA: u16 = 0x0400;
static HFLAG_MASK_TC: u16 = 0x0200;
static HFLAG_MASK_RD: u16 = 0x0100;
static HFLAG_MASK_RA: u16 = 0x0080;
static HFLAG_MASK_OPCODE: u16 = 0x7800;
//static HFLAG_MASK_Z: u16 = 0x0040; // Currently unused
static HFLAG_MASK_AD: u16 = 0x0020;
static HFLAG_MASK_CD: u16 = 0x0010;
static HFLAG_MASK_RCODE: u16 = 0x000F;
impl Message {
pub fn new(
id: u16,
query: bool,
opcode: OpCode,
authoritative: bool,
truncated: bool,
recursion_desired: bool,
recursion_available: bool,
authenticated: bool,
checking_disabled: bool,
response_code: RCode,
) -> Message {
let flags =
0u16 | (if query {0} else {HFLAG_MASK_QR})
| (if authoritative {HFLAG_MASK_AA} else {0})
| (if truncated {HFLAG_MASK_TC} else {0})
| (if recursion_desired {HFLAG_MASK_RD} else {0})
| (if recursion_available {HFLAG_MASK_RA} else {0})
| ((((opcode as u8) as u16) << 11) & HFLAG_MASK_OPCODE)
| (if authenticated {HFLAG_MASK_AD} else {0})
| (if checking_disabled {HFLAG_MASK_CD} else {0})
| ((response_code as u16) & HFLAG_MASK_RCODE);
Message { id: id, flags: flags, questions: Vec::new(), answers: Vec::new(), nameservers: Vec::new(), additionals: Vec::new() }
}
pub fn is_query(&self) -> bool {
(self.flags & HFLAG_MASK_QR) == 0
}
pub fn is_response(&self) -> bool {
(self.flags & HFLAG_MASK_QR) != 0
}
pub fn get_opcode(&self) -> Result<OpCode, IdentifierError> {
OpCode::from_u8(((self.flags & HFLAG_MASK_OPCODE) >> 11) as u8)
}
pub fn is_authoritative(&self) -> bool {
(self.flags & HFLAG_MASK_AA) != 0
}
pub fn is_truncated(&self) -> bool {
(self.flags & HFLAG_MASK_TC) != 0
}
pub fn recursion_desired(&self) -> bool {
(self.flags & HFLAG_MASK_RD) != 0
}
pub fn recursion_available(&self) -> bool {
(self.flags & HFLAG_MASK_RA) != 0
}
pub fn is_authenticated(&self) -> bool {
(self.flags & HFLAG_MASK_AD) != 0
}
pub fn checking_disabled(&self) -> bool {
(self.flags & HFLAG_MASK_CD) != 0
}
pub fn response_code(&self) -> Result<RCode, IdentifierError> {
RCode::from_u16(self.flags & HFLAG_MASK_RCODE)
}
pub fn from_buf(buf: &[u8]) -> io::IoResult<Message> {
let mut reader = io::BufReader::new(buf);
let mut message = Message { id: 0, flags: 0, questions: Vec::new(), answers: Vec::new(), nameservers: Vec::new(), additionals: Vec::new() };
message.id = try!(reader.read_be_u16());
message.flags = try!(reader.read_be_u16());
let message_qc = try!(reader.read_be_u16());
let message_rc = try!(reader.read_be_u16());
let message_nc = try!(reader.read_be_u16());
let message_ac = try!(reader.read_be_u16());
for i in range(0, message_qc) { message.questions.push(Question::new()); }
for i in range(0, message_rc) { message.answers.push(ResourceRecord::new()); }
for i in range(0, message_nc) { message.nameservers.push(ResourceRecord::new()); }
for i in range(0, message_ac) { message.additionals.push(ResourceRecord::new()); }
drop(reader);
Ok(message)
}
}
pub trait DNSMessageReader {
fn read_dns_message(&mut self) -> io::IoResult<Message>;
}
impl<'a> DNSMessageReader for io::BufReader<'a> {
fn read_dns_message(&mut self) -> io::IoResult<Message> {
let mut message = Message { id: 0, flags: 0, questions: Vec::new(), answers: Vec::new(), nameservers: Vec::new(), additionals: Vec::new() };
message.id = try!(self.read_be_u16());
message.flags = try!(self.read_be_u16());
let message_qc = try!(self.read_be_u16());
let message_rc = try!(self.read_be_u16());
let message_nc = try!(self.read_be_u16());
let message_ac = try!(self.read_be_u16());
for i in range(0, message_qc) { message.questions.push(try!(self.read_dns_question())); }
for i in range(0, message_rc) { message.answers.push(try!(self.read_dns_resource_record())); }
for i in range(0, message_nc) { message.nameservers.push(try!(self.read_dns_resource_record())); }
for i in range(0, message_ac) { message.additionals.push(try!(self.read_dns_resource_record())); }
Ok(message)
}
}
pub trait DNSMessageWriter {
fn write_dns_message(&mut self, message: &Message) -> io::IoResult<()>;
}
impl<'a> DNSMessageWriter for io::BufWriter<'a> {
fn write_dns_message(&mut self, message: &Message) -> io::IoResult<()> {
let pointer_map: HashMap<Name,uint> = HashMap::new();
Ok(())
}
}
#[cfg(test)]
mod test_message {
use super::{DNSMessageReader,Message,OpCode,RCode};
use std::io;
#[test]
fn test_flags_from_u16() {
let f = Message { id: 0x1234, flags: 0x8180, questions: Vec::new(), answers: Vec::new(), nameservers: Vec::new(), additionals: Vec::new() };
assert!(!f.is_query());
assert!(f.is_response());
assert!(f.get_opcode().ok().unwrap() == OpCode::Query);
assert!(!f.is_authoritative());
assert!(!f.is_truncated());
assert!(f.recursion_desired());
assert!(f.recursion_available());
assert!(!f.is_authenticated());
assert!(!f.checking_disabled());
assert!(f.response_code().ok().unwrap() == RCode::NoError);
}
#[test]
fn test_flags_to_u16() {
let m = Message::new(0x1234, false, OpCode::Query, false, false, true, true, false, false, RCode::NoError);
assert_eq!(m.flags, 0x8180);
}
#[test]
fn test_from_buf() {
let buf = [0xbu8, 0x8d, 0x81, 0x80, 0x0, 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x8, 0x66, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x3, 0x63, 0x6f, 0x6d
, 0x0, 0x0, 0x1, 0x0, 0x1, 0xc0, 0xc, 0x0, 0x1, 0x0, 0x1, 0x0, 0x0, 0x3, 0x30, 0x0, 0x4, 0xad, 0xfc, 0x78, 0x6];
let mut r = io::BufReader::new(&buf);
let m = match r.read_dns_message() {
Ok(msg) => msg,
Err(e) => {
println!("{}", e);
return;
}
};
assert_eq!(m.flags, 0x8180);
}
} |
use vek::*;
#[derive(Copy, Clone, Debug, PartialEq,Serialize, Deserialize)]
pub enum SpellBounds {
Sphere(Vec3<f32>, f32),
Ray(Vec3<f32>, Vec3<f32>),
}
#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum SpellShape {
Sphere(f32),
Ray(f32),
} |
fn main() {
let data1 = (10, 'x', 12, 183.19, 'q', false, -9);
let mut data2: (u16, char, i16, f64, bool, char, i16);
data2 = data1;
}
|
use serde::{Deserialize, Serialize};
use smart_default::SmartDefault;
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum ConvolutionTileSize {
Lowest,
Low,
Medium,
High,
}
#[derive(Clone, Debug, Deserialize, PartialEq, SmartDefault, Serialize)]
pub struct Aperture {
pub filter: String,
#[default(ConvolutionTileSize::Medium)]
pub tile_size: ConvolutionTileSize,
}
|
use bonuses;
/// An object which tracks circumstance bonus values.
pub struct CircumstanceBonus {
tracker: bonuses::StackingTracker,
}
impl CircumstanceBonus {
/// Create an instance of CircumstanceBonus.
pub fn new() -> CircumstanceBonus {
CircumstanceBonus {
tracker: bonuses::StackingTracker::new()
}
}
}
impl bonuses::BonusTracker for CircumstanceBonus {
/// Returns the total bonus.
fn total(&self) -> u8 {
return self.tracker.total();
}
/// Adds a value.
fn add(&mut self, amt: u8) -> &mut CircumstanceBonus {
self.tracker.add(amt);
return self;
}
/// Removes a value.
fn remove(&mut self, amt: u8) -> &mut CircumstanceBonus {
self.tracker.remove(amt);
return self;
}
} |
mod bindings;
mod broadcaster;
mod watcher;
pub use broadcaster::Broadcaster;
pub use watcher::MoebiusWatcher;
|
//! An HTTP log monitoring tool.
//!
//! Provides a summary information and alerts of HTTP traffic.
#[macro_use]
extern crate assert_matches;
use clap::{AppSettings, Clap};
use csv::Reader;
use processor::Record;
use std::collections::VecDeque;
use std::error::Error;
use std::io;
use std::process;
pub mod alerts;
pub mod display;
pub mod stats;
use alerts::AlertHandler;
use display::get_display;
#[derive(Clap)]
#[clap(version = "1.0", author = "Adrian F. <aef@fastmail.com>")]
#[clap(setting = AppSettings::ColoredHelp)]
struct Opts {
#[clap(short, long, default_value = "cli")]
display: String,
#[clap(
short,
long,
default_value = "10",
about = "Summarize logs for every N seconds of log lines"
)]
summary_cadence: i64,
#[clap(
short,
long,
default_value = "10",
about = "Avg. requests per second to trigger an alert."
)]
high_alert_seconds_per_request: i64,
}
fn process_logs(opts: Opts) -> Result<(), Box<dyn Error>> {
let display = get_display(&opts.display);
let high_alert_threshold = opts.high_alert_seconds_per_request;
let summary_cadence: i64 = opts.summary_cadence;
let mut interval_buffer: VecDeque<Record> = VecDeque::new();
let mut alert_handler = AlertHandler::new(2 * 60, high_alert_threshold);
let mut reader = Reader::from_reader(io::stdin());
for result in reader.deserialize() {
let record: Record = result?;
if !interval_buffer.is_empty() {
let start_time = interval_buffer[0].date;
let curr_time = record.date;
if curr_time > start_time && curr_time - start_time > summary_cadence {
display.summary_stats(stats::build_summary_stats(&interval_buffer))?;
interval_buffer.clear();
}
}
if let Some(ref alert) = alert_handler.current_alert {
display.alert(alert)?;
}
interval_buffer.push_back(record.to_owned());
alert_handler.new_record(record.date);
}
Ok(())
}
fn main() {
let opts: Opts = Opts::parse();
if let Err(err) = process_logs(opts) {
println!("Error processing logs: {}", err);
process::exit(1);
}
}
|
extern crate rand;
use std::fmt;
use std::{thread, time};
use std::process;
use rand::{thread_rng, Rng};
trait State : fmt::Display {
fn do_clock(&self, hour: u32) -> Box<State>;
fn do_use(&self, context: Box<&Context>);
fn do_alarm(&self, context: Box<&Context>);
fn do_phone(&self, context: Box<&Context>);
fn value(&self) -> String;
}
impl PartialEq<State> for State {
fn eq(&self, other: &State) -> bool {
self.value() == other.value()
}
}
trait Context {
fn set_clock(&mut self, hour: u32);
fn change_state(&mut self, state: Box<State>);
fn call_security_center(&self, msg: String);
fn record_log(&self, msg: String);
}
#[derive(PartialEq)]
struct DayState {}
impl DayState {
fn new() -> DayState {
DayState {}
}
}
impl State for DayState {
fn do_clock(&self, hour: u32) -> Box<State> {
if hour < 9 || 17 <= hour {
Box::new(NightState::new())
} else {
Box::new(DayState::new())
}
}
fn do_use(&self, context: Box<&Context>) {
context.record_log("金庫使用(昼間)".to_string());
}
fn do_alarm(&self, context: Box<&Context>) {
context.call_security_center("非常ベル(昼間)".to_string());
}
fn do_phone(&self, context: Box<&Context>) {
context.call_security_center("通常の通話(昼間)".to_string());
}
fn value(&self) -> String {
"昼間".to_string()
}
}
impl fmt::Display for DayState {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[昼間]")
}
}
#[derive(PartialEq)]
struct NightState {}
impl NightState {
fn new() -> NightState {
NightState {}
}
}
impl State for NightState {
fn do_clock(&self, hour: u32) -> Box<State> {
if 9 <= hour && hour < 17 {
Box::new(DayState::new())
} else {
Box::new(NightState::new())
}
}
fn do_use(&self, context: Box<&Context>) {
context.call_security_center("非常:夜間の金庫使用!".to_string());
}
fn do_alarm(&self, context: Box<&Context>) {
context.call_security_center("非常ベル(夜間)".to_string());
}
fn do_phone(&self, context: Box<&Context>) {
context.record_log("夜間の通話録音".to_string());
}
fn value(&self) -> String {
"夜間".to_string()
}
}
impl fmt::Display for NightState {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[夜間]")
}
}
struct SafeFrame {
title: String,
state: Box<State>,
}
impl SafeFrame {
fn new(title: String, state: Box<State>) -> SafeFrame {
SafeFrame {
title: title,
state: state,
}
}
fn click_use(&self) {
self.state.do_use(Box::new(self));
}
fn click_alarm(&self) {
self.state.do_alarm(Box::new(self));
}
fn click_phone(&self) {
self.state.do_phone(Box::new(self));
}
fn click_exit(&self) {
process::exit(0);
}
}
impl Context for SafeFrame {
fn set_clock(&mut self, hour: u32) {
println!("現在時刻は{0: >02}:00", hour);
let state = self.state.do_clock(hour);
if &self.state != &state {
self.change_state(state);
}
}
fn change_state(&mut self, state: Box<State>) {
println!("{}から{}へ状態が変化しました。", self.state, state);
self.state = state;
}
fn call_security_center(&self, msg: String) {
println!("call! {}", msg);
}
fn record_log(&self, msg: String) {
println!("record ... {}", msg);
}
}
fn main() {
let mut frame = SafeFrame::new("State Sample".to_string(), Box::new(NightState::new()));
let mut rng = thread_rng();
println!("------------");
println!("{}", frame.title);
println!("------------\n");
loop {
for hour in 0..24 {
frame.set_clock(hour);
match rng.gen_range(0, 3) {
0 => frame.click_use(),
1 => frame.click_alarm(),
2 => frame.click_phone(),
_ => frame.click_exit(),
}
thread::sleep(time::Duration::from_millis(1000));
}
}
}
|
use log::trace;
use std::sync::Arc;
use super::style::Style;
pub type GridCell = Option<(String, Option<Arc<Style>>)>;
pub struct CharacterGrid {
pub width: u64,
pub height: u64,
pub should_clear: bool,
dirty: Vec<bool>,
characters: Vec<GridCell>,
}
impl CharacterGrid {
pub fn new(size: (u64, u64)) -> CharacterGrid {
let mut result = CharacterGrid {
characters: vec![],
dirty: vec![],
width: 0,
height: 0,
should_clear: true,
};
result.resize(size.0, size.1);
result
}
pub fn resize(&mut self, width: u64, height: u64) {
trace!("Editor resized");
self.width = width;
self.height = height;
self.clear();
}
pub fn clear(&mut self) {
trace!("Editor cleared");
self.characters.clear();
self.dirty.clear();
let cell_count = (self.width * self.height) as usize;
self.characters.resize_with(cell_count, || None);
self.dirty.resize_with(cell_count, || true);
self.should_clear = true;
}
fn cell_index(&self, x: u64, y: u64) -> Option<usize> {
if x >= self.width || y >= self.height {
None
} else {
Some((x + y * self.width) as usize)
}
}
pub fn get_cell(&self, x: u64, y: u64) -> Option<&GridCell> {
self.cell_index(x, y).map(|idx| &self.characters[idx])
}
pub fn get_cell_mut(&mut self, x: u64, y: u64) -> Option<&mut GridCell> {
self.cell_index(x, y)
.map(move |idx| &mut self.characters[idx])
}
pub fn is_dirty_cell(&self, x: u64, y: u64) -> bool {
if let Some(idx) = self.cell_index(x, y) {
self.dirty[idx]
} else {
false
}
}
pub fn set_dirty_cell(&mut self, x: u64, y: u64) {
if let Some(idx) = self.cell_index(x, y) {
self.dirty[idx] = true;
}
}
pub fn set_dirty_all(&mut self, value: bool) {
self.dirty.clear();
self.dirty
.resize_with((self.width * self.height) as usize, || value);
}
pub fn rows(&self) -> impl Iterator<Item = &[GridCell]> {
(0..self.height).map(move |row| {
&self.characters[(row * self.width) as usize..((row + 1) * self.width) as usize]
})
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.