com.itextpdf.styledxmlparser.jsoup.select Documentation Differences

iText7 7.2.0 Overview Package Class Text Changes Statistics Help

Generated by
JDiff

PREV PACKAGE NEXT PACKAGE FRAMES NO FRAMES

com.itextpdf.styledxmlparser.jsoup.select Documentation Differences

This file contains all the changes in documentation in the package com.itextpdf.styledxmlparser.jsoup.select as colored differences. Deletions are shown ~~like this~~ , and additions are shown like this.

If no deletions or additions are shown in an entry, the HTML tags will be what has changed. The new HTML tags are shown in the differences. If no documentation existed, and then some was added in a later version, this change is noted in the appropriate class pages of differences, but the change is not shown on this page. Only changes in existing text are shown here. Similarly, documentation which was inherited from another class or interface is not shown here.

Note that an HTML error in the new documentation may cause the display of other documentation changes to be presented incorrectly. For instance, failure to close a tag will cause all subsequent paragraphs to be displayed differently.

 
  
 Class Elements, Elements addClass(String) 
  
 
  
 
  
    Add the class name to every matched element's {@code class} attribute. 
      
   @param className class name to add  
   @return this 
  
 Class Elements, String attr(String) 
  
 
  
 
  
    Get an attribute value from the first matched element that has the attribute. 
     @param attributeKey The attribute key.  
   @return The attribute value from the first matched element that has the attribute.. If no elements were matched (isEmpty() == true),  
   or if the no elements have the attribute, returns empty string.  
   @see #hasAttr(String) 
  
 Class Elements, Object clone() 
  
 
  
 
  
    Creates a deep copy of these elements. 
     @return a deep copy 
  
 Class Elements, boolean hasAttr(String) 
  
 
  
 
  
    Checks if any of the matched elements have this attribute 
     set 
   defined. 
      
   @param attributeKey attribute key  
   @return true if any of the elements have the attribute; false if none do. 
  
 Class Elements, boolean hasClass(String) 
  
 
  
 
  
    Determine if any of the matched elements have this class name set in their {@code class} attribute. 
      
   @param className class name to check for  
   @return true if any do, false if none do 
  
 Class Elements, Elements remove() 
  
 
  
 
  
    Remove each matched element from the DOM. This is similar to setting the outer HTML of each element to nothing. 
    E.g. HTML: {@code  
    
    Hello 
    there 
     
   } 
   
 doc.select("p").remove(); 
   
 HTML = {@code 
    
     
   } 
    Note that this method should not be used to clean user-submitted HTML; rather, use com.itextpdf.styledxmlparser.jsoup.safety.Cleaner to clean HTML. @return this, for chaining @see Element#empty() @see #empty() 
  
 Class Elements, Elements removeClass(String) 
  
 
  
 
  
    Remove the class name from every matched element's {@code class} attribute, if present. 
      
   @param className class name to remove  
   @return this 
  
 Class Elements, Elements tagName(String) 
  
 
  
 
  
    Update (rename) the tag name of each matched element. For example, to change each {@code } to a {@code }, do {@code doc.select("i").tagName("em");} 
      
       @param tagName the new tag name @return this, for chaining @see Element#tagName(String) 
  
 Class Elements, String text()

 
    
      Get the combined text of all the matched elements. 
      Note that it is possible to get repeats if the matched elements contain both parent elements and their own children, as the Element.text() method returns the combined text of a parent and all its children. @return string of all text: unescaped and no HTML. @see Element#text() @see #eachText() 
    
 Class Elements, Elements toggleClass(String)

 
    
      Toggle the class name on every matched element's {@code class} attribute. 
       @param className class name to add if missing, or remove if present, from every element.  
     @return this 
    
 Class Elements, Elements unwrap()

 
    
      Removes the matched elements from the DOM, and moves their children up into their parents. This has the effect of dropping the elements but keeping their children. 
      This is useful for e.g removing unwanted formatting elements but keeping their contents.  E.g. with HTML: 
        
      {@code  
      One Two 
     } 
      {@code doc.select("font").unwrap();}  
      HTML = {@code  
     
       One Two 
     } @return this (for chaining) @see Node#unwrap 
    
 Class Elements, Elements wrap(String)

 
    
      Wrap the supplied HTML around each matched elements. For example, with HTML  
     {@code 
     This is Jsoup
},  
     doc.select("b").wrap("");  
     becomes {@code 
     This is jsoup
} 
        
     @param html HTML to wrap around each element, e.g. {@code 
     
}. Can be arbitrarily deep.  
     @return this (for chaining)  
     @see Element#wrap 
     
    
 Class NodeVisitor

 
    
      Node visitor interface. Provide an implementing class to NodeTraversor to iterate through nodes. 
      This interface provides two methods, {@code head} and {@code tail}. The head method is called when the node is first seen, and the tail method when all of the node's children have been visited. As an example, {@code head} can be used to 
        create 
      emit a start tag for a node, and {@code tail} to create the end tag. 
    
 Class NodeVisitor, void head(Node, int)

 
    
      Callback for when a node is first visited.  The node may be modified (e.g. Node.attr(String) or replaced Node.replaceWith(Node)). If it's {@code instanceOf Element}, you may cast it to an Element and access those methods. 
 Note that nodes may not be removed during traversal using this method; use NodeTraversor.filter(NodeFilter, Node) with a NodeFilter.FilterResult.REMOVE return instead. @param node  the node being visited. @param depth the depth of the node, relative to the root node. E.g., the root node has depth 0, and a child node  of that will have depth 1. 
    
 Class NodeVisitor, void tail(Node, int)

 
    
      Callback for when a node is last visited, after all of its descendants have been visited.  Note that replacement with Node.replaceWith(Node) is not supported in {@code tail}. @param node  the node being visited. @param depth the depth of the node, relative to the root node. E.g., the root node has depth 0, and a child node  of that will have depth 1. 
     
    
 Class QueryParser, Evaluator parse(String)

 
    
      Parse a CSS query into an Evaluator. @param query CSS query @return 
       Evaluator 
     Evaluator @see Selector selector query syntax 
     
    
 Class Selector

 
    
      CSS-like element selector, that finds elements matching a query. 
     Selector syntax 
      A selector is a chain of simple selectors, separated by combinators. Selectors are case insensitive (including against elements, attributes, and attribute values).  
      The universal selector (*) is implicit when no element selector is supplied (i.e. {@code *.header} and {@code .header} is equivalent).   
      
       
        
        
        
       
       
        
        Pattern 
        Matches 
        Example 
        
        
        * 
        any element 
        * 
        
        
        tag 
        elements with the given tag name 
        div 
        
        
        *|E 
        elements of type E in any namespace ns 
        *|name finds  elements 
        
        
        ns|E 
        elements of type E in the namespace ns 
        fb|name finds  elements 
        
        
        #id 
        elements with attribute ID of "id" 
        div#wrap, #logo 
        
        
        .class 
        elements with a class name of "class" 
        div.left, .result 
        
        
        [attr] 
        elements with an attribute named "attr" (with any value) 
        a[href], [title] 
        
        
        [^attrPrefix] 
        elements with an attribute name starting with "attrPrefix". Use to find elements with HTML5 datasets 
        [^data-], div[^data-] 
        
        
        [attr=val] 
        elements with an attribute named "attr", and value equal to "val" 
        img[width=500], a[rel=nofollow] 
        
        
        [attr="val"] 
        elements with an attribute named "attr", and value equal to "val" 
        span[hello="Cleveland"][goodbye="Columbus"], a[rel="nofollow"] 
        
        
        [attr^=valPrefix] 
        elements with an attribute named "attr", and value starting with "valPrefix" 
        a[href^=http:] 
        
        
        [attr$=valSuffix] 
        elements with an attribute named "attr", and value ending with "valSuffix" 
        img[src$=.png] 
        
        
        [attr*=valContaining] 
        elements with an attribute named "attr", and value containing "valContaining" 
        a[href*=/search/] 
        
        
        [attr~=regex] 
        elements with an attribute named "attr", and value matching the regular expression 
        img[src~=(?i)\\.(png|jpe?g)] 
        
        
         
        The above may be combined in any order 
        div.header[title] 
        
        
        Combinators 
        
        
        E F 
        an F element descended from an E element 
        div a, .logo h1 
        
        
        E {@literal >} F 
        an F direct child of E 
        ol {@literal >} li 
        
        
        E + F 
        an F element immediately preceded by sibling E 
        li + li, div.head + div 
        
        
        E ~ F 
        an F element preceded by sibling E 
        h1 ~ p 
        
        
        E, F, G 
        all matching elements E, F, or G 
        a[href], div, h3 
        
        
        Pseudo selectors 
        
        
        :lt(n) 
        elements whose sibling index is less than n 
        td:lt(3) finds the first 3 cells of each row 
        
        
        :gt(n) 
        elements whose sibling index is greater than n 
        td:gt(1) finds cells after skipping the first two 
        
        
        :eq(n) 
        elements whose sibling index is equal to n 
        td:eq(0) finds the first cell of each row 
        
        
        :has(selector) 
        elements that contains at least one element matching the selector 
        div:has(p) finds 
           divs 
         divs that contain p elements.
div:has(> a) selects div elements that have at least one direct child a element. 
        
        
        :not(selector) 
        elements that do not match the selector. See also Elements.not(String) 
        div:not(.logo) finds all divs that do not have the "logo" class.div:not(:has(div)) finds divs that do not contain divs. 
        
        
        :contains(text) 
        elements that contains the specified text. The search is case insensitive. The text may appear in the found element, or any of its descendants. 
        p:contains(jsoup) finds p elements containing the text "jsoup". 
        
        
        :matches(regex) 
        elements whose text matches the specified regular expression. The text may appear in the found element, or any of its descendants. 
        td:matches(\\d+) finds table cells containing digits. div:matches((?i)login) finds divs containing the text, case insensitively. 
        
        
        :containsOwn(text) 
        elements that directly contain the specified text. The search is case insensitive. The text must appear in the found element, not any of its descendants. 
        p:containsOwn(jsoup) finds p elements with own text "jsoup". 
        
        
        :matchesOwn(regex) 
        elements whose own text matches the specified regular expression. The text must appear in the found element, not any of its descendants. 
        td:matchesOwn(\\d+) finds table cells directly containing digits. div:matchesOwn((?i)login) finds divs containing the text, case insensitively. 
        
        
        :containsData(data) 
        elements that contains the specified data. The contents of {@code script} and {@code style} elements, and {@code comment} nodes (etc) are considered data nodes, not text nodes. The search is case insensitive. The data may appear in the found element, or any of its descendants. 
        script:contains(jsoup) finds script elements containing the data "jsoup". 
        
        
         
        The above may be combined in any order and with other selectors 
        .light:contains(name):eq(0) 
        
        
        :matchText 
        treats text nodes as elements, and so allows you to match against and select text nodes.Note that using this selector will modify the DOM, so you may want to {@code clone} your document before using. 
        {@code p:matchText:firstChild} with input {@code One
Two
} will return one com.itextpdf.styledxmlparser.jsoup.nodes.PseudoTextElement with text "{@code One}". 
        
        
        Structural pseudo selectors 
        
        
        :root 
        The element that is the root of the document. In HTML, this is the html element 
        :root 
        
        
        :nth-child(an+b) 
        elements that have an+b-1 siblings before it in the document tree, for any positive integer or zero value of n, and has a parent element. For values of a and b greater than zero, this effectively divides the element's children into groups of a elements (the last group taking the remainder), and selecting the bth element of each group. For example, this allows the selectors to address every other row in a table, and could be used to alternate the color of paragraph text in a cycle of four. The a and b values must be integers (positive, negative, or zero). The index of the first child of an element is 1. In addition to this, :nth-child() can take odd and even as arguments instead. odd has the same signification as 2n+1, and even has the same signification as 2n. 
        tr:nth-child(2n+1) finds every odd row of a table. :nth-child(10n-1) the 9th, 19th, 29th, etc, element. li:nth-child(5) the 5h li 
        
        
        :nth-last-child(an+b) 
        elements that have an+b-1 siblings after it in the document tree. Otherwise like :nth-child() 
        tr:nth-last-child(-n+2) the last two rows of a table 
        
        
        :nth-of-type(an+b) 
        pseudo-class notation represents an element that has an+b-1 siblings with the same expanded element name before it in the document tree, for any zero or positive integer value of n, and has a parent element 
        img:nth-of-type(2n+1) 
        
        
        :nth-last-of-type(an+b) 
        pseudo-class notation represents an element that has an+b-1 siblings with the same expanded element name after it in the document tree, for any zero or positive integer value of n, and has a parent element 
        img:nth-last-of-type(2n+1) 
        
        
        :first-child 
        elements that are the first child of some other element. 
        div {@literal >} p:first-child 
        
        
        :last-child 
        elements that are the last child of some other element. 
        ol {@literal >} li:last-child 
        
        
        :first-of-type 
        elements that are the first sibling of its type in the list of children of its parent element 
        dl dt:first-of-type 
        
        
        :last-of-type 
        elements that are the last sibling of its type in the list of children of its parent element 
        tr {@literal >} td:last-of-type 
        
        
        :only-child 
        elements that have a parent element and whose parent element 
           hasve 
         have no other element children 
         
        
        
        :only-of-type 
         an element that has a parent element and whose parent element has no other element children with the same expanded element name 
         
        
        
        :empty 
        elements that have no children at all 
         
        
       
      @author Jonathan Hedley, jonathan@hedley.net @see Element#select(String)

Pattern	Matches	Example
`*`	any element	`*`
`tag`	elements with the given tag name	`div`
`*\|E`	elements of type E in any namespace ns	`*\|name` finds elements
`ns\|E`	elements of type E in the namespace ns	`fb\|name` finds elements
`#id`	elements with attribute ID of "id"	`div#wrap`, `#logo`
`.class`	elements with a class name of "class"	`div.left`, `.result`
`[attr]`	elements with an attribute named "attr" (with any value)	`a[href]`, `[title]`
`[^attrPrefix]`	elements with an attribute name starting with "attrPrefix". Use to find elements with HTML5 datasets	`[^data-]`, `div[^data-]`
`[attr=val]`	elements with an attribute named "attr", and value equal to "val"	`img[width=500]`, `a[rel=nofollow]`
`[attr="val"]`	elements with an attribute named "attr", and value equal to "val"	`span[hello="Cleveland"][goodbye="Columbus"]`, `a[rel="nofollow"]`
`[attr^=valPrefix]`	elements with an attribute named "attr", and value starting with "valPrefix"	`a[href^=http:]`
`[attr$=valSuffix]`	elements with an attribute named "attr", and value ending with "valSuffix"	`img[src$=.png]`
`[attr*=valContaining]`	elements with an attribute named "attr", and value containing "valContaining"	`a[href*=/search/]`
`[attr~=regex]`	elements with an attribute named "attr", and value matching the regular expression	`img[src~=(?i)\\.(png\|jpe?g)]`
	The above may be combined in any order	`div.header[title]`
Combinators
`E F`	an F element descended from an E element	`div a`, `.logo h1`
`E {@literal >} F`	an F direct child of E	`ol {@literal >} li`
`E + F`	an F element immediately preceded by sibling E	`li + li`, `div.head + div`
`E ~ F`	an F element preceded by sibling E	`h1 ~ p`
`E, F, G`	all matching elements E, F, or G	`a[href], div, h3`
Pseudo selectors
`:lt(n)`	elements whose sibling index is less than n	`td:lt(3)` finds the first 3 cells of each row
`:gt(n)`	elements whose sibling index is greater than n	`td:gt(1)` finds cells after skipping the first two
`:eq(n)`	elements whose sibling index is equal to n	`td:eq(0)` finds the first cell of each row
`:has(selector)`	elements that contains at least one element matching the selector	`div:has(p)` finds ~~divs~~ `div`s that contain `p` elements. `div:has(>` `a)` selects `div` elements that have at least one direct child `a` element.
`:not(selector)`	elements that do not match the selector. See also `Elements.not(String)`	`div:not(.logo)` finds all divs that do not have the "logo" class. `div:not(:has(div))` finds divs that do not contain divs.
`:contains(text)`	elements that contains the specified text. The search is case insensitive. The text may appear in the found element, or any of its descendants.	`p:contains(jsoup)` finds p elements containing the text "jsoup".
`:matches(regex)`	elements whose text matches the specified regular expression. The text may appear in the found element, or any of its descendants.	`td:matches(\\d+)` finds table cells containing digits. `div:matches((?i)login)` finds divs containing the text, case insensitively.
`:containsOwn(text)`	elements that directly contain the specified text. The search is case insensitive. The text must appear in the found element, not any of its descendants.	`p:containsOwn(jsoup)` finds p elements with own text "jsoup".
`:matchesOwn(regex)`	elements whose own text matches the specified regular expression. The text must appear in the found element, not any of its descendants.	`td:matchesOwn(\\d+)` finds table cells directly containing digits. `div:matchesOwn((?i)login)` finds divs containing the text, case insensitively.
`:containsData(data)`	elements that contains the specified data. The contents of {@code script} and {@code style} elements, and {@code comment} nodes (etc) are considered data nodes, not text nodes. The search is case insensitive. The data may appear in the found element, or any of its descendants.	`script:contains(jsoup)` finds script elements containing the data "jsoup".
	The above may be combined in any order and with other selectors	`.light:contains(name):eq(0)`
`:matchText`	treats text nodes as elements, and so allows you to match against and select text nodes. Note that using this selector will modify the DOM, so you may want to {@code clone} your document before using.	{@code p:matchText:firstChild} with input {@code One Two } will return one `com.itextpdf.styledxmlparser.jsoup.nodes.PseudoTextElement` with text "{@code One}".
Structural pseudo selectors
`:root`	The element that is the root of the document. In HTML, this is the `html` element	`:root`
`:nth-child(an+b)`	elements that have `an+b-1` siblings before it in the document tree, for any positive integer or zero value of `n`, and has a parent element. For values of `a` and `b` greater than zero, this effectively divides the element's children into groups of a elements (the last group taking the remainder), and selecting the bth element of each group. For example, this allows the selectors to address every other row in a table, and could be used to alternate the color of paragraph text in a cycle of four. The `a` and `b` values must be integers (positive, negative, or zero). The index of the first child of an element is 1. In addition to this, `:nth-child()` can take `odd` and `even` as arguments instead. `odd` has the same signification as `2n+1`, and `even` has the same signification as `2n`.	`tr:nth-child(2n+1)` finds every odd row of a table. `:nth-child(10n-1)` the 9th, 19th, 29th, etc, element. `li:nth-child(5)` the 5h li
`:nth-last-child(an+b)`	elements that have `an+b-1` siblings after it in the document tree. Otherwise like `:nth-child()`	`tr:nth-last-child(-n+2)` the last two rows of a table
`:nth-of-type(an+b)`	pseudo-class notation represents an element that has `an+b-1` siblings with the same expanded element name before it in the document tree, for any zero or positive integer value of n, and has a parent element	`img:nth-of-type(2n+1)`
`:nth-last-of-type(an+b)`	pseudo-class notation represents an element that has `an+b-1` siblings with the same expanded element name after it in the document tree, for any zero or positive integer value of n, and has a parent element	`img:nth-last-of-type(2n+1)`
`:first-child`	elements that are the first child of some other element.	`div {@literal >} p:first-child`
`:last-child`	elements that are the last child of some other element.	`ol {@literal >} li:last-child`
`:first-of-type`	elements that are the first sibling of its type in the list of children of its parent element	`dl dt:first-of-type`
`:last-of-type`	elements that are the last sibling of its type in the list of children of its parent element	`tr {@literal >} td:last-of-type`
`:only-child`	elements that have a parent element and whose parent element ~~hasve~~ have no other element children
`:only-of-type`	an element that has a parent element and whose parent element has no other element children with the same expanded element name
`:empty`	elements that have no children at all