|
||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface Match
A wrapper type for Element
This is the main type of the jOOX library. It wraps an ordered list of DOM elements without duplicates and provides useful operations upon all of the contained elements. The wrapped DOM elements have been previously "matched" by a jOOX operation.
The API has been inspired by http://jquery.com, a fantastic DOM abstraction library for JavaScript.
Method Summary | ||
---|---|---|
Match |
add(Element... elements)
Add some elements to the set of matched elements |
|
Match |
add(Match... elements)
Add some elements to the set of matched elements |
|
Match |
after(Content content)
Add content after each element in the set of matched elements. |
|
Match |
after(Element... content)
Add content after each element in the set of matched elements. |
|
Match |
after(Match... content)
Add content after each element in the set of matched elements. |
|
Match |
after(String content)
Add content after each element in the set of matched elements. |
|
Match |
andSelf()
Add the previous set of matched elements to the current one. |
|
Match |
append(Content content)
Append content to the end of each element's content in the set of matched elements. |
|
Match |
append(Element... content)
Append content to the end of each element's content in the set of matched elements. |
|
Match |
append(Match... content)
Append content to the end of each element's content in the set of matched elements. |
|
Match |
append(String content)
Append content to the end of each element's content in the set of matched elements. |
|
String |
attr(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. |
|
|
attr(String name,
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. |
|
Match |
attr(String name,
Content value)
Set an attribute on all elements in the set of matched elements. |
|
Match |
attr(String name,
String value)
Set an attribute on all elements in the set of matched elements. |
|
List<String> |
attrs(String name)
Get an attribute from all elements in the set of matched elements |
|
|
attrs(String name,
Class<T> type)
Get a converted attribute from all elements in the set of matched elements |
|
Match |
before(Content content)
Add content before each element in the set of matched elements. |
|
Match |
before(Element... content)
Add content before each element in the set of matched elements. |
|
Match |
before(Match... content)
Add content before each element in the set of matched elements. |
|
Match |
before(String content)
Add content before each element in the set of matched elements. |
|
Match |
child()
Find the first child of each element in the current set of matched elements. |
|
Match |
child(Filter filter)
Find the first matching child of each element in the current set of matched elements |
|
Match |
child(int index)
Find the child at a given index of each element in the current set of matched elements. |
|
Match |
child(String selector)
Find the first matching child of each element in the current set of matched elements |
|
Match |
children()
Find all children of each element in the current set of matched elements. |
|
Match |
children(Filter filter)
Find all children of each element in the current set of matched elements. |
|
Match |
children(int... indexes)
Find all children of each element at given indexes in the current set of matched elements. |
|
Match |
children(String selector)
Find all children of each element in the current set of matched elements. |
|
String |
content()
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) |
|
Match |
content(Content content)
Add some XML content to all elements in the set of matched elements (possibly replacing existing content). |
|
String |
content(int index)
Get the XML content at a given index in the current set of matched elements. |
|
Match |
content(String content)
Add some XML content to all elements in the set of matched elements (possibly replacing existing content). |
|
List<String> |
contents()
Get all XML content of the elements in the set of matched elements. |
|
List<String> |
contents(int... indexes)
Get all XML content of the elements at given indexes in the set of matched elements. |
|
Match |
copy()
Get a copy of the Match wrapper. |
|
Document |
document()
Get the underlying document of the set of matched elements. |
|
List<Match> |
each()
Get all elements in the set of matched elements in a list of matches, every match representing one element |
|
Match |
each(Each each)
Execute a callback for every element in the current set of matched elements. |
|
Match |
empty()
Removes all content from all elements in the set of matched elements. |
|
Match |
eq(int... indexes)
Reduce the current set of matched elements to the elements at the given indexes. |
|
Match |
filter(Filter filter)
Reduce the current set of matched elements. |
|
Match |
filter(String selector)
Reduce the current set of matched elements. |
|
Match |
find()
Find all descendants of each element in the current set of matched elements. |
|
Match |
find(Filter filter)
Find all descendants of each element in the current set of matched elements. |
|
Match |
find(String selector)
Find all descendants of each element in the current set of matched elements. |
|
Match |
first()
Get the first in a set of matched elements. |
|
List<Element> |
get()
Get an the set of matched elements |
|
List<Element> |
get(int... indexes)
Get some elements from the set of matched elements at the given indexes Negative indexes are possible, too. |
|
Element |
get(int index)
Get an element from the set of matched elements at a given index Negative indexes are possible, too. |
|
Match |
has(Filter filter)
Reduce the set of matched element to those who have a descendant that matches a filter. |
|
Match |
has(String selector)
Reduce the set of matched element to those who have a descendant that matches a selector. |
|
String |
id()
Get the first id value This is the same as calling id(0) |
|
|
id(Class<T> type)
Get the first converted id value |
|
String |
id(int index)
Get an id value at a given index in the current set of matched elements. |
|
List<String> |
ids()
Get a list of id values in the current set of matched elements. |
|
|
ids(Class<T> type)
Get a list of converted id values in the current set of matched elements. |
|
List<String> |
ids(int... indexes)
Get a list of id values at given indexes in the current set of matched elements. |
|
boolean |
is(Filter filter)
Check if at least one element in the set of matched elements satisfies a filter. |
|
boolean |
is(String selector)
Check if at least one element in the set of matched elements satisfies a selector. |
|
boolean |
isEmpty()
Whether there are any matched elements in the set of matched elements |
|
Match |
last()
Get the last in a set of matched elements. |
|
|
map(Mapper<E> map)
Map the set of matched elements to a list of something |
|
Match |
next()
Get the immediate next sibling of every element in set of matched elements. |
|
Match |
next(Filter filter)
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
|
|
Match |
next(String selector)
Get the immediate next sibling of every element in set of matched elements, matching a selector |
|
Match |
nextAll()
Get all next siblings of every element in a set of matched elements |
|
Match |
nextAll(Filter filter)
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
|
|
Match |
nextAll(String selector)
Get all next siblings of every element in a set of matched elements, matching a selector |
|
Match |
nextUntil(Filter until)
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
|
|
Match |
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 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
|
|
Match |
nextUntil(Filter until,
String selector)
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
|
|
Match |
nextUntil(String until)
Get all next siblings of every element in a set of matched elements until the provided selector matches |
|
Match |
nextUntil(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 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
|
|
Match |
nextUntil(String until,
String selector)
Get all next siblings of every element in a set of matched elements, matching a selector, until the provided selector matches |
|
Match |
not(Filter filter)
Remove elements from the set of matched elements. |
|
Match |
not(String selector)
Remove elements from the set of matched elements. |
|
Match |
parent()
Get the immediate parent elements of every element in a set of matched elements |
|
Match |
parent(Filter filter)
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
|
|
Match |
parent(String selector)
Get the immediate parent elements of every element in a set of matched elements, matching a selector |
|
Match |
parents()
Get all ancestor elements of every element in a set of matched elements |
|
Match |
parents(Filter filter)
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
|
|
Match |
parents(String selector)
Get all ancestor elements of every element in a set of matched elements, matching a selector |
|
Match |
parentsUntil(Filter until)
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
|
|
Match |
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 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
|
|
Match |
parentsUntil(Filter until,
String selector)
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
|
|
Match |
parentsUntil(String until)
Get all ancestors of every element in a set of matched elements until the provided selector matches |
|
Match |
parentsUntil(String until,
Filter filter)
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
|
|
Match |
parentsUntil(String until,
String selector)
Get all ancestors of every element in a set of matched elements, matching a selector, until the provided selector matches |
|
Match |
prepend(Content content)
Prepend content to the beginning of each element's content in the set of matched elements. |
|
Match |
prepend(Element... content)
Prepend content to the beginning of each element's content in the set of matched elements. |
|
Match |
prepend(Match... content)
Prepend content to the beginning of each element's content in the set of matched elements. |
|
Match |
prepend(String content)
Prepend content to the beginning of each element's content in the set of matched elements. |
|
Match |
prev()
Get the immediate previous sibling of every element in set of matched elements. |
|
Match |
prev(Filter filter)
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
|
|
Match |
prev(String selector)
Get the immediate previous sibling of every element in set of matched elements, matching a selector |
|
Match |
prevAll()
Get all previous siblings of every element in a set of matched elements |
|
Match |
prevAll(Filter filter)
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
|
|
Match |
prevAll(String selector)
Get all previous siblings of every element in a set of matched elements, matching a selector |
|
Match |
prevUntil(Filter until)
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
|
|
Match |
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 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
|
|
Match |
prevUntil(Filter until,
String selector)
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
|
|
Match |
prevUntil(String until)
Get all previous siblings of every element in a set of matched elements until the provided selector matches |
|
Match |
prevUntil(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 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
|
|
Match |
prevUntil(String until,
String selector)
Get all previous siblings of every element in a set of matched elements, matching a selector, until the provided selector matches |
|
Match |
remove()
Removes all elements in the set of matched elements. |
|
Match |
remove(Filter filter)
Removes all elements 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
|
|
Match |
remove(String selector)
Removes all elements in the set of matched elements, matching a selector |
|
Match |
removeAttr(String name)
Remove an attribute from all elements in the set of matched elements. |
|
Match |
replaceWith(Content content)
Replace all elements in the set of matched elements with some new content. |
|
Match |
replaceWith(Element... content)
Replace all elements in the set of matched elements with some new content. |
|
Match |
replaceWith(Match... content)
Replace all elements in the set of matched elements with some new content. |
|
Match |
replaceWith(String content)
Replace all elements in the set of matched elements with some new content. |
|
Match |
reverse()
Reverse the order of the set of matched elements |
|
Match |
siblings()
Get all siblings of every element in a set of matched elements |
|
Match |
siblings(Filter filter)
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. |
|
Match |
siblings(String selector)
Get all siblings of every element in a set of matched elements, matching a selector |
|
int |
size()
Get the number of matched elements in the set of matched elements |
|
Match |
slice(int start)
Reduce the set of matched elements by specifying a range of indexes This is the same as calling slice(start, Integer.MAX_VALUE) |
|
Match |
slice(int start,
int end)
Reduce the set of matched elements by specifying a range of indexes |
|
String |
tag()
Get the tag name of the first element in the current set of matched elements. |
|
String |
tag(int index)
Get a tag name of the element at a given index in the current set of matched elements. |
|
List<String> |
tags()
Get a list of tag names of the elements in the current set of matched elements. |
|
List<String> |
tags(int... indexes)
Get a list of tag names of the elements at given indexes in the current set of matched elements. |
|
String |
text()
Get the text content of the first element in the set of matched elements, or null if there are no matched elements. |
|
|
text(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. |
|
Match |
text(Content content)
Set some text content to all elements in the set of matched elements (possibly replacing existing content). |
|
String |
text(int index)
Get the text content at a given index in the current set of matched elements. |
|
Match |
text(String content)
Set some text content to all elements in the set of matched elements (possibly replacing existing content). |
|
List<String> |
texts()
Get all text content of the elements in the set of matched elements. |
|
|
texts(Class<T> type)
Get all converted text content of the elements in the set of matched elements. |
|
List<String> |
texts(int... indexes)
Get all text content of the elements at given indexes in the set of matched elements. |
|
|
unmarshal(Class<T> type)
Unmarshal the current set of matched elements into a JAXB-annotated type. |
|
|
unmarshal(Class<T> type,
int... indexes)
Unmarshal the current set of matched elements at given indexes into a JAXB-annotated type. |
|
|
unmarshalOne(Class<T> type)
Unmarshal the first element in the current set of matched elements into a JAXB-annotated type. |
|
|
unmarshalOne(Class<T> type,
int index)
Unmarshal the element at a given index in the current set of matched elements into a JAXB-annotated type. |
|
String |
xpath()
Get an XPath expression describing the first element in the current set of matched elements This is the same as calling xpath(0) |
|
String |
xpath(int index)
Get an XPath expression describing the element at a given index in the current set of matched elements |
|
Match |
xpath(String expression)
Match all elements given a certain XPath expression applied to each element in the current set of matched element. |
|
List<String> |
xpaths()
Get a list of XPath expressions describing the elements in the current set of matched elements |
|
List<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 interface java.lang.Iterable |
---|
iterator |
Method Detail |
---|
Element get(int 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.
Document document()
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.
List<Element> get(int... 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.
List<Element> get()
int size()
boolean isEmpty()
Match add(Element... elements)
Match add(Match... elements)
Match reverse()
Match andSelf()
child()
children()
find()
next()
nextAll()
nextUntil(Filter)
parent()
parents()
parentsUntil(Filter)
prev()
prevAll()
prevUntil(Filter)
siblings()
eq(int...)
, and then add the removed
elements again, using andSelf()
.
Match child()
This is the same as calling child(0)
.
Match child(String selector)
Match child(Filter filter)
Match child(int index)
Match children()
Match children(String selector)
Match children(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose children are
searchedContext.matchIndex()
- the index of the matched element whose
children are searchedContext.element()
- the child candidate that is being
filteredContext.elementIndex()
- the index within its parent of the
child candidate that is being filtered
Match children(int... indexes)
List<Match> each()
Match each(Each each)
Match filter(String selector)
Match filter(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element being filteredContext.matchIndex()
- the index of the matched element being
filtered
Match eq(int... 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.
Match find()
Match find(String selector)
Match find(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose descendants are
searchedContext.matchIndex()
- the index of the matched element whose
descendants are searchedContext.element()
- the descendant candidate that is being
filteredContext.elementIndex()
- the iteration index of the
descendant candidate that is being filtered
Match xpath(String expression)
The XPath expression is evaluated using standard
XPath
. Note that only matched elements will be
considered in the results. Examples:
xpath("//*")
xpath("/library/books/book")
xpath("//book").ids()
xpath("//book/name").texts()
xpath("//book/@id")
xpath("//book/name/text()")
Match first()
Match has(String selector)
Match has(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose descendants are
searchedContext.matchIndex()
- the index of the matched element whose
descendants are searchedContext.element()
- the descendant candidate that is being
filteredContext.elementIndex()
- the iteration index of the
descendant candidate that is being filtered
boolean is(String selector)
boolean is(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element being checkedContext.matchIndex()
- the index of the matched element being
checked
Match last()
<E> List<E> map(Mapper<E> map)
Match next()
Match next(String selector)
Match next(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose next sibling is
searchedContext.matchIndex()
- the index of the matched element whose
next sibling is searchedContext.element()
- the next sibling that is being filteredContext.elementIndex()
- 1
Match nextAll()
Match nextAll(String selector)
Match nextAll(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose next siblings are
searchedContext.matchIndex()
- the index of the matched element whose
next siblings are searchedContext.element()
- the next siblings that is being filteredContext.elementIndex()
- the relative index of the next
siblings that are being filtered
Match nextUntil(String until)
Match nextUntil(Filter until)
The callback Context
is populated like this:
Context.match()
- the matched element whose next siblings are
searchedContext.matchIndex()
- the index of the matched element whose
next siblings are searchedContext.element()
- the next siblings that is being filteredContext.elementIndex()
- the relative index of the next
siblings that are being filtered
Match nextUntil(String until, String selector)
Match nextUntil(String until, Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose next siblings are
searchedContext.matchIndex()
- the index of the matched element whose
next siblings are searchedContext.element()
- the next siblings that is being filteredContext.elementIndex()
- the relative index of the next
siblings that are being filtered
Match nextUntil(Filter until, String selector)
The callback Context
is populated like this:
Context.match()
- the matched element whose next siblings are
searchedContext.matchIndex()
- the index of the matched element whose
next siblings are searchedContext.element()
- the next siblings that is being filteredContext.elementIndex()
- the relative index of the next
siblings that are being filtered
Match nextUntil(Filter until, Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose next siblings are
searchedContext.matchIndex()
- the index of the matched element whose
next siblings are searchedContext.element()
- the next siblings that is being filteredContext.elementIndex()
- the relative index of the next
siblings that are being filtered
Match not(String selector)
Match not(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element being checkedContext.matchIndex()
- the index of the matched element being
checked
Match parent()
Match parent(String selector)
Match parent(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose parent is
searchedContext.matchIndex()
- the index of the matched element whose
parent is searchedContext.element()
- the parent that is being filteredContext.elementIndex()
- 1
Match parents()
Match parents(String selector)
Match parents(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose parents are
searchedContext.matchIndex()
- the index of the matched element whose
parents are searchedContext.element()
- the parent that is being filteredContext.elementIndex()
- the relative index of the parent
that is being filtered
Match parentsUntil(String until)
Match parentsUntil(Filter until)
The callback Context
is populated like this:
Context.match()
- the matched element whose parents are
searchedContext.matchIndex()
- the index of the matched element whose
parents are searchedContext.element()
- the parent that is being filteredContext.elementIndex()
- the relative index of the parent
that is being filtered
Match parentsUntil(String until, String selector)
Match parentsUntil(String until, Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose parents are
searchedContext.matchIndex()
- the index of the matched element whose
parents are searchedContext.element()
- the parent that is being filteredContext.elementIndex()
- the relative index of the parent
that is being filtered
Match parentsUntil(Filter until, String selector)
The callback Context
is populated like this:
Context.match()
- the matched element whose parents are
searchedContext.matchIndex()
- the index of the matched element whose
parents are searchedContext.element()
- the parent that is being filteredContext.elementIndex()
- the relative index of the parent
that is being filtered
Match parentsUntil(Filter until, Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose parents are
searchedContext.matchIndex()
- the index of the matched element whose
parents are searchedContext.element()
- the parent that is being filteredContext.elementIndex()
- the relative index of the parent
that is being filtered
Match prev()
Match prev(String selector)
Match prev(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose previous sibling
is searchedContext.matchIndex()
- the index of the matched element whose
previous sibling is searchedContext.element()
- the previous sibling that is being
filteredContext.elementIndex()
- 1
Match prevAll()
Match prevAll(String selector)
Match prevAll(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose previous siblings
are searchedContext.matchIndex()
- the index of the matched element whose
previous siblings are searchedContext.element()
- the previous siblings that is being
filteredContext.elementIndex()
- the relative index of the previous
siblings that are being filtered
Match prevUntil(String until)
Match prevUntil(Filter until)
The callback Context
is populated like this:
Context.match()
- the matched element whose previous siblings
are searchedContext.matchIndex()
- the index of the matched element whose
previous siblings are searchedContext.element()
- the previous siblings that is being
filteredContext.elementIndex()
- the relative index of the previous
siblings that are being filtered
Match prevUntil(String until, String selector)
Match prevUntil(String until, Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose previous siblings
are searchedContext.matchIndex()
- the index of the matched element whose
previous siblings are searchedContext.element()
- the previous siblings that is being
filteredContext.elementIndex()
- the relative index of the previous
siblings that are being filtered
Match prevUntil(Filter until, String selector)
The callback Context
is populated like this:
Context.match()
- the matched element whose previous siblings
are searchedContext.matchIndex()
- the index of the matched element whose
previous siblings are searchedContext.element()
- the previous siblings that is being
filteredContext.elementIndex()
- the relative index of the previous
siblings that are being filtered
Match prevUntil(Filter until, Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose previous siblings
are searchedContext.matchIndex()
- the index of the matched element whose
previous siblings are searchedContext.element()
- the previous siblings that is being
filteredContext.elementIndex()
- the relative index of the previous
siblings that are being filtered
Match siblings()
Match siblings(String selector)
Match siblings(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element whose siblings are
searchedContext.matchIndex()
- the index of the matched element whose
siblings are searchedContext.element()
- the sibling that is being filteredContext.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()
Match slice(int start)
This is the same as calling slice(start, Integer.MAX_VALUE)
Match slice(int start, int end)
Match before(String content)
Match before(Content content)
The callback Context
is populated like this:
Context.match()
- the matched element being prepended beforeContext.matchIndex()
- the index of the matched element being
prepended before
Match before(Match... 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.
Match before(Element... 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.
Match after(String content)
Match after(Content content)
The callback Context
is populated like this:
Context.match()
- the matched element being appended afterContext.matchIndex()
- the index of the matched element being
appended after
Match after(Match... 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.
Match after(Element... 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.
Match prepend(String content)
Match prepend(Content content)
The callback Context
is populated like this:
Context.match()
- the matched element being prepended toContext.matchIndex()
- the index of the matched element being
prepended to
Match prepend(Match... 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.
Match prepend(Element... 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.
Match append(String content)
Match append(Content content)
The callback Context
is populated like this:
Context.match()
- the matched element being appended toContext.matchIndex()
- the index of the matched element being
appended to
Match append(Match... 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.
Match append(Element... 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.
Match replaceWith(String content)
Match replaceWith(Content content)
Match replaceWith(Match... 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.
Match replaceWith(Element... 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.
Match empty()
Match remove()
Match remove(String selector)
Match remove(Filter filter)
The callback Context
is populated like this:
Context.match()
- the matched element being removedContext.matchIndex()
- the index of the matched element being
removed
String attr(String name)
null
if the first element does not have that attribute.
<T> T attr(String name, Class<T> type)
null
if the first element does not have that
attribute.
JOOX.convert(String, Class)
List<String> attrs(String name)
<T> List<T> attrs(String name, Class<T> type)
JOOX.convert(String, Class)
Match attr(String name, String value)
value
is null, then the attribute is removed. If the
attribute already exists, then it is replaced.
Match attr(String name, Content value)
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 attributedContext.matchIndex()
- the index of the matched element being
attributed
Match removeAttr(String name)
attr(name, null)
.
List<String> contents()
List<String> contents(int... indexes)
String content()
null
if there are no matched elements
This is the same as calling content(0)
String content(int index)
Match content(String content)
text(String)
Match content(Content content)
text(String)
The callback Context
is populated like this:
Context.match()
- the matched element being added toContext.matchIndex()
- the index of the matched element being
added to
List<String> texts()
<T> List<T> texts(Class<T> type)
JOOX.convert(String, Class)
List<String> texts(int... indexes)
String text()
null
if there are no matched elements.
This is the same as calling text(0)
<T> T text(Class<T> type)
null
if there are no matched elements.
JOOX.convert(String, Class)
String text(int index)
Match text(String content)
Match text(Content content)
The callback Context
is populated like this:
Context.match()
- the matched element being added toContext.matchIndex()
- the index of the matched element being
added to
Match copy()
Match
wrapper. This is not a deep-copy of
wrapped Element
objects. Both this and the copy will reference
the same Element
's
List<String> xpaths()
List<String> xpaths(int... indexes)
String xpath()
This is the same as calling xpath(0)
String xpath(int index)
List<String> tags()
List<String> tags(int... indexes)
String tag()
This is the same as calling tag(0)
String tag(int index)
List<String> ids()
This is the same as calling attrs("id")
List<String> ids(int... indexes)
<T> List<T> ids(Class<T> type)
JOOX.convert(String, Class)
String id()
This is the same as calling id(0)
String id(int index)
This is the same as calling eq(index).attr("id")
<T> T id(Class<T> type)
JOOX.convert(String, Class)
<T> List<T> unmarshal(Class<T> type)
<T> List<T> unmarshal(Class<T> type, int... indexes)
<T> T unmarshalOne(Class<T> type)
This is the same as calling unmarshalOne(type, 0)
<T> T unmarshalOne(Class<T> type, int index)
This is the same as calling unmarshalOne(type, 0)
|
||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |