Upstream/ShopChest-Updated
1
0
Fork 0
mirror of https://github.com/Flowsqy/ShopChest.git synced 2025-01-23 10:01:20 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Generify basic operators and conditions and merge 'and' & 'or' condition

Browse Source
This commit is contained in:
Flowsqy 2022-02-16 16:02:38 +01:00
parent 4d7c0434ae
commit 2926e345fa
12 changed files with 171 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
plugin/src/main/java/de/epiceric/shopchest/config/hologram/calculation/Calculation.java
View File

@ -1,26 +1,23 @@
package de.epiceric.shopchest.config.hologram.calculation; package de.epiceric.shopchest.config.hologram.calculation;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.function.Function; import java.util.function.Function;
/** /**
* Represents a hologram calculation * Represents a hologram calculation
*/ */
public interface Calculation { public interface Calculation<P> {
double calculate(Map<HologramFormat.Requirement, Object> provider); double calculate(P provider);
abstract class AbstractCalculation implements Calculation { abstract class AbstractCalculation<P> implements Calculation<P> {
protected final Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider; protected final Function<P, Double> firstArgProvider;
protected final Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider; protected final Function<P, Double> secondArgProvider;
public AbstractCalculation( public AbstractCalculation(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
this.firstArgProvider = firstArgProvider; this.firstArgProvider = firstArgProvider;
this.secondArgProvider = secondArgProvider; this.secondArgProvider = secondArgProvider;
@ -30,7 +27,7 @@ public interface Calculation {
public boolean equals(Object o) { public boolean equals(Object o) {
if (this == o) return true; if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; if (o == null || getClass() != o.getClass()) return false;
AbstractCalculation that = (AbstractCalculation) o; AbstractCalculation<?> that = (AbstractCalculation<?>) o;
return Objects.equals(firstArgProvider, that.firstArgProvider) && Objects.equals(secondArgProvider, that.secondArgProvider); return Objects.equals(firstArgProvider, that.firstArgProvider) && Objects.equals(secondArgProvider, that.secondArgProvider);
} }
@ -41,18 +38,18 @@ public interface Calculation {
} }
class Addition extends AbstractCalculation { class Addition<P> extends AbstractCalculation<P> {
public Addition( public Addition(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public double calculate(Map<HologramFormat.Requirement, Object> requirementValues) { public double calculate(P values) {
return this.firstArgProvider.apply(requirementValues) + secondArgProvider.apply(requirementValues); return this.firstArgProvider.apply(values) + secondArgProvider.apply(values);
} }
@Override @Override
@ -61,18 +58,18 @@ public interface Calculation {
} }
} }
class Subtraction extends AbstractCalculation { class Subtraction<P> extends AbstractCalculation<P> {
public Subtraction( public Subtraction(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public double calculate(Map<HologramFormat.Requirement, Object> requirementValues) { public double calculate(P values) {
return this.firstArgProvider.apply(requirementValues) - secondArgProvider.apply(requirementValues); return this.firstArgProvider.apply(values) - secondArgProvider.apply(values);
} }
@Override @Override
@ -81,18 +78,18 @@ public interface Calculation {
} }
} }
class Multiplication extends AbstractCalculation { class Multiplication<P> extends AbstractCalculation<P> {
public Multiplication( public Multiplication(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public double calculate(Map<HologramFormat.Requirement, Object> requirementValues) { public double calculate(P values) {
return this.firstArgProvider.apply(requirementValues) * secondArgProvider.apply(requirementValues); return this.firstArgProvider.apply(values) * secondArgProvider.apply(values);
} }
@Override @Override
@ -101,18 +98,18 @@ public interface Calculation {
} }
} }
class Division extends AbstractCalculation { class Division<P> extends AbstractCalculation<P> {
public Division( public Division(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public double calculate(Map<HologramFormat.Requirement, Object> requirementValues) { public double calculate(P values) {
return this.firstArgProvider.apply(requirementValues) / secondArgProvider.apply(requirementValues); return this.firstArgProvider.apply(values) / secondArgProvider.apply(values);
} }
@Override @Override
@ -121,18 +118,18 @@ public interface Calculation {
} }
} }
class Modulo extends AbstractCalculation { class Modulo<P> extends AbstractCalculation<P> {
public Modulo( public Modulo(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public double calculate(Map<HologramFormat.Requirement, Object> requirementValues) { public double calculate(P values) {
return this.firstArgProvider.apply(requirementValues) % secondArgProvider.apply(requirementValues); return this.firstArgProvider.apply(values) % secondArgProvider.apply(values);
} }
@Override @Override

35
plugin/src/main/java/de/epiceric/shopchest/config/hologram/condition/AbstractEqualityCondition.java
View File

@ -1,19 +1,16 @@
package de.epiceric.shopchest.config.hologram.condition; package de.epiceric.shopchest.config.hologram.condition;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.function.Function; import java.util.function.Function;
public abstract class AbstractEqualityCondition<T> implements Condition { public abstract class AbstractEqualityCondition<P, T> implements Condition<P> {
protected final Function<Map<HologramFormat.Requirement, Object>, T> firstArgProvider; protected final Function<P, T> firstArgProvider;
protected final Function<Map<HologramFormat.Requirement, Object>, T> secondArgProvider; protected final Function<P, T> secondArgProvider;
public AbstractEqualityCondition( public AbstractEqualityCondition(
Function<Map<HologramFormat.Requirement, Object>, T> firstArgProvider, Function<P, T> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, T> secondArgProvider Function<P, T> secondArgProvider
) { ) {
this.firstArgProvider = firstArgProvider; this.firstArgProvider = firstArgProvider;
this.secondArgProvider = secondArgProvider; this.secondArgProvider = secondArgProvider;
@ -23,7 +20,7 @@ public abstract class AbstractEqualityCondition<T> implements Condition {
public boolean equals(Object o) { public boolean equals(Object o) {
if (this == o) return true; if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; if (o == null || getClass() != o.getClass()) return false;
AbstractEqualityCondition<?> that = (AbstractEqualityCondition<?>) o; AbstractEqualityCondition<?, ?> that = (AbstractEqualityCondition<?, ?>) o;
return Objects.equals(firstArgProvider, that.firstArgProvider) && Objects.equals(secondArgProvider, that.secondArgProvider); return Objects.equals(firstArgProvider, that.firstArgProvider) && Objects.equals(secondArgProvider, that.secondArgProvider);
} }
@ -32,18 +29,18 @@ public abstract class AbstractEqualityCondition<T> implements Condition {
return Objects.hash(firstArgProvider, secondArgProvider); return Objects.hash(firstArgProvider, secondArgProvider);
} }
public static class EqualityCondition<T> extends AbstractEqualityCondition<T> { public static class EqualityCondition<P, T> extends AbstractEqualityCondition<P, T> {
public EqualityCondition( public EqualityCondition(
Function<Map<HologramFormat.Requirement, Object>, T> firstArgProvider, Function<P, T> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, T> secondArgProvider Function<P, T> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public boolean test(Map<HologramFormat.Requirement, Object> requirementValues) { public boolean test(P values) {
return Objects.equals(firstArgProvider.apply(requirementValues), secondArgProvider.apply(requirementValues)); return Objects.equals(firstArgProvider.apply(values), secondArgProvider.apply(values));
} }
@Override @Override
@ -53,18 +50,18 @@ public abstract class AbstractEqualityCondition<T> implements Condition {
} }
public static class InequalityCondition<T> extends AbstractEqualityCondition<T> { public static class InequalityCondition<P, T> extends AbstractEqualityCondition<P, T> {
public InequalityCondition( public InequalityCondition(
Function<Map<HologramFormat.Requirement, Object>, T> firstArgProvider, Function<P, T> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, T> secondArgProvider Function<P, T> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public boolean test(Map<HologramFormat.Requirement, Object> requirementValues) { public boolean test(P values) {
return !Objects.equals(firstArgProvider.apply(requirementValues), secondArgProvider.apply(requirementValues)); return !Objects.equals(firstArgProvider.apply(values), secondArgProvider.apply(values));
} }
@Override @Override

40
plugin/src/main/java/de/epiceric/shopchest/config/hologram/condition/AndCondition.java
View File

@ -1,40 +0,0 @@
package de.epiceric.shopchest.config.hologram.condition;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map;
import java.util.Objects;
public class AndCondition implements Condition {
private final Condition firstCondition;
private final Condition secondCondition;
public AndCondition(Condition firstCondition, Condition secondCondition) {
this.firstCondition = firstCondition;
this.secondCondition = secondCondition;
}
@Override
public boolean test(Map<HologramFormat.Requirement, Object> requirementValues) {
return firstCondition.test(requirementValues) && secondCondition.test(requirementValues);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
AndCondition that = (AndCondition) o;
return Objects.equals(firstCondition, that.firstCondition) && Objects.equals(secondCondition, that.secondCondition);
}
@Override
public int hashCode() {
return Objects.hash(firstCondition, secondCondition);
}
@Override
public String toString() {
return "(" + firstCondition.toString() + " && " + secondCondition.toString() + ")";
}
}

15
plugin/src/main/java/de/epiceric/shopchest/config/hologram/condition/BooleanCondition.java
View File

@ -1,29 +1,26 @@
package de.epiceric.shopchest.config.hologram.condition; package de.epiceric.shopchest.config.hologram.condition;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.function.Function; import java.util.function.Function;
public class BooleanCondition implements Condition { public class BooleanCondition<P> implements Condition<P> {
private final Function<Map<HologramFormat.Requirement, Object>, Boolean> booleanProvider; private final Function<P, Boolean> booleanProvider;
public BooleanCondition(Function<Map<HologramFormat.Requirement, Object>, Boolean> booleanProvider) { public BooleanCondition(Function<P, Boolean> booleanProvider) {
this.booleanProvider = booleanProvider; this.booleanProvider = booleanProvider;
} }
@Override @Override
public boolean test(Map<HologramFormat.Requirement, Object> requirementValues) { public boolean test(P values) {
return booleanProvider.apply(requirementValues); return booleanProvider.apply(values);
} }
@Override @Override
public boolean equals(Object o) { public boolean equals(Object o) {
if (this == o) return true; if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; if (o == null || getClass() != o.getClass()) return false;
BooleanCondition that = (BooleanCondition) o; BooleanCondition<?> that = (BooleanCondition<?>) o;
return Objects.equals(booleanProvider, that.booleanProvider); return Objects.equals(booleanProvider, that.booleanProvider);
} }

55
plugin/src/main/java/de/epiceric/shopchest/config/hologram/condition/ComparisonCondition.java
View File

@ -1,19 +1,16 @@
package de.epiceric.shopchest.config.hologram.condition; package de.epiceric.shopchest.config.hologram.condition;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.function.Function; import java.util.function.Function;
public abstract class ComparisonCondition implements Condition { public abstract class ComparisonCondition<P> implements Condition<P> {
protected final Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider; protected final Function<P, Double> firstArgProvider;
protected final Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider; protected final Function<P, Double> secondArgProvider;
public ComparisonCondition( public ComparisonCondition(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
this.firstArgProvider = firstArgProvider; this.firstArgProvider = firstArgProvider;
this.secondArgProvider = secondArgProvider; this.secondArgProvider = secondArgProvider;
@ -23,7 +20,7 @@ public abstract class ComparisonCondition implements Condition {
public boolean equals(Object o) { public boolean equals(Object o) {
if (this == o) return true; if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; if (o == null || getClass() != o.getClass()) return false;
ComparisonCondition that = (ComparisonCondition) o; ComparisonCondition<?> that = (ComparisonCondition<?>) o;
return Objects.equals(firstArgProvider, that.firstArgProvider) && Objects.equals(secondArgProvider, that.secondArgProvider); return Objects.equals(firstArgProvider, that.firstArgProvider) && Objects.equals(secondArgProvider, that.secondArgProvider);
} }
@ -32,18 +29,18 @@ public abstract class ComparisonCondition implements Condition {
return Objects.hash(firstArgProvider, secondArgProvider); return Objects.hash(firstArgProvider, secondArgProvider);
} }
public static class GreaterCondition extends ComparisonCondition { public static class GreaterCondition<P> extends ComparisonCondition<P> {
public GreaterCondition( public GreaterCondition(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public boolean test(Map<HologramFormat.Requirement, Object> requirementValues) { public boolean test(P values) {
return firstArgProvider.apply(requirementValues) > secondArgProvider.apply(requirementValues); return firstArgProvider.apply(values) > secondArgProvider.apply(values);
} }
@Override @Override
@ -53,18 +50,18 @@ public abstract class ComparisonCondition implements Condition {
} }
public static class LessCondition extends ComparisonCondition { public static class LessCondition<P> extends ComparisonCondition<P> {
public LessCondition( public LessCondition(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public boolean test(Map<HologramFormat.Requirement, Object> requirementValues) { public boolean test(P values) {
return firstArgProvider.apply(requirementValues) < secondArgProvider.apply(requirementValues); return firstArgProvider.apply(values) < secondArgProvider.apply(values);
} }
@Override @Override
@ -74,18 +71,18 @@ public abstract class ComparisonCondition implements Condition {
} }
public static class GreaterOrEqualCondition extends ComparisonCondition { public static class GreaterOrEqualCondition<P> extends ComparisonCondition<P> {
public GreaterOrEqualCondition( public GreaterOrEqualCondition(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public boolean test(Map<HologramFormat.Requirement, Object> requirementValues) { public boolean test(P values) {
return firstArgProvider.apply(requirementValues) >= secondArgProvider.apply(requirementValues); return firstArgProvider.apply(values) >= secondArgProvider.apply(values);
} }
@Override @Override
@ -95,18 +92,18 @@ public abstract class ComparisonCondition implements Condition {
} }
public static class LessOrEqualCondition extends ComparisonCondition { public static class LessOrEqualCondition<P> extends ComparisonCondition<P> {
public LessOrEqualCondition( public LessOrEqualCondition(
Function<Map<HologramFormat.Requirement, Object>, Double> firstArgProvider, Function<P, Double> firstArgProvider,
Function<Map<HologramFormat.Requirement, Object>, Double> secondArgProvider Function<P, Double> secondArgProvider
) { ) {
super(firstArgProvider, secondArgProvider); super(firstArgProvider, secondArgProvider);
} }
@Override @Override
public boolean test(Map<HologramFormat.Requirement, Object> requirementValues) { public boolean test(P values) {
return firstArgProvider.apply(requirementValues) <= secondArgProvider.apply(requirementValues); return firstArgProvider.apply(values) <= secondArgProvider.apply(values);
} }
@Override @Override

5
plugin/src/main/java/de/epiceric/shopchest/config/hologram/condition/Condition.java
View File

@ -1,13 +1,10 @@
package de.epiceric.shopchest.config.hologram.condition; package de.epiceric.shopchest.config.hologram.condition;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map;
import java.util.function.Predicate; import java.util.function.Predicate;
/** /**
* Represents a hologram requirement condition * Represents a hologram requirement condition
*/ */
public interface Condition extends Predicate<Map<HologramFormat.Requirement, Object>> { public interface Condition<P> extends Predicate<P> {
} }

62
plugin/src/main/java/de/epiceric/shopchest/config/hologram/condition/LogicCondition.java Normal file
View File

@ -0,0 +1,62 @@
package de.epiceric.shopchest.config.hologram.condition;
import java.util.Objects;
public abstract class LogicCondition<P> implements Condition<P> {
protected final Condition<P> firstCondition;
protected final Condition<P> secondCondition;
public LogicCondition(Condition<P> firstCondition, Condition<P> secondCondition) {
this.firstCondition = firstCondition;
this.secondCondition = secondCondition;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
LogicCondition<?> that = (LogicCondition<?>) o;
return Objects.equals(firstCondition, that.firstCondition) && Objects.equals(secondCondition, that.secondCondition);
}
@Override
public int hashCode() {
return Objects.hash(firstCondition, secondCondition);
}
public final static class AndCondition<P> extends LogicCondition<P> {
public AndCondition(Condition<P> firstCondition, Condition<P> secondCondition) {
super(firstCondition, secondCondition);
}
@Override
public boolean test(P values) {
return firstCondition.test(values) && secondCondition.test(values);
}
@Override
public String toString() {
return "(" + firstCondition.toString() + " && " + secondCondition.toString() + ")";
}
}
public final static class OrCondition<P> extends LogicCondition<P> {
public OrCondition(Condition<P> firstCondition, Condition<P> secondCondition) {
super(firstCondition, secondCondition);
}
@Override
public boolean test(P values) {
return firstCondition.test(values) || secondCondition.test(values);
}
@Override
public String toString() {
return "(" + firstCondition.toString() + " || " + secondCondition.toString() + ")";
}
}
}

40
plugin/src/main/java/de/epiceric/shopchest/config/hologram/condition/OrCondition.java
View File

@ -1,40 +0,0 @@
package de.epiceric.shopchest.config.hologram.condition;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map;
import java.util.Objects;
public class OrCondition implements Condition {
private final Condition firstCondition;
private final Condition secondCondition;
public OrCondition(Condition firstCondition, Condition secondCondition) {
this.firstCondition = firstCondition;
this.secondCondition = secondCondition;
}
@Override
public boolean test(Map<HologramFormat.Requirement, Object> requirementValues) {
return firstCondition.test(requirementValues) || secondCondition.test(requirementValues);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
OrCondition that = (OrCondition) o;
return Objects.equals(firstCondition, that.firstCondition) && Objects.equals(secondCondition, that.secondCondition);
}
@Override
public int hashCode() {
return Objects.hash(firstCondition, secondCondition);
}
@Override
public String toString() {
return "(" + firstCondition.toString() + " || " + secondCondition.toString() + ")";
}
}

15
plugin/src/main/java/de/epiceric/shopchest/config/hologram/condition/ReverseCondition.java
View File

@ -1,28 +1,25 @@
package de.epiceric.shopchest.config.hologram.condition; package de.epiceric.shopchest.config.hologram.condition;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map;
import java.util.Objects; import java.util.Objects;
public class ReverseCondition implements Condition { public class ReverseCondition<P> implements Condition<P> {
private final Condition condition; private final Condition<P> condition;
public ReverseCondition(Condition condition) { public ReverseCondition(Condition<P> condition) {
this.condition = condition; this.condition = condition;
} }
@Override @Override
public boolean test(Map<HologramFormat.Requirement, Object> requirementValues) { public boolean test(P values) {
return !condition.test(requirementValues); return !condition.test(values);
} }
@Override @Override
public boolean equals(Object o) { public boolean equals(Object o) {
if (this == o) return true; if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; if (o == null || getClass() != o.getClass()) return false;
ReverseCondition that = (ReverseCondition) o; ReverseCondition<?> that = (ReverseCondition<?>) o;
return Objects.equals(condition, that.condition); return Objects.equals(condition, that.condition);
} }

10
plugin/src/main/java/de/epiceric/shopchest/config/hologram/provider/ConstantProvider.java
View File

@ -1,11 +1,9 @@
package de.epiceric.shopchest.config.hologram.provider; package de.epiceric.shopchest.config.hologram.provider;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.function.Function;
public class ConstantProvider<T> implements RequirementProvider<T> { public class ConstantProvider<P, T> implements Function<P, T> {
private final T constant; private final T constant;
@ -15,7 +13,7 @@ public class ConstantProvider<T> implements RequirementProvider<T> {
@Override @Override
public T apply(Map<HologramFormat.Requirement, Object> requirementObjectMap) { public T apply(P values) {
return constant; return constant;
} }
@ -23,7 +21,7 @@ public class ConstantProvider<T> implements RequirementProvider<T> {
public boolean equals(Object o) { public boolean equals(Object o) {
if (this == o) return true; if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; if (o == null || getClass() != o.getClass()) return false;
ConstantProvider<?> that = (ConstantProvider<?>) o; ConstantProvider<?, ?> that = (ConstantProvider<?, ?>) o;
return Objects.equals(constant, that.constant); return Objects.equals(constant, that.constant);
} }

35
plugin/src/main/java/de/epiceric/shopchest/config/hologram/provider/MapProvider.java
View File

@ -1,15 +1,14 @@
package de.epiceric.shopchest.config.hologram.provider; package de.epiceric.shopchest.config.hologram.provider;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map; import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.function.Function;
public abstract class MapProvider<T> implements RequirementProvider<T> { public abstract class MapProvider<P, T> implements Function<Map<P, Object>, T> {
protected final HologramFormat.Requirement requirement; protected final P requirement;
public MapProvider(HologramFormat.Requirement requirement) { public MapProvider(P requirement) {
this.requirement = requirement; this.requirement = requirement;
} }
@ -17,7 +16,7 @@ public abstract class MapProvider<T> implements RequirementProvider<T> {
public boolean equals(Object o) { public boolean equals(Object o) {
if (this == o) return true; if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; if (o == null || getClass() != o.getClass()) return false;
MapProvider<?> that = (MapProvider<?>) o; MapProvider<?, ?> that = (MapProvider<?, ?>) o;
return requirement == that.requirement; return requirement == that.requirement;
} }
@ -31,41 +30,41 @@ public abstract class MapProvider<T> implements RequirementProvider<T> {
return requirement.toString(); return requirement.toString();
} }
public final static class StringMapProvider extends MapProvider<String> { public final static class StringMapProvider<P> extends MapProvider<P, String> {
public StringMapProvider(HologramFormat.Requirement requirement) { public StringMapProvider(P requirement) {
super(requirement); super(requirement);
} }
@Override @Override
public String apply(Map<HologramFormat.Requirement, Object> requirementValues) { public String apply(Map<P, Object> values) {
return (String) requirementValues.get(requirement); return (String) values.get(requirement);
} }
} }
public final static class BooleanMapProvider extends MapProvider<Boolean> { public final static class BooleanMapProvider<P> extends MapProvider<P, Boolean> {
public BooleanMapProvider(HologramFormat.Requirement requirement) { public BooleanMapProvider(P requirement) {
super(requirement); super(requirement);
} }
@Override @Override
public Boolean apply(Map<HologramFormat.Requirement, Object> requirementValues) { public Boolean apply(Map<P, Object> values) {
return (Boolean) requirementValues.get(requirement); return (Boolean) values.get(requirement);
} }
} }
public final static class DoubleMapProvider extends MapProvider<Double> { public final static class DoubleMapProvider<P> extends MapProvider<P, Double> {
public DoubleMapProvider(HologramFormat.Requirement requirement) { public DoubleMapProvider(P requirement) {
super(requirement); super(requirement);
} }
@Override @Override
public Double apply(Map<HologramFormat.Requirement, Object> requirementValues) { public Double apply(Map<P, Object> values) {
return (Double) requirementValues.get(requirement); return (Double) values.get(requirement);
} }
} }

10
plugin/src/main/java/de/epiceric/shopchest/config/hologram/provider/RequirementProvider.java
View File

@ -1,10 +0,0 @@
package de.epiceric.shopchest.config.hologram.provider;
import de.epiceric.shopchest.config.hologram.HologramFormat;
import java.util.Map;
import java.util.function.Function;
public interface RequirementProvider<T> extends Function<Map<HologramFormat.Requirement, Object>, T> {
}