source: fedd/abac-src/rtml/src/edu/stanford/rt/datatype/EnumType.java @ 8780cbec

package edu.stanford.rt.datatype;

import java.util.*;

import edu.stanford.rt.credential.*;

/**
 * @author Ninghui Li, Sandra Qiu<br>
 *
 * Represents <code>EnumType</code> element in DomainSpecification.
 * Each <code>EnumType</code> declaration object knows its legal values
 * and the ordering of the values if the values are ordered.
 */
public class EnumType extends OrderedType
{
    /** the number of values this type has*/
        private int size;
    
        /** Defines the ordering of values.*/
        private DataType valueType;

    /** are  values  case-sensitive?*/
        private boolean ignoreCase;
    
    /** are values  ordered in any way?*/
        private boolean ordered;

        /** the list of values in their natural order, i.e. the order that 
        being added to the list*/
        private ArrayList values;

        /** We also store the values in a hash set to speed up 
        membership tests.*/
        private HashSet valuesCopy;

        /**
         * Constructor for EnumType.
         */
        public EnumType(
                String name,
                DataType valueType,
                OrderedMap enumValues,
                boolean ignoreCase,
                boolean ordered,
                int size)
                throws IllegalArgumentException
        {
                super(name);
                this.valueType = valueType;

                if (size != 0)
                        this.size = size;
                else
                        this.size = enumValues.size();
                if (this.size <= 0)
                {
                        throw new IllegalArgumentException("EnumType constructor error: empty values.");
                }

                if (!enumValues.getKeyClass().equals(String.class))
                {
                        throw new IllegalArgumentException("EnumType constructor error: non-string value.");
                }

                this.values = new ArrayList(enumValues.keyList());
                this.valuesCopy = new HashSet(enumValues.keyList());
                this.ignoreCase = ignoreCase;
                this.ordered = ordered;
        }

        /**
         * Method setValueType.
         * @param type
         */
        public void setValueType(DataType type)
        {
                valueType = type;
        }

    /**
     * Method getValueType.
     * @return DataType
     */
    public DataType getValueType()
    {
        return valueType;
    }

        /**
         * Method getValues.<p>
     *      returns an unmodifiable view of the legal values.
         * @return List
         */
        public synchronized List getValues()
        {
                return Collections.unmodifiableList(values);
        }

        /**
         * Method contains.<p>
     *      checks whether the given value is part of the legal values.
         * @param value
         * @return boolean
         */
        public boolean contains(String value)
        {
                return valuesCopy.contains(value);
        }

        /**
         * Method getSize.<p>
     *      returns the actual number of legal values defined 
     *      for this type.
         * @return int
         */
        public int getSize()
        {
                return size;
        }

        /**
         * Method isIgnoreCase.<p>
         * @return boolean
         */
        public boolean isIgnoreCase()
        {
                return ignoreCase;
        }
        /**
         * Method isOrdered.
         * @return boolean
         */
        public boolean isOrdered()
        {
                return ordered;
        }

        /* (non-Javadoc)
         * @see edu.stanford.rt.datatype.SimpleType#isValidValue(DataValue)
         */
        public boolean isValidValue(DataValue v)
        {
                if (!(v instanceof EnumValue))
                        return false;
                String val = ((EnumValue) v).getValue();
                if (!valuesCopy.contains(val))
                        return false;
                return true;
        }

        /* (non-Javadoc)
         * @see edu.stanford.rt.datatype.OrderedType#compares(DataValue, DataValue)
         */
        public int compares(DataValue value1, DataValue value2)
        {
                if (!(value1 instanceof EnumValue)
                        || !(value2 instanceof EnumValue))
                        throw new IllegalArgumentException("Wrong argument type");

                String val1 = ((EnumValue) value1).getValue();
                String val2 = ((EnumValue) value2).getValue();

                return val1.compareTo(val2);
        }

        /* (non-Javadoc)
         * @see edu.stanford.rt.datatype.DataType#toString(String)
         */
        public String toString(String indent)
        {
                String thisIndent = indent + "  ";
                StringBuffer sb = new StringBuffer();
                sb.append(thisIndent).append("EnumType:   ").append(
                        getName()).append(
                        "\n");
                sb.append(thisIndent+"  ").append(" {");
                Iterator it = values.iterator();
                while (it.hasNext())
                {
                        sb.append("\"").append((String) it.next()).append("\"  ");
                }
                sb.append("} \n");

                sb
                        .append(thisIndent + "  ")
                        .append("valueType: ")
                        .append(
                                (valueType == null)
                                        ? "null"
                                        : valueType.toString(thisIndent + "  "))
                        .append("\n");

                return sb.toString();

        }

}