Source code: org/apache/axis/constants/Enum.java

   /*
    * Copyright 2001-2004 The Apache Software Foundation.
    * 
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
    *      http://www.apache.org/licenses/LICENSE-2.0
    * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.axis.constants;
  
  import org.apache.axis.components.logger.LogFactory;
  import org.apache.axis.utils.Messages;
  import org.apache.commons.logging.Log;
  
  import java.util.Hashtable;
  
  
  /**
   * General support for 'enumerated' data types.
   * Name searches are case insensitive.
   * 
   * @author Richard Sitze (rsitze@apache.org)
   */
  public abstract class Enum implements java.io.Serializable {
      private static final Hashtable types = new Hashtable(13);
      
      protected static Log log =
          LogFactory.getLog(Enum.class.getName());
  
      private final Type   type;
      public  final int    value;
      public  final String name;
      
      protected Enum(Type type, int value, String name) {
          this.type = type;
          this.value = value;
          this.name = name.intern();
      }
      
      public final int    getValue() { return value; }
      public final String getName()  { return name; }
      public final Type   getType()  { return type; }
  
      public String toString() {
          return name;
      }
  
      public final boolean equals(Object obj) {
          return (obj != null  &&  obj instanceof Enum)
                 ? _equals((Enum)obj)
                 : false;
      }
  
      public int hashCode() {
          return value;
      }
      
      public final boolean equals(Enum obj) {
          return (obj != null) ? _equals(obj) : false;
      }
  
      /**
       * The 'equals' logic assumes that there is a one-to-one
       * relationship between value & name.  If this isn't true,
       * then expect to be confused when using this class with
       * Collections.
       */
      private final boolean _equals(Enum obj) {
          return (//obj.name == name  &&  // names are internalized
                  obj.type == type  &&
                  obj.value == value);
      }
  
      public abstract static class Type implements java.io.Serializable {
          private final String name;
          private final Enum[] enums;
          private Enum  dephault = null;
          
          protected Type(String name, Enum[] enums) {
              this.name = name.intern();
              this.enums = enums;
              synchronized (types) {
                  types.put(name, this);
              }
          }
          
          public void setDefault(Enum dephault) {
              this.dephault = dephault;
          }
          
          public Enum getDefault() {
             return dephault;
         }
         
         public final String getName() {
             return name;
         }
         
         public final boolean isValid(String enumName) {
             for (int enumElt = 0; enumElt < enums.length; enumElt++) {
                 if (enums[enumElt].getName().equalsIgnoreCase(enumName))
                     return true;
             }
             
             return false;
         }
         
         public final int size() {
             return enums.length;
         }
         
         /**
          * Returns array of names for enumerated values
          */
         public final String[] getEnumNames() {
             String[] nms = new String[ size() ];
             
             for (int idx = 0; idx < enums.length; idx++)
                 nms[idx] = enums[idx].getName();
     
             return nms;
         }
         
         /**
          * Returns name of enumerated value
          */
         public final Enum getEnum(int enumElt) {
             return (enumElt >= 0  &&  enumElt < enums.length) ? enums[enumElt] : null;
         }
         
         /**
          * Returns enumerated value of name
          */
         public final Enum getEnum(String enumName) {
             Enum e = getEnum(enumName, null);
             
             if (e == null) {
                 log.error(Messages.getMessage("badEnum02", name, enumName));
             }
     
             return e;
         }
         
         /**
          * Returns enumerated value of name
          * 
          * For large sets of enumerated values, a HashMap could
          * be used to retrieve.  It's not clear if there is any
          * benefit for small (3 to 4) sets, as used now.
          */
         public final Enum getEnum(String enumName, Enum dephault) {
             if (enumName != null  &&  enumName.length() > 0) {
                 for (int enumElt = 0; enumElt < enums.length; enumElt++) {
                     Enum e = enums[enumElt];
                     if (e.getName().equalsIgnoreCase(enumName))
                         return e;
                 }
             }
     
             return dephault;
         }
 
         private Object readResolve() throws java.io.ObjectStreamException {
             Object type = types.get(name);
             if (type == null) {
                 type = this;
                 types.put(name, type);
             }
             return type;
         }
     }
 }