/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 2005 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 com.sun.org.apache.xerces.internal.jaxp.validation;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import com.sun.org.apache.xerces.internal.xni.grammars.Grammar;
import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;
import com.sun.org.apache.xerces.internal.xni.grammars.XMLSchemaDescription;
import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarPool;
/**
* <p>This grammar pool is a memory sensitive cache. The grammars
* stored in the pool are softly reachable and may be cleared by
* the garbage collector in response to memory demand. Equality
* of <code>XMLSchemaDescription</code>s is determined using both
* the target namespace for the schema and schema location.</p>
*
* @author Michael Glavassevich, IBM
* @version $Id: SoftReferenceGrammarPool.java,v 1.1.4.1 2005/09/05 11:43:19 sunithareddy Exp $
*/
final class SoftReferenceGrammarPool implements XMLGrammarPool {
//
// Constants
//
/** Default size. */
protected static final int TABLE_SIZE = 11;
/** Zero length grammar array. */
protected static final Grammar [] ZERO_LENGTH_GRAMMAR_ARRAY = new Grammar [0];
//
// Data
//
/** Grammars. */
protected Entry [] fGrammars = null;
/** Flag indicating whether this pool is locked */
protected boolean fPoolIsLocked;
/** The number of grammars in the pool */
protected int fGrammarCount = 0;
/** Reference queue for cleared grammar references */
protected final ReferenceQueue fReferenceQueue = new ReferenceQueue();
//
// Constructors
//
/** Constructs a grammar pool with a default number of buckets. */
public SoftReferenceGrammarPool() {
fGrammars = new Entry[TABLE_SIZE];
fPoolIsLocked = false;
} // <init>()
/** Constructs a grammar pool with a specified number of buckets. */
public SoftReferenceGrammarPool(int initialCapacity) {
fGrammars = new Entry[initialCapacity];
fPoolIsLocked = false;
}
//
// XMLGrammarPool methods
//
/* <p> Retrieve the initial known set of grammars. This method is
* called by a validator before the validation starts. The application
* can provide an initial set of grammars available to the current
* validation attempt. </p>
*
* @param grammarType The type of the grammar, from the
* <code>com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription</code>
* interface.
* @return The set of grammars the validator may put in its "bucket"
*/
public Grammar [] retrieveInitialGrammarSet (String grammarType) {
synchronized (fGrammars) {
clean();
// Return no grammars. This allows the garbage collector to sift
// out grammars which are not in use when memory demand is high.
// It also allows the pool to return the "right" schema grammar
// based on schema locations.
return ZERO_LENGTH_GRAMMAR_ARRAY;
}
} // retrieveInitialGrammarSet (String): Grammar[]
/* <p> Return the final set of grammars that the validator ended up
* with. This method is called after the validation finishes. The
* application may then choose to cache some of the returned grammars.</p>
* <p>In this implementation, we make our choice based on whether this object
* is "locked"--that is, whether the application has instructed
* us not to accept any new grammars.</p>
*
* @param grammarType The type of the grammars being returned;
* @param grammars An array containing the set of grammars being
* returned; order is not significant.
*/
public void cacheGrammars(String grammarType, Grammar[] grammars) {
if (!fPoolIsLocked) {
for (int i = 0; i < grammars.length; ++i) {
putGrammar(grammars[i]);
}
}
} // cacheGrammars(String, Grammar[]);
/* <p> This method requests that the application retrieve a grammar
* corresponding to the given GrammarIdentifier from its cache.
* If it cannot do so it must return null; the parser will then
* call the EntityResolver. </p>
* <strong>An application must not call its EntityResolver itself
* from this method; this may result in infinite recursions.</strong>
*
* This implementation chooses to use the root element name to identify a DTD grammar
* and the target namespace to identify a Schema grammar.
*
* @param desc The description of the Grammar being requested.
* @return The Grammar corresponding to this description or null if
* no such Grammar is known.
*/
public Grammar retrieveGrammar(XMLGrammarDescription desc) {
return getGrammar(desc);
} // retrieveGrammar(XMLGrammarDescription): Grammar
//
// Public methods
//
/**
* Puts the specified grammar into the grammar pool and associates it to
* its root element name or its target namespace.
*
* @param grammar The Grammar.
*/
public void putGrammar(Grammar grammar) {
if (!fPoolIsLocked) {
synchronized (fGrammars) {
clean();
XMLGrammarDescription desc = grammar.getGrammarDescription();
int hash = hashCode(desc);
int index = (hash & 0x7FFFFFFF) % fGrammars.length;
for (Entry entry = fGrammars[index]; entry != null; entry = entry.next) {
if (entry.hash == hash && equals(entry.desc, desc)) {
if (entry.grammar.get() != grammar) {
entry.grammar = new SoftGrammarReference(entry, grammar, fReferenceQueue);
}
return;
}
}
// create a new entry
Entry entry = new Entry(hash, index, desc, grammar, fGrammars[index], fReferenceQueue);
fGrammars[index] = entry;
fGrammarCount++;
}
}
} // putGrammar(Grammar)
/**
* Returns the grammar associated to the specified grammar description.
* Currently, the root element name is used as the key for DTD grammars
* and the target namespace is used as the key for Schema grammars.
*
* @param desc The Grammar Description.
*/
public Grammar getGrammar(XMLGrammarDescription desc) {
synchronized (fGrammars) {
clean();
int hash = hashCode(desc);
int index = (hash & 0x7FFFFFFF) % fGrammars.length;
for (Entry entry = fGrammars[index]; entry != null; entry = entry.next) {
Grammar tempGrammar = (Grammar) entry.grammar.get();
/** If the soft reference has been cleared, remove this entry from the pool. */
if (tempGrammar == null) {
removeEntry(entry);
}
else if ((entry.hash == hash) && equals(entry.desc, desc)) {
return tempGrammar;
}
}
return null;
}
} // getGrammar(XMLGrammarDescription):Grammar
/**
* Removes the grammar associated to the specified grammar description from the
* grammar pool and returns the removed grammar. Currently, the root element name
* is used as the key for DTD grammars and the target namespace is used
* as the key for Schema grammars.
*
* @param desc The Grammar Description.
* @return The removed grammar.
*/
public Grammar removeGrammar(XMLGrammarDescription desc) {
synchronized (fGrammars) {
clean();
int hash = hashCode(desc);
int index = (hash & 0x7FFFFFFF) % fGrammars.length;
for (Entry entry = fGrammars[index]; entry != null; entry = entry.next) {
if ((entry.hash == hash) && equals(entry.desc, desc)) {
return removeEntry(entry);
}
}
return null;
}
} // removeGrammar(XMLGrammarDescription):Grammar
/**
* Returns true if the grammar pool contains a grammar associated
* to the specified grammar description. Currently, the root element name
* is used as the key for DTD grammars and the target namespace is used
* as the key for Schema grammars.
*
* @param desc The Grammar Description.
*/
public boolean containsGrammar(XMLGrammarDescription desc) {
synchronized (fGrammars) {
clean();
int hash = hashCode(desc);
int index = (hash & 0x7FFFFFFF) % fGrammars.length;
for (Entry entry = fGrammars[index]; entry != null ; entry = entry.next) {
Grammar tempGrammar = (Grammar) entry.grammar.get();
/** If the soft reference has been cleared, remove this entry from the pool. */
if (tempGrammar == null) {
removeEntry(entry);
}
else if ((entry.hash == hash) && equals(entry.desc, desc)) {
return true;
}
}
return false;
}
} // containsGrammar(XMLGrammarDescription):boolean
/* <p> Sets this grammar pool to a "locked" state--i.e.,
* no new grammars will be added until it is "unlocked".
*/
public void lockPool() {
fPoolIsLocked = true;
} // lockPool()
/* <p> Sets this grammar pool to an "unlocked" state--i.e.,
* new grammars will be added when putGrammar or cacheGrammars
* are called.
*/
public void unlockPool() {
fPoolIsLocked = false;
} // unlockPool()
/*
* <p>This method clears the pool-i.e., removes references
* to all the grammars in it.</p>
*/
public void clear() {
for (int i=0; i<fGrammars.length; i++) {
if(fGrammars[i] != null) {
fGrammars[i].clear();
fGrammars[i] = null;
}
}
fGrammarCount = 0;
} // clear()
/**
* This method checks whether two grammars are the same. Currently, we compare
* the root element names for DTD grammars and the target namespaces for Schema grammars.
* The application can override this behaviour and add its own logic.
*
* @param desc1 The grammar description
* @param desc2 The grammar description of the grammar to be compared to
* @return True if the grammars are equal, otherwise false
*/
public boolean equals(XMLGrammarDescription desc1, XMLGrammarDescription desc2) {
if (desc1 instanceof XMLSchemaDescription) {
if (!(desc2 instanceof XMLSchemaDescription)) {
return false;
}
final XMLSchemaDescription sd1 = (XMLSchemaDescription) desc1;
final XMLSchemaDescription sd2 = (XMLSchemaDescription) desc2;
final String targetNamespace = sd1.getTargetNamespace();
if (targetNamespace != null) {
if (!targetNamespace.equals(sd2.getTargetNamespace())) {
return false;
}
}
else if (sd2.getTargetNamespace() != null) {
return false;
}
// The JAXP 1.3 spec says that the implementation can assume that
// if two schema location hints are the same they always resolve
// to the same document. In the default grammar pool implementation
// we only look at the target namespaces. Here we also compare
// location hints.
final String expandedSystemId = sd1.getExpandedSystemId();
if (expandedSystemId != null) {
if (!expandedSystemId.equals(sd2.getExpandedSystemId())) {
return false;
}
}
else if (sd2.getExpandedSystemId() != null) {
return false;
}
return true;
}
return desc1.equals(desc2);
}
/**
* Returns the hash code value for the given grammar description.
*
* @param desc The grammar description
* @return The hash code value
*/
public int hashCode(XMLGrammarDescription desc) {
if (desc instanceof XMLSchemaDescription) {
final XMLSchemaDescription sd = (XMLSchemaDescription) desc;
final String targetNamespace = sd.getTargetNamespace();
final String expandedSystemId = sd.getExpandedSystemId();
int hash = (targetNamespace != null) ? targetNamespace.hashCode() : 0;
hash ^= (expandedSystemId != null) ? expandedSystemId.hashCode() : 0;
return hash;
}
return desc.hashCode();
}
/**
* Removes the given entry from the pool
*
* @param entry the entry to remove
* @return The grammar attached to this entry
*/
private Grammar removeEntry(Entry entry) {
if (entry.prev != null) {
entry.prev.next = entry.next;
}
else {
fGrammars[entry.bucket] = entry.next;
}
if (entry.next != null) {
entry.next.prev = entry.prev;
}
--fGrammarCount;
entry.grammar.entry = null;
return (Grammar) entry.grammar.get();
}
/**
* Removes stale entries from the pool.
*/
private void clean() {
Reference ref = fReferenceQueue.poll();
while (ref != null) {
Entry entry = ((SoftGrammarReference) ref).entry;
if (entry != null) {
removeEntry(entry);
}
ref = fReferenceQueue.poll();
}
}
/**
* This class is a grammar pool entry. Each entry acts as a node
* in a doubly linked list.
*/
static final class Entry {
public int hash;
public int bucket;
public Entry prev;
public Entry next;
public XMLGrammarDescription desc;
public SoftGrammarReference grammar;
protected Entry(int hash, int bucket, XMLGrammarDescription desc, Grammar grammar, Entry next, ReferenceQueue queue) {
this.hash = hash;
this.bucket = bucket;
this.prev = null;
this.next = next;
if (next != null) {
next.prev = this;
}
this.desc = desc;
this.grammar = new SoftGrammarReference(this, grammar, queue);
}
// clear this entry; useful to promote garbage collection
// since reduces reference count of objects to be destroyed
protected void clear () {
desc = null;
grammar = null;
if(next != null) {
next.clear();
next = null;
}
} // clear()
} // class Entry
/**
* This class stores a soft reference to a grammar object. It keeps a reference
* to its associated entry, so that it can be easily removed from the pool.
*/
static final class SoftGrammarReference extends SoftReference {
public Entry entry;
protected SoftGrammarReference(Entry entry, Grammar grammar, ReferenceQueue queue) {
super(grammar, queue);
this.entry = entry;
}
} // class SoftGrammarReference
} // class SoftReferenceGrammarPool