Java Validate.notEmpty方法代码示例

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
/**
 Add an enforced attribute to a tag. An enforced attribute will always be added to the element. If the element
 already has the attribute set, it will be overridden.
 <p>
 E.g.: <code>addEnforcedAttribute("a", "rel", "nofollow")</code> will make all <code>a</code> tags output as
 <code>&lt;a href="..." rel="nofollow"&gt;</code>
 </p>

 @param tag   The tag the enforced attribute is for. The tag will be added to the allowed tag list if necessary.
 @param key   The attribute key
 @param value The enforced attribute value
 @return this (for chaining)
 */
public Whitelist addEnforcedAttribute(String tag, String key, String value) {
    Validate.notEmpty(tag);
    Validate.notEmpty(key);
    Validate.notEmpty(value);

    TagName tagName = TagName.valueOf(tag);
    if (!tagNames.contains(tagName))
        tagNames.add(tagName);
    AttributeKey attrKey = AttributeKey.valueOf(key);
    AttributeValue attrVal = AttributeValue.valueOf(value);

    if (enforcedAttributes.containsKey(tagName)) {
        enforcedAttributes.get(tagName).put(attrKey, attrVal);
    } else {
        Map<AttributeKey, AttributeValue> attrMap = new HashMap<AttributeKey, AttributeValue>();
        attrMap.put(attrKey, attrVal);
        enforcedAttributes.put(tagName, attrMap);
    }
    return this;
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
/**
 * Get a Tag by name. If not previously defined (unknown), returns a new generic tag, that can do anything.
 * <p>
 * Pre-defined tags (P, DIV etc) will be ==, but unknown tags are not registered and will only .equals().
 * </p>
 * 
 * @param tagName Name of tag, e.g. "p". Case insensitive.
 * @return The tag, either defined or new generic.
 */
public static Tag valueOf(String tagName) {
    Validate.notNull(tagName);
    Tag tag = tags.get(tagName);

    if (tag == null) {
        tagName = tagName.trim().toLowerCase();
        Validate.notEmpty(tagName);
        tag = tags.get(tagName);

        if (tag == null) {
            // not defined: create default; go anywhere, do anything! (incl be inside a <p>)
            tag = new Tag(tagName);
            tag.isBlock = false;
            tag.canContainBlock = true;
        }
    }
    return tag;
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
/**
 * Find elements matching selector.
 *
 * @param query CSS selector
 * @param roots root elements to descend into
 * @return matching elements, empty if none
 */
public static Elements select(String query, Iterable<Element> roots) {
    Validate.notEmpty(query);
    Validate.notNull(roots);
    Evaluator evaluator = QueryParser.parse(query);
    ArrayList<Element> elements = new ArrayList<Element>();
    IdentityHashMap<Element, Boolean> seenElements = new IdentityHashMap<Element, Boolean>();
    // dedupe elements by identity, not equality

    for (Element root : roots) {
        final Elements found = select(evaluator, root);
        for (Element el : found) {
            if (!seenElements.containsKey(el)) {
                elements.add(el);
                seenElements.put(el, Boolean.TRUE);
            }
        }
    }
    return new Elements(elements);
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
/**
 Add a list of allowed attributes to a tag. (If an attribute is not allowed on an element, it will be removed.)
 <p>
 E.g.: <code>addAttributes("a", "href", "class")</code> allows <code>href</code> and <code>class</code> attributes
 on <code>a</code> tags.
 </p>
 <p>
 To make an attribute valid for <b>all tags</b>, use the pseudo tag <code>:all</code>, e.g.
 <code>addAttributes(":all", "class")</code>.
 </p>

 @param tag  The tag the attributes are for. The tag will be added to the allowed tag list if necessary.
 @param keys List of valid attributes for the tag
 @return this (for chaining)
 */
public Whitelist addAttributes(String tag, String... keys) {
    Validate.notEmpty(tag);
    Validate.notNull(keys);
    Validate.isTrue(keys.length > 0, "No attributes supplied.");

    TagName tagName = TagName.valueOf(tag);
    if (!tagNames.contains(tagName))
        tagNames.add(tagName);
    Set<AttributeKey> attributeSet = new HashSet<AttributeKey>();
    for (String key : keys) {
        Validate.notEmpty(key);
        attributeSet.add(AttributeKey.valueOf(key));
    }
    if (attributes.containsKey(tagName)) {
        Set<AttributeKey> currentSet = attributes.get(tagName);
        currentSet.addAll(attributeSet);
    } else {
        attributes.put(tagName, attributeSet);
    }
    return this;
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
private void byTag() {
    String tagName = tq.consumeElementSelector();
    Validate.notEmpty(tagName);

    // namespaces: if element name is "abc:def", selector must be "abc|def", so flip:
    if (tagName.contains("|"))
        tagName = tagName.replace("|", ":");

    evals.add(new Evaluator.Tag(tagName.trim().toLowerCase()));
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
private void byAttribute() {
    TokenQueue cq = new TokenQueue(tq.chompBalanced('[', ']')); // content queue
    String key = cq.consumeToAny(AttributeEvals); // eq, not, start, end, contain, match, (no val)
    Validate.notEmpty(key);
    cq.consumeWhitespace();

    if (cq.isEmpty()) {
        if (key.startsWith("^"))
            evals.add(new Evaluator.AttributeStarting(key.substring(1)));
        else
            evals.add(new Evaluator.Attribute(key));
    } else {
        if (cq.matchChomp("="))
            evals.add(new Evaluator.AttributeWithValue(key, cq.remainder()));

        else if (cq.matchChomp("!="))
            evals.add(new Evaluator.AttributeWithValueNot(key, cq.remainder()));

        else if (cq.matchChomp("^="))
            evals.add(new Evaluator.AttributeWithValueStarting(key, cq.remainder()));

        else if (cq.matchChomp("$="))
            evals.add(new Evaluator.AttributeWithValueEnding(key, cq.remainder()));

        else if (cq.matchChomp("*="))
            evals.add(new Evaluator.AttributeWithValueContaining(key, cq.remainder()));

        else if (cq.matchChomp("~="))
            evals.add(new Evaluator.AttributeWithValueMatching(key, Pattern.compile(cq.remainder())));
        else
            throw new Selector.SelectorParseException(
                    "Could not parse attribute query '%s': unexpected token at '%s'", query, cq.remainder());
    }
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
private void contains(boolean own) {
    tq.consume(own ? ":containsOwn" : ":contains");
    String searchText = TokenQueue.unescape(tq.chompBalanced('(', ')'));
    Validate.notEmpty(searchText, ":contains(text) query must not be empty");
    if (own)
        evals.add(new Evaluator.ContainsOwnText(searchText));
    else
        evals.add(new Evaluator.ContainsText(searchText));
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
private void matches(boolean own) {
    tq.consume(own ? ":matchesOwn" : ":matches");
    String regex = tq.chompBalanced('(', ')'); // don't unescape, as regex bits will be escaped
    Validate.notEmpty(regex, ":matches(regex) query must not be empty");

    if (own)
        evals.add(new Evaluator.MatchesOwn(Pattern.compile(regex)));
    else
        evals.add(new Evaluator.Matches(Pattern.compile(regex)));
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
private void not() {
    tq.consume(":not");
    String subQuery = tq.chompBalanced('(', ')');
    Validate.notEmpty(subQuery, ":not(selector) subselect must not be empty");

    evals.add(new StructuralEvaluator.Not(parse(subQuery)));
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
/**
 * Find elements that have an attribute name starting with the supplied prefix. Use {@code data-} to find elements
 * that have HTML5 datasets.
 * @param keyPrefix name prefix of the attribute e.g. {@code data-}
 * @return elements that have attribute names that start with with the prefix, empty if none.
 */
public Elements getElementsByAttributeStarting(String keyPrefix) {
    Validate.notEmpty(keyPrefix);
    keyPrefix = keyPrefix.trim().toLowerCase();

    return Collector.collect(new Evaluator.AttributeStarting(keyPrefix), this);
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
/**
 Add allowed URL protocols for an element's URL attribute. This restricts the possible values of the attribute to
 URLs with the defined protocol.
 <p>
 E.g.: <code>addProtocols("a", "href", "ftp", "http", "https")</code>
 </p>
 <p>
 To allow a link to an in-page URL anchor (i.e. <code>&lt;a href="#anchor"&gt;</code>, add a <code>#</code>:<br>
 E.g.: <code>addProtocols("a", "href", "#")</code>
 </p>

 @param tag       Tag the URL protocol is for
 @param key       Attribute key
 @param protocols List of valid protocols
 @return this, for chaining
 */
public Whitelist addProtocols(String tag, String key, String... protocols) {
    Validate.notEmpty(tag);
    Validate.notEmpty(key);
    Validate.notNull(protocols);

    TagName tagName = TagName.valueOf(tag);
    AttributeKey attrKey = AttributeKey.valueOf(key);
    Map<AttributeKey, Set<Protocol>> attrMap;
    Set<Protocol> protSet;

    if (this.protocols.containsKey(tagName)) {
        attrMap = this.protocols.get(tagName);
    } else {
        attrMap = new HashMap<AttributeKey, Set<Protocol>>();
        this.protocols.put(tagName, attrMap);
    }
    if (attrMap.containsKey(attrKey)) {
        protSet = attrMap.get(attrKey);
    } else {
        protSet = new HashSet<Protocol>();
        attrMap.put(attrKey, protSet);
    }
    for (String protocol : protocols) {
        Validate.notEmpty(protocol);
        Protocol prot = Protocol.valueOf(protocol);
        protSet.add(prot);
    }
    return this;
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
/**
 * Find elements that have a named attribute set. Case insensitive.
 *
 * @param key name of the attribute, e.g. {@code href}
 * @return elements that have this attribute, empty if none
 */
public Elements getElementsByAttribute(String key) {
    Validate.notEmpty(key);
    key = key.trim().toLowerCase();

    return Collector.collect(new Evaluator.Attribute(key), this);
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
public AttributeKeyPair(String key, String value) {
    Validate.notEmpty(key);
    Validate.notEmpty(value);

    this.key = key.trim().toLowerCase();
    if (value.startsWith("\"") && value.endsWith("\"")
            || value.startsWith("'") && value.endsWith("'")) {
        value = value.substring(1, value.length()-1);
    }
    this.value = value.trim().toLowerCase();
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
/**
 Remove an attribute by key.
 @param key attribute key to remove
 */
public void remove(String key) {
    Validate.notEmpty(key);
    if (attributes == null)
        return;
    attributes.remove(key.toLowerCase());
}
 

import org.jsoup.helper.Validate; //导入方法依赖的package包/类
/**
 * Find an element by ID, including or under this element.
 * <p>
 * Note that this finds the first matching ID, starting with this element. If you search down from a different
 * starting point, it is possible to find a different element by ID. For unique element by ID within a Document,
 * use {@link Document#getElementById(String)}
 * @param id The ID to search for.
 * @return The first matching element by ID, starting with this element, or null if none found.
 */
public Element getElementById(String id) {
    Validate.notEmpty(id);
    
    Elements elements = Collector.collect(new Evaluator.Id(id), this);
    if (elements.size() > 0)
        return elements.get(0);
    else
        return null;
}