praktikum-holons/src/holeg/model/Flexibility.java

package holeg.model;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

/**
 * Representative of a flexibility for a HolonElement.
 */
public class Flexibility {
    /*
     *  MODEL
     */
    /**
     * The Name of a Flexibility.
     */
    public String name;
    /**
     * How fast in TimeSteps the Flexibility can be activated.
     */
    public int speed;
    /**
     * How high the cost for a activation are.
     */
    public float cost;
    /**
     * SHould this Flexibility be Offered when is constrainList is fulfilled the flexibility can be activated.
     */
    public boolean offered;
    /**
     * The List of Constrains the Flexibility
     */
    public List<Constrain> constrainList;
    /**
     * The owner of the Flexibility.
     */
    private transient HolonElement element;
    /**
     * The Duration in TimeSteps how long the Flexibility is activated.
     */
    private int duration;
    /** The Element this flexibility is assigned.*/
    /**
     * The Duration after a successful activation between the next possible activation.
     */
    private int cooldown;
    /*
     *  STATE
     */
    private transient FlexState state = FlexState.OFFERED;
    private transient int timeStep;
    private transient int activationTime = -1;
    private transient int durationEndTime = -1;
    private transient int coolDownEndTime = -1;

    public Flexibility(HolonElement element) {
        this(0, 0.f, 1, 0, false, element);
    }

    public Flexibility(int speed, float cost, int duration, int cooldown, boolean offered, HolonElement element) {
        this.speed = speed;
        this.cost = cost;
        setDuration(duration);
        setCooldown(cooldown);
        this.offered = offered;
        this.element = element;
        constrainList = new ArrayList<Constrain>();
    }

    public HolonElement getElement() {
        return element;
    }

    public void setElement(HolonElement element) {
        this.element = element;
    }

    public int getDuration() {
        return duration;
    }

    /**
     * Minimum duration is 1 TimeStep.
     */
    public void setDuration(int duration) {
        this.duration = Math.max(1, duration);
    }

    public int getCooldown() {
        return cooldown;
    }

    /**
     * No negative cooldown TimeSteps.
     */
    public void setCooldown(int cooldown) {
        this.cooldown = Math.max(0, cooldown);
    }

    /**
     * returns the total energy Amount accumulated over the TimeSteps.
     */
    public float magnitude() {
        return ((float) duration) * element.getEnergy();
    }

    public float energyReleased() {
        return (constrainList.stream().map(Constrain::getName).anyMatch(name -> name.equals("onConstrain")) ? -1.0f : 1.0f) * element.getEnergy();
    }

    public boolean isPositive() {
        return energyReleased() >= 0;
    }

    public boolean isNegative() {
        return energyReleased() < 0;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    @Override
    public String toString() {
        return "Flexibility: " + name + " from [HolonElement: " + element.getName() + "]";
    }

    void calculateState(int timestep) {
        this.timeStep = timestep;
        state = revalidateState();
    }
    public boolean order() {
        if (canOrder()) {
            state = FlexState.IN_USE;
            durationEndTime = timeStep + this.getDuration();
            coolDownEndTime = durationEndTime + this.getCooldown();
            activationTime = timeStep;
            return true;
        }
        return false;
    }

    public boolean cancel() {
        if (activationTime == timeStep) {
            reset();
            return true;
        }
        return false;
    }

    void reset() {
        durationEndTime = -1;
        coolDownEndTime = -1;
        state = revalidateState();
    }

    public boolean canActivate() {
        return remainingTimeTillActivation() == 0;
    }

    public boolean canOrder() {
        boolean flexIsOffered = state.equals(FlexState.OFFERED);
        return flexIsOffered && !element.isFlexActive();
    }

    public FlexState getState() {
        return state;
    }

    public int remainingTimeTillActivation() {
        return Math.max(0, coolDownEndTime - timeStep);
    }

    public int remainingDuration() {
        return Math.max(0, durationEndTime - timeStep);
    }

    /**
     * Checks if all assigned constrains are fulfilled. When no constrains assigned returns true.
     */
    private boolean fulfillsConstrains() {
        return constrainList.stream().map(Constrain::getConstrainFunction).reduce(Predicate::and).orElse(f -> true).test(this);
    }

    private FlexState revalidateState() {
        if (canActivate()) {
            if (!this.fulfillsConstrains() || element.isFlexActive()) {
                return FlexState.UNAVAILABLE;
            } else if (this.offered) {
                return FlexState.OFFERED;
            }
            return FlexState.NOT_OFFERED;
        } else if (remainingDuration() == 0) {
            return FlexState.ON_COOLDOWN;
        } else {
            return FlexState.IN_USE;
        }
    }

    public enum FlexState {
        IN_USE, ON_COOLDOWN, OFFERED, NOT_OFFERED, UNAVAILABLE
    }



}