History.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2014 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.autopsy.coreutils;

import java.util.Objects;
import javafx.beans.property.ReadOnlyBooleanProperty;
import javafx.beans.property.ReadOnlyBooleanWrapper;
import javafx.beans.property.ReadOnlyObjectProperty;
import javafx.beans.property.ReadOnlyObjectWrapper;
import javafx.beans.property.SimpleListProperty;
import javafx.collections.FXCollections;
import javax.annotation.concurrent.GuardedBy;
import javax.annotation.concurrent.ThreadSafe;

@ThreadSafe
public class History<T> {

    // Stack of things that were previously shown before an 'advance' was done
    @GuardedBy("this")
    private final ObservableStack<T> historyStack = new ObservableStack<>();

    // stack of things that were previously shown before a 'retreat' (i.e. a back) was done
    @GuardedBy("this")
    private final ObservableStack<T> forwardStack = new ObservableStack<>();

    // what is currently being shown
    @GuardedBy("this")
    private final ReadOnlyObjectWrapper<T> currentState = new ReadOnlyObjectWrapper<>();

    // Is the forward stack empty?
    @GuardedBy("this")
    private final ReadOnlyBooleanWrapper canAdvance = new ReadOnlyBooleanWrapper();

    // is the historyStack empty?
    @GuardedBy("this")
    private final ReadOnlyBooleanWrapper canRetreat = new ReadOnlyBooleanWrapper();

    synchronized public T getCurrentState() {
        return currentState.get();
    }

    synchronized public boolean canAdvance() {
        return canAdvance.get();
    }

    synchronized public boolean canRetreat() {
        return canRetreat.get();
    }

    synchronized public ReadOnlyObjectProperty<T> currentState() {
        return currentState.getReadOnlyProperty();
    }

    synchronized public ReadOnlyBooleanProperty getCanAdvance() {
        return canAdvance.getReadOnlyProperty();
    }

    synchronized public ReadOnlyBooleanProperty getCanRetreat() {
        return canRetreat.getReadOnlyProperty();
    }

    public History(T initialState) {
        this();
        currentState.set(initialState);
    }

    public History() {
        canAdvance.bind(forwardStack.emptyProperty().not());
        canRetreat.bind(historyStack.emptyProperty().not());
    }

    synchronized public void reset(T newState) {
        forwardStack.clear();
        historyStack.clear();
        currentState.set(newState);
    }

    synchronized public T advance() {
        final T peek = forwardStack.peek();

        if (peek != null && peek.equals(currentState.get()) == false) {
            historyStack.push(currentState.get());
            currentState.set(peek);
            forwardStack.pop();
        }
        return peek;
    }

    synchronized public T retreat() {
        final T pop = historyStack.pop();

        if (pop != null && pop.equals(currentState.get()) == false) {
            forwardStack.push(currentState.get());
            currentState.set(pop);
            return pop;
        } else if (pop != null && pop.equals(currentState.get())) {
            return retreat();
        }
        return pop;
    }

    synchronized public void advance(T newState) throws IllegalArgumentException {
        if (newState != null && Objects.equals(currentState.get(), newState) == false) {
            if (currentState.get() != null) {
                historyStack.push(currentState.get());
            }
            currentState.set(newState);
            if (newState.equals(forwardStack.peek())) {
                forwardStack.pop();
            } else {
                forwardStack.clear();
            }
        }
    }

    synchronized public void clear() {
        historyStack.clear();
        forwardStack.clear();
        currentState.set(null);
    }

    private static class ObservableStack<T> extends SimpleListProperty<T> {

        public ObservableStack() {
            super(FXCollections.<T>synchronizedObservableList(FXCollections.<T>observableArrayList()));
        }

        public void push(T item) {
            synchronized (this) {
                add(0, item);
            }
        }

        public T pop() {
            synchronized (this) {
                if (isEmpty()) {
                    return null;
                } else {
                    return remove(0);
                }
            }
        }

        public T peek() {
            synchronized (this) {
                if (isEmpty()) {
                    return null;
                } else {
                    return get(0);
                }
            }
        }
    }
}