matthewjberger

fn contains_single_num_in_range(s: &str, section_index: usize, min: u8, max: u8) -> Option<u8> {
    s.split('/')
        .nth(section_index)?
        .split('-')
        .filter_map(|part| part.parse::<u8>().ok())
        .find(|&num| (min..=max).contains(&num))
}

#[cfg(test)]
mod tests {

matthewjberger

use petgraph::{graph::NodeIndex, prelude::*};
use std::ops::{Index, IndexMut};

pub trait Aggregatable: Clone + PartialEq + std::fmt::Debug {
    fn aggregate(&self, parent: &Self) -> Self;
}

// The SceneGraph is now generic over the type of the transform
#[derive(Default)]
pub struct SceneGraph<T: Aggregatable>(pub Graph<T, ()>);

matthewjberger

// ===========================
// Approach 1: Direct Function
// ===========================

struct DirectProcessor {
    process: fn() -> &'static str,
}

impl DirectProcessor {
    fn process_data() -> &'static str {

matthewjberger

Does it build in wasm?

cargo build --target wasm32-unknown-unknown

How do I specify crates just for the wasm target?

Here's an example using legion:

matthewjberger

//! Tokio Async Topic-based Pub/Sub Messaging
//!
//! This module provides a broker-client communication system where
//! multiple clients can communicate with each other through a central broker.
//! The broker is responsible for routing messages between clients based on topics.
//! 
//! # Structures
//! 
//! - `Broker`: Represents the central message router. It manages topics and routes messages between subscribers.
//! - `Client`: Represents a client that can subscribe to topics, send, and receive messages through the broker.

matthewjberger

// From: https://github.com/serde-rs/serde/issues/1465#issuecomment-800686252
use common::serde::{self, Deserialize, Serialize}

#[derive(Copy, Clone, Debug, Deserialize, Serialize)]
#[serde(crate = "self::serde")] // must be below the derive attribute
struct Vertex {
    position: [u32; 3],
}

matthewjberger

#[derive(Default, Debug, Clone, Copy, PartialEq)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
    fn lerp(self, other: Self, t: f64) -> Self {
        Self {
            x: (1.0 - t) * self.x + t * other.x,

matthewjberger

use std::{
    cell::RefCell,
    collections::{HashMap, VecDeque},
    rc::{Rc, Weak},
};
use uuid::Uuid;

pub type ClientHandle<T> = Rc<RefCell<Client<T>>>;

pub struct Client<T> {

matthewjberger

/// Time of day as seconds since midnight. Used for clock in demo app.
pub(crate) fn seconds_since_midnight() -> f64 {
    use chrono::Timelike;
    let time = chrono::Local::now().time();
    time.num_seconds_from_midnight() as f64 + 1e-9 * (time.nanosecond() as f64)
}

matthewjberger

fn levenshtein(a: &str, b: &str) -> usize {
    let (a_len, b_len) = (a.chars().count(), b.chars().count());
    let mut matrix = vec![vec![0; b_len + 1]; a_len + 1];

    for i in 0..=a_len {
        matrix[i][0] = i;
    }
    for j in 0..=b_len {
        matrix[0][j] = j;
    }