public class Resolver<M extends Match> extends AbstractSet<M>
Match objects, which can then be
retrieved using a string by comparing that string to the pattern of
the Match objects. Patterns consist of characters
with either the '*' or '?' characters as wild characters. The '*'
character is completely wild meaning that is will match nothing or
a long sequence of characters. The '?' character matches a single
character.
If the '?' character immediately follows the '*' character then the match is made as any sequence of characters up to the first match of the next character. For example "/*?/index.jsp" will match all files preceeded by only a single path. So "/pub/index.jsp" will match, however "/pub/bin/index.jsp" will not, as it has two paths. So, in effect the '*?' sequence will match anything or nothing up to the first occurence of the next character in the pattern.
A design goal of the Resolver was to make it capable
of high performance. In order to achieve a high performance the
Resolver can cache the resolutions it makes so that if
the same text is given to the Resolver.resolve method
a cached result can be retrived quickly which will decrease the
length of time and work required to perform the match.
The semantics of the resolver are such that the last pattern added
with a wild string is the first one checked for a match. This means
that if a sequence of insertions like add(x) followed
by add(y) is made, then a resolve(z) will
result in a comparison to y first and then x, if z matches y then
it is given as the result and if z does not match y and matches x
then x is returned, remember if z matches both x and y then y will
be the result due to the fact that is was the last pattern added.
| Modifier and Type | Field and Description |
|---|---|
protected org.simpleframework.xml.util.Resolver.Cache |
cache
Caches the text resolutions made to reduce the work required.
|
protected org.simpleframework.xml.util.Resolver.Stack |
stack
Stores the matches added to the resolver in resolution order.
|
| Constructor and Description |
|---|
Resolver()
The default constructor will create a
Resolver
without a large cache size. |
| Modifier and Type | Method and Description |
|---|---|
boolean |
add(M match)
This inserts the
Match implementation into the set
so that it can be used for resolutions. |
void |
clear()
This is used to clear all matches from the set.
|
Iterator<M> |
iterator()
This returns an
Iterator that iterates over the
matches in insertion order. |
boolean |
remove(M match)
This is used to remove the
Match implementation
from the resolver. |
M |
resolve(String text)
This will search the patterns in this
Resolver to
see if there is a pattern in it that matches the string given. |
List<M> |
resolveAll(String text)
This will search the patterns in this
Resolver to
see if there is a pattern in it that matches the string given. |
int |
size()
Returns the number of matches that have been inserted into
the
Resolver. |
equals, hashCode, removeAlladdAll, contains, containsAll, isEmpty, remove, retainAll, toArray, toArray, toStringclone, finalize, getClass, notify, notifyAll, wait, wait, waitaddAll, contains, containsAll, isEmpty, remove, retainAll, spliterator, toArray, toArrayparallelStream, removeIf, streamprotected final org.simpleframework.xml.util.Resolver.Cache cache
protected final org.simpleframework.xml.util.Resolver.Stack stack
public Resolver()
Resolver
without a large cache size. This is intended for use when
the requests for resolve tend to use strings
that are reasonably similar. If the strings issued to this
instance are dramatically different then the cache tends
to be an overhead rather than a bonus.public M resolve(String text)
Resolver to
see if there is a pattern in it that matches the string given.
This will search the patterns from the last entered pattern to
the first entered. So that the last entered patterns are the
most searched patterns and will resolve it first if it matches.text - this is the string that is to be matched by thispublic List<M> resolveAll(String text)
Resolver to
see if there is a pattern in it that matches the string given.
This will search the patterns from the last entered pattern to
the first entered. So that the last entered patterns are the
most searched patterns and will resolve it first if it matches.text - this is the string that is to be matched by thispublic boolean add(M match)
Match implementation into the set
so that it can be used for resolutions. The last added match is
the first resolved. Because this changes the state of the
resolver this clears the cache as it may affect resolutions.add in interface Collection<M extends Match>add in interface Set<M extends Match>add in class AbstractCollection<M extends Match>match - this is the match that is to be inserted to thispublic Iterator<M> iterator()
Iterator that iterates over the
matches in insertion order. So the first match added is the
first retrieved from the Iterator. This order is
used to ensure that resolver can be serialized properly.iterator in interface Iterable<M extends Match>iterator in interface Collection<M extends Match>iterator in interface Set<M extends Match>iterator in class AbstractCollection<M extends Match>public boolean remove(M match)
Match implementation
from the resolver. This clears the cache as the removal of
a match may affect the resoultions existing in the cache. The
equals method of the match must be implemented.match - this is the match that is to be removedpublic int size()
Resolver. Although this is a set, it does
not mean that matches cannot used the same pattern string.public void clear()