Dataset.java

Go to the documentation of this file.

package cedar.hepdata.model;

import java.util.*;
import org.apache.log4j.*;

import javax.persistence.*;

@Entity
@Table(name="Datasets")
public class Dataset extends Storeable implements Comparable<Dataset> {
    @Id @GeneratedValue
    @Column(name="DATASET_ID")
    private Long _id;

    @ManyToOne
    private Paper _paper;

    @Column(name="LocalId", nullable=false)
    private Integer _localId;

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

    @org.hibernate.annotations.CollectionOfElements
    @JoinTable(name="DatasetErrors", joinColumns=@JoinColumn(name="DATASET_ID"))
    @org.hibernate.annotations.CollectionId(columns=@Column(name="DatasetErrorId"),
                                            type=@org.hibernate.annotations.Type(type="long"),
                                            generator="sequence")
    @org.hibernate.annotations.Sort(type=org.hibernate.annotations.SortType.NATURAL)
    private SortedSet<DatasetError> _errors = new TreeSet<DatasetError>();

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

    @OneToMany(mappedBy="_dataset")
    @org.hibernate.annotations.Fetch(value=org.hibernate.annotations.FetchMode.SUBSELECT)
    @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)
    private SortedSet<XAxis> _xAxes = new TreeSet<XAxis>();

    @OneToMany(mappedBy="_dataset")
    @org.hibernate.annotations.Fetch(value=org.hibernate.annotations.FetchMode.SUBSELECT)
    @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)
    private SortedSet<YAxis> _yAxes = new TreeSet<YAxis>();






    public Dataset() { }


    public Dataset(Paper paper) {
        this();
        setPaper(paper);
    }





    public Integer getId() {
        return _localId;
    }

    public Dataset setId(Integer datasetId) {
        _localId = datasetId;
        return this;
    }



    public Paper getPaper() {
        return _paper;
    }

    public Dataset setPaper(Paper paper) {
        if (paper != null) {
            if (getId() == null) {
                int highestId = 0;
                if (paper.getDatasets().size() > 0) {
                    highestId = paper.getDatasets().last().getId();
                }
                log().debug("Incrementing dataset ID: " + (highestId + 1));
                setId(highestId + 1);
            }
            paper.getDatasets().add(this);
            _paper = paper;
        } else {
            log().warn("Tried to attach myself to a null Paper");
        }
        return this;
    }



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



    public Set<DatasetProperty> getProperties() {
        return _properties;
    }

    public Dataset setProperties(Set<DatasetProperty> properties) {
        _properties = properties;
        return this;
    }

    public Dataset addProperty(DatasetProperty property) {
        if (property != null) {
            property.setDataset(this);
            _properties.add(property);
        } else {
            log().warn("Tried to add a null DatasetProperty to a Dataset");
        }
        return this;
    }

    public Dataset removeProperty(DatasetProperty property) {
        if (property != null) {
            _properties.remove(property);
            property.setDataset(null);
        } else {
            log().warn("Tried to remove a null DatasetProperty from a Dataset");
        }
        return this;
    }



    public SortedSet<DatasetError> getErrors() {
        return _errors;
    }

    public Dataset setErrors(SortedSet<DatasetError> datasetErrors) {
        getErrors().clear();
        for (DatasetError e : datasetErrors) addError(e);
        return this;
    }

    public Dataset setErrors(Collection<DatasetError> datasetErrors) {
        getErrors().clear();
        for (DatasetError e : datasetErrors) addError(e);
        return this;
    }

    public Dataset setErrors(DatasetError[] datasetErrors) {
        setErrors(Arrays.asList(datasetErrors));
        return this;
    }

    public Dataset addError(DatasetError datasetError) {
        if (datasetError != null) {
            getErrors().add(datasetError);
            // Auto-increment the local ID if necessary
            if (datasetError.getId() == null) {
                if (getErrors().last() != null && getErrors().last().getId() != null) {
                    datasetError.setId(getErrors().last().getId() + 1);
                } else {
                    datasetError.setId(getErrors().size() + 1);
                }
            }
        } else {
            log().warn("Tried to add a null DatasetError to a Dataset");
        }
        return this;
    }

    public Dataset removeError(DatasetError datasetError) {
        if (datasetError != null) {
            getErrors().remove(datasetError);
        } else {
            log().warn("Tried to remove a null DatasetError from a Dataset");
        }
        return this;
    }



    public SortedSet<XAxis> getXAxes() {
        return _xAxes;
    }

    public XAxis getXAxis(Integer xAxisId) {
        XAxis theXAxis = null;
        for (XAxis x : getXAxes()) {
            if (x.getId().equals(xAxisId)) {
                theXAxis = x;
                break;
            }
        }
        return theXAxis;
    }

    public Dataset setXAxes(SortedSet<XAxis> xAxes) {
        _xAxes = xAxes;
        return this;
    }

    public Dataset setXAxes(Collection<XAxis> xAxes) {
        _xAxes.clear();
        for (XAxis x : xAxes) addXAxis(x);
        return this;
    }

    public Dataset setXAxes(XAxis[] xAxes) {
        setXAxes(Arrays.asList(xAxes));
        return this;
    }

    public Dataset addXAxis(XAxis xAxis) {
        if (xAxis != null) {
            if (xAxis.getId() == null) {
                int highestId = 0;
                if (getXAxes().size() > 0) {
                    highestId = getXAxes().last().getId();
                }
                log().debug("Incrementing x-axis ID: " + (highestId + 1));
                xAxis.setId(highestId + 1);
            }
            log().debug("Adding x-axis: ID = " + xAxis.getId());
            _xAxes.add(xAxis);
            xAxis.setDataset(this);
        } else {
            log().warn("Tried to add a null XAxis to a Dataset");
        }
        return this;
    }

    public Dataset removeXAxis(XAxis xAxis) {
        if (xAxis != null) {
            xAxis.setDataset(null); 
            _xAxes.remove(xAxis);
        } else {
            log().warn("Tried to remove a null XAxis from a Dataset");
        }
        return this;
    }




    public SortedSet<YAxis> getYAxes() {
        return _yAxes;
    }

    public YAxis getYAxis(Integer yAxisId) {
        YAxis theYAxis = null;
        for (YAxis y : getYAxes()) {
            if (y.getId().equals(yAxisId)) {
                theYAxis = y;
                break;
            }
        }
        return theYAxis;
    }

    public Dataset setYAxes(SortedSet<YAxis> yAxes) {
        getYAxes().clear();
        for (YAxis y : yAxes) addYAxis(y);
        return this;
    }

    public Dataset setYAxes(Collection<YAxis> yAxes) {
        getYAxes().clear();
        for (YAxis y : yAxes) addYAxis(y);
        return this;
    }

    public Dataset setYAxes(YAxis[] yAxes) {
        setYAxes(Arrays.asList(yAxes));
        return this;
    }

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

    public Dataset removeYAxis(YAxis yAxis) {
        if (yAxis != null) {
            yAxis.setDataset(null); 
            _yAxes.add(yAxis);
        } else {
            log().warn("Tried to remove a null XAxis from a Dataset");
        }
        return this;
    }






    public SortedSet<Bin> getBins(Integer binId) {
        SortedSet<Bin> matchingBins = new TreeSet<Bin>();
        for (XAxis x : getXAxes()) {
            Bin mybin = x.getBin(binId);
            if (mybin != null) {
                matchingBins.add(mybin);
            }
        }
        return matchingBins;
    }

    public SortedSet<Point> getPoints(Integer pointId) {
        SortedSet<Point> matchingPoints = new TreeSet<Point>();
        for (YAxis y : getYAxes()) {
            Point mypoint = y.getPoint(pointId);
            if (mypoint != null) {
                matchingPoints.add(mypoint);
            }
        }
        return matchingPoints;
    }






    public int compareTo(Dataset other) {
        log().debug("Comparing datasets...");
        if (getId() == null) {
            log().warn("Null dataset ID");
            return 1; // Sort null datasets 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 dataset as a string");
        String indent = "";
        for (int i  = 0; i < indentBy; ++i) indent += " ";
        StringBuffer s = new StringBuffer();

        // Dataset comments
        s.append(indent + "Dataset ID: " + getId() + "\n");
        if (! getComments().isEmpty()) {
            s.append(indent + "Comments: ");
            for (String comment : getComments()) {
                s.append("\n" + indent + comment);
            }
            s.append("\n");
        }

        // Axes
        s.append(indent + getXAxes().size() + " x-axes, ");
        s.append(indent + getYAxes().size() + " y-axes");
        for (XAxis xaxis : getXAxes()) {
            log().debug("Getting x-axis string representation");
            s.append("\n" + xaxis.toString(indentBy + 2));
        }
        for (YAxis yaxis : getYAxes()) {
            log().debug("Getting y-axis string representation");
            s.append("\n" + yaxis.toString(indentBy + 2));
        }
        s.append("\n");

        // Dataset errors
        if (! getErrors().isEmpty()) {
            s.append(indent + "Dataset errors:");
            for (Uncertainty err : getErrors()) {
                log().debug("Getting dataset error string representation");
                s.append("\n" + err.toString(indentBy + 2));
            }
        }

        return s.toString();
    }

}

---