serial:

serial:

 public BasicAttribute(String id) 
{
        this(id, false);
}

Constructs a new instance of an unordered attribute with no value.

Parameters:

id - The attribute's id. It cannot be null.

 public BasicAttribute(String id,
    Object value) 
{
        this(id, value, false);
}

Constructs a new instance of an unordered attribute with a single value.

Parameters:

id - The attribute's id. It cannot be null.

value - The attribute's value. If null, a null value is added to the attribute.

 public BasicAttribute(String id,
    boolean ordered) 
{
        attrID = id;
        values = new Vector();
        this.ordered = ordered;
}

Constructs a new instance of a possibly ordered attribute with no value.

Parameters:

id - The attribute's id. It cannot be null.

ordered - true means the attribute's values will be ordered; false otherwise.

 public BasicAttribute(String id,
    Object value,
    boolean ordered) 
{
        this(id, ordered);
        values.addElement(value);
}

Constructs a new instance of a possibly ordered attribute with a single value.

Parameters:

id - The attribute's id. It cannot be null.

value - The attribute's value. If null, a null value is added to the attribute.

ordered - true means the attribute's values will be ordered; false otherwise.

 public boolean add(Object attrVal) 
{
        if (isOrdered() || (find(attrVal) <  0)) {
            values.addElement(attrVal);
            return true;
        } else {
            return false;
        }
}

Adds a new value to this attribute.

By default, Object.equals() is used when comparing attrVal with this attribute's values except when attrVal is an array. For an array, each element of the array is checked using Object.equals(). A subclass may use schema information to determine equality.

 public  void add(int ix,
    Object attrVal) 
{
        if (!isOrdered() && contains(attrVal)) {
            throw new IllegalStateException(
                "Cannot add duplicate to unordered attribute");
        }
        values.insertElementAt(attrVal, ix);
}

 public  void clear() 
{
        values.setSize(0);
}

 public Object clone() 
{
        BasicAttribute attr;
        try {
            attr = (BasicAttribute)super.clone();
        } catch (CloneNotSupportedException e) {
            attr = new BasicAttribute(attrID, ordered);
        }
        attr.values = (Vector)values.clone();
        return attr;
}

 public boolean contains(Object attrVal) 
{
        return (find(attrVal)  >= 0);
}

Determines whether a value is in this attribute.

By default, Object.equals() is used when comparing attrVal with this attribute's values except when attrVal is an array. For an array, each element of the array is checked using Object.equals(). A subclass may use schema information to determine equality.

 public boolean equals(Object obj) 
{
        if ((obj != null) && (obj instanceof Attribute)) {
            Attribute target = (Attribute)obj;
            // Check order first
            if (isOrdered() != target.isOrdered()) {
                return false;
            }
            int len;
            if (attrID.equals(target.getID()) &&
                (len=size()) == target.size()) {
                try {
                    if (isOrdered()) {
                        // Go through both list of values
                        for (int i = 0; i <  len; i++) {
                            if (!valueEquals(get(i), target.get(i))) {
                                return false;
                            }
                        }
                    } else {
                        // order is not relevant; check for existence
                        Enumeration theirs = target.getAll();
                        while (theirs.hasMoreElements()) {
                            if (find(theirs.nextElement()) <  0)
                                return false;
                        }
                    }
                } catch (NamingException e) {
                    return false;
                }
                return true;
            }
        }
        return false;
}

Determines whether obj is equal to this attribute. Two attributes are equal if their attribute-ids, syntaxes and values are equal. If the attribute values are unordered, the order that the values were added are irrelevant. If the attribute values are ordered, then the order the values must match. If obj is null or not an Attribute, false is returned.

By default Object.equals() is used when comparing the attribute id and its values except when a value is an array. For an array, each element of the array is checked using Object.equals(). A subclass may override this to make use of schema syntax information and matching rules, which define what it means for two attributes to be equal. How and whether a subclass makes use of the schema information is determined by the subclass. If a subclass overrides equals(), it should also override hashCode() such that two attributes that are equal have the same hash code.

 public Object get() throws NamingException 
{
        if (values.size() == 0) {
            throw new
        NoSuchElementException("Attribute " + getID() + " has no value");
        } else {
            return values.elementAt(0);
        }
}

Retrieves one of this attribute's values.

By default, the value returned is one of those passed to the constructor and/or manipulated using the add/replace/remove methods. A subclass may override this to retrieve the value dynamically from the directory.

 public Object get(int ix) throws NamingException 
{
        return values.elementAt(ix);
}

 public NamingEnumeration<?> getAll() throws NamingException 
{
      return new ValuesEnumImpl();
}

Retrieves an enumeration of this attribute's values.

By default, the values returned are those passed to the constructor and/or manipulated using the add/replace/remove methods. A subclass may override this to retrieve the values dynamically from the directory.

 public DirContext getAttributeDefinition() throws NamingException 
{
        throw new OperationNotSupportedException("attribute definition");
}

Retrieves this attribute's schema definition.

This method by default throws OperationNotSupportedException. A subclass should override this method if it supports schema.

 public DirContext getAttributeSyntaxDefinition() throws NamingException 
{
            throw new OperationNotSupportedException("attribute syntax");
}

Retrieves the syntax definition associated with this attribute.

This method by default throws OperationNotSupportedException. A subclass should override this method if it supports schema.

 public String getID() 
{
        return attrID;
}

 public int hashCode() 
{
        int hash = attrID.hashCode();
        int num = values.size();
        Object val;
        for (int i = 0; i <  num; i ++) {
            val = values.elementAt(i);
            if (val != null) {
                if (val.getClass().isArray()) {
                    Object it;
                    int len = Array.getLength(val);
                    for (int j = 0 ; j <  len ; j++) {
                        it = Array.get(val, j);
                        if (it != null) {
                            hash += it.hashCode();
                        }
                    }
                } else {
                    hash += val.hashCode();
                }
            }
        }
        return hash;
}

Calculates the hash code of this attribute.

The hash code is computed by adding the hash code of the attribute's id and that of all of its values except for values that are arrays. For an array, the hash code of each element of the array is summed. If a subclass overrides hashCode(), it should override equals() as well so that two attributes that are equal have the same hash code.

 public boolean isOrdered() 
{
        return ordered;
}

 public boolean remove(Object attrval) 
{
        // For the Java 2 platform, can just use "return removeElement(attrval);"
        // Need to do the following to handle null case
        int i = find(attrval);
        if (i  >= 0) {
            values.removeElementAt(i);
            return true;
        }
        return false;
}

Removes a specified value from this attribute.

By default, Object.equals() is used when comparing attrVal with this attribute's values except when attrVal is an array. For an array, each element of the array is checked using Object.equals(). A subclass may use schema information to determine equality.

 public Object remove(int ix) 
{
        Object answer = values.elementAt(ix);
        values.removeElementAt(ix);
        return answer;
}

 public Object set(int ix,
    Object attrVal) 
{
        if (!isOrdered() && contains(attrVal)) {
            throw new IllegalStateException(
                "Cannot add duplicate to unordered attribute");
        }
        Object answer = values.elementAt(ix);
        values.setElementAt(attrVal, ix);
        return answer;
}

 public int size() 
{
      return values.size();
}

 public String toString() 
{
        StringBuffer answer = new StringBuffer(attrID + ": ");
        if (values.size() == 0) {
            answer.append("No values");
        } else {
            boolean start = true;
            for (Enumeration e = values.elements(); e.hasMoreElements(); ) {
                if (!start)
                    answer.append(", ");
                answer.append(e.nextElement());
                start = false;
            }
        }
        return answer.toString();
}

Generates the string representation of this attribute. The string consists of the attribute's id and its values. This string is meant for debugging and not meant to be interpreted programmatically.