Как можно сделать откат и повтор OOP?

Question

[Egor Tini]

echo $calculate->init(20).
    ->compute('+', 2)
    ->replay();
    ->undo();
    ->getResult();

каким образом можно реализовать откат и повтор метода в OOP?

Comments

[Дмитрий]

Смотря на сколько шагов. На один все просто. Просто храним клона

[Egor Tini]

Дмитрий, на 1 нужно

[Дмитрий]

Egor Tini, делаешь приватный метод, который сохраняет клон в свойстве. Перед операцией вызываешь метод, метод undo просто возвращает клон. Повтор операции, надо сохранять операцию и аргументы в свойстве, метод повтора вызываешь операцию с аргументами

Answer 1

[Василий Банников]

В таком виде можно реализовать это при помощи стека.
В самом начале кладёте в поле началное значение
При вызове compute - кладёте в стек операцию и значение
При вызове replay - кладёте в стек операцию и значение с верхушки стека
При вызове undo - убираете пару с верхушки тека
При вызове getResult - применяете все операции к сохранённому начальному значению

Comments

[Egor Tini]

а можно более подробно?

[Василий Банников]

Egor Tini, придумал, как можно вообще почти без паттернов сделать. Правда пример не на php будет.

[Egor Tini]

Василий Банников, мне нужно на php oop

[Василий Банников]

Egor Tini,

use std::ops::{Add, Div, Mul, Sub};
pub struct Calculator<Value: Add + Sub + Div + Mul + Copy> {
    init: Value,
    actions: Vec<Action<Value>>,
}

#[derive(Clone, Copy)]
pub enum Action<Value: Add + Sub + Div + Mul + Copy> {
    Add(Value),
    Sub(Value),
    Mul(Value),
    Div(Value),
}
impl<Value> Calculator<Value>
where
    Value: Add<Output = Value>
        + Sub<Output = Value>
        + Div<Output = Value>
        + Mul<Output = Value>
        + Copy,
{
    pub fn new(value: Value) -> Self {
        Self {
            init: value,
            actions: Vec::new(),
        }
    }

    pub fn apply(&mut self, action: Action<Value>) -> &mut Self {
        self.actions.push(action);
        self
    }

    pub fn replay(&mut self) -> &mut Self {
        let last_action = *self.actions.last().unwrap();
        self.apply(last_action);
        self
    }

    pub fn undo(&mut self) -> &mut Self {
        self.actions.pop();
        self
    }

    pub fn result(&self) -> Value {
        (&self.actions)
            .into_iter()
            .fold(self.init, |acc, action| match action {
                Action::Add(v) => acc + *v,
                Action::Sub(v) => acc - *v,
                Action::Mul(v) => acc * *v,
                Action::Div(v) => acc / *v,
            })
    }
}

Короче просто стек со всеми действиями заведи.

[Egor Tini]

Василий Банников, а можно на PHP?

[Василий Банников]

Egor Tini, Обновил ответ. Там подробное описание алгоритма.

Answer 2

[Антон Шаманов]

откат с какого метода до какого? проще всего хранить собственный клон и в случае отката вернуть его.

Answer 3

[rPman]

2 основных подхода к реализации отката:
1. вместо вычислений, на каждом шаге просто добавляете или удаляете описание операций (иногда подойдут обычные замыкания) в специальный массив, реальные вычисления проводите в момент когда запрашивается результат
2. каждый шаг вычислений сохраняет предыдущее значение в специальном массиве, соответственно откат - это получение этого значения и удаление последнего элемента в масссиве (если не нужен redo)

Оба подхода имеют свои плюсы и минусы, для простого калькулятора удобнее второй подход, а вот редактора сложного документа - первый.

Так же возможно сочетание обоих подходов, для оптимизации ресурсов.