XAxis.java

Go to the documentation of this file.

package cedar.hepdata.model;

import java.util.SortedSet;
import java.util.TreeSet;
import java.util.Set;
import java.util.Collection;
import java.util.Arrays;

import javax.persistence.*;

import cedar.hepdata.util.Unit;


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

    @OneToMany(mappedBy="_xAxis")
    @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<Bin> _bins = new TreeSet<Bin>();

    @ManyToOne
    protected Dataset _dataset;




    public XAxis() {
        super();
        log().debug("Making an XAxis (No dataset, 0 arg constructor)");
    }

    public XAxis(String header) {
        super(header);
        log().debug("Making an XAxis (No dataset, 1 arg constructor)");
    }

    public XAxis(String header, Unit unit) {
        super(header, unit);
        log().debug("Making an XAxis (No dataset, 2 arg constructor)");
    }

    public XAxis(Dataset dataset) {
        this();
        setDataset(dataset);
        log().debug("Making an XAxis (With dataset, 1 arg constructor)");
    }

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

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




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


    // XAxis ID
    public Integer getId() {
        return _localId;
    }
    public XAxis setId(Integer xAxisId) {
        _localId = xAxisId;
        return this;
    }


    public Dataset getDataset() {
        return _dataset;
    }
    public XAxis setDataset(Dataset dataset) {
        log().debug("Calling setDataset()");
        _dataset = dataset;
        if (dataset != null) {
            if (getId() == null) {
                int highestId = 0;
                if (dataset.getXAxes().size() > 0) {
                    highestId = dataset.getXAxes().last().getId();
                }
                log().debug("Incrementing x-axis ID: " + (highestId + 1));
                setId(highestId + 1);

            }
            log().debug("Adding myself to a Dataset");
            dataset.getXAxes().add(this);
        } else {
            log().warn("Tried to attach a XAxis to a null Dataset");
        }
        return this;
    }


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


    public SortedSet<Bin> getBins() {
        return _bins;
    }
    public Bin getBin(Integer binId) {
        Bin theBin = null;
        for (Bin b : getBins()) {
            if (b.getId() == binId) {
                theBin = b;
                break;
            }
        }
        return theBin;
    }
    public XAxis setBins(SortedSet<Bin> bins) {
        _bins = bins;
        return this;
    }
//     /** Set this axis' bins from a generic collection */
//     public XAxis setBins(Collection<Bin> bins) {
//         _bins.clear(); // Cascade
//         for (Bin b : bins) addBin(b);
//         return this;
//     }
//     /** Set this axis' bins from an array */
//     public XAxis setBins(Bin[] bins) {
//         log().debug("Setting bins from array");
//         setBins(Arrays.asList(bins));
//         return this;
//     }

    public XAxis addBin(Bin bin) {
        if (bin != null) {
            if (bin.getId() == null) {
                int highestId = 0;
                if (getBins().size() > 0) {
                    highestId = getBins().last().getId();
                }
                log().debug("Incrementing bin ID: " + (highestId + 1));
                bin.setId(highestId + 1);
            }
            log().debug("Adding bin: ID = " + bin.getId());
            bin.setXAxis(this);
        } else {
            log().warn("Tried to add a null Bin to an XAxis");
        }
        return this;
    }
    public XAxis removeBin(Bin bin) {
        if (bin != null) {
            bin.setXAxis(null); 
            _bins.remove(bin);
        } else {
            log().warn("Tried to remove a null Bin from an XAxis");
        }
        return this;
    }




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

        s.append(indent + "X-axis ID: " + getId() + "\n");
        s.append(indent + "Header: " + getHeader());
        for (Bin bin : getBins()) {
            s.append("\n" + bin.toString(indentBy + 2));
        }
        return s.toString();
    }




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

        final XAxis test = (XAxis) 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; ++code; // ensure this is odd
        return code;
    }
}

---