@Immutable public class PathExpression extends Object implements Serializable
Let's first look at some simple examples of path expressions:
Path expression | Description |
---|---|
/a/b | Match node "b " that is a child of the top level node "a ". Neither node may have any
same-name-sibilings. |
/a/* | Match any child node of the top level node "a ". |
/a/*.txt | Match any child node of the top level node "a " that also has a name ending in ".txt ". |
/a/b@c | Match the property "c " of node "/a/b ". |
/a/b[2] | The second child named "b " below the top level node "a ". |
/a/b[2,3,4] | The second, third or fourth child named "b " below the top level node "a ". |
/a/b[*] | Any (and every) child named "b " below the top level node "a ". |
//a/b | Any node named "b " that exists below a node named "a ", regardless of where node "a "
occurs. Again, neither node may have any same-name-sibilings. |
With these simple examples, you can probably discern the most important rules. First, the '*
' is a wildcard
character that matches any character or sequence of characters in a node's name (or index if appearing in between square
brackets), and can be used in conjunction with other characters (e.g., "*.txt
").
Second, square brackets (i.e., '[
' and ']
') are used to match a node's same-name-sibiling index. You
can put a single non-negative number or a comma-separated list of non-negative numbers. Use '0' to match a node that has no
same-name-sibilings, or any positive number to match the specific same-name-sibling.
Third, combining two delimiters (e.g., "//
") matches any sequence of nodes, regardless of what their names are or
how many nodes. Often used with other patterns to identify nodes at any level matching other patterns. Three or more sequential
slash characters are treated as two.
Many path expressions can be created using just these simple rules. However, input paths can be more complicated. Here are some more examples:
Path expressions | Description |
---|---|
/a/(b|c|d) | Match children of the top level node "a " that are named "a ", "b " or "c
". None of the nodes may have same-name-sibling indexes. |
/a/b[c/d] | Match node "b " child of the top level node "a ", when node "b " has a child named "
c ", and "c " has a child named "d ". Node "b
" is the selected node, while nodes "b " and "b " are used as criteria but are not selected. |
/a(/(b|c|d|)/e)[f/g/@something] | Match node "/a/b/e ", "/a/c/e ", "/a/d/e ", or "/a/e
" when they also have a child "f " that itself has a child "g " with property "something ".
None of the nodes may have same-name-sibling indexes. |
These examples show a few more advanced rules. Parentheses (i.e., '(
' and ')
') can be used to define
a set of options for names, as shown in the first and third rules. Whatever part of the selected node's path appears between
the parentheses is captured for use within the output path. Thus, the first input path in the previous table would match node "
/a/b
", and "b" would be captured and could be used within the output path using "$1
", where the
number used in the output path identifies the parentheses.
Square brackets can also be used to specify criteria on a node's properties or children. Whatever appears in between the square brackets does not appear in the selected node.
Path expressions can also specify restrictions on the workspace name to constrain the path expression to matching only paths from certain workspaces meeting the name criteria. Of course, if the path expression doesn't include these restrictions, the workspace name are not considered when matching paths.
Modifier and Type | Class and Description |
---|---|
static class |
PathExpression.Matcher |
static class |
PathExpression.WorkspacePath |
Constructor and Description |
---|
PathExpression(String expression)
Create the supplied expression.
|
Modifier and Type | Method and Description |
---|---|
static PathExpression |
all() |
static PathExpression |
compile(String expression)
Compile the supplied expression and return the resulting path expression instance.
|
boolean |
equals(Object obj) |
String |
getExpression() |
String |
getSelectExpression() |
int |
hashCode() |
PathExpression.Matcher |
matcher(String absolutePath)
Obtain a Matcher that can be used to convert the supplied absolute path into an output repository, and output workspace
name, and output path.
|
boolean |
matchesAnything()
Return whether this expression matches anything and therefore is not restrictive.
|
boolean |
matchesWorkspace(String workspaceName)
Determine if this path expression applies to content within the supplied workspace name.
|
static PathExpression.WorkspacePath |
parsePathInWorkspace(String path)
Parse a path of the form
{workspaceName}:{absolutePath} or {absolutePath} . |
protected String |
removeAllPredicatesExceptIndexes(String expression)
Remove all XPath predicates from the supplied regular expression string.
|
protected String |
removeUnusedPredicates(String expression)
Replace certain XPath patterns that are not used or understood.
|
protected String |
replaceXPathPatterns(String expression)
Replace certain XPath patterns, including some predicates, with substrings that are compatible with regular expressions.
|
String |
toString() |
public PathExpression(String expression) throws InvalidPathExpressionException
expression
- the expressionIllegalArgumentException
- if the expression is nullInvalidPathExpressionException
- if the expression is blank or is not a valid expressionpublic static final PathExpression compile(String expression) throws InvalidPathExpressionException
expression
- the expressionIllegalArgumentException
- if the expression is nullInvalidPathExpressionException
- if the expression is blank or is not a valid expressionpublic String getExpression()
protected String removeUnusedPredicates(String expression)
expression
- the input regular expressions string; may not be nullprotected String removeAllPredicatesExceptIndexes(String expression)
expression
- the input regular expressions string; may not be nullprotected String replaceXPathPatterns(String expression)
expression
- the input regular expressions string; may not be nullpublic String getSelectExpression()
public boolean matchesWorkspace(String workspaceName)
workspaceName
- the name of the workspace; may not be nullpublic final PathExpression.Matcher matcher(String absolutePath)
matches
.absolutePath
- the path in the workspacepublic boolean matchesAnything()
/
"), any sequence of nodes ("//
"), the self reference (".
"), or wildcard ("
*
", "*[]
" or "*[*]
"). Combinations of these individual expressions are also
considered to match anything.public static PathExpression all()
public static PathExpression.WorkspacePath parsePathInWorkspace(String path)
{workspaceName}:{absolutePath}
or {absolutePath}
.path
- the pathCopyright © 2008–2016 JBoss, a division of Red Hat. All rights reserved.