src/main/java/gregtech/api/recipe/check/RecipeValidator.java


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

package gregtech.api.recipe.check;

import java.util.function.Function;
import java.util.function.Predicate;

import gregtech.api.util.GT_OverclockCalculator;
import gregtech.api.util.GT_ParallelHelper;
import gregtech.api.util.GT_Recipe;

/**
 * Predicate for simple recipe validation.
 * Also store some validation results for reusing it
 */
public class RecipeValidator implements Predicate<GT_Recipe> {

    private CheckRecipeResult firstCheckResult;
    private CheckRecipeResult lastCheckResult;
    private GT_ParallelHelper lastParallelHelper;
    private GT_OverclockCalculator lastOverclockCalculator;
    private boolean wasExecutedAtLeastOnce = false;
    private final Function<GT_Recipe, CheckRecipeResult> recipeValidator;
    private final Function<GT_Recipe, GT_ParallelHelper> parallelHelperFactory;
    private final Function<GT_Recipe, GT_OverclockCalculator> overclockCalculatorFactory;

    public RecipeValidator(Function<GT_Recipe, CheckRecipeResult> recipeValidator,
        Function<GT_Recipe, GT_ParallelHelper> parallelHelperFactory,
        Function<GT_Recipe, GT_OverclockCalculator> overclockCalculatorFactory) {
        this.recipeValidator = recipeValidator;
        this.parallelHelperFactory = parallelHelperFactory;
        this.overclockCalculatorFactory = overclockCalculatorFactory;
    }

    @Override
    public boolean test(GT_Recipe recipe) {
        wasExecutedAtLeastOnce = true;
        CheckRecipeResult checkRecipeResult = checkRecipe(recipe);
        if (firstCheckResult == null) {
            firstCheckResult = checkRecipeResult;
        }
        return checkRecipeResult.wasSuccessful();
    }

    private CheckRecipeResult checkRecipe(GT_Recipe recipe) {
        lastCheckResult = recipeValidator.apply(recipe);

        if (!lastCheckResult.wasSuccessful()) {
            return lastCheckResult;
        }

        lastParallelHelper = parallelHelperFactory.apply(recipe);
        lastOverclockCalculator = overclockCalculatorFactory.apply(recipe);
        lastParallelHelper.setCalculator(lastOverclockCalculator);
        lastParallelHelper.build();

        return lastParallelHelper.getResult();
    }

    public Boolean isExecutedAtLeastOnce() {
        return wasExecutedAtLeastOnce;
    }

    /**
     * Gets first check result in case if nothing matching recipe found.
     */
    public CheckRecipeResult getFirstCheckResult() {
        return firstCheckResult;
    }

    public CheckRecipeResult getLastCheckResult() {
        return lastCheckResult;
    }

    public GT_ParallelHelper getLastParallelHelper() {
        return lastParallelHelper;
    }

    public GT_OverclockCalculator getLastOverclockCalculator() {
        return lastOverclockCalculator;
    }
}