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
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

use crate::decklist::unpopulated_decklist::UnpopulatedDecklist;
use std::collections::VecDeque;
use std::ops::Index;

impl UnpopulatedDecklist {
    pub fn parse_raw<S: ToString>(data: S) -> Option<Self> {
        let mut main = vec![];
        let mut sideboard = vec![];
        let mut writing = true;
        for line in data.to_string().lines() {
            if line.is_empty() {
                continue;
            }
            if line == "Sideboard:" {
                writing = false;
                continue;
            }
            let mut parts = line.split(" ").collect::<VecDeque<&str>>();
            let amount = match match parts.pop_front() {
                Some(str) => str,
                _ => return None,
            }
            .parse::<u16>()
            {
                Ok(amount) => amount,
                _ => return None,
            };
            let name: String = parts
                .into_iter()
                .collect::<Vec<&str>>()
                .join(" ")
                .to_string();
            let entry = (amount, name);
            if writing {
                main.push(entry)
            } else {
                sideboard.push(entry)
            }
        }
        Some(Self { main, sideboard })
    }

    pub fn parse_arena<S: ToString>(data: S) -> Option<Self> {
        let mut main = vec![];
        let mut sideboard = vec![];
        let mut writing = true;
        for line in data.to_string().lines() {
            if line.is_empty() {
                writing = false;
                continue;
            }
            let mut parts = line.split(" ").collect::<VecDeque<&str>>();
            let amount = match match parts.pop_front() {
                Some(str) => str,
                _ => return None,
            }
            .parse::<u16>()
            {
                Ok(amount) => amount,
                _ => return None,
            };
            let name: String = parts
                .into_iter()
                .collect::<Vec<&str>>()
                .join(" ")
                .to_string();
            let entry = (amount, name);
            if writing {
                main.push(entry)
            } else {
                sideboard.push(entry)
            }
        }
        Some(Self { main, sideboard })
    }
    pub fn parse_csv<S: ToString>(data: S) -> Option<Self> {
        let mut main = vec![];
        let mut sideboard = vec![];
        for result in csv::Reader::from_reader(data.to_string().as_bytes()).records() {
            let record = match result {
                Ok(record) => record,
                _ => return None,
            };
            if record.len() != 3 {
                return None;
            }
            if record.index(0) == "Count" {
                continue;
            }
            let amount = match record.index(0).parse::<u16>() {
                Ok(amount) => amount,
                _ => return None,
            };
            let name = record.index(1);
            let position = record.index(2);
            let entry = (amount, name.to_string());
            match position {
                "main" => main.push(entry),
                "sideboard" => sideboard.push(entry),
                _ => return None,
            }
        }
        Some(Self { main, sideboard })
    }
}