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

package holeg.model;


public class Edge {

    // Max. capacity of the Edge, if flow is greater than the status --> is
    // Working would be false
    public float maxCapacity;
    // Source
    AbstractCanvasObject a;
    // Destination
    AbstractCanvasObject b;
    public EdgeMode mode = EdgeMode.Normal;
    private transient EdgeState state = initState();
    private transient float flowEnergy = 0;

    /**
     * Constructor with a user-defined max. capacity
     *
     * @param a      Source
     * @param b      Destination
     * @param maxCap Maximum Capacity
     */
    public Edge(AbstractCanvasObject a, AbstractCanvasObject b, float maxCap) {
        setA(a);
        setB(b);
        this.maxCapacity = maxCap;
    }


    /**
     * Clone Constructor
     */
    public Edge(Edge other) {
        setA(other.a);
        setB(other.b);
        this.maxCapacity = other.maxCapacity;
        this.state = other.state;
        this.mode = other.mode;
        this.flowEnergy = other.flowEnergy;
    }

    /**
     * Getter for the length of the Cable.
     */
    public float getLength() {
        return a.getPosition().getDistance(b.getPosition());
    }

    /**
     * Getter for the Source.
     *
     * @return the a
     */
    public AbstractCanvasObject getA() {
        return a;
    }

    /**
     * Set the Source to a new one.
     *
     * @param a the a to set
     */
    public void setA(AbstractCanvasObject a) {
        this.a = a;
    }

    /**
     * Getter for the destination.
     *
     * @return the b
     */
    public AbstractCanvasObject getB() {
        return b;
    }

    /**
     * Set the Destination to a new one.
     *
     * @param b the b to set
     */
    public void setB(AbstractCanvasObject b) {
        this.b = b;
    }

    /**
     * Check if a CpsEdge is Connected to the AbstractCpsObject.
     *
     * @param holonObject the AbstractCpsObject to check.
     * @return true if either a or b is the AbstractCpsObject to check.
     */
    public boolean isConnectedTo(AbstractCanvasObject holonObject) {
        return (holonObject.equals(a) || holonObject.equals(b));
    }

    @Override
    public String toString() {
        String A = (a == null) ? "null" : a.getName() + "[" + a.getId() + "]";
        String B = (b == null) ? "null" : b.getName() + "[" + b.getId() + "]";
        return "CpsEdge: " + A + " to " + B;
    }

    public EdgeState getState() {
        return state;
    }

    //TODO(Tom 2021-12-3): public -> package
    public void setState(EdgeState state) {
        this.state = state;
    }

    //TODO(Tom 2021-12-3): public -> package
    public void reset() {
        state = initState();
    }

    private EdgeState initState() {
        if (mode == EdgeMode.Disconnected) {
            return EdgeState.Burned;
        }
        return EdgeState.Working;
    }

    public float getActualFlow() {
        return flowEnergy;
    }

    //TODO(Tom 2021-12-3): public -> package
    public void setActualFlow(float energyToSupplyInTheNetwork) {
        flowEnergy = energyToSupplyInTheNetwork;
    }

    public float getEnergyFromConneted() {
        float energy = 0.0f;
        if (getA() instanceof HolonObject hO && hO.getActualEnergy() > 0) {
            energy += hO.getActualEnergy();
        }
        if (getB() instanceof HolonObject hO && hO.getActualEnergy() > 0) {
            energy += hO.getActualEnergy();
        }
        return energy;
    }

    public enum EdgeMode {
        Normal, Unlimited, Disconnected
    }

    /*
     * STATE
     */
    public enum EdgeState {
        Working, Burned
    }
}