Package eu.bandm.tools.xslt.base

Class TPathCache

java.lang.Object

eu.bandm.tools.xslt.base.TPathCache

public class TPathCache
extends Object

Maintains a cache for parsing and analyzing xpath/tpath expressions in context of txsl. All these expressions are values of attributes in an xslt document, i.e. of xslt elements or of result elements. This cache supports two disjoint sets of keys, i.e. two different front-end formats, namely (a) values of dedicated xslt attributes, which are always an xpath source as a whole, (b) attribute value templates (AVTs), containing xpath expressions embedded into constant data, limited by reserved escape characters. The latter can appear in EVERY attribute of a result element, or in dedicated xslt attributes.
The syntax constraints on attribute values are DIFFERENT than in pure XML: Whenever an embedded xpath expressions is indicated by an escape character, the further contents must be parsable as such. So "a{" is a valid value for any CDATA attribute in XML, but not in xslt result elements.
The involved compiler for AVTs is AttributeValueTemplate. It always delivers a TPath.Expr; if there are no opening brackets in the source, this will be one single constant literal expression.
This value is turned into a an TPathCache.ExprClassified, which contains the parsed code and analysis results (or "null" in the code field iff there had been errors.)
Look-up and memorization go in two steps: (1) first look for verbatim cached source. (2) Then parse and look up for canonical source text. If look-up fails, perform analyses and store accordingly.
+ FIXME: List of all variable names collected !?!?
Additionally, the "sensitivity" on the context is calculated:
None -> needs evaluation only once, is constant
Session -> depends only on global variables, needs evaluation only once per application
Multi -> depends on context (=input focus, local vars), needs always re-evaluation

FIXME variable access is context depended.
FIXME But if ALL appearing variable NAMES appear only on global level, this raises sensivity only to "session", not to "multi".
FIXME the "union of relative and absolute" is not yet supported, (????) code has to be unified with /tpath/Util.isAbsolute() !!!!

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	TPathCache.ExprClassified	Holds the results of parsing and analysis.
static class	TPathCache.PatternPart	Statistic data on the sub-expressions of the top-level TPath.Union expression.
protected class	TPathCache.PredicateChecker
static enum	TPathCache.sensitivity	This value is ONLY related to the current-node-(list)-context, not to referred variables nor functions!

Field Summary

Fields

Modifier and Type	Field	Description
static final TPath.Union	ALL_LOWERS	tpath "(preceding::node()|nacestor-or-self::node())"
static final TPath.Step	ANYWHERE_IN_DOM
protected Map<String,String>	attributeValue_to_canonical
protected Map<String,String>	attributeValueTemplates_to_canonical
static final TPath.AxisSpecifier	AXIS_ANC_OR_SELF
static final TPath.AxisSpecifier	AXIS_DESC
static final TPath.AxisSpecifier	AXIS_DESC_OR_SELF
static final TPath.AxisSpecifier	AXIS_PRECEDING
static final TPath.AxisSpecifier	AXIS_PRECEDING_SIBS
(package private) static final Map<TPath.Expr,TPath.Expr>	cache_all_quantified
protected Map<String,TPathCache.ExprClassified>	canonical_to_parsed
(package private) TPathCache.PatternPart	curPart
(package private) boolean	inTemplateOrKeyMatch
(package private) Location<XMLDocumentIdentifier>	loc
(package private) MessageReceiver<SimpleMessage<XMLDocumentIdentifier>>	msg
(package private) boolean	patternOkay
static final TPath.Step	PRECEDING_SIBS	tpath "precedingSiblings::node()"
(package private) final TPathCache.PredicateChecker	predicateChecker
static final TPath.Step	RELATIVE_TO_PRECEDING
(package private) String	role
(package private) TPathCache.ExprClassified	toCheck
static final TPath.Node	TPATH_NODE
static final TPath.Root	TPATH_ROOT

Constructor Summary

Constructors

Constructor	Description
TPathCache()

Method Summary

Modifier and Type	Method	Description
protected void	checkFunction(TPath.FunctionCall f)	Means to check the function which can appear as first (umod: deepest) expression on a path expression ("id(x)/a/b/")
boolean	checkPattern(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg_EXT, @Opt Location<XMLDocumentIdentifier> loc, TPathCache.ExprClassified expr, boolean inTemplateOrKeyMatch, String role)	Returns whether the ExprClassified is a pattern, and updates TPathCache.ExprClassified.patternParts accordingly.
protected void	checkStep(TPath.Step step, boolean isTop)
protected void	checkTop(TPath.Expr expr)
(package private) static TPath.Expr	copyLocation(TPath.Expr newer, TPath.Expr old)
(package private) void	error(String s)
(package private) static final TPath.Expr	make_all_quantified(TPath.Expr expr)	Any expression of un-rooted type "a/b/..." = TPath.Step()->base->Step->base->null can be interpreted existentially quantified by prepending with "/descendant-or-self::node()/a/b/.." = TPath.Step()->base->Step->base-> (descendant-or-self) Root This is realized by a copy, which is cached and can be used as key for the cached evaluation result.
@Opt TPathCache.ExprClassified	parse(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg_EXT, Location<XMLDocumentIdentifier> loc, NamespaceName attribName, @Opt String data, boolean isTemplate)	Parse expression source and store result to caches.
protected void	splitTop(TPath.Expr expr)
(package private) static final TPath.Step	topStep(TPath.Step step)
(package private) static TPath.Expr	withRoot(TPath.Expr expr, TPath.Expr root)	Return a clone which has the given root instead of a base of null; distribute this over a possible top-level "union" operation.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

attributeValueTemplates_to_canonical

protected Map<String,String> attributeValueTemplates_to_canonical

attributeValue_to_canonical

protected Map<String,String> attributeValue_to_canonical

canonical_to_parsed

protected Map<String,TPathCache.ExprClassified> canonical_to_parsed

msg

MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg

loc

Location<XMLDocumentIdentifier> loc

inTemplateOrKeyMatch

boolean inTemplateOrKeyMatch

role

String role

patternOkay

boolean patternOkay

toCheck

TPathCache.ExprClassified toCheck

curPart

TPathCache.PatternPart curPart

predicateChecker

final TPathCache.PredicateChecker predicateChecker

TPATH_NODE

public static final TPath.Node TPATH_NODE

TPATH_ROOT

public static final TPath.Root TPATH_ROOT

AXIS_ANC_OR_SELF

public static final TPath.AxisSpecifier AXIS_ANC_OR_SELF

AXIS_DESC

public static final TPath.AxisSpecifier AXIS_DESC

AXIS_DESC_OR_SELF

public static final TPath.AxisSpecifier AXIS_DESC_OR_SELF

AXIS_PRECEDING

public static final TPath.AxisSpecifier AXIS_PRECEDING

AXIS_PRECEDING_SIBS

public static final TPath.AxisSpecifier AXIS_PRECEDING_SIBS

RELATIVE_TO_PRECEDING

public static final TPath.Step RELATIVE_TO_PRECEDING

ANYWHERE_IN_DOM

public static final TPath.Step ANYWHERE_IN_DOM

ALL_LOWERS

public static final TPath.Union ALL_LOWERS

tpath "(preceding::node()|nacestor-or-self::node())"

PRECEDING_SIBS

public static final TPath.Step PRECEDING_SIBS

tpath "precedingSiblings::node()"

cache_all_quantified

static final Map<TPath.Expr,TPath.Expr> cache_all_quantified

Constructor Details

TPathCache

public TPathCache()

Method Details

parse

@Opt
public @Opt TPathCache.ExprClassified parse(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg_EXT,
 Location<XMLDocumentIdentifier> loc,
 NamespaceName attribName,
 @Opt
 @Opt String data,
 boolean isTemplate)

Parse expression source and store result to caches. Return null in case of parsing errors. Otherwise classify expression for sensitivity. Return cached value, iff it exists. (Error msg must contain an attribute name, since location has only element granularity.)

error

void error(String s)

checkStep

protected void checkStep(TPath.Step step,
 boolean isTop)

checkFunction

protected void checkFunction(TPath.FunctionCall f)

Means to check the function which can appear as first (umod: deepest) expression on a path expression ("id(x)/a/b/")

checkTop

protected void checkTop(TPath.Expr expr)

splitTop

protected void splitTop(TPath.Expr expr)

checkPattern

public boolean checkPattern(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg_EXT,
 @Opt
 @Opt Location<XMLDocumentIdentifier> loc,
 TPathCache.ExprClassified expr,
 boolean inTemplateOrKeyMatch,
 String role)

Returns whether the ExprClassified is a pattern, and updates TPathCache.ExprClassified.patternParts accordingly. Generates errors if ExprClassified is not correct as a pattern.

copyLocation

static TPath.Expr copyLocation(TPath.Expr newer,
 TPath.Expr old)

withRoot

static TPath.Expr withRoot(TPath.Expr expr,
 TPath.Expr root)

Return a clone which has the given root instead of a base of null; distribute this over a possible top-level "union" operation.

topStep

static final TPath.Step topStep(TPath.Step step)

make_all_quantified

static final TPath.Expr make_all_quantified(TPath.Expr expr)

Any expression of un-rooted type "a/b/..."
= TPath.Step()->base->Step->base->null
can be interpreted existentially quantified by prepending with
"/descendant-or-self::node()/a/b/.."
= TPath.Step()->base->Step->base-> (descendant-or-self) Root
This is realized by a copy, which is cached and can be used as key for the cached evaluation result.

Parameters:

expr - an un-rooted expression serving as pattern-part, i.e. not a Union.