package atlas.classifiers; public class ProviderTerminalConfigurationClassifier implements java.io.Serializable, iapp.services.Classifier { public static final ProviderTerminalConfigurationClassifier CONTACT = new ProviderTerminalConfigurationClassifier("CC"); public static final ProviderTerminalConfigurationClassifier CONTACTLESS = new ProviderTerminalConfigurationClassifier("CL"); private static final java.util.Map values = new java.util.TreeMap(); private static java.util.List literals = new java.util.ArrayList(3); private static java.util.List names = new java.util.ArrayList(3); /** * Initializes the values. */ static { values.put(CONTACT.value, CONTACT); literals.add(CONTACT.value); CONTACT.setName("CONTACT"); names.add("CONTACT"); values.put(CONTACTLESS.value, CONTACTLESS); literals.add(CONTACTLESS.value); CONTACTLESS.setName("CONTACTLESS"); names.add("CONTACTLESS"); literals = java.util.Collections.unmodifiableList(literals); names = java.util.Collections.unmodifiableList(names); } private java.lang.String value; private java.lang.String name; /** * The default constructor allowing super classes to access it. */ protected ProviderTerminalConfigurationClassifier() {} private ProviderTerminalConfigurationClassifier(java.lang.String value) { this.value = value; } public String toString() { return java.lang.String.valueOf(value); } /** * Creates an instance of ProviderTerminalConfigurationClassifier from <code>value</code>. * * @param value the value to create the ProviderTerminalConfigurationClassifier from. */ public static ProviderTerminalConfigurationClassifier fromString(java.lang.String value) { if(value == null) return null; final ProviderTerminalConfigurationClassifier typeValue = (ProviderTerminalConfigurationClassifier) values.get(value); if (typeValue == null) { throw new IllegalArgumentException("invalid value '" + value + "', possible values are: " + literals); } return typeValue; } /** * Checks correct value for the classifier */ public boolean isProviderTerminalConfigurationClassifier(java.lang.String value){ return (value == null || values.get(value) != null); } /** * Get/set for value */ public java.lang.String getValue() { return this.value; } public java.lang.String getName() { return this.name; } /** * Get/set for name */ private void setName(java.lang.String name) { this.name = name; } /** * @see java.lang.Comparable#compareTo(java.lang.Object) */ public int compareTo(Object that) { return (this == that) ? 0 : this.getValue().compareTo(((ProviderTerminalConfigurationClassifier)that).getValue()); } public static java.util.Map getValues() { return values; } /** * Returns an unmodifiable list containing the literals that are known by this enumeration. * * @return A List containing the actual literals defined by this enumeration, this list * can not be modified. */ public static java.util.List literals() { return literals; } /** * Returns an unmodifiable list containing the names of the literals that are known * by this enumeration. * * @return A List containing the actual names of the literals defined by this * enumeration, this list can not be modified. */ public static java.util.List names() { return names; } /** * @see java.lang.Object#equals(java.lang.Object) */ public boolean equals(Object object) { return (this == object) || (object instanceof ProviderTerminalConfigurationClassifier && ((ProviderTerminalConfigurationClassifier)object).getValue().equals( this.getValue())); } /** * @see java.lang.Object#hashCode() */ public int hashCode() { return this.getValue().hashCode(); } /** * This method allows the deserialization of an instance of this enumeration type to return the actual instance * that will be the singleton for the JVM in which the current thread is running. * <p/> * Doing this will allow users to safely use the equality operator <code>==</code> for enumerations because * a regular deserialized object is always a newly constructed instance and will therefore never be * an existing reference; it is this <code>readResolve()</code> method which will intercept the deserialization * process in order to return the proper singleton reference. */ private java.lang.Object readResolve() throws java.io.ObjectStreamException { return ProviderTerminalConfigurationClassifier.fromString(this.value); } }