YAxis.java

Go to the documentation of this file.

package cedar.hepdata.model;

import java.util.*;
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>();

    //@Embedded
    //private Observable _observable = null;
    @Column(name="Observable", nullable=true)
    private String _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(Dataset dataset) {
        this();
        log().debug("Making a YAxis (1 arg constructor)");
        setDataset(dataset);
    }

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

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




    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);
        }
        return this;
    }


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


    public Set<AxisReaction> getReactions() {
        return _reactions;
    }
    public YAxis setReactions(Set<AxisReaction> reactions) {
        getReactions().clear();
        for (AxisReaction r : reactions) addReaction(r);
        return this;
    }
    public YAxis addReaction(AxisReaction reaction) {
        if (reaction != null) {
            reaction.setYAxis(this);
        } 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 String getObservable() {
        return _observable;
    }

    public YAxis setObservable(String observable) {
        _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>)");
        this.getPoints().clear();
        for (Point p : points) addPoint(p);
        return this;
    }

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

    public YAxis setPoints(Point[] points) {
        setPoints(Arrays.asList(points));
        return this;
    }

    public YAxis addPoint(Point point) {
        if (point != null) {
            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);
        } else {
            log().warn("Tried to remove a null Point from a YAxis");
        }
        log().debug("Removing point: done");
        return this;
    }

    public YAxis setPoints(double[] pointvals) {
        this.getPoints().clear();
        for (Double pv : pointvals) addPoint(pv);
        return this;
    }

    public YAxis addPoint(double pointval) {
        return addPoint(new Point(pointval));
    }

    public YAxis removePoint(double pointval) {
        return removePoint(new Point(pointval));
    }


    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) {
            axisError.setAxis(this);
        } 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;
    }


    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;
    }


    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());
        s.append(indent + "Observable: " + getObservable());
        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;
        return hashCode() == other.hashCode();
    }


    public int hashCode() {
        int code = 31;
        if (getDataset() != null) code ^= getDataset().hashCode();
        if (getHeader()  != null) code ^= getHeader().hashCode();
        if (getUnit()    != null) code ^= getUnit().hashCode();
        return code;
    }

}

---