162 lines
4.2 KiB
Rust
162 lines
4.2 KiB
Rust
// src/logic.rs
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use std::fmt;
|
|
|
|
#[derive(Default, Serialize, Deserialize, PartialEq)]
|
|
enum Stav {
|
|
#[default] Nova = 0,
|
|
Pouzivana = 1,
|
|
Poskodena = 2,
|
|
Vyradena = 3,
|
|
}
|
|
|
|
impl fmt::Display for Stav {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Stav::Nova => write!(f, "Nova"),
|
|
Stav::Pouzivana => write!(f, "Pouzivana"),
|
|
Stav::Poskodena => write!(f, "Poskodena"),
|
|
Stav::Vyradena => write!(f, "Vyradena")
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default, Serialize, Deserialize)]
|
|
struct Kniha {
|
|
autori: Vec<String>,
|
|
nazov: String,
|
|
vydavatelstvo: String,
|
|
zaner: String,
|
|
pocet_stran: usize,
|
|
isbn: String,
|
|
rok_vydania: usize,
|
|
je_pozicana: bool,
|
|
stav_knihy: Stav,
|
|
}
|
|
|
|
impl fmt::Display for Kniha {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(f, "(Autori: {},
|
|
Nazov: {},
|
|
Vydavatelstvo: {},
|
|
Zaner: {},
|
|
Pocet stran: {},
|
|
ISBN: {},
|
|
Rok vydania: {},
|
|
Je pozicana {},
|
|
Stav knihy: {})",
|
|
self.autori.join(", "),
|
|
self.nazov,
|
|
self.vydavatelstvo,
|
|
self.zaner,
|
|
self.pocet_stran,
|
|
self.isbn,
|
|
self.rok_vydania,
|
|
self.je_pozicana,
|
|
self.stav_knihy,
|
|
)
|
|
}
|
|
}
|
|
|
|
|
|
#[derive(Default, Serialize, Deserialize)]
|
|
struct Kniznica {
|
|
knihy: Vec<Kniha>
|
|
}
|
|
|
|
impl Kniznica {
|
|
// Asociovana funkcia
|
|
fn nacitaj_zo_suboru(cesta: &std::path::PathBuf) -> Option<Self>{
|
|
let obsah = match std::fs::read_to_string(cesta) {
|
|
Ok(text) => text,
|
|
Err(_) => return None,
|
|
};
|
|
let kniznica = match serde_json::from_str(obsah.as_str()) {
|
|
Ok(k) => k,
|
|
Err(_) => return None,
|
|
};
|
|
Some(kniznica)
|
|
}
|
|
// Metoda
|
|
fn uloz_do_suboru(&self, cesta: &std::path::PathBuf) -> bool {
|
|
let converted = match serde_json::to_string(&self) {
|
|
Ok(k) => k,
|
|
Err(_) => return false,
|
|
};
|
|
match std::fs::write(cesta, converted) {
|
|
Ok(_) => return true,
|
|
Err(_) => return false,
|
|
};
|
|
}
|
|
|
|
fn pridaj_knihu(&mut self, nova_kniha: Kniha) -> Result<(), ()> {
|
|
for x in &self.knihy {
|
|
if x.isbn == nova_kniha.isbn {
|
|
return Err(());
|
|
}
|
|
}
|
|
self.knihy.push(nova_kniha);
|
|
Ok(())
|
|
}
|
|
|
|
fn pridaj_knihu2(&mut self, nova_kniha: Kniha) -> Result<(), ()> {
|
|
let moze = self.knihy.iter()
|
|
.all(|x| x.isbn != nova_kniha.isbn);
|
|
if moze {
|
|
self.knihy.push(nova_kniha);
|
|
} else {
|
|
return Err(());
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn odstran_knihu(&mut self, isbn: &str) -> Result<Kniha, ()> {
|
|
if let Some(index) = self.knihy.iter()
|
|
.position(|x| x.isbn == isbn) {
|
|
let kniha = self.knihy.remove(index);
|
|
Ok(kniha)
|
|
} else {
|
|
Err(())
|
|
}
|
|
|
|
}
|
|
|
|
fn daj_knihu_podla_isbn(&self, isbn: &str) -> Option<&Kniha> {
|
|
if let Some(vrat) = self.knihy.iter().find(|x| x.isbn == isbn) {
|
|
return Some(vrat);
|
|
}
|
|
None
|
|
}
|
|
|
|
fn daj_knihy_podla_stavu(&self, stav_knihy: Stav) -> Vec<&Kniha> {
|
|
self.knihy.iter().filter(|x| x.stav_knihy == stav_knihy).collect()
|
|
}
|
|
|
|
fn vypis_vydavatelstva_a_pocet_knih(&self) {
|
|
// hashmap obsahuje <K, V> kde K moze byt string a V pocet
|
|
let mut mapa = std::collections::HashMap::new();
|
|
for k in &self.knihy {
|
|
let meno = &k.vydavatelstvo;
|
|
|
|
let novy_pocet = match mapa.get(meno) {
|
|
Some(pocet) => pocet + 1,
|
|
None => 1,
|
|
};
|
|
|
|
mapa.insert(meno, novy_pocet);
|
|
|
|
}
|
|
for (vyd, pocet) in mapa {
|
|
println!("{}: {}", vyd, pocet);
|
|
}
|
|
}
|
|
|
|
fn vypis_knihy_daneho_zanru(&self, zaner_st: &str) {
|
|
let k = &self.knihy.iter().filter(|x| x.zaner == zaner_st).collect();
|
|
for x in k {
|
|
|
|
}
|
|
}
|
|
}
|