public XMLAttributesImpl() 
{
    //
    // Constructors
    //
        this(TABLE_SIZE);
}

Default constructor.

 public XMLAttributesImpl(int tableSize) 
{
        fTableViewBuckets = tableSize;
        for (int i = 0; i <  fAttributes.length; i++) {
            fAttributes[i] = new Attribute();
        }
}

Parameters:

tableSize - initial size of table view

 public int addAttribute(QName name,
    String type,
    String value) 
{
        int index;
        if (fLength <  SIZE_LIMIT) {
            index = name.uri != null && !name.uri.equals("") 
                ? getIndexFast(name.uri, name.localpart)
                : getIndexFast(name.rawname);
            if (index == -1) {
                index = fLength;
                if (fLength++ == fAttributes.length) {
                    Attribute[] attributes = new Attribute[fAttributes.length + 4];
                    System.arraycopy(fAttributes, 0, attributes, 0, fAttributes.length);
                    for (int i = fAttributes.length; i <  attributes.length; i++) {
                        attributes[i] = new Attribute();
                    }
                    fAttributes = attributes;
                }
            }
        }
        else if (name.uri == null || 
            name.uri.length() == 0 || 
            (index = getIndexFast(name.uri, name.localpart)) == -1) {
            /**
             * If attributes were removed from the list after the table
             * becomes in use this isn't reflected in the table view. It's
             * assumed that once a user starts removing attributes they're 
             * not likely to add more. We only make the view consistent if
             * the user of this class adds attributes, removes them, and
             * then adds more.
             */
            if (!fIsTableViewConsistent || fLength == SIZE_LIMIT) {
                prepareAndPopulateTableView();
                fIsTableViewConsistent = true;
            }
            int bucket = getTableViewBucket(name.rawname); 
            // The chain is stale. 
            // This must be a unique attribute.
            if (fAttributeTableViewChainState[bucket] != fLargeCount) {
                index = fLength;
                if (fLength++ == fAttributes.length) {
                    Attribute[] attributes = new Attribute[fAttributes.length < <  1];
                    System.arraycopy(fAttributes, 0, attributes, 0, fAttributes.length);
                    for (int i = fAttributes.length; i <  attributes.length; i++) {
                        attributes[i] = new Attribute();
                    }
                    fAttributes = attributes;
                }
                // Update table view.
                fAttributeTableViewChainState[bucket] = fLargeCount;
                fAttributes[index].next = null;
                fAttributeTableView[bucket] = fAttributes[index];
            }
            // This chain is active. 
            // We need to check if any of the attributes has the same rawname.
            else {
                // Search the table.
                Attribute found = fAttributeTableView[bucket];
                while (found != null) {
                    if (found.name.rawname == name.rawname) {
                        break;
                    }
                    found = found.next;
                }
                // This attribute is unique.
                if (found == null) {
                    index = fLength;
                    if (fLength++ == fAttributes.length) {
                        Attribute[] attributes = new Attribute[fAttributes.length < <  1];
                        System.arraycopy(fAttributes, 0, attributes, 0, fAttributes.length);
                        for (int i = fAttributes.length; i <  attributes.length; i++) {
                            attributes[i] = new Attribute();
                        }
                        fAttributes = attributes;
                    }
                    // Update table view
                    fAttributes[index].next = fAttributeTableView[bucket];
                    fAttributeTableView[bucket] = fAttributes[index];
                }
                // Duplicate. We still need to find the index.
                else {
                    index = getIndexFast(name.rawname);
                }
            }
        }          
        // set values
        Attribute attribute = fAttributes[index];
        attribute.name.setValues(name);
        attribute.type = type;
        attribute.value = value;
        attribute.nonNormalizedValue = value;
        attribute.specified = false;
        // clear augmentations
        attribute.augs.removeAllItems();
        return index;
}

Adds an attribute. The attribute's non-normalized value of the attribute will have the same value as the attribute value until set using the setNonNormalizedValue method. Also, the added attribute will be marked as specified in the XML instance document unless set otherwise using the setSpecified method.

Note: If an attribute of the same name already exists, the old values for the attribute are replaced by the new values.

 public  void addAttributeNS(QName name,
    String type,
    String value) 
{
        int index = fLength;
        if (fLength++ == fAttributes.length) {
            Attribute[] attributes;
            if (fLength <  SIZE_LIMIT) {
                attributes = new Attribute[fAttributes.length + 4];
            }
            else {
                attributes = new Attribute[fAttributes.length < <  1];
            }
            System.arraycopy(fAttributes, 0, attributes, 0, fAttributes.length);
            for (int i = fAttributes.length; i <  attributes.length; i++) {
                attributes[i] = new Attribute();
            }
            fAttributes = attributes;
        }
        // set values
        Attribute attribute = fAttributes[index];
        attribute.name.setValues(name);
        attribute.type = type;
        attribute.value = value;
        attribute.nonNormalizedValue = value;
        attribute.specified = false;
        // clear augmentations
        attribute.augs.removeAllItems();
}

Adds an attribute. The attribute's non-normalized value of the attribute will have the same value as the attribute value until set using the setNonNormalizedValue method. Also, the added attribute will be marked as specified in the XML instance document unless set otherwise using the setSpecified method.

This method differs from addAttribute in that it does not check if an attribute of the same name already exists in the list before adding it. In order to improve performance of namespace processing, this method allows uniqueness checks to be deferred until all the namespace information is available after the entire attribute specification has been read.

Caution: If this method is called it should not be mixed with calls to addAttribute unless it has been determined that all the attribute names are unique.

 public QName checkDuplicatesNS() 
{
        // If the list is small check for duplicates using pairwise comparison.
        if (fLength < = SIZE_LIMIT) {
            for (int i = 0; i <  fLength - 1; ++i) {
            	Attribute att1 = fAttributes[i];
                for (int j = i + 1; j <  fLength; ++j) {
                    Attribute att2 = fAttributes[j];
                    if (att1.name.localpart == att2.name.localpart &&
                        att1.name.uri == att2.name.uri) {
                        return att2.name;    	
                    }
                }
            }
    	}
    	// If the list is large check duplicates using a hash table.
    	else {
            // We don't want this table view to be read if someone calls 
            // addAttribute so we invalidate it up front.
            fIsTableViewConsistent = false;
            prepareTableView();
            Attribute attr;
            int bucket;
            for (int i = fLength - 1; i  >= 0; --i) {
                attr = fAttributes[i];
                bucket = getTableViewBucket(attr.name.localpart, attr.name.uri);
                // The chain is stale. 
                // This must be a unique attribute.
                if (fAttributeTableViewChainState[bucket] != fLargeCount) {
                    fAttributeTableViewChainState[bucket] = fLargeCount;
                    attr.next = null;
                    fAttributeTableView[bucket] = attr;
                } 
                // This chain is active. 
                // We need to check if any of the attributes has the same name.
                else {
                    // Search the table.
                    Attribute found = fAttributeTableView[bucket];
                    while (found != null) {
                        if (found.name.localpart == attr.name.localpart &&
                            found.name.uri == attr.name.uri) {
                            return attr.name;
                        }
                        found = found.next;
                    }
                    // Update table view
                    attr.next = fAttributeTableView[bucket];
                    fAttributeTableView[bucket] = attr;
                }
            }
    	}
    	return null;
}

Checks for duplicate expanded names (local part and namespace name pairs) in the attribute specification. If a duplicate is found its name is returned.

This should be called once all the in-scope namespaces for the element enclosing these attributes is known, and after all the attributes have gone through namespace binding.

 protected  void cleanTableView() 
{
        if (++fLargeCount <  0) {
            // Overflow. We actually need to visit the chain state array.
            if (fAttributeTableViewChainState != null) {
                for (int i = fTableViewBuckets - 1; i  >= 0; --i) {
                    fAttributeTableViewChainState[i] = 0;
                } 
            }
            fLargeCount = 1;
        }
}

Purges all elements from the table view.

 public Augmentations getAugmentations(String qName) 
{
        int index = getIndex(qName);
        return index != -1 ? fAttributes[index].augs : null;
}

Look up an augmentation by XML 1.0 qualified name.

 public Augmentations getAugmentations(int attributeIndex) 
{
        if (attributeIndex <  0 || attributeIndex  >= fLength) {
            return null;
        }
        return fAttributes[attributeIndex].augs;
}

Look up an augmentations by attributes index.

 public Augmentations getAugmentations(String uri,
    String localName) 
{
        int index = getIndex(uri, localName);
        return index != -1 ? fAttributes[index].augs : null;
}

Look up an augmentations by Namespace name.

 public int getIndex(String qName) 
{
        for (int i = 0; i <  fLength; i++) {
            Attribute attribute = fAttributes[i];
            if (attribute.name.rawname != null &&
                attribute.name.rawname.equals(qName)) {
                return i;
            }
        }
        return -1;
}

Look up the index of an attribute by XML 1.0 qualified name.

 public int getIndex(String uri,
    String localPart) 
{
        for (int i = 0; i <  fLength; i++) {
            Attribute attribute = fAttributes[i];
            if (attribute.name.localpart != null &&
                attribute.name.localpart.equals(localPart) &&
                ((uri==attribute.name.uri) ||
                (uri!=null && attribute.name.uri!=null && attribute.name.uri.equals(uri))))
            {
                return i;
            }
        }
        return -1;
}

Look up the index of an attribute by Namespace name.

 public int getIndexFast(String qName) 
{
        for (int i = 0; i <  fLength; ++i) {
            Attribute attribute = fAttributes[i];
            if (attribute.name.rawname == qName) {
                return i;
            }
        }
        return -1;
}

Look up the index of an attribute by XML 1.0 qualified name.

Note: This method uses reference comparison, and thus should only be used internally. We cannot use this method in any code exposed to users as they may not pass in unique strings.

 public int getIndexFast(String uri,
    String localPart) 
{
        for (int i = 0; i <  fLength; ++i) {
            Attribute attribute = fAttributes[i];
            if (attribute.name.localpart == localPart && 
                attribute.name.uri == uri) {
                return i;
            }
        }
        return -1;
}

Look up the index of an attribute by Namespace name.

Note: This method uses reference comparison, and thus should only be used internally. We cannot use this method in any code exposed to users as they may not pass in unique strings.

 public int getLength() 
{
        return fLength;
}

Return the number of attributes in the list.

Once you know the number of attributes, you can iterate through the list.

 public String getLocalName(int index) 
{
        if (!fNamespaces) {
            return "";
        }
        if (index <  0 || index  >= fLength) {
            return null;
        }
        return fAttributes[index].name.localpart;
}

Look up an attribute's local name by index.

 public String getName(int index) 
{
        if (index <  0 || index  >= fLength) {
            return null;
        }
        return fAttributes[index].name.rawname;
}

Return the name of an attribute in this list (by position).

The names must be unique: the SAX parser shall not include the same attribute twice. Attributes without values (those declared #IMPLIED without a value specified in the start tag) will be omitted from the list.

If the attribute name has a namespace prefix, the prefix will still be attached.

 public  void getName(int attrIndex,
    QName attrName) 
{
        attrName.setValues(fAttributes[attrIndex].name);
}

Sets the fields in the given QName structure with the values of the attribute name at the specified index.

 public String getNonNormalizedValue(int attrIndex) 
{
        String value = fAttributes[attrIndex].nonNormalizedValue;
        return value;
}

Returns the non-normalized value of the attribute at the specified index. If no non-normalized value is set, this method will return the same value as the getValue(int) method.

 public String getPrefix(int index) 
{
        if (index <  0 || index  >= fLength) {
            return null;
        }
        String prefix = fAttributes[index].name.prefix;
        // REVISIT: The empty string is not entered in the symbol table!
        return prefix != null ? prefix : "";
}

Returns the prefix of the attribute at the specified index.

 public String getQName(int index) 
{
        if (index <  0 || index  >= fLength) {
            return null;
        }
        String rawname = fAttributes[index].name.rawname;
        return rawname != null ? rawname : "";
}

Look up an attribute's XML 1.0 qualified name by index.

 public boolean getSchemaId(int index) 
{
        if (index <  0 || index  >= fLength) {
            return false;
        }
        return fAttributes[index].schemaId;
}

 public boolean getSchemaId(String qname) 
{
        int index = getIndex(qname);
        return index != -1 ? fAttributes[index].schemaId : false;
}

 public boolean getSchemaId(String uri,
    String localName) 
{
        if (!fNamespaces) {
            return false;
        }
        int index = getIndex(uri, localName);
        return index != -1 ? fAttributes[index].schemaId : false;
}

 protected int getTableViewBucket(String qname) 
{
        return (qname.hashCode() & 0x7FFFFFFF) % fTableViewBuckets;
}

Returns the position in the table view where the given attribute name would be hashed.

 protected int getTableViewBucket(String localpart,
    String uri) 
{
        if (uri == null) {
            return (localpart.hashCode() & 0x7FFFFFFF) % fTableViewBuckets;
        }
        else {
            return ((localpart.hashCode() + uri.hashCode()) 
               & 0x7FFFFFFF) % fTableViewBuckets;
        }
}

Returns the position in the table view where the given attribute name would be hashed.

 public String getType(int index) 
{
        if (index <  0 || index  >= fLength) {
            return null;
        }
        return getReportableType(fAttributes[index].type);
}

Look up an attribute's type by index.

The attribute type is one of the strings "CDATA", "ID", "IDREF", "IDREFS", "NMTOKEN", "NMTOKENS", "ENTITY", "ENTITIES", or "NOTATION" (always in upper case).

If the parser has not read a declaration for the attribute, or if the parser does not report attribute types, then it must return the value "CDATA" as stated in the XML 1.0 Recommentation (clause 3.3.3, "Attribute-Value Normalization").

For an enumerated attribute that is not a notation, the parser will report the type as "NMTOKEN".

 public String getType(String qname) 
{
        int index = getIndex(qname);
        return index != -1 ? getReportableType(fAttributes[index].type) : null;
}

Look up an attribute's type by XML 1.0 qualified name.

See getType(int) for a description of the possible types.

 public String getType(String uri,
    String localName) 
{
        if (!fNamespaces) {
            return null;
        }
        int index = getIndex(uri, localName);
        return index != -1 ? getReportableType(fAttributes[index].type) : null;
}

Look up an attribute's type by Namespace name.

See getType(int) for a description of the possible types.

 public String getURI(int index) 
{
        if (index <  0 || index  >= fLength) {
            return null;
        }
        String uri = fAttributes[index].name.uri;
        return uri;
}

Look up an attribute's Namespace URI by index.

 public String getValue(int index) 
{
        if (index <  0 || index  >= fLength) {
            return null;
        }
        return fAttributes[index].value;
}

Look up an attribute's value by index.

If the attribute value is a list of tokens (IDREFS, ENTITIES, or NMTOKENS), the tokens will be concatenated into a single string with each token separated by a single space.

 public String getValue(String qname) 
{
        int index = getIndex(qname);
        return index != -1 ? fAttributes[index].value : null;
}

Look up an attribute's value by XML 1.0 qualified name.

See getValue(int) for a description of the possible values.

 public String getValue(String uri,
    String localName) 
{
        int index = getIndex(uri, localName);
        return index != -1 ? getValue(index) : null;
}

Look up an attribute's value by Namespace name.

See getValue(int) for a description of the possible values.

 public boolean isSpecified(int attrIndex) 
{
        return fAttributes[attrIndex].specified;
}

Returns true if the attribute is specified in the instance document.

 protected  void prepareAndPopulateTableView() 
{
        prepareTableView();
        // Need to populate the hash table with the attributes we've scanned so far.
        Attribute attr;
        int bucket;
        for (int i = 0; i <  fLength; ++i) {
            attr = fAttributes[i];
            bucket = getTableViewBucket(attr.name.rawname);
            if (fAttributeTableViewChainState[bucket] != fLargeCount) {
                fAttributeTableViewChainState[bucket] = fLargeCount;
                attr.next = null;
                fAttributeTableView[bucket] = attr;
            } 
            else {
                // Update table view
                attr.next = fAttributeTableView[bucket];
                fAttributeTableView[bucket] = attr;
            }
        }
}

Prepares the table view of the attributes list for use, and populates it with the attributes which have been previously read.

 protected  void prepareTableView() 
{
        if (fAttributeTableView == null) {
            fAttributeTableView = new Attribute[fTableViewBuckets];
            fAttributeTableViewChainState = new int[fTableViewBuckets];
        }
        else {
            cleanTableView();
        }
}

Prepares the table view of the attributes list for use.

 public  void removeAllAttributes() 
{
        fLength = 0;
}

Removes all of the attributes. This method will also remove all entities associated to the attributes.

 public  void removeAttributeAt(int attrIndex) 
{
        fIsTableViewConsistent = false;
        if (attrIndex <  fLength - 1) {
            Attribute removedAttr = fAttributes[attrIndex];
            System.arraycopy(fAttributes, attrIndex + 1,
                fAttributes, attrIndex, fLength - attrIndex - 1);
            // Make the discarded Attribute object available for re-use
            // by tucking it after the Attributes that are still in use
            fAttributes[fLength-1] = removedAttr;
        }
        fLength--;
}

Removes the attribute at the specified index.

Note: This operation changes the indexes of all attributes following the attribute at the specified index.

 public  void setAugmentations(int attrIndex,
    Augmentations augs) 
{
        fAttributes[attrIndex].augs = augs;
}

Sets the augmentations of the attribute at the specified index.

 public  void setName(int attrIndex,
    QName attrName) 
{
        fAttributes[attrIndex].name.setValues(attrName);
}

Sets the name of the attribute at the specified index.

 public  void setNamespaces(boolean namespaces) 
{
        fNamespaces = namespaces;
}

Sets whether namespace processing is being performed. This state is needed to return the correct value from the getLocalName method.

 public  void setNonNormalizedValue(int attrIndex,
    String attrValue) 
{
        if (attrValue == null) {
            attrValue = fAttributes[attrIndex].value;
        }
        fAttributes[attrIndex].nonNormalizedValue = attrValue;
}

Sets the non-normalized value of the attribute at the specified index.

 public  void setSchemaId(int attrIndex,
    boolean schemaId) 
{
        fAttributes[attrIndex].schemaId = schemaId;
}

 public  void setSpecified(int attrIndex,
    boolean specified) 
{
        fAttributes[attrIndex].specified = specified;
}

Sets whether an attribute is specified in the instance document or not.

 public  void setType(int attrIndex,
    String attrType) 
{
        fAttributes[attrIndex].type = attrType;
}

Sets the type of the attribute at the specified index.

 public  void setURI(int attrIndex,
    String uri) 
{
        fAttributes[attrIndex].name.uri = uri;
}

Sets the uri of the attribute at the specified index.

 public  void setValue(int attrIndex,
    String attrValue) 
{
        Attribute attribute = fAttributes[attrIndex];
        attribute.value = attrValue;
        attribute.nonNormalizedValue = attrValue;
}

Sets the value of the attribute at the specified index. This method will overwrite the non-normalized value of the attribute.