/** Create and compile an XPath expression object. */
public Object makeObject() throws Exception {
if (logger.isDebugEnabled()) logger.debug("makeObject(" + xpathString + ")");
// Create context
final IndependentContext independentContext = new XPathCacheStaticContext(allowAllVariables);
// Set the base URI if specified
if (baseURI != null) independentContext.setBaseURI(baseURI);
// Declare namespaces
if (prefixToURIMap != null) {
for (final String prefix : prefixToURIMap.keySet()) {
independentContext.declareNamespace(prefix, prefixToURIMap.get(prefix));
}
}
// Declare variables (we don't use the values here, just the names)
final Map<String, Variable> variables = new HashMap<String, Variable>();
if (variableNames != null) {
for (final String name : variableNames) {
final Variable variable = independentContext.declareVariable(name);
variable.setUseStack(
true); // "Indicate that values of variables are to be found on the stack, not in the
// Variable object itself"
variables.put(name, variable);
}
}
// Add function library
if (functionLibrary != null) {
// This is ok
((FunctionLibraryList) independentContext.getFunctionLibrary())
.libraryList.add(0, functionLibrary);
}
// Create and compile the expression
try {
final Expression expression;
if (isAvt) {
final Expression tempExpression =
AttributeValueTemplate.make(xpathString, -1, independentContext);
// Running typeCheck() is mandatory otherwise things break! This is also done when using
// evaluator.createExpression()
expression = tempExpression.typeCheck(independentContext, Type.ITEM_TYPE);
} else {
// We used to use XPathEvaluator.createExpression(), but there is a bug in it related to
// slots allocation, so we do the work ourselves instead.
final Expression tempExpression =
ExpressionTool.make(xpathString, independentContext, 0, Token.EOF, 1);
expression = tempExpression.typeCheck(independentContext, Type.ITEM_TYPE);
}
// Allocate variable slots in all cases
ExpressionTool.allocateSlots(
expression,
independentContext.getStackFrameMap().getNumberOfVariables(),
independentContext.getStackFrameMap());
{
// Provide an Executable with the only purpose of allowing the evaluate() function find
// the right
// FunctionLibrary
if (expression instanceof ComputedExpression) {
final ComputedExpression computedExpression = (ComputedExpression) expression;
computedExpression.setParentExpression(
new Container() {
public Executable getExecutable() {
return new Executable() {
{
setFunctionLibrary(independentContext.getFunctionLibrary());
setLocationMap(new LocationMap());
setConfiguration(independentContext.getConfiguration());
}
};
}
public LocationProvider getLocationProvider() {
return computedExpression.getLocationProvider();
}
public int getHostLanguage() {
return Configuration.JAVA_APPLICATION;
}
public boolean replaceSubExpression(
Expression expression, Expression expression1) {
return computedExpression.replaceSubExpression(expression, expression1);
}
public int getColumnNumber() {
return (locationData != null) ? locationData.getCol() : -1;
}
public int getLineNumber() {
return (locationData != null) ? locationData.getLine() : -1;
}
public String getPublicId() {
return (locationData != null) ? locationData.getPublicID() : null;
}
public String getSystemId() {
return (locationData != null) ? locationData.getSystemID() : null;
}
});
}
}
// TODO: For now only play with XForms expressions. But should decide probably based on
// flag?
if (false && functionLibrary == XFormsContainingDocument.getFunctionLibrary()) {
final List<String> instanceIds = analyzeExpression(expression, xpathString);
if (instanceIds == null)
logger.info(" XXX EXPRESSION DEPENDS ON MORE THAN INSTANCES: " + xpathString);
else {
logger.info(" XXX EXPRESSION DEPENDS ON INSTANCES: " + xpathString);
for (String instanceId : instanceIds) {
logger.info(" instance: " + instanceId);
}
}
}
return new PooledXPathExpression(expression, pool, independentContext, variables);
} catch (Throwable t) {
throw new OXFException(t);
}
}
public static PooledXPathExpression getXPathExpression(
PropertyContext propertyContext,
List<Item> contextItems,
int contextPosition,
String xpathString,
Map<String, String> prefixToURIMap,
Map<String, ValueRepresentation> variableToValueMap,
FunctionLibrary functionLibrary,
String baseURI,
boolean isAvt,
boolean testNoCache,
LocationData locationData) {
try {
// Find pool from cache
final Long validity = (long) 0;
final Cache cache = ObjectCache.instance(XPATH_CACHE_NAME, XPATH_CACHE_DEFAULT_SIZE);
final FastStringBuffer cacheKeyString = new FastStringBuffer(xpathString);
{
if (functionLibrary != null) { // This is ok
cacheKeyString.append('|');
cacheKeyString.append(Integer.toString(functionLibrary.hashCode()));
}
}
{
// NOTE: Mike Kay confirms on 2007-07-04 that compilation depends on the namespace context,
// so we need
// to use it as part of the cache key.
// TODO: PERF: It turns out that this takes a lot of time. Now that the namespace
// information is computed statically, we can do better.
if (DEBUG_TEST_KEY_OPTIMIZATION) {
// PERF TEST ONLY
cacheKeyString.append("|DUMMYNSVAR|");
} else {
if (prefixToURIMap != null) {
final Map<String, String> sortedMap =
(prefixToURIMap instanceof TreeMap)
? prefixToURIMap
: new TreeMap<String, String>(
prefixToURIMap); // this should make sure we always get the keys in the same
// order
for (Map.Entry<String, String> currentEntry : sortedMap.entrySet()) {
cacheKeyString.append('|');
cacheKeyString.append(currentEntry.getKey());
cacheKeyString.append('=');
cacheKeyString.append(currentEntry.getValue());
}
}
}
}
if (DEBUG_TEST_KEY_OPTIMIZATION) {
// PERF TEST ONLY
// NOP
} else {
if (variableToValueMap != null && variableToValueMap.size() > 0) {
// There are some variables in scope. They must be part of the key
// TODO: Put this in static state as this can be determined statically once and for all
for (final String variableName : variableToValueMap.keySet()) {
cacheKeyString.append('|');
cacheKeyString.append(variableName);
}
}
}
{
// Add this to the key as evaluating "name" as XPath or as AVT is very different!
cacheKeyString.append('|');
cacheKeyString.append(Boolean.toString(isAvt));
}
// TODO: Add baseURI to cache key (currently, baseURI is pretty much unused)
final Set<String> variableNames =
(variableToValueMap != null) ? variableToValueMap.keySet() : null;
final PooledXPathExpression expr;
if (testNoCache) {
// For testing only: don't get expression from cache
final Object o =
new XFormsCachePoolableObjetFactory(
null,
xpathString,
prefixToURIMap,
variableNames,
functionLibrary,
baseURI,
isAvt,
false,
locationData)
.makeObject();
expr = (PooledXPathExpression) o;
} else {
// Get or create pool
final InternalCacheKey cacheKey =
new InternalCacheKey("XPath Expression2", cacheKeyString.toString());
ObjectPool pool = (ObjectPool) cache.findValid(propertyContext, cacheKey, validity);
if (pool == null) {
pool =
createXPathPool(
xpathString,
prefixToURIMap,
variableNames,
functionLibrary,
baseURI,
isAvt,
locationData);
cache.add(propertyContext, cacheKey, validity, pool);
}
// Get object from pool
final Object o = pool.borrowObject();
expr = (PooledXPathExpression) o;
}
// Set context items and position
expr.setContextItems(contextItems, contextPosition);
// Set variables
expr.setVariables(variableToValueMap);
return expr;
} catch (Exception e) {
throw handleXPathException(e, xpathString, "preparing XPath expression", locationData);
}
}