florent.becker
/
kikikoz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Ajout / suppressions de queues, priorités

master
Florent Becker 2022-07-23 18:31:25 +02:00
parent 5c5cabb4d0
commit 72e27dc20d
1 changed files with 249 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

445
src/main.rs
View File

@ -1,270 +1,323 @@
use sycamore::prelude::*;
use sycamore::builder::prelude::*;
use sycamore::rt::JsCast;
use rand::prelude::*;
use rand::distributions::Alphanumeric; use rand::distributions::Alphanumeric;
use rand::prelude::*;
enum NomQueue { use sycamore::builder::prelude::*;
A, B use sycamore::prelude::*;
} use sycamore::rt::JsCast;
#[derive(Clone, Copy, PartialEq, Eq)] #[derive(Clone, Copy, PartialEq, Eq)]
enum ModeQueue { enum ModeQueue {
Chrono, Chrono,
Aléatoire Aléatoire,
} }
impl ModeQueue { impl ModeQueue {
fn set_aléatoire(&mut self, b: bool) { fn set_aléatoire(&mut self, b: bool) {
match b { match b {
false => { *self = ModeQueue::Chrono}, false => *self = ModeQueue::Chrono,
true => { *self = ModeQueue::Aléatoire}, true => *self = ModeQueue::Aléatoire,
} }
} }
} }
impl std::fmt::Display for ModeQueue { impl std::fmt::Display for ModeQueue {
fn fmt(&self, fmt: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { fn fmt(&self, fmt: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
let s = match self { let s = match self {
ModeQueue::Chrono => "Chrono", ModeQueue::Chrono => "Chrono",
ModeQueue::Aléatoire => "Aléatoire" ModeQueue::Aléatoire => "Aléatoire",
}; };
write!(fmt, "{}", s) write!(fmt, "{}", s)
} }
} }
#[derive(Clone)] #[derive(Clone)]
struct ÉtatQueue<'a> { struct ÉtatQueue<'a> {
nom: String, nom: String,
id: usize,
mode: &'a Signal<ModeQueue>, mode: &'a Signal<ModeQueue>,
contenu: &'a Signal<Vec<String>>, contenu: &'a Signal<Vec<String>>,
nouvelleau: &'a Signal<String>, nouvelleau: &'a Signal<String>,
priorité: &'a Signal<u8>, priorité: &'a Signal<u8>,
crédit_parole: &'a Signal<f32>,
à_détruire: &'a Signal<bool>,
} }
impl<'a> PartialEq for ÉtatQueue<'a> {
fn eq(&self, other: &Self) -> bool {
self.id == other.id
}
}
impl<'a> Eq for ÉtatQueue<'a> {}
impl<'a> ÉtatQueue<'a> { impl<'a> ÉtatQueue<'a> {
fn new<'b>(cx: BoundedScope<'a, 'b>, nom: &str) -> Self { fn new<'b>(cx: BoundedScope<'a, 'b>, nom: &str) -> Self {
ÉtatQueue { ÉtatQueue {
nom: nom.into(), nom: nom.into(),
mode: create_signal(cx, ModeQueue::Aléatoire), mode: create_signal(cx, ModeQueue::Aléatoire),
contenu: create_signal(cx, vec![]), contenu: create_signal(cx, vec![]),
nouvelleau: create_signal(cx, "".into()), nouvelleau: create_signal(cx, "".into()),
priorité: create_signal(cx, 1.into()), priorité: create_signal(cx, 1),
} crédit_parole: create_signal(cx, 0.0),
id: thread_rng().gen(),
à_détruire: create_signal(cx, false),
}
} }
fn len(&self) -> usize { fn len(&self) -> usize {
return self.contenu.get().len() return self.contenu.get().len();
} }
fn enqueue(&mut self, rng: &mut ThreadRng) { fn enqueue(&mut self, rng: &mut ThreadRng) {
// //
let s = &self.nouvelleau; let s = &self.nouvelleau;
let n = self.len(); let n = self.len();
let k = match *self.mode.get() { let k = match *self.mode.get() {
ModeQueue::Chrono => n, ModeQueue::Chrono => n,
ModeQueue::Aléatoire => { ModeQueue::Aléatoire => rng.gen_range(0, n + 1),
rng.gen_range(0, n + 1) };
} self.contenu.modify().insert(k, s.to_string())
};
self.contenu.modify().insert(k, s.to_string())
} }
fn dequeue(&mut self) -> Option<String> { fn dequeue(&mut self) -> Option<String> {
if self.len() > 0 { *self.crédit_parole.modify() -= 1.0;
Some(self.contenu.modify().remove(0)) if self.len() > 0 {
} else { Some(self.contenu.modify().remove(0))
None } else {
} None
}
} }
} }
#[derive(Prop)] #[derive(Prop)]
struct QueueProp<'a>{ struct QueueProp<'a> {
q: ÉtatQueue<'a> q: ÉtatQueue<'a>,
} }
fn validate_queue<'a>(mut queue: ÉtatQueue<'a>) -> impl FnMut(web_sys::Event) + 'a { fn validate_queue<'a>(mut queue: ÉtatQueue<'a>) -> impl FnMut(web_sys::Event) + 'a {
move |ev: web_sys::Event| { move |ev: web_sys::Event| {
let mut rng = thread_rng(); let mut rng = thread_rng();
let event : web_sys::KeyboardEvent = ev.unchecked_into(); let event: web_sys::KeyboardEvent = ev.unchecked_into();
if event.key_code() == 13 { if event.key_code() == 13 && !event.ctrl_key() {
queue.enqueue(&mut rng); queue.enqueue(&mut rng);
queue.nouvelleau.set(String::new()) queue.nouvelleau.set(String::new())
} }
} }
} }
// #[component]
// fn Queue<'a, G: Html>(cx: Scope<'a>, queue: QueueProp<'a>) -> View<G> {
// let queue_courante = use_context::<Signal<NomQueue>>(cx);
// }
#[component] #[component]
fn ConfigQueue<'a, G: Html>(cx: Scope<'a>, queue: QueueProp<'a>) -> View<G> { fn ConfigQueue<'a, G: Html>(cx: Scope<'a>, q: QueueProp<'a>) -> View<G> {
let queue: ÉtatQueue = q.q;
let prio_str = create_signal(cx, String::new()); let prio_str = create_signal(cx, String::new());
let est_aléatoire = create_signal(cx, true); //*queue.q.mode.get() == ModeQueue::Aléatoire); let est_aléatoire = create_signal(cx, true); //*queue.q.mode.get() == ModeQueue::Aléatoire);
let nom = queue.q.nom; let nom = queue.nom;
let suffix = rand::thread_rng() let suffix = rand::thread_rng()
.sample_iter(&Alphanumeric) .sample_iter(&Alphanumeric)
.take(15) .take(15)
.map(char::from) .map(char::from)
.collect::<String>(); .collect::<String>();
create_effect(cx, || create_effect(cx, || {
if let Ok(p) = prio_str.get().parse::<u8>() { if let Ok(p) = prio_str.get().parse::<u8>() {
queue.q.priorité.set(p) queue.priorité.set(p)
}); }
create_effect(cx, || prio_str.set(format!("{}", queue.q.priorité.get()))); });
create_effect(cx, || prio_str.set(format!("{}", queue.priorité.get())));
create_effect(cx, || create_effect(cx, || {
queue.q.mode.modify().set_aléatoire(*est_aléatoire.get())); queue.mode.modify().set_aléatoire(*est_aléatoire.get())
create_effect(cx, || est_aléatoire.set(*queue.q.mode.get() == ModeQueue::Aléatoire)); });
create_effect(cx, || {
est_aléatoire.set(*queue.mode.get() == ModeQueue::Aléatoire)
});
section() section()
.c(h3().dyn_t(move || nom.clone())) .c(h3().dyn_t(move || nom.clone()))
.c(input() .c(input()
.attr("type", "checkbox") .attr("type", "checkbox")
.dyn_attr("id", { let suffix = suffix.clone(); .dyn_attr("id", {
move || Some(format!("mode_queue_{}", &suffix.clone())) let suffix = suffix.clone();
}) move || Some(format!("mode_queue_{}", &suffix.clone()))
.bind_checked(est_aléatoire) })
) .bind_checked(est_aléatoire))
.c(label() .c(label()
.dyn_attr("for", { .dyn_attr("for", {
let suffix = suffix.clone(); let suffix = suffix.clone();
move || Some(format!("mode_queue_{}", &suffix.clone())) move || Some(format!("mode_queue_{}", &suffix.clone()))
}) })
.t("Entrée aléatoire") .t("Entrée aléatoire"))
) .c(br())
.c(br()) .c(input()
.c(input() .dyn_attr("id", {
.dyn_attr("id", { let suffix = suffix.clone(); let suffix = suffix.clone();
move || Some(format!("prio_queue_{}", &suffix.clone())) move || Some(format!("prio_queue_{}", &suffix.clone()))
}) })
.attr("type", "range") .attr("type", "range")
.attr("min", "1") .attr("min", "1")
.attr("max", "7") .attr("max", "7")
.bind_value(prio_str) .bind_value(prio_str))
) .c(label()
.c( .dyn_attr("for", {
label() let suffix = suffix.clone();
.dyn_attr("for", { let suffix = suffix.clone(); move || Some(format!("prio_queue_{}", &suffix.clone()))
move || Some(format!("prio_queue_{}", &suffix.clone())) })
}) .dyn_t(|| format!("Priorité: {}", queue.priorité.get())))
.dyn_t(|| format!("Priorité: {}", queue.q.priorité.get())) .c(button()
) .t("Supprimer")
.view(cx) .on("click", move |ev| (queue.à_détruire.set(true))))
.view(cx)
} }
#[component] #[component]
fn Queue<'a, G: Html>(cx: Scope<'a>, queue: QueueProp<'a>) -> View<G> { fn Queue<'a, G: Html>(cx: Scope<'a>, queue: QueueProp<'a>) -> View<G> {
let ok_queue = validate_queue(queue.q.clone()); let ok_queue = validate_queue(queue.q.clone());
view! { cx, view! { cx,
div { div {
section(class="queue") { section(class="queue") {
h3 {(queue.q.nom)} h3 {(format!("{} ({} - {})", queue.q.nom, queue.q.crédit_parole.get(), queue.q.priorité.get()))}
input(type="text", bind:value = queue.q.nouvelleau, on:keypress=ok_queue) {} input(type="text", bind:value = queue.q.nouvelleau, on:keypress=ok_queue) {}
ul { ul {
Keyed { Keyed {
iterable: queue.q.contenu, iterable: queue.q.contenu,
view: |cx, item: String| view! {cx, li { (item) }}, view: |cx, item: String| view! {cx, li { (item) }},
key: |x| x.clone() key: |x| x.clone()
} }
} }
} }
} }
} }
} }
fn main() { fn main() {
sycamore::render(|cx| { sycamore::render(|cx| {
let prochainə = create_signal(cx, String::from("personne encore")); let prochainə = create_signal(cx, String::from("personne encore"));
let conf_visible = create_signal(cx, false); let conf_visible = create_signal(cx, false);
let queue_A = ÉtatQueue::new(cx, "Gauche"); let queues = create_signal(
let queue_B = ÉtatQueue::new(cx, "Droite"); cx,
let queue_courante = create_signal(cx, NomQueue::A); vec![ÉtatQueue::new(cx, "Gauche"), ÉtatQueue::new(cx, "Droite")],
provide_context_ref(cx, queue_courante); );
let next = { let supprime_queue =
let mut my_queue_A = queue_A.clone(); create_effect(cx, || queues.modify().retain(|q| !(*q.à_détruire.get())));
let mut my_queue_B = queue_B.clone(); let queues_suppression = queues.clone();
move |_ev| { let index_queues = create_memo(cx, {
let (queue, next) = match *queue_courante.get() { || (0..queues.get().len()).into_iter().collect::<Vec<_>>()
NomQueue::A => (&mut my_queue_A, NomQueue::B), });
NomQueue::B => (&mut my_queue_B, NomQueue::A) let total_priorités: &ReadSignal<usize> = create_memo(cx, {
}; let queues = queues.clone();
match queue.dequeue() { move || {
Some(p) => prochainə.set(p), queues
None => () .get()
} .iter()
queue_courante.set(next); .map(|q| *q.priorité.get() as usize)
} .sum()
}
}; });
let queue_courante: &ReadSignal<(usize, usize)> = create_memo(cx, {
let queue_A_pour_aff = queue_A.clone(); let queues = queues.clone();
let queue_A_pour_conf = queue_A.clone(); move || {
let queue_B_pour_aff = queue_B.clone(); let (idx, (id, _q)) = queues
let queue_B_pour_conf = queue_B.clone(); .get()
.iter()
.map(|q| (q.id, *q.crédit_parole.get()))
.enumerate()
.max_by(|(ia, (id_a, a)), (ib, (id_b, b))| {
a.partial_cmp(b).expect("Tried to compare a NaN")
})
.expect("bla");
(idx, id)
}
});
provide_context_ref(cx, queue_courante);
let next = {
let mut queues = queues.clone();
let queue_courante = queue_courante.clone();
move |_ev| {
//js_sys::alert("coucou");
let mut queue: ÉtatQueue = queues.get()[queue_courante.get().0].clone();
match queue.dequeue() {
Some(p) => prochainə.set(p),
None => (),
}
for q in queues.get().iter() {
*q.crédit_parole.modify() +=
(*q.priorité.get() as f32) / (*total_priorités.get() as f32)
}
}
};
let nom_nouvelle_file = create_signal(cx, String::new());
let nouvelle_file = {
let mut queues = queues.clone();
move |_ev| {
let q = ÉtatQueue::new(cx, &nom_nouvelle_file.get());
queues.modify().push(q);
*nom_nouvelle_file.modify() = String::new();
}
};
view! { cx, view! { cx,
main { div(on:keypress= {let mut next = next.clone();
h1 { "Kikikoz" } move |ev: web_sys::Event| {
p(class="orateurice") { let event: web_sys::KeyboardEvent = ev.clone().unchecked_into();
"On écoute " (prochainə.get()) "." if event.key_code() == 13 && event.ctrl_key() {
br {} next(ev)
button(on:click=next) { "Suivantə" } }
} }
section(id="les_queues") { }) {
div(class=(match *queue_courante.get(){NomQueue::A=> "active", NomQueue::B=>"attente"})) { main {
Queue { h1 { "Kikikoz" }
q: queue_A_pour_aff p(class="orateurice") {
} "On écoute " (prochainə.get()) "."
} br {}
button(on:click=next) { "Suivantə" }
}
section(id="les_queues") {
Keyed {
iterable: queues, //_pour_aff,
key: |q| q.id,
view: {
let queue_courante = queue_courante.clone();
move |cx, q|
view!{ cx,
div(class=(if queue_courante.get().1 == q.id {"active"} else {"attente"})) {
Queue {q}
}
div(class=(match *queue_courante.get(){NomQueue::B=>"active", NomQueue::A=>"attente"})) { }
Queue { }
q: queue_B_pour_aff }
} }
} }
} aside {
} button(on:click=|_| conf_visible.set(! *conf_visible.get())) {
aside { (
button(on:click=|_| conf_visible.set(! *conf_visible.get())) { if *conf_visible.get() {
( "cacher"
if *conf_visible.get() { } else {
"cacher" "configuration"
} else { }
"configuration" )
} }
)
}
div(class=if *conf_visible.get() { "visible" } else { "hidden" }) { div(class=if *conf_visible.get() { "visible" } else { "hidden" }) {
h2 { "Configuration" } h2 { "Configuration" }
ConfigQueue { Keyed {
q: queue_A_pour_conf iterable: queues,
} key: |q| q.id,
ConfigQueue { view: |cx, q| view!{cx, ConfigQueue{ q }}
q: queue_B_pour_conf }
} section {
// section { h3 {"Nouvelle file" }
// h3 { "Queue B" } input(type="text", bind:value=nom_nouvelle_file, on:keypress=move |ev: web_sys::Event| {
// input(type="checkbox", id="mélanger_queue_B") {} let event : web_sys::KeyboardEvent = ev.clone().unchecked_into();
// label(for="enable_queue_B") {"Randomiser"} if event.key_code() == 13 && !event.ctrl_key() {
// br {} nouvelle_file(ev)
// input(type="range", id="prio_queue_B", min="1", max="7", bind:value=queue_B.priorité) {} }
// label(for="prio_queue_B") {"Priorité "} // (queue_B.priorité.get())} }) {}
// } button(on:click=nouvelle_file) { "Créer" }
} }
} }
} }
}
}
}); });
} }