java.lang.Object
- org.joox.Impl

All Implemented Interfaces:

java.lang.Iterable<org.w3c.dom.Element>, Match
```
class Impl
extends java.lang.Object
implements Match
```

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`private class`	`Impl.ChainedContext`	A namespace context that is aware of this Impl's configured namespaces, as well as a chained context.
`private static class`	`Impl.VariableResolver`	A simple variable resolver mapping variable names to their respective index in an XPath expression.

Field Summary

Fields
Modifier and Type	Field	Description
`private org.w3c.dom.Document`	`document`
`private java.util.List<org.w3c.dom.Element>`	`elements`
`private java.util.Map<java.lang.String,java.lang.String>`	`namespaces`
`private Impl`	`previousMatch`
`static java.util.regex.Pattern`	`SIMPLE_SELECTOR`	A selector pattern that can be evaluated using standard DOM API

Constructor Summary

Constructors
Constructor	Description
`Impl(org.w3c.dom.Document document, java.util.Map<java.lang.String,java.lang.String> namespaces)`
`Impl(org.w3c.dom.Document document, java.util.Map<java.lang.String,java.lang.String> namespaces, Impl previousMatch)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Impl`	`add(Match... e)`	Add some elements to the set of matched elements
`Impl`	`add(org.w3c.dom.Element... e)`	Add some elements to the set of matched elements
`(package private) Impl`	`addElements(java.util.Collection<org.w3c.dom.Element> e)`
`(package private) Impl`	`addElements(org.w3c.dom.Element... e)`
`(package private) Impl`	`addNodeList(org.w3c.dom.NodeList list)`
`(package private) Impl`	`addNodeLists(java.util.List<org.w3c.dom.NodeList> lists)`
`(package private) Impl`	`addUniqueElements(java.util.List<org.w3c.dom.Element> e)`
`(package private) Impl`	`addUniqueElements(org.w3c.dom.Element... e)`
`Impl`	`after(java.lang.String content)`	Add content after each element in the set of matched elements.
`Impl`	`after(Content content)`	Add content after each element in the set of matched elements.
`Impl`	`after(Match... content)`	Add content after each element in the set of matched elements.
`Impl`	`after(org.w3c.dom.Element... content)`	Add content after each element in the set of matched elements.
`Impl`	`andSelf()`	Add the previous set of matched elements to the current one.
`Impl`	`append(java.lang.String content)`	Append content to the end of each element's content in the set of matched elements.
`Impl`	`append(Content content)`	Append content to the end of each element's content in the set of matched elements.
`Impl`	`append(Match... content)`	Append content to the end of each element's content in the set of matched elements.
`Impl`	`append(org.w3c.dom.Element... content)`	Append content to the end of each element's content in the set of matched elements.
`java.lang.String`	`attr(java.lang.String name)`	Get an attribute from the first element in the set of matched elements, or `null` if the first element does not have that attribute.
`<T> T`	`attr(java.lang.String name, java.lang.Class<T> type)`	Get a converted attribute from the first element in the set of matched elements, or `null` if the first element does not have that attribute.
`Impl`	`attr(java.lang.String name, java.lang.String value)`	Set an attribute on all elements in the set of matched elements.
`Impl`	`attr(java.lang.String name, Content content)`	Set an attribute on all elements in the set of matched elements.
`java.util.List<java.lang.String>`	`attrs(java.lang.String name)`	Get an attribute from all elements in the set of matched elements
`<T> java.util.List<T>`	`attrs(java.lang.String name, java.lang.Class<T> type)`	Get a converted attribute from all elements in the set of matched elements
`private Impl`	`axis(boolean all, Filter until, Filter filter, java.util.function.Function<org.w3c.dom.Node,org.w3c.dom.Node> iterate, java.util.function.Consumer<java.util.List<org.w3c.dom.Element>> finisher)`
`Impl`	`before(java.lang.String content)`	Add content before each element in the set of matched elements.
`Impl`	`before(Content content)`	Add content before each element in the set of matched elements.
`Impl`	`before(Match... content)`	Add content before each element in the set of matched elements.
`Impl`	`before(org.w3c.dom.Element... content)`	Add content before each element in the set of matched elements.
`java.lang.String`	`cdata()`	Get the CDATA content of the first element in the set of matched elements, or `null` if there are no matched elements.
`java.lang.String`	`cdata(int index)`	Get the CDATA content at a given index in the current set of matched elements.
`<T> T`	`cdata(java.lang.Class<T> type)`	Get the converted CDATA content of the first element in the set of matched elements, or `null` if there are no matched elements.
`Impl`	`cdata(java.lang.String content)`	Set some CDATA content to all elements in the set of matched elements (possibly replacing existing content).
`Impl`	`cdata(Content content)`	Set some CDATA content to all elements in the set of matched elements (possibly replacing existing content).
`java.util.List<java.lang.String>`	`cdatas()`	Get all CDATA content of the elements in the set of matched elements.
`java.util.List<java.lang.String>`	`cdatas(int... indexes)`	Get all CDATA content of the elements at given indexes in the set of matched elements.
`<T> java.util.List<T>`	`cdatas(java.lang.Class<T> type)`	Get all converted CDATA content of the elements in the set of matched elements.
`Impl`	`child()`	Find the first child of each element in the current set of matched elements.
`Impl`	`child(int index)`	Find the child at a given index of each element in the current set of matched elements.
`Impl`	`child(java.lang.String selector)`	Find the first matching child of each element in the current set of matched elements
`Impl`	`child(Filter filter)`	Find the first matching child of each element in the current set of matched elements
`Impl`	`children()`	Find all children of each element in the current set of matched elements.
`Impl`	`children(int... indexes)`	Find all children of each element at given indexes in the current set of matched elements.
`Impl`	`children(java.lang.String selector)`	Find all children of each element in the current set of matched elements.
`Impl`	`children(Filter filter)`	Find all children of each element in the current set of matched elements.
`java.lang.String`	`content()`	Get the XML content of the first element in the set of matched elements, or `null` if there are no matched elements.
`java.lang.String`	`content(int index)`	Get the XML content at a given index in the current set of matched elements.
`Impl`	`content(java.lang.Object content)`	Add some JAXB-marshallable XML content to all elements in the set of matched elements (possibly replacing existing content).
`Impl`	`content(java.lang.String content)`	Add some XML content to all elements in the set of matched elements (possibly replacing existing content).
`Impl`	`content(Content content)`	Add some XML content to all elements in the set of matched elements (possibly replacing existing content).
`private java.lang.String`	`content(org.w3c.dom.Element element)`
`java.util.List<java.lang.String>`	`contents()`	Get all XML content of the elements in the set of matched elements.
`java.util.List<java.lang.String>`	`contents(int... indexes)`	Get all XML content of the elements at given indexes in the set of matched elements.
`Impl`	`copy()`	Get a copy of the `Match` wrapper.
`org.w3c.dom.Document`	`document()`	Get the underlying document of the set of matched elements.
`java.util.List<Match>`	`each()`	Get all elements in the set of matched elements in a list of matches, every match representing one element
`Impl`	`each(java.lang.Iterable<? extends Each> each)`	Execute several callbacks for every element in the current set of matched elements.
`Impl`	`each(Each each)`	Execute a callback for every element in the current set of matched elements.
`Impl`	`each(Each... each)`	Execute several callbacks for every element in the current set of matched elements.
`Match`	`empty()`	Removes all content from all elements in the set of matched elements.
`private void`	`empty(org.w3c.dom.Element element)`
`Impl`	`eq(int... indexes)`	Reduce the current set of matched elements to the elements at the given indexes.
`boolean`	`equals(java.lang.Object obj)`
`Impl`	`filter(java.lang.String selector)`	Reduce the current set of matched elements.
`Impl`	`filter(Filter filter)`	Reduce the current set of matched elements.
`private java.util.List<org.w3c.dom.Element>`	`filter0(Filter filter)`
`Impl`	`find()`	Find all descendants of each element in the current set of matched elements.
`Impl`	`find(java.lang.String selector)`	Find all descendants of each element in the current set of matched elements.
`Impl`	`find(Filter filter)`	Find all descendants of each element in the current set of matched elements.
`Impl`	`first()`	Get the first in a set of matched elements.
`java.util.List<org.w3c.dom.Element>`	`get()`	Get an the set of matched elements
`org.w3c.dom.Element`	`get(int index)`	Get an element from the set of matched elements at a given index
`java.util.List<org.w3c.dom.Element>`	`get(int... indexes)`	Get some elements from the set of matched elements at the given indexes
`Impl`	`has(java.lang.String selector)`	Reduce the set of matched element to those who have a descendant that matches a selector.
`Impl`	`has(Filter filter)`	Reduce the set of matched element to those who have a descendant that matches a filter.
`int`	`hashCode()`
`java.lang.String`	`id()`	Get the first id value
`java.lang.String`	`id(int index)`	Get an id value at a given index in the current set of matched elements.
`<T> T`	`id(java.lang.Class<T> type)`	Get the first converted id value
`java.util.List<java.lang.String>`	`ids()`	Get a list of id values in the current set of matched elements.
`java.util.List<java.lang.String>`	`ids(int... indexes)`	Get a list of id values at given indexes in the current set of matched elements.
`<T> java.util.List<T>`	`ids(java.lang.Class<T> type)`	Get a list of converted id values in the current set of matched elements.
`boolean`	`is(java.lang.String selector)`	Check if at least one element in the set of matched elements satisfies a selector.
`boolean`	`is(Filter filter)`	Check if at least one element in the set of matched elements satisfies a filter.
`boolean`	`isEmpty()`	Whether there are any matched elements in the set of matched elements
`private boolean`	`isFast(Filter filter)`
`boolean`	`isNotEmpty()`	Whether there are any matched elements in the set of matched elements
`private boolean`	`isRoot()`	Temporary utility method to indicate whether the root element is among the matched elements
`java.util.Iterator<org.w3c.dom.Element>`	`iterator()`
`Impl`	`last()`	Get the last in a set of matched elements.
`Impl`	`leaf()`	Reduce the set of matched elements to the ones that are leaf elements
`<E> java.util.List<E>`	`map(Mapper<E> map)`	Map the set of matched elements to a list of something
`Match`	`matchAttr(java.lang.String name, java.lang.String valueRegex)`	Reduce the set of matched elements by filtering out those whose attribute content doesn't match a given regex
`Match`	`matchAttr(java.lang.String name, java.lang.String valueRegex, boolean keepMatches)`	Reduce the set of matched elements by filtering out those whose attribute content doesn't match a given regex `(keepMatches = true)`, or those whose text content matches a given regex `(keepMatches = false)`
`Impl`	`matchTag(java.lang.String regex)`	Reduce the set of matched elements by filtering out those whose tag name doesn't match a given regex
`Impl`	`matchTag(java.lang.String regex, boolean keepMatches)`	Reduce the set of matched elements by filtering out those whose tag name doesn't match a given regex `(keepMatches = true)`, or those whose tag name matches a given regex `(keepMatches = false)`
`Impl`	`matchText(java.lang.String regex)`	Reduce the set of matched elements by filtering out those whose text content doesn't match a given regex
`Impl`	`matchText(java.lang.String regex, boolean keepMatches)`	Reduce the set of matched elements by filtering out those whose text content doesn't match a given regex `(keepMatches = true)`, or those whose text content matches a given regex `(keepMatches = false)`
`Match`	`namespace(java.lang.String namespacePrefix, java.lang.String namespaceURI)`	Get a new Match with added namespace configuration for subsequent XPath calls
`java.lang.String`	`namespacePrefix()`	Get the namespace prefix of the first element in the current set of matched elements.
`java.lang.String`	`namespacePrefix(int index)`	Get a namespace prefix of the element at a given index in the current set of matched elements.
`java.util.List<java.lang.String>`	`namespacePrefixes()`	Get a list of namespace prefixes of the elements in the current set of matched elements.
`java.util.List<java.lang.String>`	`namespacePrefixes(int... indexes)`	Get a list of namespace prefixes of the elements at given indexes in the current set of matched elements.
`Match`	`namespaces(java.util.Map<java.lang.String,java.lang.String> map)`	Get a new Match with added namespace configuration for subsequent XPath calls
`java.lang.String`	`namespaceURI()`	Get the namespace URI of the first element in the current set of matched elements.
`java.lang.String`	`namespaceURI(int index)`	Get a namespace URI of the element at a given index in the current set of matched elements.
`java.util.List<java.lang.String>`	`namespaceURIs()`	Get a list of namespace URIs of the elements in the current set of matched elements.
`java.util.List<java.lang.String>`	`namespaceURIs(int... indexes)`	Get a list of namespace URIs of the elements at given indexes in the current set of matched elements.
`Impl`	`next()`	Get the immediate next sibling of every element in set of matched elements.
`private Impl`	`next(boolean all, Filter until, Filter filter)`
`Impl`	`next(java.lang.String selector)`	Get the immediate next sibling of every element in set of matched elements, matching a selector
`Impl`	`next(Filter filter)`	Get the immediate next sibling of every element in set of matched elements, matching a filter
`Impl`	`nextAll()`	Get all next siblings of every element in a set of matched elements
`Impl`	`nextAll(java.lang.String selector)`	Get all next siblings of every element in a set of matched elements, matching a selector
`Impl`	`nextAll(Filter filter)`	Get all next siblings of every element in a set of matched elements, matching a filter
`Impl`	`nextUntil(java.lang.String until)`	Get all next siblings of every element in a set of matched elements until the provided selector matches
`Impl`	`nextUntil(java.lang.String until, java.lang.String selector)`	Get all next siblings of every element in a set of matched elements, matching a selector, until the provided selector matches
`Impl`	`nextUntil(java.lang.String until, Filter filter)`	Get all next siblings of every element in a set of matched elements, matching a filter, until the provided selector matches
`Impl`	`nextUntil(Filter until)`	Get all next siblings of every element in a set of matched elements until the provided filter matches
`Impl`	`nextUntil(Filter until, java.lang.String selector)`	Get all next siblings of every element in a set of matched elements, matching a selector until the provided filter matches
`Impl`	`nextUntil(Filter until, Filter filter)`	Get all next siblings of every element in a set of matched elements, matching a filter until the provided filter matches
`Impl`	`not(java.lang.String selector)`	Remove elements from the set of matched elements.
`Impl`	`not(Filter filter)`	Remove elements from the set of matched elements.
`Impl`	`parent()`	Get the immediate parent elements of every element in a set of matched elements
`Impl`	`parent(java.lang.String selector)`	Get the immediate parent elements of every element in a set of matched elements, matching a selector
`Impl`	`parent(Filter filter)`	Get the immediate parent elements of every element in a set of matched elements, matching a filter
`Impl`	`parents()`	Get all ancestor elements of every element in a set of matched elements
`private Impl`	`parents(boolean all, Filter until, Filter filter)`
`Impl`	`parents(java.lang.String selector)`	Get all ancestor elements of every element in a set of matched elements, matching a selector
`Impl`	`parents(Filter filter)`	Get all ancestor elements of every element in a set of matched elements, matching a filter
`Impl`	`parentsUntil(java.lang.String until)`	Get all ancestors of every element in a set of matched elements until the provided selector matches
`Impl`	`parentsUntil(java.lang.String until, java.lang.String selector)`	Get all ancestors of every element in a set of matched elements, matching a selector, until the provided selector matches
`Impl`	`parentsUntil(java.lang.String until, Filter filter)`	Get all ancestors of every element in a set of matched elements, matching a filter, until the provided selector matches
`Impl`	`parentsUntil(Filter until)`	Get all ancestors of every element in a set of matched elements until the provided filter matches
`Impl`	`parentsUntil(Filter until, java.lang.String selector)`	Get all ancestors of every element in a set of matched elements, matching a selector until the provided filter matches
`Impl`	`parentsUntil(Filter until, Filter filter)`	Get all ancestors of every element in a set of matched elements, matching a filter until the provided filter matches
`Impl`	`prepend(java.lang.String content)`	Prepend content to the beginning of each element's content in the set of matched elements.
`Impl`	`prepend(Content content)`	Prepend content to the beginning of each element's content in the set of matched elements.
`Impl`	`prepend(Match... content)`	Prepend content to the beginning of each element's content in the set of matched elements.
`Impl`	`prepend(org.w3c.dom.Element... content)`	Prepend content to the beginning of each element's content in the set of matched elements.
`Impl`	`prev()`	Get the immediate previous sibling of every element in set of matched elements.
`private Impl`	`prev(boolean all, Filter until, Filter filter)`
`Impl`	`prev(java.lang.String selector)`	Get the immediate previous sibling of every element in set of matched elements, matching a selector
`Impl`	`prev(Filter filter)`	Get the immediate previous sibling of every element in set of matched elements, matching a filter
`Impl`	`prevAll()`	Get all previous siblings of every element in a set of matched elements
`Impl`	`prevAll(java.lang.String selector)`	Get all previous siblings of every element in a set of matched elements, matching a selector
`Impl`	`prevAll(Filter filter)`	Get all previous siblings of every element in a set of matched elements, matching a filter
`Impl`	`prevUntil(java.lang.String until)`	Get all previous siblings of every element in a set of matched elements until the provided selector matches
`Impl`	`prevUntil(java.lang.String until, java.lang.String selector)`	Get all previous siblings of every element in a set of matched elements, matching a selector, until the provided selector matches
`Impl`	`prevUntil(java.lang.String until, Filter filter)`	Get all previous siblings of every element in a set of matched elements, matching a filter, until the provided selector matches
`Impl`	`prevUntil(Filter until)`	Get all previous siblings of every element in a set of matched elements until the provided filter matches
`Impl`	`prevUntil(Filter until, java.lang.String selector)`	Get all previous siblings of every element in a set of matched elements, matching a selector until the provided filter matches
`Impl`	`prevUntil(Filter until, Filter filter)`	Get all previous siblings of every element in a set of matched elements, matching a filter until the provided filter matches
`Impl`	`remove()`	Removes all elements from their parent nodes in the set of matched elements.
`Impl`	`remove(java.lang.String selector)`	Removes all elements from their parent nodes in the set of matched elements, matching a selector
`Impl`	`remove(Filter filter)`	Removes all elements from their parent nodes in the set of matched elements, matching a filter
`private void`	`remove(org.w3c.dom.Element element)`
`Impl`	`removeAttr(java.lang.String name)`	Remove an attribute from all elements in the set of matched elements.
`Match`	`rename(java.lang.String tag)`	Rename all tags in the set of matched elements to some new tag name
`Match`	`rename(Content tag)`	Rename all tags in the set of matched elements to some new tag name
`Impl`	`replaceWith(java.lang.String content)`	Replace all elements in the set of matched elements with some new content.
`Impl`	`replaceWith(Content content)`	Replace all elements in the set of matched elements with some new content.
`Impl`	`replaceWith(Match... content)`	Replace all elements in the set of matched elements with some new content.
`Impl`	`replaceWith(org.w3c.dom.Element... content)`	Replace all elements in the set of matched elements with some new content.
`Impl`	`reverse()`	Reverse the order of the set of matched elements
`Impl`	`siblings()`	Get all siblings of every element in a set of matched elements
`Impl`	`siblings(java.lang.String selector)`	Get all siblings of every element in a set of matched elements, matching a selector
`Impl`	`siblings(Filter filter)`	Get all siblings of every element in a set of matched elements, matching a filter
`int`	`size()`	Get the number of matched elements in the set of matched elements
`Impl`	`slice(int start)`	Reduce the set of matched elements by specifying a range of indexes
`Impl`	`slice(int start, int end)`	Reduce the set of matched elements by specifying a range of indexes
`Match`	`sort(java.util.Comparator<org.w3c.dom.Element> comparator)`	Allows to sort the result with the given comparator.
`java.lang.String`	`tag()`	Get the tag name of the first element in the current set of matched elements.
`java.lang.String`	`tag(int index)`	Get a tag name of the element at a given index in the current set of matched elements.
`java.util.List<java.lang.String>`	`tags()`	Get a list of tag names of the elements in the current set of matched elements.
`java.util.List<java.lang.String>`	`tags(int... indexes)`	Get a list of tag names of the elements at given indexes in the current set of matched elements.
`java.lang.String`	`text()`	Get the text content of the first element in the set of matched elements, or `null` if there are no matched elements.
`java.lang.String`	`text(int index)`	Get the text content at a given index in the current set of matched elements.
`<T> T`	`text(java.lang.Class<T> type)`	Get the converted text content of the first element in the set of matched elements, or `null` if there are no matched elements.
`Impl`	`text(java.lang.String content)`	Set some text content to all elements in the set of matched elements (possibly replacing existing content).
`Impl`	`text(Content content)`	Set some text content to all elements in the set of matched elements (possibly replacing existing content).
`java.util.List<java.lang.String>`	`texts()`	Get all text content of the elements in the set of matched elements.
`java.util.List<java.lang.String>`	`texts(int... indexes)`	Get all text content of the elements at given indexes in the set of matched elements.
`<T> java.util.List<T>`	`texts(java.lang.Class<T> type)`	Get all converted text content of the elements in the set of matched elements.
`java.lang.String`	`toString()`
`Impl`	`transform(java.io.File transformer)`	Transform all elements in the set of matched elements.
`Impl`	`transform(java.io.InputStream transformer)`	Transform all elements in the set of matched elements.
`Impl`	`transform(java.io.Reader transformer)`	Transform all elements in the set of matched elements.
`Impl`	`transform(java.lang.String transformer)`	Transform all elements in the set of matched elements.
`Impl`	`transform(java.net.URL transformer)`	Transform all elements in the set of matched elements.
`Impl`	`transform(javax.xml.transform.Source transformer)`	Transform all elements in the set of matched elements.
`Impl`	`transform(javax.xml.transform.Transformer transformer)`	Transform all elements in the set of matched elements.
`<T> java.util.List<T>`	`unmarshal(java.lang.Class<T> type)`	Unmarshal the current set of matched elements into a JAXB-annotated type.
`<T> java.util.List<T>`	`unmarshal(java.lang.Class<T> type, int... indexes)`	Unmarshal the current set of matched elements at given indexes into a JAXB-annotated type.
`<T> T`	`unmarshalOne(java.lang.Class<T> type)`	Unmarshal the first element in the current set of matched elements into a JAXB-annotated type.
`<T> T`	`unmarshalOne(java.lang.Class<T> type, int index)`	Unmarshal the element at a given index in the current set of matched elements into a JAXB-annotated type.
`Impl`	`unwrap()`	Removes all elements in the set of matched elements from their parents
`Impl`	`wrap(java.lang.String content)`	Wrap all elements from their parent nodes in the set of matched elements in a new parent element
`Impl`	`wrap(Content content)`	Wrap all elements in the set of matched elements in a new parent element
`Match`	`write(java.io.File file)`	Write the set of matched elements into a file
`Match`	`write(java.io.OutputStream stream)`	Write the set of matched elements into a stream
`Match`	`write(java.io.Writer writer)`	Write the set of matched elements into a writer
`java.lang.String`	`xpath()`	Get an XPath expression describing the first element in the current set of matched elements
`java.lang.String`	`xpath(int index)`	Get an XPath expression describing the element at a given index in the current set of matched elements
`Impl`	`xpath(java.lang.String expression)`	Match all elements given a certain XPath expression applied to each element in the current set of matched elements.
`Impl`	`xpath(java.lang.String expression, java.lang.Object... variables)`	Match all elements given a certain XPath expression applied to each element in the current set of matched elements.
`java.util.List<java.lang.String>`	`xpaths()`	Get a list of XPath expressions describing the elements in the current set of matched elements
`java.util.List<java.lang.String>`	`xpaths(int... indexes)`	Get a list of XPath expressions describing the elements at the given indexes in the current set of matched elements

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - document
```
private final org.w3c.dom.Document document
```
  - elements
```
private final java.util.List<org.w3c.dom.Element> elements
```
  - previousMatch
```
private final Impl previousMatch
```
  - namespaces
```
private final java.util.Map<java.lang.String,java.lang.String> namespaces
```
  - SIMPLE_SELECTOR
```
public static final java.util.regex.Pattern SIMPLE_SELECTOR
```
    A selector pattern that can be evaluated using standard DOM API
- Constructor Detail
  - Impl
```
Impl(org.w3c.dom.Document document,
     java.util.Map<java.lang.String,java.lang.String> namespaces)
```
  - Impl
```
Impl(org.w3c.dom.Document document,
     java.util.Map<java.lang.String,java.lang.String> namespaces,
     Impl previousMatch)
```
- Method Detail
  - addNodeLists
```
final Impl addNodeLists(java.util.List<org.w3c.dom.NodeList> lists)
```
  - addNodeList
```
final Impl addNodeList(org.w3c.dom.NodeList list)
```
  - addUniqueElements
```
final Impl addUniqueElements(org.w3c.dom.Element... e)
```
  - addUniqueElements
```
final Impl addUniqueElements(java.util.List<org.w3c.dom.Element> e)
```
  - addElements
```
final Impl addElements(org.w3c.dom.Element... e)
```
  - addElements
```
final Impl addElements(java.util.Collection<org.w3c.dom.Element> e)
```
  - iterator
```
public final java.util.Iterator<org.w3c.dom.Element> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<org.w3c.dom.Element>
  - namespace
```
public final Match namespace(java.lang.String namespacePrefix,
                             java.lang.String namespaceURI)
```
    Description copied from interface: Match
    
    Get a new Match with added namespace configuration for subsequent XPath calls
    This is a convenience method for Match.namespaces(java.util.Map)
    
    Specified by:
    
    namespace in interface Match
    
    Parameters:
    
    namespacePrefix - A namespace prefix
    
    namespaceURI - A namespace URI
    
    Returns:
    
    A modified Match
    
    See Also:
    
    Match.namespaces(Map)
  - namespaces
```
public final Match namespaces(java.util.Map<java.lang.String,java.lang.String> map)
```
    Description copied from interface: Match
    
    Get a new Match with added namespace configuration for subsequent XPath calls
    
    Specified by:
    
    namespaces in interface Match
    
    Parameters:
    
    map - A mapping between prefix and namespace URI
    
    Returns:
    
    A modified Match
  - namespaceURI
```
public final java.lang.String namespaceURI()
```
    Description copied from interface: Match
    
    Get the namespace URI of the first element in the current set of matched elements.
    This is the same as calling namespaceURI(0)
    This only works if the underlying document is namespace-aware
    
    Specified by:
    
    namespaceURI in interface Match
    
    See Also:
    
    Node.getNamespaceURI()
  - namespaceURI
```
public final java.lang.String namespaceURI(int index)
```
    Description copied from interface: Match
    
    Get a namespace URI of the element at a given index in the current set of matched elements.
    This only works if the underlying document is namespace-aware
    
    Specified by:
    
    namespaceURI in interface Match
    
    See Also:
    
    Node.getNamespaceURI()
  - namespaceURIs
```
public final java.util.List<java.lang.String> namespaceURIs()
```
    Description copied from interface: Match
    
    Get a list of namespace URIs of the elements in the current set of matched elements.
    This only works if the underlying document is namespace-aware
    
    Specified by:
    
    namespaceURIs in interface Match
    
    See Also:
    
    Node.getNamespaceURI()
  - namespaceURIs
```
public final java.util.List<java.lang.String> namespaceURIs(int... indexes)
```
    Description copied from interface: Match
    
    Get a list of namespace URIs of the elements at given indexes in the current set of matched elements.
    This only works if the underlying document is namespace-aware
    
    Specified by:
    
    namespaceURIs in interface Match
    
    See Also:
    
    Node.getNamespaceURI()
  - namespacePrefix
```
public final java.lang.String namespacePrefix()
```
    Description copied from interface: Match
    
    Get the namespace prefix of the first element in the current set of matched elements.
    This is the same as calling namespaceURI(0)
    
    Specified by:
    
    namespacePrefix in interface Match
  - namespacePrefix
```
public final java.lang.String namespacePrefix(int index)
```
    Description copied from interface: Match
    
    Get a namespace prefix of the element at a given index in the current set of matched elements.
    
    Specified by:
    
    namespacePrefix in interface Match
  - namespacePrefixes
```
public final java.util.List<java.lang.String> namespacePrefixes()
```
    Description copied from interface: Match
    
    Get a list of namespace prefixes of the elements in the current set of matched elements.
    
    Specified by:
    
    namespacePrefixes in interface Match
  - namespacePrefixes
```
public final java.util.List<java.lang.String> namespacePrefixes(int... indexes)
```
    Description copied from interface: Match
    
    Get a list of namespace prefixes of the elements at given indexes in the current set of matched elements.
    
    Specified by:
    
    namespacePrefixes in interface Match
  - document
```
public final org.w3c.dom.Document document()
```
    Description copied from interface: Match
    
    Get the underlying document of the set of matched elements.
    This will also return a document if there are no elements in the set of matched elements, either because a new document has been created previously, or the set of matched elements has been reduced to an empty set.
    
    Specified by:
    
    document in interface Match
  - get
```
public final org.w3c.dom.Element get(int index)
```
    Description copied from interface: Match
    Get an element from the set of matched elements at a given index
    Negative indexes are possible, too.
    
    -1 corresponds to the last element in the set of matched elements.
    
    -2 corresponds to the second-last element, etc.
    Specified by:
    
    get in interface Match
  - get
```
public final java.util.List<org.w3c.dom.Element> get(int... indexes)
```
    Description copied from interface: Match
    Get some elements from the set of matched elements at the given indexes
    Negative indexes are possible, too.
    
    -1 corresponds to the last element in the set of matched elements.
    
    -2 corresponds to the second-last element, etc.
    Specified by:
    
    get in interface Match
  - get
```
public final java.util.List<org.w3c.dom.Element> get()
```
    Description copied from interface: Match
    
    Get an the set of matched elements
    
    Specified by:
    
    get in interface Match
  - size
```
public final int size()
```
    Description copied from interface: Match
    
    Get the number of matched elements in the set of matched elements
    
    Specified by:
    
    size in interface Match
  - isEmpty
```
public final boolean isEmpty()
```
    Description copied from interface: Match
    
    Whether there are any matched elements in the set of matched elements
    
    Specified by:
    
    isEmpty in interface Match
  - isNotEmpty
```
public final boolean isNotEmpty()
```
    Description copied from interface: Match
    
    Whether there are any matched elements in the set of matched elements
    
    Specified by:
    
    isNotEmpty in interface Match
  - add
```
public final Impl add(org.w3c.dom.Element... e)
```
    Description copied from interface: Match
    
    Add some elements to the set of matched elements
    
    Specified by:
    
    add in interface Match
  - add
```
public final Impl add(Match... e)
```
    Description copied from interface: Match
    
    Add some elements to the set of matched elements
    
    Specified by:
    
    add in interface Match
  - reverse
```
public final Impl reverse()
```
    Description copied from interface: Match
    
    Reverse the order of the set of matched elements
    
    Specified by:
    
    reverse in interface Match
  - andSelf
```
public final Impl andSelf()
```
    Description copied from interface: Match
    Add the previous set of matched elements to the current one. This works after any of these methods (including all overloaded variants):
    
    Match.child()
    
    Match.children()
    
    Match.find()
    
    Match.next()
    
    Match.nextAll()
    
    Match.nextUntil(Filter)
    
    Match.parent()
    
    Match.parents()
    
    Match.parentsUntil(Filter)
    
    Match.prev()
    
    Match.prevAll()
    
    Match.prevUntil(Filter)
    
    Match.siblings()
    
    In all other cases, this just returns the same match this was called upon. For instance, it does not make sense to first reduce a set of matched elements using Match.eq(int...), and then add the removed elements again, using Match.andSelf().
    Specified by:
    
    andSelf in interface Match
  - child
```
public final Impl child()
```
    Description copied from interface: Match
    
    Find the first child of each element in the current set of matched elements.
    This is the same as calling child(0).
    
    Specified by:
    
    child in interface Match
  - child
```
public final Impl child(java.lang.String selector)
```
    Description copied from interface: Match
    Find the first matching child of each element in the current set of matched elements
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    child in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - child
```
public final Impl child(Filter filter)
```
    Description copied from interface: Match
    
    Find the first matching child of each element in the current set of matched elements
    
    Specified by:
    
    child in interface Match
  - child
```
public final Impl child(int index)
```
    Description copied from interface: Match
    
    Find the child at a given index of each element in the current set of matched elements.
    
    Specified by:
    
    child in interface Match
  - children
```
public final Impl children()
```
    Description copied from interface: Match
    
    Find all children of each element in the current set of matched elements.
    
    Specified by:
    
    children in interface Match
  - children
```
public final Impl children(int... indexes)
```
    Description copied from interface: Match
    
    Find all children of each element at given indexes in the current set of matched elements.
    
    Specified by:
    
    children in interface Match
  - children
```
public final Impl children(java.lang.String selector)
```
    Description copied from interface: Match
    Find all children of each element in the current set of matched elements.
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    children in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - children
```
public final Impl children(Filter filter)
```
    Description copied from interface: Match
    Find all children of each element in the current set of matched elements.
    The callback Context is populated like this:
    
    Context.match() - the matched element whose children are searched
    
    Context.matchIndex() - the index of the matched element whose children are searched
    
    Context.element() - the child candidate that is being filtered
    
    Context.elementIndex() - the index within its parent of the child candidate that is being filtered
    Specified by:
    
    children in interface Match
  - each
```
public final java.util.List<Match> each()
```
    Description copied from interface: Match
    
    Get all elements in the set of matched elements in a list of matches, every match representing one element
    
    Specified by:
    
    each in interface Match
  - each
```
public final Impl each(Each each)
```
    Description copied from interface: Match
    
    Execute a callback for every element in the current set of matched elements.
    
    Specified by:
    
    each in interface Match
  - each
```
public final Impl each(Each... each)
```
    Description copied from interface: Match
    
    Execute several callbacks for every element in the current set of matched elements.
    
    Specified by:
    
    each in interface Match
    
    See Also:
    
    JOOX.chain(Each...)
  - each
```
public final Impl each(java.lang.Iterable<? extends Each> each)
```
    Description copied from interface: Match
    
    Execute several callbacks for every element in the current set of matched elements.
    
    Specified by:
    
    each in interface Match
    
    See Also:
    
    JOOX.chain(Iterable)
  - filter
```
public final Impl filter(java.lang.String selector)
```
    Description copied from interface: Match
    Reduce the current set of matched elements.
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    filter in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - filter
```
public final Impl filter(Filter filter)
```
    Description copied from interface: Match
    Reduce the current set of matched elements.
    The callback Context is populated like this:
    
    Context.match() - the matched element being filtered
    
    Context.matchIndex() - the index of the matched element being filtered
    Specified by:
    
    filter in interface Match
  - filter0
```
private final java.util.List<org.w3c.dom.Element> filter0(Filter filter)
```
  - eq
```
public final Impl eq(int... indexes)
```
    Description copied from interface: Match
    Reduce the current set of matched elements to the elements at the given indexes. If the given indexes are not in the range of indexes, the resulting set will be empty.
    Negative indexes are possible, too.
    
    -1 corresponds to the last element in the set of matched elements.
    
    -2 corresponds to the second-last element, etc.
    Specified by:
    
    eq in interface Match
  - find
```
public final Impl find()
```
    Description copied from interface: Match
    
    Find all descendants of each element in the current set of matched elements.
    
    Specified by:
    
    find in interface Match
  - find
```
public final Impl find(java.lang.String selector)
```
    Description copied from interface: Match
    Find all descendants of each element in the current set of matched elements.
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String) Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    CSS selectors can be used to select XML elements using XPath (see CSS2XPath.css2xpath(String))
    
    The following features are not supported:
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    find in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - isRoot
```
private boolean isRoot()
```
    Temporary utility method to indicate whether the root element is among the matched elements
  - find
```
public final Impl find(Filter filter)
```
    Description copied from interface: Match
    Find all descendants of each element in the current set of matched elements.
    The callback Context is populated like this:
    
    Context.match() - the matched element whose descendants are searched
    
    Context.matchIndex() - the index of the matched element whose descendants are searched
    
    Context.element() - the descendant candidate that is being filtered
    
    Context.elementIndex() - the iteration index of the descendant candidate that is being filtered
    Specified by:
    
    find in interface Match
  - xpath
```
public final Impl xpath(java.lang.String expression)
```
    Description copied from interface: Match
    Match all elements given a certain XPath expression applied to each element in the current set of matched elements.
    The XPath expression is evaluated using standard XPath. It must not contain any variables. Use Match.xpath(String, Object...) instead, if you wish to use variables. Note that only matched elements will be considered in the results. You cannot match attributes or text nodes, for instance. Examples:
    
    Match all elements : xpath("//*")
    
    Match all books : xpath("/library/books/book")
    
    Match all book ID's : xpath("//book").ids()
    
    Match all book names : xpath("//book/name").texts()
    
    This doesn't work (not matching elements):
    
    Match all book ID's : xpath("//book/@id")
    
    Match all book names : xpath("//book/name/text()")
    
    Using jOOX with Namespaces
    
    Namespace declarations are supported in XPath expressions. If you wish to use namespace-specific XPath elements, call Match.namespace(String, String) prior to Match.xpath(String)
    
    Using jOOX with Xalan
    
    If Xalan is on your classpath, jOOX will automatically load xalan's namespace and function extensions. All functionality supported by http://exslt.org will be available in your XPath expressions. Some examples:
    
    Match the book with the highest ID : xpath("//book[number(@id) = math:max(//book/@id)]")
    
    Match books written by Orwell : xpath("//book[java:org.joox.test.Functions.byOrwellWithNodes(.)]
    Specified by:
    
    xpath in interface Match
  - xpath
```
public final Impl xpath(java.lang.String expression,
                        java.lang.Object... variables)
```
    Description copied from interface: Match
    Match all elements given a certain XPath expression applied to each element in the current set of matched elements.
    The XPath expression is evaluated using standard XPath. It may contain numerical variables, declared as $1, $2, etc, starting with $1. Other variables, such as $myVar are not supported. You must provide at least one variable in the variables argument for every variable index. Note that only matched elements will be considered in the results. You cannot match attributes or text nodes, for instance. Examples:
    
    Match all elements with id greater than 5: xpath("//*[@id > $1]", 5)
    
    Match all books with more than two authors and one author is "George Orwell" : xpath("/library/books/book[count(authors/author) > $1][authors/author[text() = $2]]", 2, "George Orwell")
    
    This doesn't work (not matching elements):
    
    Match all book ID's : xpath("//book/@id")
    
    Match all book names : xpath("//book/name/text()")
    
    Using jOOX with Namespaces
    
    Namespace declarations are supported in XPath expressions. If you wish to use namespace-specific XPath elements, call Match.namespace(String, String) prior to Match.xpath(String)
    
    Using jOOX with Xalan
    
    If Xalan is on your classpath, jOOX will automatically load xalan's namespace and function extensions. All functionality supported by http://exslt.org will be available in your XPath expressions. Some examples:
    
    Match the book with the highest ID : xpath("//book[number(@id) = math:max(//book/@id)]")
    
    Match books written by Orwell : xpath("//book[java:org.joox.test.Functions.byOrwellWithNodes(.)]
    Specified by:
    
    xpath in interface Match
  - first
```
public final Impl first()
```
    Description copied from interface: Match
    
    Get the first in a set of matched elements.
    
    Specified by:
    
    first in interface Match
  - has
```
public final Impl has(java.lang.String selector)
```
    Description copied from interface: Match
    Reduce the set of matched element to those who have a descendant that matches a selector.
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    has in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - has
```
public final Impl has(Filter filter)
```
    Description copied from interface: Match
    Reduce the set of matched element to those who have a descendant that matches a filter.
    The callback Context is populated like this:
    
    Context.match() - the matched element whose descendants are searched
    
    Context.matchIndex() - the index of the matched element whose descendants are searched
    
    Context.element() - the descendant candidate that is being filtered
    
    Context.elementIndex() - the iteration index of the descendant candidate that is being filtered
    Specified by:
    
    has in interface Match
  - is
```
public final boolean is(java.lang.String selector)
```
    Description copied from interface: Match
    Check if at least one element in the set of matched elements satisfies a selector.
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    is in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - is
```
public final boolean is(Filter filter)
```
    Description copied from interface: Match
    Check if at least one element in the set of matched elements satisfies a filter.
    The callback Context is populated like this:
    
    Context.match() - the matched element being checked
    
    Context.matchIndex() - the index of the matched element being checked
    Specified by:
    
    is in interface Match
  - last
```
public final Impl last()
```
    Description copied from interface: Match
    
    Get the last in a set of matched elements.
    
    Specified by:
    
    last in interface Match
  - map
```
public final <E> java.util.List<E> map(Mapper<E> map)
```
    Description copied from interface: Match
    
    Map the set of matched elements to a list of something
    
    Specified by:
    
    map in interface Match
  - next
```
public final Impl next()
```
    Description copied from interface: Match
    
    Get the immediate next sibling of every element in set of matched elements.
    
    Specified by:
    
    next in interface Match
  - next
```
public final Impl next(java.lang.String selector)
```
    Description copied from interface: Match
    Get the immediate next sibling of every element in set of matched elements, matching a selector
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    next in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - next
```
public final Impl next(Filter filter)
```
    Description copied from interface: Match
    Get the immediate next sibling of every element in set of matched elements, matching a filter
    The callback Context is populated like this:
    
    Context.match() - the matched element whose next sibling is searched
    
    Context.matchIndex() - the index of the matched element whose next sibling is searched
    
    Context.element() - the next sibling that is being filtered
    
    Context.elementIndex() - 1
    Specified by:
    
    next in interface Match
  - nextAll
```
public final Impl nextAll()
```
    Description copied from interface: Match
    
    Get all next siblings of every element in a set of matched elements
    
    Specified by:
    
    nextAll in interface Match
  - nextAll
```
public final Impl nextAll(java.lang.String selector)
```
    Description copied from interface: Match
    Get all next siblings of every element in a set of matched elements, matching a selector
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    nextAll in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - nextAll
```
public final Impl nextAll(Filter filter)
```
    Description copied from interface: Match
    Get all next siblings of every element in a set of matched elements, matching a filter
    The callback Context is populated like this:
    
    Context.match() - the matched element whose next siblings are searched
    
    Context.matchIndex() - the index of the matched element whose next siblings are searched
    
    Context.element() - the next siblings that is being filtered
    
    Context.elementIndex() - the relative index of the next siblings that are being filtered
    Specified by:
    
    nextAll in interface Match
  - nextUntil
```
public final Impl nextUntil(java.lang.String until)
```
    Description copied from interface: Match
    Get all next siblings of every element in a set of matched elements until the provided selector matches
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    nextUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - nextUntil
```
public final Impl nextUntil(Filter until)
```
    Description copied from interface: Match
    Get all next siblings of every element in a set of matched elements until the provided filter matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose next siblings are searched
    
    Context.matchIndex() - the index of the matched element whose next siblings are searched
    
    Context.element() - the next siblings that is being filtered
    
    Context.elementIndex() - the relative index of the next siblings that are being filtered
    Specified by:
    
    nextUntil in interface Match
  - nextUntil
```
public final Impl nextUntil(java.lang.String until,
                            java.lang.String selector)
```
    Description copied from interface: Match
    Get all next siblings of every element in a set of matched elements, matching a selector, until the provided selector matches
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    nextUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - nextUntil
```
public final Impl nextUntil(java.lang.String until,
                            Filter filter)
```
    Description copied from interface: Match
    Get all next siblings of every element in a set of matched elements, matching a filter, until the provided selector matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose next siblings are searched
    
    Context.matchIndex() - the index of the matched element whose next siblings are searched
    
    Context.element() - the next siblings that is being filtered
    
    Context.elementIndex() - the relative index of the next siblings that are being filtered
    Specified by:
    
    nextUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - nextUntil
```
public final Impl nextUntil(Filter until,
                            java.lang.String selector)
```
    Description copied from interface: Match
    Get all next siblings of every element in a set of matched elements, matching a selector until the provided filter matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose next siblings are searched
    
    Context.matchIndex() - the index of the matched element whose next siblings are searched
    
    Context.element() - the next siblings that is being filtered
    
    Context.elementIndex() - the relative index of the next siblings that are being filtered
    Specified by:
    
    nextUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - nextUntil
```
public final Impl nextUntil(Filter until,
                            Filter filter)
```
    Description copied from interface: Match
    Get all next siblings of every element in a set of matched elements, matching a filter until the provided filter matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose next siblings are searched
    
    Context.matchIndex() - the index of the matched element whose next siblings are searched
    
    Context.element() - the next siblings that is being filtered
    
    Context.elementIndex() - the relative index of the next siblings that are being filtered
    Specified by:
    
    nextUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - next
```
private final Impl next(boolean all,
                        Filter until,
                        Filter filter)
```
  - not
```
public final Impl not(java.lang.String selector)
```
    Description copied from interface: Match
    Remove elements from the set of matched elements.
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    not in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - not
```
public final Impl not(Filter filter)
```
    Description copied from interface: Match
    Remove elements from the set of matched elements.
    The callback Context is populated like this:
    
    Context.match() - the matched element being checked
    
    Context.matchIndex() - the index of the matched element being checked
    Specified by:
    
    not in interface Match
  - parent
```
public final Impl parent()
```
    Description copied from interface: Match
    
    Get the immediate parent elements of every element in a set of matched elements
    
    Specified by:
    
    parent in interface Match
  - parent
```
public final Impl parent(java.lang.String selector)
```
    Description copied from interface: Match
    Get the immediate parent elements of every element in a set of matched elements, matching a selector
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    parent in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - parent
```
public final Impl parent(Filter filter)
```
    Description copied from interface: Match
    Get the immediate parent elements of every element in a set of matched elements, matching a filter
    The callback Context is populated like this:
    
    Context.match() - the matched element whose parent is searched
    
    Context.matchIndex() - the index of the matched element whose parent is searched
    
    Context.element() - the parent that is being filtered
    
    Context.elementIndex() - 1
    Specified by:
    
    parent in interface Match
  - parents
```
public final Impl parents()
```
    Description copied from interface: Match
    
    Get all ancestor elements of every element in a set of matched elements
    
    Specified by:
    
    parents in interface Match
  - parents
```
public final Impl parents(java.lang.String selector)
```
    Description copied from interface: Match
    Get all ancestor elements of every element in a set of matched elements, matching a selector
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    parents in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - parents
```
public final Impl parents(Filter filter)
```
    Description copied from interface: Match
    Get all ancestor elements of every element in a set of matched elements, matching a filter
    The callback Context is populated like this:
    
    Context.match() - the matched element whose parents are searched
    
    Context.matchIndex() - the index of the matched element whose parents are searched
    
    Context.element() - the parent that is being filtered
    
    Context.elementIndex() - the relative index of the parent that is being filtered
    Specified by:
    
    parents in interface Match
  - parentsUntil
```
public final Impl parentsUntil(java.lang.String until)
```
    Description copied from interface: Match
    Get all ancestors of every element in a set of matched elements until the provided selector matches
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    parentsUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - parentsUntil
```
public final Impl parentsUntil(Filter until)
```
    Description copied from interface: Match
    Get all ancestors of every element in a set of matched elements until the provided filter matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose parents are searched
    
    Context.matchIndex() - the index of the matched element whose parents are searched
    
    Context.element() - the parent that is being filtered
    
    Context.elementIndex() - the relative index of the parent that is being filtered
    Specified by:
    
    parentsUntil in interface Match
  - parentsUntil
```
public final Impl parentsUntil(java.lang.String until,
                               java.lang.String selector)
```
    Description copied from interface: Match
    Get all ancestors of every element in a set of matched elements, matching a selector, until the provided selector matches
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    parentsUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - parentsUntil
```
public final Impl parentsUntil(java.lang.String until,
                               Filter filter)
```
    Description copied from interface: Match
    Get all ancestors of every element in a set of matched elements, matching a filter, until the provided selector matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose parents are searched
    
    Context.matchIndex() - the index of the matched element whose parents are searched
    
    Context.element() - the parent that is being filtered
    
    Context.elementIndex() - the relative index of the parent that is being filtered
    Specified by:
    
    parentsUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - parentsUntil
```
public final Impl parentsUntil(Filter until,
                               java.lang.String selector)
```
    Description copied from interface: Match
    Get all ancestors of every element in a set of matched elements, matching a selector until the provided filter matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose parents are searched
    
    Context.matchIndex() - the index of the matched element whose parents are searched
    
    Context.element() - the parent that is being filtered
    
    Context.elementIndex() - the relative index of the parent that is being filtered
    Specified by:
    
    parentsUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - parentsUntil
```
public final Impl parentsUntil(Filter until,
                               Filter filter)
```
    Description copied from interface: Match
    Get all ancestors of every element in a set of matched elements, matching a filter until the provided filter matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose parents are searched
    
    Context.matchIndex() - the index of the matched element whose parents are searched
    
    Context.element() - the parent that is being filtered
    
    Context.elementIndex() - the relative index of the parent that is being filtered
    Specified by:
    
    parentsUntil in interface Match
  - parents
```
private final Impl parents(boolean all,
                           Filter until,
                           Filter filter)
```
  - prev
```
public final Impl prev()
```
    Description copied from interface: Match
    
    Get the immediate previous sibling of every element in set of matched elements.
    
    Specified by:
    
    prev in interface Match
  - prev
```
public final Impl prev(java.lang.String selector)
```
    Description copied from interface: Match
    Get the immediate previous sibling of every element in set of matched elements, matching a selector
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    prev in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - prev
```
public final Impl prev(Filter filter)
```
    Description copied from interface: Match
    Get the immediate previous sibling of every element in set of matched elements, matching a filter
    The callback Context is populated like this:
    
    Context.match() - the matched element whose previous sibling is searched
    
    Context.matchIndex() - the index of the matched element whose previous sibling is searched
    
    Context.element() - the previous sibling that is being filtered
    
    Context.elementIndex() - 1
    Specified by:
    
    prev in interface Match
  - prevAll
```
public final Impl prevAll()
```
    Description copied from interface: Match
    
    Get all previous siblings of every element in a set of matched elements
    
    Specified by:
    
    prevAll in interface Match
  - prevAll
```
public final Impl prevAll(java.lang.String selector)
```
    Description copied from interface: Match
    Get all previous siblings of every element in a set of matched elements, matching a selector
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    prevAll in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - prevAll
```
public final Impl prevAll(Filter filter)
```
    Description copied from interface: Match
    Get all previous siblings of every element in a set of matched elements, matching a filter
    The callback Context is populated like this:
    
    Context.match() - the matched element whose previous siblings are searched
    
    Context.matchIndex() - the index of the matched element whose previous siblings are searched
    
    Context.element() - the previous siblings that is being filtered
    
    Context.elementIndex() - the relative index of the previous siblings that are being filtered
    Specified by:
    
    prevAll in interface Match
  - prevUntil
```
public final Impl prevUntil(java.lang.String until)
```
    Description copied from interface: Match
    Get all previous siblings of every element in a set of matched elements until the provided selector matches
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    prevUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - prevUntil
```
public final Impl prevUntil(Filter until)
```
    Description copied from interface: Match
    Get all previous siblings of every element in a set of matched elements until the provided filter matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose previous siblings are searched
    
    Context.matchIndex() - the index of the matched element whose previous siblings are searched
    
    Context.element() - the previous siblings that is being filtered
    
    Context.elementIndex() - the relative index of the previous siblings that are being filtered
    Specified by:
    
    prevUntil in interface Match
  - prevUntil
```
public final Impl prevUntil(java.lang.String until,
                            java.lang.String selector)
```
    Description copied from interface: Match
    Get all previous siblings of every element in a set of matched elements, matching a selector, until the provided selector matches
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    prevUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - prevUntil
```
public final Impl prevUntil(java.lang.String until,
                            Filter filter)
```
    Description copied from interface: Match
    Get all previous siblings of every element in a set of matched elements, matching a filter, until the provided selector matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose previous siblings are searched
    
    Context.matchIndex() - the index of the matched element whose previous siblings are searched
    
    Context.element() - the previous siblings that is being filtered
    
    Context.elementIndex() - the relative index of the previous siblings that are being filtered
    Specified by:
    
    prevUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - prevUntil
```
public final Impl prevUntil(Filter until,
                            java.lang.String selector)
```
    Description copied from interface: Match
    Get all previous siblings of every element in a set of matched elements, matching a selector until the provided filter matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose previous siblings are searched
    
    Context.matchIndex() - the index of the matched element whose previous siblings are searched
    
    Context.element() - the previous siblings that is being filtered
    
    Context.elementIndex() - the relative index of the previous siblings that are being filtered
    Specified by:
    
    prevUntil in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - prevUntil
```
public final Impl prevUntil(Filter until,
                            Filter filter)
```
    Description copied from interface: Match
    Get all previous siblings of every element in a set of matched elements, matching a filter until the provided filter matches
    The callback Context is populated like this:
    
    Context.match() - the matched element whose previous siblings are searched
    
    Context.matchIndex() - the index of the matched element whose previous siblings are searched
    
    Context.element() - the previous siblings that is being filtered
    
    Context.elementIndex() - the relative index of the previous siblings that are being filtered
    Specified by:
    
    prevUntil in interface Match
  - prev
```
private final Impl prev(boolean all,
                        Filter until,
                        Filter filter)
```
  - axis
```
private final Impl axis(boolean all,
                        Filter until,
                        Filter filter,
                        java.util.function.Function<org.w3c.dom.Node,org.w3c.dom.Node> iterate,
                        java.util.function.Consumer<java.util.List<org.w3c.dom.Element>> finisher)
```
  - siblings
```
public final Impl siblings()
```
    Description copied from interface: Match
    
    Get all siblings of every element in a set of matched elements
    
    Specified by:
    
    siblings in interface Match
  - siblings
```
public final Impl siblings(java.lang.String selector)
```
    Description copied from interface: Match
    Get all siblings of every element in a set of matched elements, matching a selector
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    siblings in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - siblings
```
public final Impl siblings(Filter filter)
```
    Description copied from interface: Match
    Get all siblings of every element in a set of matched elements, matching a filter
    The callback Context is populated like this:
    
    Context.match() - the matched element whose siblings are searched
    
    Context.matchIndex() - the index of the matched element whose siblings are searched
    
    Context.element() - the sibling that is being filtered
    
    Context.elementIndex() - the relative index of the sibling that is being filtered. This is less than zero if it is a previous sibling or more than zero if it is a subsequent sibling, compared to the element in Context.match()
    Specified by:
    
    siblings in interface Match
  - slice
```
public final Impl slice(int start)
```
    Description copied from interface: Match
    
    Reduce the set of matched elements by specifying a range of indexes
    This is the same as calling slice(start, Integer.MAX_VALUE)
    
    Specified by:
    
    slice in interface Match
  - slice
```
public final Impl slice(int start,
                        int end)
```
    Description copied from interface: Match
    
    Reduce the set of matched elements by specifying a range of indexes
    
    Specified by:
    
    slice in interface Match
  - matchText
```
public final Impl matchText(java.lang.String regex)
```
    Description copied from interface: Match
    
    Reduce the set of matched elements by filtering out those whose text content doesn't match a given regex
    This is the same as calling matchText(regex, true)
    
    Specified by:
    
    matchText in interface Match
    
    See Also:
    
    JOOX.matchText(String)
  - matchText
```
public final Impl matchText(java.lang.String regex,
                            boolean keepMatches)
```
    Description copied from interface: Match
    
    Reduce the set of matched elements by filtering out those whose text content doesn't match a given regex (keepMatches = true), or those whose text content matches a given regex (keepMatches = false)
    
    Specified by:
    
    matchText in interface Match
    
    See Also:
    
    JOOX.matchText(String)
  - matchTag
```
public final Impl matchTag(java.lang.String regex)
```
    Description copied from interface: Match
    
    Reduce the set of matched elements by filtering out those whose tag name doesn't match a given regex
    This is the same as calling matchText(regex, true)
    
    Specified by:
    
    matchTag in interface Match
    
    See Also:
    
    JOOX.matchTag(String)
  - matchTag
```
public final Impl matchTag(java.lang.String regex,
                           boolean keepMatches)
```
    Description copied from interface: Match
    
    Reduce the set of matched elements by filtering out those whose tag name doesn't match a given regex (keepMatches = true), or those whose tag name matches a given regex (keepMatches = false)
    
    Specified by:
    
    matchTag in interface Match
    
    See Also:
    
    JOOX.matchTag(String)
  - matchAttr
```
public final Match matchAttr(java.lang.String name,
                             java.lang.String valueRegex)
```
    Description copied from interface: Match
    
    Reduce the set of matched elements by filtering out those whose attribute content doesn't match a given regex
    This is the same as calling matchAttr(name, valueRegex, true)
    
    Specified by:
    
    matchAttr in interface Match
    
    See Also:
    
    JOOX.matchAttr(String, String)
  - matchAttr
```
public final Match matchAttr(java.lang.String name,
                             java.lang.String valueRegex,
                             boolean keepMatches)
```
    Description copied from interface: Match
    
    Reduce the set of matched elements by filtering out those whose attribute content doesn't match a given regex (keepMatches = true), or those whose text content matches a given regex (keepMatches = false)
    
    Specified by:
    
    matchAttr in interface Match
    
    See Also:
    
    JOOX.matchAttr(String, String)
  - leaf
```
public final Impl leaf()
```
    Description copied from interface: Match
    
    Reduce the set of matched elements to the ones that are leaf elements
    
    Specified by:
    
    leaf in interface Match
    
    See Also:
    
    JOOX.leaf()
  - after
```
public final Impl after(java.lang.String content)
```
    Description copied from interface: Match
    
    Add content after each element in the set of matched elements.
    
    Specified by:
    
    after in interface Match
  - after
```
public final Impl after(Content content)
```
    Description copied from interface: Match
    Add content after each element in the set of matched elements.
    The callback Context is populated like this:
    
    Context.match() - the matched element being appended after
    
    Context.matchIndex() - the index of the matched element being appended after
    Specified by:
    
    after in interface Match
  - after
```
public final Impl after(Match... content)
```
    Description copied from interface: Match
    
    Add content after each element in the set of matched elements.
    If the added content is already contained in this document, then it is moved. Otherwise, it is cloned. If there are several elements in the set of matched elements, then the added content is duplicated.
    
    Specified by:
    
    after in interface Match
  - after
```
public final Impl after(org.w3c.dom.Element... content)
```
    Description copied from interface: Match
    
    Add content after each element in the set of matched elements.
    If the added content is already contained in this document, then it is moved. Otherwise, it is cloned. If there are several elements in the set of matched elements, then the added content is duplicated.
    
    Specified by:
    
    after in interface Match
  - before
```
public final Impl before(java.lang.String content)
```
    Description copied from interface: Match
    
    Add content before each element in the set of matched elements.
    
    Specified by:
    
    before in interface Match
  - before
```
public final Impl before(Content content)
```
    Description copied from interface: Match
    Add content before each element in the set of matched elements.
    The callback Context is populated like this:
    
    Context.match() - the matched element being prepended before
    
    Context.matchIndex() - the index of the matched element being prepended before
    Specified by:
    
    before in interface Match
  - before
```
public final Impl before(Match... content)
```
    Description copied from interface: Match
    
    Add content before each element in the set of matched elements.
    If the added content is already contained in this document, then it is moved. Otherwise, it is cloned. If there are several elements in the set of matched elements, then the added content is duplicated.
    
    Specified by:
    
    before in interface Match
  - before
```
public final Impl before(org.w3c.dom.Element... content)
```
    Description copied from interface: Match
    
    Add content before each element in the set of matched elements.
    If the added content is already contained in this document, then it is moved. Otherwise, it is cloned. If there are several elements in the set of matched elements, then the added content is duplicated.
    
    Specified by:
    
    before in interface Match
  - append
```
public final Impl append(java.lang.String content)
```
    Description copied from interface: Match
    
    Append content to the end of each element's content in the set of matched elements.
    
    Specified by:
    
    append in interface Match
  - append
```
public final Impl append(Content content)
```
    Description copied from interface: Match
    Append content to the end of each element's content in the set of matched elements.
    The callback Context is populated like this:
    
    Context.match() - the matched element being appended to
    
    Context.matchIndex() - the index of the matched element being appended to
    Specified by:
    
    append in interface Match
  - append
```
public final Impl append(Match... content)
```
    Description copied from interface: Match
    
    Append content to the end of each element's content in the set of matched elements.
    If the added content is already contained in this document, then it is moved. Otherwise, it is cloned. If there are several elements in the set of matched elements, then the added content is duplicated.
    
    Specified by:
    
    append in interface Match
  - append
```
public final Impl append(org.w3c.dom.Element... content)
```
    Description copied from interface: Match
    
    Append content to the end of each element's content in the set of matched elements.
    If the added content is already contained in this document, then it is moved. Otherwise, it is cloned. If there are several elements in the set of matched elements, then the added content is duplicated.
    
    Specified by:
    
    append in interface Match
  - prepend
```
public final Impl prepend(java.lang.String content)
```
    Description copied from interface: Match
    
    Prepend content to the beginning of each element's content in the set of matched elements.
    
    Specified by:
    
    prepend in interface Match
  - prepend
```
public final Impl prepend(Content content)
```
    Description copied from interface: Match
    Prepend content to the beginning of each element's content in the set of matched elements.
    The callback Context is populated like this:
    
    Context.match() - the matched element being prepended to
    
    Context.matchIndex() - the index of the matched element being prepended to
    Specified by:
    
    prepend in interface Match
  - prepend
```
public final Impl prepend(Match... content)
```
    Description copied from interface: Match
    
    Prepend content to the beginning of each element's content in the set of matched elements.
    If the added content is already contained in this document, then it is moved. Otherwise, it is cloned. If there are several elements in the set of matched elements, then the added content is duplicated.
    
    Specified by:
    
    prepend in interface Match
  - prepend
```
public final Impl prepend(org.w3c.dom.Element... content)
```
    Description copied from interface: Match
    
    Prepend content to the beginning of each element's content in the set of matched elements.
    If the added content is already contained in this document, then it is moved. Otherwise, it is cloned. If there are several elements in the set of matched elements, then the added content is duplicated.
    
    Specified by:
    
    prepend in interface Match
  - attr
```
public final java.lang.String attr(java.lang.String name)
```
    Description copied from interface: Match
    
    Get an attribute from the first element in the set of matched elements, or null if the first element does not have that attribute.
    jOOX is namespace-unaware. The supplied attribute name will be compared against all attributes, matching the first one that has the given name.
    
    Specified by:
    
    attr in interface Match
  - attr
```
public final <T> T attr(java.lang.String name,
                        java.lang.Class<T> type)
```
    Description copied from interface: Match
    
    Get a converted attribute from the first element in the set of matched elements, or null if the first element does not have that attribute.
    jOOX is namespace-unaware. The supplied attribute name will be compared against all attributes, matching the first one that has the given name.
    
    Specified by:
    
    attr in interface Match
    
    See Also:
    
    JOOX.convert(String, Class)
  - attrs
```
public final java.util.List<java.lang.String> attrs(java.lang.String name)
```
    Description copied from interface: Match
    
    Get an attribute from all elements in the set of matched elements
    jOOX is namespace-unaware. The supplied attribute name will be compared against all attributes, matching the first one that has the given name.
    
    Specified by:
    
    attrs in interface Match
  - attrs
```
public final <T> java.util.List<T> attrs(java.lang.String name,
                                         java.lang.Class<T> type)
```
    Description copied from interface: Match
    
    Get a converted attribute from all elements in the set of matched elements
    jOOX is namespace-unaware. The supplied attribute name will be compared against all attributes, matching the first one that has the given name.
    
    Specified by:
    
    attrs in interface Match
    
    See Also:
    
    JOOX.convert(String, Class)
  - attr
```
public final Impl attr(java.lang.String name,
                       java.lang.String value)
```
    Description copied from interface: Match
    
    Set an attribute on all elements in the set of matched elements. If value is null, then the attribute is removed. If the attribute already exists, then it is replaced.
    
    Specified by:
    
    attr in interface Match
  - attr
```
public final Impl attr(java.lang.String name,
                       Content content)
```
    Description copied from interface: Match
    Set an attribute on all elements in the set of matched elements. If value returns null, then the attribute is removed. If the attribute already exists, then it is replaced.
    The callback Context is populated like this:
    
    Context.match() - the matched element being attributed
    
    Context.matchIndex() - the index of the matched element being attributed
    Specified by:
    
    attr in interface Match
  - removeAttr
```
public final Impl removeAttr(java.lang.String name)
```
    Description copied from interface: Match
    
    Remove an attribute from all elements in the set of matched elements. This is the same as calling attr(name, null).
    
    Specified by:
    
    removeAttr in interface Match
  - content
```
public final java.lang.String content()
```
    Description copied from interface: Match
    
    Get the XML content of the first element in the set of matched elements, or null if there are no matched elements.
    This is the same as calling content(0)
    
    Specified by:
    
    content in interface Match
  - content
```
public final java.lang.String content(int index)
```
    Description copied from interface: Match
    
    Get the XML content at a given index in the current set of matched elements.
    
    Specified by:
    
    content in interface Match
  - contents
```
public final java.util.List<java.lang.String> contents()
```
    Description copied from interface: Match
    
    Get all XML content of the elements in the set of matched elements.
    
    Specified by:
    
    contents in interface Match
  - contents
```
public final java.util.List<java.lang.String> contents(int... indexes)
```
    Description copied from interface: Match
    
    Get all XML content of the elements at given indexes in the set of matched elements.
    
    Specified by:
    
    contents in interface Match
  - content
```
private final java.lang.String content(org.w3c.dom.Element element)
```
  - content
```
public final Impl content(java.lang.String content)
```
    Description copied from interface: Match
    
    Add some XML content to all elements in the set of matched elements (possibly replacing existing content). If the supplied content is invalid XML or plain text, then it will be added as text just as with Match.text(String)
    
    Specified by:
    
    content in interface Match
  - content
```
public final Impl content(java.lang.Object content)
```
    Description copied from interface: Match
    
    Add some JAXB-marshallable XML content to all elements in the set of matched elements (possibly replacing existing content).
    
    Specified by:
    
    content in interface Match
    
    See Also:
    
    JOOX.$(Object), JOOX.content(Object)
  - content
```
public final Impl content(Content content)
```
    Description copied from interface: Match
    Add some XML content to all elements in the set of matched elements (possibly replacing existing content). If the supplied content is invalid XML or plain text, then it will be added as text just as with Match.text(String)
    The callback Context is populated like this:
    
    Context.match() - the matched element being added to
    
    Context.matchIndex() - the index of the matched element being added to
    Specified by:
    
    content in interface Match
  - text
```
public final java.lang.String text()
```
    Description copied from interface: Match
    
    Get the text content of the first element in the set of matched elements, or null if there are no matched elements.
    This is the same as calling text(0)
    
    Specified by:
    
    text in interface Match
  - text
```
public final java.lang.String text(int index)
```
    Description copied from interface: Match
    
    Get the text content at a given index in the current set of matched elements.
    
    Specified by:
    
    text in interface Match
  - text
```
public final <T> T text(java.lang.Class<T> type)
```
    Description copied from interface: Match
    
    Get the converted text content of the first element in the set of matched elements, or null if there are no matched elements.
    
    Specified by:
    
    text in interface Match
    
    See Also:
    
    JOOX.convert(String, Class)
  - texts
```
public final java.util.List<java.lang.String> texts()
```
    Description copied from interface: Match
    
    Get all text content of the elements in the set of matched elements.
    
    Specified by:
    
    texts in interface Match
  - texts
```
public final java.util.List<java.lang.String> texts(int... indexes)
```
    Description copied from interface: Match
    
    Get all text content of the elements at given indexes in the set of matched elements.
    
    Specified by:
    
    texts in interface Match
  - texts
```
public final <T> java.util.List<T> texts(java.lang.Class<T> type)
```
    Description copied from interface: Match
    
    Get all converted text content of the elements in the set of matched elements.
    
    Specified by:
    
    texts in interface Match
    
    See Also:
    
    JOOX.convert(String, Class)
  - text
```
public final Impl text(java.lang.String content)
```
    Description copied from interface: Match
    
    Set some text content to all elements in the set of matched elements (possibly replacing existing content).
    
    Specified by:
    
    text in interface Match
  - text
```
public final Impl text(Content content)
```
    Description copied from interface: Match
    Set some text content to all elements in the set of matched elements (possibly replacing existing content).
    The callback Context is populated like this:
    
    Context.match() - the matched element being added to
    
    Context.matchIndex() - the index of the matched element being added to
    Specified by:
    
    text in interface Match
  - cdata
```
public final java.lang.String cdata()
```
    Description copied from interface: Match
    
    Get the CDATA content of the first element in the set of matched elements, or null if there are no matched elements.
    This is the same as calling cdata(0) or Match.text().
    
    Specified by:
    
    cdata in interface Match
  - cdata
```
public final java.lang.String cdata(int index)
```
    Description copied from interface: Match
    
    Get the CDATA content at a given index in the current set of matched elements.
    This is the same as Match.text(int).
    
    Specified by:
    
    cdata in interface Match
  - cdata
```
public final <T> T cdata(java.lang.Class<T> type)
```
    Description copied from interface: Match
    
    Get the converted CDATA content of the first element in the set of matched elements, or null if there are no matched elements.
    This is the same as Match.text(Class).
    
    Specified by:
    
    cdata in interface Match
    
    See Also:
    
    JOOX.convert(String, Class)
  - cdatas
```
public final java.util.List<java.lang.String> cdatas()
```
    Description copied from interface: Match
    
    Get all CDATA content of the elements in the set of matched elements.
    This is the same as Match.texts().
    
    Specified by:
    
    cdatas in interface Match
  - cdatas
```
public final java.util.List<java.lang.String> cdatas(int... indexes)
```
    Description copied from interface: Match
    
    Get all CDATA content of the elements at given indexes in the set of matched elements.
    This is the same as Match.texts(int...).
    
    Specified by:
    
    cdatas in interface Match
  - cdatas
```
public final <T> java.util.List<T> cdatas(java.lang.Class<T> type)
```
    Description copied from interface: Match
    
    Get all converted CDATA content of the elements in the set of matched elements.
    This is the same as Match.texts(Class).
    
    Specified by:
    
    cdatas in interface Match
    
    See Also:
    
    JOOX.convert(String, Class)
  - cdata
```
public final Impl cdata(java.lang.String content)
```
    Description copied from interface: Match
    
    Set some CDATA content to all elements in the set of matched elements (possibly replacing existing content).
    Unlike Match.text(Content), this generates a Node.CDATA_SECTION_NODE.
    
    Specified by:
    
    cdata in interface Match
  - cdata
```
public final Impl cdata(Content content)
```
    Description copied from interface: Match
    Set some CDATA content to all elements in the set of matched elements (possibly replacing existing content).
    The callback Context is populated like this:
    
    Context.match() - the matched element being added to
    
    Context.matchIndex() - the index of the matched element being added to
    
    Unlike Match.text(Content), this generates a Node.CDATA_SECTION_NODE.
    Specified by:
    
    cdata in interface Match
  - empty
```
public final Match empty()
```
    Description copied from interface: Match
    
    Removes all content from all elements in the set of matched elements.
    
    Specified by:
    
    empty in interface Match
  - remove
```
public final Impl remove()
```
    Description copied from interface: Match
    
    Removes all elements from their parent nodes in the set of matched elements.
    
    Specified by:
    
    remove in interface Match
  - remove
```
public final Impl remove(java.lang.String selector)
```
    Description copied from interface: Match
    Removes all elements from their parent nodes in the set of matched elements, matching a selector
    The selector provided to this method supports the following features:
    
    * can be used to select everything
    
    tag names can be used to select XML elements by tag names (see Element.getElementsByTagName(String). Tag names are namespace-unaware. This means that existing namespaces will be ignored
    
    The following features are not supported:
    
    CSS selectors cannot be used (yet) to select XML elements from this method. Use Match.find(String) instead
    
    XPath cannot be used. Use Match.xpath(String) instead
    
    Namespaces cannot be used. Use Match.xpath(String) with Match.namespaces(Map) instead
    Specified by:
    
    remove in interface Match
    
    See Also:
    
    JOOX.selector(String)
  - remove
```
public final Impl remove(Filter filter)
```
    Description copied from interface: Match
    Removes all elements from their parent nodes in the set of matched elements, matching a filter
    The callback Context is populated like this:
    
    Context.match() - the matched element being removed
    
    Context.matchIndex() - the index of the matched element being removed
    Specified by:
    
    remove in interface Match
  - remove
```
private final void remove(org.w3c.dom.Element element)
```
  - empty
```
private final void empty(org.w3c.dom.Element element)
```
  - wrap
```
public final Impl wrap(java.lang.String content)
```
    Description copied from interface: Match
    
    Wrap all elements from their parent nodes in the set of matched elements in a new parent element
    The resulting set of matched elements contains the newly wrapped elements
    
    Specified by:
    
    wrap in interface Match
    
    See Also:
    
    Match.unwrap()
  - wrap
```
public final Impl wrap(Content content)
```
    Description copied from interface: Match
    
    Wrap all elements in the set of matched elements in a new parent element
    The resulting set of matched elements contains the newly wrapped elements
    
    Specified by:
    
    wrap in interface Match
    
    See Also:
    
    Match.unwrap()
  - unwrap
```
public final Impl unwrap()
```
    Description copied from interface: Match
    
    Removes all elements in the set of matched elements from their parents
    The resulting set of matched elements contains the newly unwrapped elements
    
    Specified by:
    
    unwrap in interface Match
    
    See Also:
    
    Match.wrap(String)
  - replaceWith
```
public final Impl replaceWith(java.lang.String content)
```
    Description copied from interface: Match
    
    Replace all elements in the set of matched elements with some new content.
    
    Specified by:
    
    replaceWith in interface Match
  - replaceWith
```
public final Impl replaceWith(Content content)
```
    Description copied from interface: Match
    
    Replace all elements in the set of matched elements with some new content.
    
    Specified by:
    
    replaceWith in interface Match
  - replaceWith
```
public final Impl replaceWith(Match... content)
```
    Description copied from interface: Match
    
    Replace all elements in the set of matched elements with some new content.
    If the added content is already contained in this document, then it is moved. Otherwise, it is cloned. If there are several elements in the set of matched elements, then the added content is duplicated.
    
    Specified by:
    
    replaceWith in interface Match
  - replaceWith
```
public final Impl replaceWith(org.w3c.dom.Element... content)
```
    Description copied from interface: Match
    
    Replace all elements in the set of matched elements with some new content.
    If the added content is already contained in this document, then it is moved. Otherwise, it is cloned. If there are several elements in the set of matched elements, then the added content is duplicated.
    
    Specified by:
    
    replaceWith in interface Match
  - rename
```
public final Match rename(java.lang.String tag)
```
    Description copied from interface: Match
    
    Rename all tags in the set of matched elements to some new tag name
    
    Specified by:
    
    rename in interface Match
  - rename
```
public final Match rename(Content tag)
```
    Description copied from interface: Match
    
    Rename all tags in the set of matched elements to some new tag name
    
    Specified by:
    
    rename in interface Match
  - isFast
```
private final boolean isFast(Filter filter)
```
  - copy
```
public final Impl copy()
```
    Description copied from interface: Match
    
    Get a copy of the Match wrapper. This is not a deep-copy of wrapped Element objects. Both this and the copy will reference the same Element's
    
    Specified by:
    
    copy in interface Match
  - xpath
```
public final java.lang.String xpath()
```
    Description copied from interface: Match
    
    Get an XPath expression describing the first element in the current set of matched elements
    This is the same as calling xpath(0)
    
    Specified by:
    
    xpath in interface Match
  - xpath
```
public final java.lang.String xpath(int index)
```
    Description copied from interface: Match
    
    Get an XPath expression describing the element at a given index in the current set of matched elements
    
    Specified by:
    
    xpath in interface Match
  - xpaths
```
public final java.util.List<java.lang.String> xpaths()
```
    Description copied from interface: Match
    
    Get a list of XPath expressions describing the elements in the current set of matched elements
    
    Specified by:
    
    xpaths in interface Match
  - xpaths
```
public final java.util.List<java.lang.String> xpaths(int... indexes)
```
    Description copied from interface: Match
    
    Get a list of XPath expressions describing the elements at the given indexes in the current set of matched elements
    
    Specified by:
    
    xpaths in interface Match
  - tag
```
public final java.lang.String tag()
```
    Description copied from interface: Match
    
    Get the tag name of the first element in the current set of matched elements.
    This is the same as calling tag(0)
    
    Specified by:
    
    tag in interface Match
  - tag
```
public final java.lang.String tag(int index)
```
    Description copied from interface: Match
    
    Get a tag name of the element at a given index in the current set of matched elements.
    
    Specified by:
    
    tag in interface Match
  - tags
```
public final java.util.List<java.lang.String> tags()
```
    Description copied from interface: Match
    
    Get a list of tag names of the elements in the current set of matched elements.
    
    Specified by:
    
    tags in interface Match
  - tags
```
public final java.util.List<java.lang.String> tags(int... indexes)
```
    Description copied from interface: Match
    
    Get a list of tag names of the elements at given indexes in the current set of matched elements.
    
    Specified by:
    
    tags in interface Match
  - id
```
public final java.lang.String id()
```
    Description copied from interface: Match
    
    Get the first id value
    This is the same as calling id(0)
    
    Specified by:
    
    id in interface Match
  - id
```
public final java.lang.String id(int index)
```
    Description copied from interface: Match
    
    Get an id value at a given index in the current set of matched elements.
    This is the same as calling eq(index).attr("id")
    
    Specified by:
    
    id in interface Match
  - id
```
public final <T> T id(java.lang.Class<T> type)
```
    Description copied from interface: Match
    
    Get the first converted id value
    
    Specified by:
    
    id in interface Match
    
    See Also:
    
    JOOX.convert(String, Class)
  - ids
```
public final java.util.List<java.lang.String> ids()
```
    Description copied from interface: Match
    
    Get a list of id values in the current set of matched elements.
    This is the same as calling attrs("id")
    
    Specified by:
    
    ids in interface Match
  - ids
```
public final java.util.List<java.lang.String> ids(int... indexes)
```
    Description copied from interface: Match
    
    Get a list of id values at given indexes in the current set of matched elements.
    
    Specified by:
    
    ids in interface Match
  - ids
```
public final <T> java.util.List<T> ids(java.lang.Class<T> type)
```
    Description copied from interface: Match
    
    Get a list of converted id values in the current set of matched elements.
    
    Specified by:
    
    ids in interface Match
    
    See Also:
    
    JOOX.convert(String, Class)
  - write
```
public final Match write(java.io.Writer writer)
                  throws java.io.IOException
```
    Description copied from interface: Match
    
    Write the set of matched elements into a writer
    If the set contains more or less than 1 element, this will result in writing non-well-formed XML
    
    Specified by:
    
    write in interface Match
    
    Throws:
    
    java.io.IOException
  - write
```
public final Match write(java.io.OutputStream stream)
                  throws java.io.IOException
```
    Description copied from interface: Match
    
    Write the set of matched elements into a stream
    If the set contains more or less than 1 element, this will result in writing non-well-formed XML
    
    Specified by:
    
    write in interface Match
    
    Throws:
    
    java.io.IOException
  - write
```
public final Match write(java.io.File file)
                  throws java.io.IOException
```
    Description copied from interface: Match
    
    Write the set of matched elements into a file
    If the set contains more or less than 1 element, this will result in writing non-well-formed XML
    
    Specified by:
    
    write in interface Match
    
    Throws:
    
    java.io.IOException
  - unmarshal
```
public final <T> java.util.List<T> unmarshal(java.lang.Class<T> type)
```
    Description copied from interface: Match
    
    Unmarshal the current set of matched elements into a JAXB-annotated type.
    
    Specified by:
    
    unmarshal in interface Match
  - unmarshal
```
public final <T> java.util.List<T> unmarshal(java.lang.Class<T> type,
                                             int... indexes)
```
    Description copied from interface: Match
    
    Unmarshal the current set of matched elements at given indexes into a JAXB-annotated type.
    
    Specified by:
    
    unmarshal in interface Match
  - unmarshalOne
```
public final <T> T unmarshalOne(java.lang.Class<T> type)
```
    Description copied from interface: Match
    
    Unmarshal the first element in the current set of matched elements into a JAXB-annotated type.
    This is the same as calling unmarshalOne(type, 0)
    
    Specified by:
    
    unmarshalOne in interface Match
  - unmarshalOne
```
public final <T> T unmarshalOne(java.lang.Class<T> type,
                                int index)
```
    Description copied from interface: Match
    
    Unmarshal the element at a given index in the current set of matched elements into a JAXB-annotated type.
    This is the same as calling unmarshalOne(type, 0)
    
    Specified by:
    
    unmarshalOne in interface Match
  - transform
```
public final Impl transform(javax.xml.transform.Transformer transformer)
```
    Description copied from interface: Match
    Transform all elements in the set of matched elements.
    This will apply a given Transformer to every element in the set of matched elements. Every element in the set of matched elements will be replaced by its corresponding Result obtained from the transformer.
    
    Example Input:
    
    <books> <book id="1"/> <book id="2"/> </books>
    
    Example XSLT:
    
    <?xml version="1.0" encoding="ISO-8859-1"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:template match="book"> <book id=""> <xsl:apply-templates/> </book> </xsl:template> <xsl:template match="@*|*"> <xsl:copy> <xsl:apply-templates select="*|@*"/> </xsl:copy> </xsl:template> </xsl:stylesheet>
    
    Apply transformation:
    
    // Applies transformation to the document element: $(document).transform("increment.xsl"); // Applies transformation to every book element: $(document).find("book").transform("increment.xsl");
    
    Result:
    
    <books> <book id="2"/> <book id="3"/> </books>
    Specified by:
    
    transform in interface Match
  - transform
```
public final Impl transform(javax.xml.transform.Source transformer)
```
    Description copied from interface: Match
    
    Transform all elements in the set of matched elements.
    
    Specified by:
    
    transform in interface Match
    
    See Also:
    
    Match.transform(Transformer)
  - transform
```
public final Impl transform(java.io.InputStream transformer)
```
    Description copied from interface: Match
    
    Transform all elements in the set of matched elements.
    
    Specified by:
    
    transform in interface Match
    
    See Also:
    
    Match.transform(Transformer)
  - transform
```
public final Impl transform(java.io.Reader transformer)
```
    Description copied from interface: Match
    
    Transform all elements in the set of matched elements.
    
    Specified by:
    
    transform in interface Match
    
    See Also:
    
    Match.transform(Transformer)
  - transform
```
public final Impl transform(java.net.URL transformer)
```
    Description copied from interface: Match
    
    Transform all elements in the set of matched elements.
    
    Specified by:
    
    transform in interface Match
    
    See Also:
    
    Match.transform(Transformer)
  - transform
```
public final Impl transform(java.io.File transformer)
```
    Description copied from interface: Match
    
    Transform all elements in the set of matched elements.
    
    Specified by:
    
    transform in interface Match
    
    See Also:
    
    Match.transform(Transformer)
  - transform
```
public final Impl transform(java.lang.String transformer)
```
    Description copied from interface: Match
    
    Transform all elements in the set of matched elements.
    
    Specified by:
    
    transform in interface Match
    
    See Also:
    
    Match.transform(Transformer)
  - sort
```
public Match sort(java.util.Comparator<org.w3c.dom.Element> comparator)
```
    Description copied from interface: Match
    
    Allows to sort the result with the given comparator.
    
    Specified by:
    
    sort in interface Match
    
    Parameters:
    
    comparator - The element comparator.
    
    Returns:
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object

Class Impl

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

document

elements

previousMatch

namespaces

SIMPLE_SELECTOR

Constructor Detail

Impl

Impl

Method Detail

addNodeLists

addNodeList

addUniqueElements

addUniqueElements

addElements

addElements

iterator

namespace

namespaces

namespaceURI

namespaceURI

namespaceURIs

namespaceURIs

namespacePrefix

namespacePrefix

namespacePrefixes

namespacePrefixes

document

get

get

get

size

isEmpty

isNotEmpty

add

add

reverse

andSelf

child

child

child

child

children

children

children

children

each

each

each

each

filter

filter

filter0

eq

find

find

isRoot

find

xpath

Using jOOX with Namespaces

Using jOOX with Xalan

xpath

Using jOOX with Namespaces

Using jOOX with Xalan

first

has

has

is

is

last

map

next

next