praktikum-holons/src/classes/CpsEdge.java

package classes;

import com.google.gson.annotations.Expose;

import java.util.ArrayList;

/**
 * The class "CpsEdge" represents the connections on the GUI. Each connection
 * contains a max. capacity, a flow, a status (isWorking), tags (for internal
 * use of electricity flow), source and destination
 *
 * @author Gruppe14
 */
public class CpsEdge {

    public static final int CON_UPPER_NODE = 0;
    public static final int CON_UPPER_NODE_AND_INSIDE = 1;
    public static final int CON_UPPER_NODE_NOT_INSIDE = 2;

    public static final float CAPACITY_INFINITE = -1;
    public static final float CAPACITY_TO_UPPER_NODE = -2;
    // Max. capacity of the Edge, if flow is greater than the status --> is
    // Working would be false
    @Expose
    float maxCapacity;
    // for internal use --> flow of electricity (simulation state)
    // Current flow of electricity (through the edge)
    @Expose
    float flow;
    /*
     * Represents the actual status of the Edge (true = flows electricity; false
     * = no flow of electricity) State represents the real status of the edge If
     * it breaks --> stay ruin no matter the actual scenario The only way to
     * repair it is through manual change (setStateEdge)
     */
    @Expose
    boolean isWorking;
    /*
     * 0 = not connected to an upper node
     * 1 = connected to an uppder node & connected inside
     * 2 = connected to an upper node but not inside
     * Is false when not
     */
    @Expose
    int isConnected;
    ArrayList<Integer> tags;
    // for internal use --> flow of electricity (simulation state)
    ArrayList<Integer> pseudoTags;
    // Source
    AbstractCpsObject a;
    // Destination
    AbstractCpsObject b;

    /**
     * Constructor without max. capacity (by default as 100)
     *
     * @param a Source
     * @param b Destination
     */
    public CpsEdge(AbstractCpsObject a, AbstractCpsObject b) {
        setA(a);
        setB(b);
        this.a.addConnection(this);
        this.b.addConnection(this);
        this.maxCapacity = 100;
        flow = 0;
        isWorking = true;
        pseudoTags = new ArrayList<>();
    }

    /**
     * Constructor with a user-defined max. capacity
     *
     * @param a      Source
     * @param b      Destination
     * @param maxCap Maximum Capacity
     */
    public CpsEdge(AbstractCpsObject a, AbstractCpsObject b, float maxCap) {
        setA(a);
        setB(b);
        this.a.addConnection(this);
        this.b.addConnection(this);
        this.maxCapacity = maxCap;
        flow = 0;
        isWorking = true;
        isConnected = CON_UPPER_NODE;
        pseudoTags = new ArrayList<>();
    }

    /**
     * Getter for the max. capacity
     *
     * @return the capacity
     */
    public float getCapacity() {
        return maxCapacity;
    }

    /**
     * Setter for the max. capacity
     *
     * @param cap the Capacity to set
     */
    public void setCapacity(float cap) {
        this.maxCapacity = cap;
    }

    /**
     * Getter fot the current flow.
     *
     * @return the flow
     */
    public float getFlow() {
        return flow;
    }

    /**
     * Set the flow into a new one.
     *
     * @param flow the flow to set
     */
    public void setFlow(float flow) {
        this.flow = flow;
        /**
         * if (flow <= maxCapacity || flow == -1) { isWorking = true; } else {
         * isWorking = false; state = false;
         **/
    }

    /**
     * Calculates the state of the edge (see description of isWorking).
     */
    public void calculateState() {
        if (flow > maxCapacity
                && maxCapacity != CAPACITY_INFINITE
                && maxCapacity != CAPACITY_TO_UPPER_NODE) {
            isWorking = false;
            flow = 0;
        }
    }

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

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

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

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

    /**
     * Getter for the status.
     *
     * @return the state
     */
    public boolean isWorking() {
        return isWorking;
    }

    /**
     * Set the state manually to a new one.
     *
     * @param state the state
     */
    public void setWorkingState(boolean state) {
        isWorking = state;
    }

    /**
     * Getter for the ArrayList of tags.
     *
     * @return tags tags for this edge
     */
    public ArrayList<Integer> getTags() {
        return tags;
    }

    /**
     * set the tags into a new set of tags.
     *
     * @param tags tags for this edge
     */
    public void setTags(ArrayList<Integer> tags) {
        this.tags = tags;
    }

    /**
     * Add a new tag to the ArrayList.
     *
     * @param tag tag for the ArrayList
     */
    public void addTag(int tag) {
        if (!tags.contains(tag)) {
            tags.add(tag);
        }
    }

    /**
     * checks whether list contains all given tags
     *
     * @param toCheck tags that are checked
     * @param list    list to be checked
     * @return true if all tags in toCheck are contained in list, false otherwise
     */
    public boolean containsTags(ArrayList<Integer> list, ArrayList<Integer> toCheck) {
        if (toCheck.size() == 0) {
            return true;
        } else {
            for (Integer i : toCheck) {
                if (!(list.contains(i))) {
                    return false;
                }
            }
            return true;
        }
    }

    public void addPseudoTag(int tag) {
        if (!pseudoTags.contains(tag)) {
            pseudoTags.add(tag);
        }
    }

    public void setPseudoTag(ArrayList<Integer> list) {
        pseudoTags = list;
    }

    public ArrayList<Integer> getPseudoTags() {
        return pseudoTags;
    }

    public void recalculateTags() {
        for (Integer i : pseudoTags) {
            if (!tags.contains(i)) {
                tags.add(i);
            }
        }
    }

    public int getConnected() {
        return isConnected;
    }

    public void setConnected(int state) {
        isConnected = state;
        if (state == CON_UPPER_NODE_AND_INSIDE) {
            //maxCapacity = CAPACITY_TO_UPPER_NODE;
        }
    }
    
    /**
     * 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(AbstractCpsObject 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;
    }

}