martinmroz

/*
 * Copyright (C) 2019 Martin Mroz
 *
 * This software may be modified and distributed under the terms
 * of the MIT license. See the LICENSE file for details.
 */

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

martinmroz

struct MemoryRegion {
    pub start: u32,
    pub end: u32,
    pub buffer: Vec<u8>,
    pub name: String,
}

/// I32HEX supports record types:
/// - Data
///   Specifies up to 255 bytes of data.

martinmroz

/*
 * tube_display.c
 * Project TubeClock/Display
 *
 * Created Friday, September  3, 2010 by Martin Mroz.
 * Copyright (C) 2010 Martin Mroz, All Rights Reserved.
 */

#include <avr/pgmspace.h>
#include "hardware/tube_display.h"

martinmroz

pub fn levenshtein_distance(source: &str, target: &str) -> usize {
    if source.len() == 0 || target.len() == 0 {
        return std::cmp::max(
            source.chars().count(), 
            target.chars().count()
        );
    }

    let source_chars: Vec<char> = source.chars().collect();

martinmroz

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_flux_over_byte_string() {
        assert_eq!(
            flux_over_byte_string("testing one two three".as_bytes()),
            Some(Flux::new(CharType::NotSpace, 4, 0, CharType::NotSpace))
        );
    }

martinmroz

martinmroz

/// Computes the flux over the provided input byte string.
fn flux_over_byte_string<T>(input: T) -> Option<Flux>
where
    T: AsRef<[u8]> {
    input.as_ref()
        .par_iter()
        .cloned()
        .map(Flux::from)
        .fold(|| None, |acc, next| span_opt(acc, Some(next)))
        .reduce(|| None, |acc, next| span_opt(acc, next))

martinmroz

/// Computes the flux over the provided input byte string.
fn flux_over_byte_string<T>(input: T) -> Option<Flux>
where
    T: AsRef<[u8]> {
    input.as_ref()
        .iter()
        .cloned()
        .map(Flux::from)
        .fold(None, |acc, next| span_opt(acc, Some(next)))
}

martinmroz

fn span(self, rhs: Flux) -> Self {
    let words = {
        // If the span is formed along a non-space to non-space boundary the word count is one less than the sum.
        if let (CharType::NotSpace, CharType::NotSpace) = (self.rightmost_char_type, rhs.leftmost_char_type) {
            self.words + rhs.words - 1
        } else {
            self.words + rhs.words
        }
    };
    Flux::new(self.leftmost_char_type, words, self.lines + rhs.lines, rhs.rightmost_char_type)

martinmroz

impl From<u8> for Flux {
    fn from(other: u8) -> Self {
        if other.is_ascii_whitespace() {
            // A line-feed is considered an ASCII whitespace character by `is_ascii_whitespace`.
            let lines = if other == ('\n' as u8) { 1 } else { 0 };
            Flux::new(CharType::IsSpace, 0, lines, CharType::IsSpace)
        } else {
            Flux::new(CharType::NotSpace, 1, 0, CharType::NotSpace)
        }
    }