GitHub/Anki
1
0
Fork 0
mirror of https://github.com/ankitects/anki.git synced 2025-09-25 01:06:35 -04:00
Code Issues Projects Releases Packages 1 Wiki Activity Actions

split review/learn/new/relearn

Browse source
This commit is contained in:
Damien Elmes 2021-02-23 15:11:39 +10:00
parent e74210717a
commit b887057448
4 changed files with 140 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

59
rslib/src/scheduler/answering/learn.rs Normal file
View file

@ -0,0 +1,59 @@
// Copyright: Ankitects Pty Ltd and contributors
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
use crate::{
card::{CardQueue, CardType},
prelude::*,
scheduler::states::{CardState, IntervalKind, LearnState, NewState},
};
use super::{CardStateUpdater, RevlogEntryPartial};
impl CardStateUpdater {
pub(super) fn apply_new_state(
&mut self,
current: CardState,
next: NewState,
) -> Result<Option<RevlogEntryPartial>> {
self.card.ctype = CardType::New;
self.card.queue = CardQueue::New;
self.card.due = next.position as i32;
Ok(RevlogEntryPartial::maybe_new(
current,
next.into(),
0.0,
self.secs_until_rollover(),
))
}
pub(super) fn apply_learning_state(
&mut self,
current: CardState,
next: LearnState,
) -> Result<Option<RevlogEntryPartial>> {
self.card.remaining_steps = next.remaining_steps;
self.card.ctype = CardType::Learn;
let interval = next
.interval_kind()
.maybe_as_days(self.secs_until_rollover());
match interval {
IntervalKind::InSecs(secs) => {
self.card.queue = CardQueue::Learn;
self.card.due = TimestampSecs::now().0 as i32 + secs as i32;
}
IntervalKind::InDays(days) => {
self.card.queue = CardQueue::DayLearn;
self.card.due = (self.timing.days_elapsed + days) as i32;
}
}
Ok(RevlogEntryPartial::maybe_new(
current,
next.into(),
0.0,
self.secs_until_rollover(),
))
}
}

109
rslib/src/scheduler/answering/mod.rs
View file

@ -2,12 +2,15 @@
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html // License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
mod current_state; mod current_state;
mod learn;
mod preview; mod preview;
mod relearn;
mod review;
mod revlog; mod revlog;
use crate::{ use crate::{
backend_proto, backend_proto,
card::{CardQueue, CardType}, card::CardQueue,
deckconf::{DeckConf, LeechAction}, deckconf::{DeckConf, LeechAction},
decks::Deck, decks::Deck,
prelude::*, prelude::*,
@ -17,10 +20,7 @@ use revlog::RevlogEntryPartial;
use super::{ use super::{
cutoff::SchedTimingToday, cutoff::SchedTimingToday,
states::{ states::{CardState, FilteredState, NextCardStates, NormalState, ReschedulingFilterState},
CardState, FilteredState, IntervalKind, LearnState, NewState, NextCardStates, NormalState,
RelearnState, ReschedulingFilterState, ReviewState,
},
timespan::answer_button_time_collapsible, timespan::answer_button_time_collapsible,
}; };
@ -96,105 +96,6 @@ impl CardStateUpdater {
Ok(revlog) Ok(revlog)
} }
fn apply_new_state(
&mut self,
current: CardState,
next: NewState,
) -> Result<Option<RevlogEntryPartial>> {
self.card.ctype = CardType::New;
self.card.queue = CardQueue::New;
self.card.due = next.position as i32;
Ok(RevlogEntryPartial::maybe_new(
current,
next.into(),
0.0,
self.secs_until_rollover(),
))
}
fn apply_learning_state(
&mut self,
current: CardState,
next: LearnState,
) -> Result<Option<RevlogEntryPartial>> {
self.card.remaining_steps = next.remaining_steps;
self.card.ctype = CardType::Learn;
let interval = next
.interval_kind()
.maybe_as_days(self.secs_until_rollover());
match interval {
IntervalKind::InSecs(secs) => {
self.card.queue = CardQueue::Learn;
self.card.due = TimestampSecs::now().0 as i32 + secs as i32;
}
IntervalKind::InDays(days) => {
self.card.queue = CardQueue::DayLearn;
self.card.due = (self.timing.days_elapsed + days) as i32;
}
}
Ok(RevlogEntryPartial::maybe_new(
current,
next.into(),
0.0,
self.secs_until_rollover(),
))
}
fn apply_review_state(
&mut self,
current: CardState,
next: ReviewState,
) -> Result<Option<RevlogEntryPartial>> {
self.card.remove_from_filtered_deck_before_reschedule();
self.card.queue = CardQueue::Review;
self.card.ctype = CardType::Review;
self.card.interval = next.scheduled_days;
self.card.due = (self.timing.days_elapsed + next.scheduled_days) as i32;
self.card.ease_factor = (next.ease_factor * 1000.0).round() as u16;
self.card.lapses = next.lapses;
Ok(RevlogEntryPartial::maybe_new(
current,
next.into(),
next.ease_factor,
self.secs_until_rollover(),
))
}
fn apply_relearning_state(
&mut self,
current: CardState,
next: RelearnState,
) -> Result<Option<RevlogEntryPartial>> {
self.card.interval = next.review.scheduled_days;
self.card.remaining_steps = next.learning.remaining_steps;
self.card.ctype = CardType::Relearn;
let interval = next
.interval_kind()
.maybe_as_days(self.secs_until_rollover());
match interval {
IntervalKind::InSecs(secs) => {
self.card.queue = CardQueue::Learn;
self.card.due = TimestampSecs::now().0 as i32 + secs as i32;
}
IntervalKind::InDays(days) => {
self.card.queue = CardQueue::DayLearn;
self.card.due = (self.timing.days_elapsed + days) as i32;
}
}
Ok(RevlogEntryPartial::maybe_new(
current,
next.into(),
next.review.ease_factor,
self.secs_until_rollover(),
))
}
fn apply_rescheduling_filter_state( fn apply_rescheduling_filter_state(
&mut self, &mut self,
current: CardState, current: CardState,

43
rslib/src/scheduler/answering/relearn.rs Normal file
View file

@ -0,0 +1,43 @@
// Copyright: Ankitects Pty Ltd and contributors
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
use crate::{
card::{CardQueue, CardType},
prelude::*,
scheduler::states::{CardState, IntervalKind, RelearnState},
};
use super::{CardStateUpdater, RevlogEntryPartial};
impl CardStateUpdater {
pub(super) fn apply_relearning_state(
&mut self,
current: CardState,
next: RelearnState,
) -> Result<Option<RevlogEntryPartial>> {
self.card.interval = next.review.scheduled_days;
self.card.remaining_steps = next.learning.remaining_steps;
self.card.ctype = CardType::Relearn;
let interval = next
.interval_kind()
.maybe_as_days(self.secs_until_rollover());
match interval {
IntervalKind::InSecs(secs) => {
self.card.queue = CardQueue::Learn;
self.card.due = TimestampSecs::now().0 as i32 + secs as i32;
}
IntervalKind::InDays(days) => {
self.card.queue = CardQueue::DayLearn;
self.card.due = (self.timing.days_elapsed + days) as i32;
}
}
Ok(RevlogEntryPartial::maybe_new(
current,
next.into(),
next.review.ease_factor,
self.secs_until_rollover(),
))
}
}

33
rslib/src/scheduler/answering/review.rs Normal file
View file

@ -0,0 +1,33 @@
// Copyright: Ankitects Pty Ltd and contributors
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
use crate::{
card::{CardQueue, CardType},
prelude::*,
scheduler::states::{CardState, ReviewState},
};
use super::{CardStateUpdater, RevlogEntryPartial};
impl CardStateUpdater {
pub(super) fn apply_review_state(
&mut self,
current: CardState,
next: ReviewState,
) -> Result<Option<RevlogEntryPartial>> {
self.card.remove_from_filtered_deck_before_reschedule();
self.card.queue = CardQueue::Review;
self.card.ctype = CardType::Review;
self.card.interval = next.scheduled_days;
self.card.due = (self.timing.days_elapsed + next.scheduled_days) as i32;
self.card.ease_factor = (next.ease_factor * 1000.0).round() as u16;
self.card.lapses = next.lapses;
Ok(RevlogEntryPartial::maybe_new(
current,
next.into(),
next.ease_factor,
self.secs_until_rollover(),
))
}
}