com.hfg.bio.seq.genomic.assembly.GenomicAssemblyLevel Maven / Gradle / Ivy
Show all versions of com_hfg Show documentation
package com.hfg.bio.seq.genomic.assembly;
import java.io.Serializable;
import java.util.Set;
import com.hfg.util.CompareUtil;
import com.hfg.util.collection.OrderedSet;
//------------------------------------------------------------------------------
/**
* Enumeration of genomic assembly levels.
*
* @author J. Alex Taylor, hairyfatguy.com
*
*/
//------------------------------------------------------------------------------
// com.hfg XML/HTML Coding Library
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// J. Alex Taylor, President, Founder, CEO, COO, CFO, OOPS hairyfatguy.com
// [email protected]
//------------------------------------------------------------------------------
public final class GenomicAssemblyLevel implements Serializable, Comparable
{
private final String mName;
private final int mIndex;
private static final Set sValues = new OrderedSet<>(4);
public static final GenomicAssemblyLevel COMPLETE_GENOME = new GenomicAssemblyLevel("Complete genome");
public static final GenomicAssemblyLevel CHROMOSOME = new GenomicAssemblyLevel("Chromosome");
public static final GenomicAssemblyLevel SCAFFOLD = new GenomicAssemblyLevel("Scaffold");
public static final GenomicAssemblyLevel CONTIG = new GenomicAssemblyLevel("Contig");
//###########################################################################
// CONSTRUCTORS
//###########################################################################
//--------------------------------------------------------------------------
private GenomicAssemblyLevel(String inName)
{
mName = inName;
mIndex = sValues.size();
sValues.add(this);
}
//###########################################################################
// PUBLIC METHODS
//###########################################################################
//--------------------------------------------------------------------------
@Override
public final String toString()
{
return mName;
}
//--------------------------------------------------------------------------
public static GenomicAssemblyLevel valueOf(String inValue)
{
GenomicAssemblyLevel outValue = null;
for (GenomicAssemblyLevel value : sValues)
{
if (value.toString().equalsIgnoreCase(inValue))
{
outValue = value;
break;
}
}
return outValue;
}
//--------------------------------------------------------------------------
public static GenomicAssemblyLevel[] values()
{
return sValues.toArray(new GenomicAssemblyLevel[] {});
}
//--------------------------------------------------------------------------
public final String name()
{
return mName;
}
//--------------------------------------------------------------------------
@Override
public final int hashCode()
{
return mIndex;
}
//--------------------------------------------------------------------------
@Override
public final boolean equals(Object inObj)
{
return (inObj instanceof GenomicAssemblyLevel
&& mIndex == ((GenomicAssemblyLevel) inObj).mIndex);
}
//--------------------------------------------------------------------------
/**
* This method is called after de-serialization, allowing the object
* to nominate a replacement object to be used in the output
* graph instead of this object. We don't want multiple objects of each type
* to exist in a target VM, so instances replace themselves with
* local objects.
*/
private Object readResolve()
{
GenomicAssemblyLevel outValue = null;
for (GenomicAssemblyLevel value : sValues)
{
if (mIndex == value.mIndex)
{
outValue = value;
break;
}
}
return outValue;
}
//--------------------------------------------------------------------------
/**
* Compares this object with the specified object for order. Returns a
* negative integer, zero, or a positive integer as this object is less
* than, equal to, or greater than the specified object.
*
* The implementor must ensure
* {@code sgn(x.compareTo(y)) == -sgn(y.compareTo(x))}
* for all {@code x} and {@code y}. (This
* implies that {@code x.compareTo(y)} must throw an exception iff
* {@code y.compareTo(x)} throws an exception.)
*
*
The implementor must also ensure that the relation is transitive:
* {@code (x.compareTo(y) > 0 && y.compareTo(z) > 0)} implies
* {@code x.compareTo(z) > 0}.
*
*
Finally, the implementor must ensure that {@code x.compareTo(y)==0}
* implies that {@code sgn(x.compareTo(z)) == sgn(y.compareTo(z))}, for
* all {@code z}.
*
*
It is strongly recommended, but not strictly required that
* {@code (x.compareTo(y)==0) == (x.equals(y))}. Generally speaking, any
* class that implements the {@code Comparable} interface and violates
* this condition should clearly indicate this fact. The recommended
* language is "Note: this class has a natural ordering that is
* inconsistent with equals."
*
*
In the foregoing description, the notation
* {@code sgn(}expression{@code )} designates the mathematical
* signum function, which is defined to return one of {@code -1},
* {@code 0}, or {@code 1} according to whether the value of
* expression is negative, zero, or positive, respectively.
*
* @param inObj2 the object to be compared.
* @return a negative integer, zero, or a positive integer as this object
* is less than, equal to, or greater than the specified object.
* @throws ClassCastException if the specified object's type prevents it
* from being compared to this object.
*/
@Override
public int compareTo(GenomicAssemblyLevel inObj2)
{
int result = -1;
if (inObj2 != null)
{
result = CompareUtil.compare(mIndex, inObj2.mIndex);
}
return result;
}
}