1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//! Wraps bktree functionality, the container and defines audio info structs to be used
use super::bktree::{BKTree, Distance};
use std::{boxed::Box, time::Duration, vec::Vec};

/// The container keeps the collection data. It currently consists of a BKTree
/// (https://en.wikipedia.org/wiki/BK-tree), because key is a string of lexical
/// data.
pub struct Container {
    bk_tree: BKTree<AudioInfoKey, Box<AudioInfo>>,
}
impl Container {
    pub fn new() -> Self {
        Self {
            bk_tree: BKTree::new(),
        }
    }
    /// wraps and protects the bktree find but with AudioInfoKey
    pub fn find(
        &self,
        searcher: &AudioInfoKey,
        tolerance: usize,
    ) -> (Vec<&Box<AudioInfo>>, Vec<&AudioInfoKey>) {
        self.bk_tree.find(&searcher, tolerance)
    }

    /// wraps and protects the bktree insert but with AudioInfoKey
    pub fn insert(&mut self, key: AudioInfoKey, value: Box<AudioInfo>) {
        self.bk_tree.insert(key, value);
    }

    pub fn flush(&self) -> Vec<(&AudioInfoKey, &Box<AudioInfo>)> {
        self.bk_tree.dfs()
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AudioInfoKey {
    k: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AudioInfo {
    pub duration: Duration,
    pub album: String,
    pub file_name: String,
    // todo: more information should be used
}

/// protect handling of AudioInfoKey
impl AudioInfoKey {
    /// Creates from the given input a key!
    /// The idea is to get a as unique key to possibly identify
    /// duplicates, but to give enough distance (hence a string
    /// distance metric is used) to similar but other keys.
    pub fn new(artist: &String, title: &String) -> Self {
        Self {
            k: format!("{} {}", artist, title),
        }
    }
    pub fn get(&self) -> &String {
        &self.k
    }
}

impl Distance for AudioInfoKey {
    fn distance(&self, other: &Self) -> usize {
        super::bktree::osa_distance(&self.k.clone(), &other.k)
    }
}