YAxis.java

Go to the documentation of this file.

package cedar.hepdata.model;

import java.util.Collection;
import java.util.Arrays;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.Set;
import java.util.HashSet;
import java.util.List;
import java.util.Vector;

import javax.persistence.*;

import cedar.hepdata.util.Unit;

@Entity
@Table(name="YAxes")
public class YAxis extends Axis implements Comparable<YAxis> {
    @Column(name="LocalId", nullable=false)
    private Integer _localId;

    @OneToMany(mappedBy="_yAxis")
    @org.hibernate.annotations.Fetch(value=org.hibernate.annotations.FetchMode.JOIN)
    @org.hibernate.annotations.Cascade(value={org.hibernate.annotations.CascadeType.ALL,
                                              org.hibernate.annotations.CascadeType.DELETE_ORPHAN})
    @org.hibernate.annotations.Sort(type=org.hibernate.annotations.SortType.NATURAL)
    @org.hibernate.annotations.BatchSize(size=20)
    private SortedSet<Point> _points = new TreeSet<Point>();

    @org.hibernate.annotations.CollectionOfElements
    @JoinTable(name="AxisErrors", joinColumns=@JoinColumn(name="AXIS_ID"))
    @org.hibernate.annotations.CollectionId(columns=@Column(name="AxisErrorId"),
                                            type=@org.hibernate.annotations.Type(type="long"),
                                            generator="sequence")
    @org.hibernate.annotations.Sort(type=org.hibernate.annotations.SortType.NATURAL)
    @org.hibernate.annotations.BatchSize(size=5)
    private SortedSet<AxisError> _errors = new TreeSet<AxisError>();

    @OneToMany(mappedBy="_yAxis")
    @org.hibernate.annotations.Cascade(value={org.hibernate.annotations.CascadeType.ALL,
                                              org.hibernate.annotations.CascadeType.DELETE_ORPHAN})
    private Set<AxisProperty> _properties = new HashSet<AxisProperty>();

    @OneToMany(mappedBy="_yAxis")
    @org.hibernate.annotations.Cascade(value={org.hibernate.annotations.CascadeType.ALL,
                                              org.hibernate.annotations.CascadeType.DELETE_ORPHAN})
    private Set<AxisReaction> _reactions = new HashSet<AxisReaction>();

    @ManyToOne
    @org.hibernate.annotations.Cascade(value={org.hibernate.annotations.CascadeType.ALL})
    private Observable _observable = null;

    @org.hibernate.annotations.CollectionOfElements
    @JoinTable(name="YAxisComments", joinColumns=@JoinColumn(name="AXIS_ID"))
    @org.hibernate.annotations.IndexColumn(name="Posn")
    @Column(name="Comments", length=10000)
    private List<String> _comments = new Vector<String>();

    @ManyToOne
    protected Dataset _dataset;




    public YAxis() {
        super();
        log().debug("Making a YAxis (0 arg constructor)");
    }

    public YAxis(String header) {
        super(header);
        log().debug("Making a YAxis (1 arg constructor)");
    }

    public YAxis(String header, Unit unit) {
        super(header, unit);
        log().debug("Making a YAxis (2 arg constructor)");
    }

    public YAxis(Dataset dataset) {
        this();
        setDataset(dataset);
        log().debug("Making a YAxis (1 arg constructor)");
    }

    public YAxis(Dataset dataset, String header) {
        this(header);
        setDataset(dataset);
        log().debug("Making a YAxis (2 arg constructor)");
    }

    public YAxis(Dataset dataset, String header, Unit unit) {
        this(header, unit);
        setDataset(dataset);
        log().debug("Making a YAxis (3 arg constructor)");
    }

    public YAxis(Observable observable) {
        this();
        log().debug("Making a YAxis (1 arg constructor)");
        setObservable(observable);
    }

    public YAxis(Observable observable, String header) {
        this(header);
        log().debug("Making a YAxis (2 arg constructor)");
        setObservable(observable);
    }

    public YAxis(Observable observable, String header, Unit unit) {
        this(header, unit);
        log().debug("Making a YAxis (3 arg constructor)");
        setObservable(observable);
    }

    public YAxis(Dataset dataset, Observable observable) {
        this(dataset);
        log().debug("Making a YAxis (2 arg constructor)");
        setObservable(observable);
    }

    public YAxis(Dataset dataset, Observable observable, String header) {
        this(dataset, header);
        log().debug("Making a YAxis (3 arg constructor)");
        setObservable(observable);
    }

    public YAxis(Dataset dataset, Observable observable, String header, Unit unit) {
        this(dataset, header, unit);
        log().debug("Making a YAxis (4 arg constructor)");
        setObservable(observable);
    }




    public Paper getPaper() {
        if (getDataset() != null) {
            return getDataset().getPaper();
        } else {
            return null;
        }
    }


    // Comments
    public List<String> getComments() {
        return _comments;
    }
    public YAxis setComments(List<String> comments) {
        _comments = comments;
        return this;
    }
    public YAxis addComment(String comment) {
        _comments.add(comment);
        return this;
    }
    public YAxis removeComment(String comment) {
        _comments.remove(comment);
        return this;
    }




    public Integer getId() {
        return _localId;
    }
    public YAxis setId(Integer yAxisId) {
        _localId = yAxisId;
        return this;
    }


    public Dataset getDataset() {
        return _dataset;
    }
    public YAxis setDataset(Dataset dataset) {
        log().debug("Calling setDataset()");
        _dataset = dataset;
        if (dataset != null) {
            if (getId() == null) {
                int highestId = 0;
                if (dataset.getYAxes().size() > 0) {
                    highestId = dataset.getYAxes().last().getId();
                }
                log().debug("Incrementing y-axis ID: " + (highestId + 1));
                setId(highestId + 1);
            }
            log().debug("Adding myself to a Dataset");
            dataset.getYAxes().add(this);
        } else {
            log().warn("Tried to attach a YAxis to a null Dataset");
        }
        return this;
    }


    public SortedSet<XAxis> getXAxes() {
        if (getDataset() != null) {
            return getDataset().getXAxes();
        } else {
            return null;
        }
    }


    // Reactions
    public Set<AxisReaction> getReactions() {
        return _reactions;
    }
    public YAxis setReactions(Set<AxisReaction> reactions) {
        _reactions = reactions;
        return this;
    }
    public YAxis addReaction(AxisReaction reaction) {
        if (reaction != null) {
            reaction.setYAxis(this);
            _reactions.add(reaction);
        } else {
            log().warn("Tried to add a null reaction to a y-axis");
        }
        return this;
    }
    public YAxis removeReaction(AxisReaction reaction) {
        if (reaction != null) {
            reaction.setYAxis(null);
            _reactions.remove(reaction);
        } else {
            log().warn("Tried to remove a null reaction from a y-axis");
        }
        return this;
    }


    public Observable getObservable() {
        return _observable;
    }

    public YAxis setObservable(Observable observable) {
        if (observable != null) observable.getYAxes().add(this);
        _observable = observable;
        return this;
    }


    public SortedSet<Point> getPoints() {
        return _points;
    }

    public Point getPoint(Integer pointId) {
        Point thePoint = null;
        for (Point p : getPoints()) {
            if (p.getId().equals(pointId)) {
                thePoint = p;
                break;
            }
        }
        return thePoint;
    }

    public YAxis setPoints(SortedSet<Point> points) {
        log().debug("Calling setPoints(SortedSet<Point>)");
        _points = points;
        return this;
    }

//     /** Set points from a Collection. */
//     public YAxis setPoints(Collection<Point> points) {
//         log().debug("Calling setPoints(Collection<Point>)");
//         this.points.clear();
//         for (Point p : points) addPoint(p);
//         return this;
//     }

//     /** Set points from an array. */
//     public YAxis setPoints(Point[] points) {
//         setPoints(Arrays.asList(points));
//         return this;
//     }

    public YAxis addPoint(Point point) {
        if (point != null) {
            if (point.getId() == null) {
                int highestId = 0;
                if (getPoints().size() > 0) {
                    highestId = getPoints().last().getId();
                }
                log().debug("Incrementing point ID: " + (highestId + 1));
                point.setId(highestId + 1);
            }
            log().debug("Adding point to y-axis " + getId() + ": ID = " + point.getId());
            point.setYAxis(this);
        } else {
            log().warn("Tried to add a null Point to a YAxis");
        }
        return this;
    }

    public YAxis removePoint(Point point) {
        log().debug("Removing point: " + point);
        if (point != null) {
            getPoints().remove(point);
            point.setYAxis(null);
        } else {
            log().warn("Tried to remove a null Point from a YAxis");
        }
        log().debug("Removing point: done");
        return this;
    }


    // Axis errors
    public SortedSet<AxisError> getErrors() {
        return _errors;
    }
    public YAxis setErrors(SortedSet<AxisError> axisErrors) {
        getErrors().clear();
        for (AxisError e : axisErrors) addError(e);
        return this;
    }
    public YAxis setErrors(Collection<AxisError> axisErrors) {
        getErrors().clear();
        for (AxisError e : axisErrors) addError(e);
        return this;
    }
    public YAxis addError(AxisError axisError) {
        if (axisError != null) {
            getErrors().add(axisError);
            // Auto-increment the local ID if necessary
            if (axisError.getId() == null) {
                if (getErrors().last() != null && getErrors().last().getId() != null) {
                    axisError.setId(getErrors().last().getId() + 1);
                } else {
                    axisError.setId(getErrors().size() + 1);
                }
            }
        } else {
            log().warn("Tried to add a null AxisError to a YAxis");
        }
        return this;
    }
    public YAxis removeError(AxisError axisError) {
        if (axisError != null) {
            getErrors().remove(axisError);
        } else {
            log().warn("Tried to remove a null AxisError from a YAxis");
        }
        return this;
    }


    // Other errors
    public SortedSet<Uncertainty> getDatasetErrors() {
        SortedSet<Uncertainty> dsErrors = new TreeSet<Uncertainty>();
        if (getDataset() != null) {
            dsErrors.addAll( getDataset().getErrors() );
        }
        return dsErrors;
    }
    public SortedSet<Uncertainty> getAllErrors() {
        SortedSet<Uncertainty> allErrors = new TreeSet<Uncertainty>();
        allErrors.addAll(getErrors());
        allErrors.addAll(getDatasetErrors());
        return allErrors;
    }


    // Properties
    public Set<AxisProperty> getProperties() {
        return _properties;
    }
    public YAxis setProperties(Set<AxisProperty> properties) {
        _properties = properties;
        return this;
    }
    public YAxis addProperty(AxisProperty property) {
        if (property != null) {
            property.setYAxis(this);
            _properties.add(property);
        } else {
            log().warn("Tried to add a null AxisProperty to a YAxis");
        }
        return this;
    }
    public YAxis removeProperty(AxisProperty property) {
        if (property != null) {
            property.setYAxis(null);
            _properties.remove(property);
        } else {
            log().warn("Tried to remove a null AxisProperty from a YAxis");
        }
        return this;
    }




    public int compareTo(YAxis other) {
        log().debug("Comparing y-axes...");
        if (getId() == null) {
            log().debug("Null YAxis ID");
            return 1; // Sort null y-axes at the end
        } else if (getId() > other.getId()) {
            log().debug("Greater than");
            return 1;
        } else if (getId() < other.getId()) {
            log().debug("Less than");
            return -1;
        } else {
            log().debug("Equal to");
            return 0;
        }
    }




    public String toString() {
        return toString(0);
    }

    public String toString(Integer indentBy) {
        log().debug("Writing out y-axis as a string");
        StringBuffer s = new StringBuffer();
        String indent = "";
        for (int i  = 0; i < indentBy; ++i) indent += " ";

        s.append(indent + "Y-axis ID: " + getId() + "\n");
        s.append(indent + "Header: " + getHeader());
        for (Point point : getPoints()) {
            s.append("\n" + point.toString(indentBy + 2));
        }
        return s.toString();
    }




    public boolean equals(Object other) {
        if (this == other) return true;
        if (! (other instanceof YAxis)) return false;

        final YAxis test = (YAxis) other;
        if (! test.getPaper().equals(getPaper()) ) return false;
        if (! test.getDataset().equals(getDataset()) ) return false;
        if (! test.getHeader().equals(getHeader()) ) return false;
        if (! test.getUnit().equals(getUnit()) ) return false;
        return true;
    }

    public int hashCode() {
        int code = 0;
        if (getPaper()   != null) code += 1000000 * getPaper().hashCode();
        if (getDataset() != null) code += 100 * getDataset().hashCode();
        if (getHeader()  != null) code += 10 * getHeader().hashCode();
        if (getUnit()    != null) code += getUnit().hashCode();
        code *= 2; // ensure this is even
        return code;
    }

}

---