Java Element.getPreviousSibling方法代码示例

import org.w3c.dom.Element; //导入方法依赖的package包/类
public static boolean hasSiblingBefore(Element element) {
    Node sibling = element.getPreviousSibling();
    while (sibling != null) {
        if (sibling.getNodeType() == Node.ELEMENT_NODE) {
            return true;
        }
        sibling = sibling.getPreviousSibling();
    }
    return false;
}
 

import org.w3c.dom.Element; //导入方法依赖的package包/类
public static boolean hasSameTypeBefore(Element element) {
    Node sibling = element.getPreviousSibling();
    while (sibling != null) {
        if (sibling.getNodeType() == Node.ELEMENT_NODE) {
            if (isSameType(element, (Element)sibling)) {
                return true;
            }
        }
        sibling = sibling.getPreviousSibling();
    }
    return false;
}
 

import org.w3c.dom.Element; //导入方法依赖的package包/类
public static int countSiblingsBefore(Element element) {
    int count = 0;
    Node sibling = element.getPreviousSibling();
    while (sibling != null) {
        if (sibling.getNodeType() == Node.ELEMENT_NODE) {
            ++count;
        }
        sibling = sibling.getPreviousSibling();
    }
    return count;
}
 

import org.w3c.dom.Element; //导入方法依赖的package包/类
public static int countSameTypeBefore(Element element) {
    int count = 0;
    Node sibling = element.getPreviousSibling();
    while (sibling != null) {
        if (sibling.getNodeType() == Node.ELEMENT_NODE) {
            if (isSameType(element, (Element)sibling)) {
                ++count;
            }
        }
        sibling = sibling.getPreviousSibling();
    }
    return count;
}
 

import org.w3c.dom.Element; //导入方法依赖的package包/类
@Override
public boolean test(Element start, Element root) {
    Node sibling = start.getPreviousSibling();
    while (sibling != null) {
        if (sibling.getNodeType() == Node.ELEMENT_NODE) {
            Element element = (Element)sibling;
            if (test(element) && testPrevious(element, root)) {
                return true;
            }
        }
        sibling = sibling.getPreviousSibling();
    }
    return false;
}
 

import org.w3c.dom.Element; //导入方法依赖的package包/类
@Override
public boolean test(Element start, Element root) {
    Node sibling = start.getPreviousSibling();
    while (sibling != null) {
        if (sibling.getNodeType() == Node.ELEMENT_NODE) {
            Element element = (Element)sibling;
            if (test(element) && testPrevious(element, root)) {
                return true;
            }
            return false;
        }
        sibling = sibling.getPreviousSibling();
    }
    return false;
}
 

import org.w3c.dom.Element; //导入方法依赖的package包/类
private boolean newlineBeforeElementOpen(Element element, int depth) {
    if (hasBlankLineAbove()) {
        return false;
    }

    if (mPrefs.removeEmptyLines || depth <= 0) {
        return false;
    }

    if (isMarkupElement(element)) {
        return false;
    }

    // See if this element should be separated from the previous element.
    // This is the case if we are not compressing whitespace (checked above),
    // or if we are not immediately following a comment (in which case the
    // newline would have been added above it), or if we are not in a formatting
    // style where
    if (mStyle == XmlFormatStyle.LAYOUT) {
        // In layouts we always separate elements
        return true;
    }

    if (mStyle == XmlFormatStyle.MANIFEST || mStyle == XmlFormatStyle.RESOURCE
            || mStyle == XmlFormatStyle.FILE) {
        Node curr = element.getPreviousSibling();

        // <style> elements are traditionally separated unless it follows a comment
        if (TAG_STYLE.equals(element.getTagName())) {
            if (curr == null
                    || curr.getNodeType() == Node.ELEMENT_NODE
                    || (curr.getNodeType() == Node.TEXT_NODE
                    && curr.getNodeValue().trim().isEmpty()
                    && (curr.getPreviousSibling() == null
                    || curr.getPreviousSibling().getNodeType()
                    == Node.ELEMENT_NODE))) {
                return true;
            }
        }

        // In all other styles, we separate elements if they have a different tag than
        // the previous one (but we don't insert a newline inside tags)
        while (curr != null) {
            short nodeType = curr.getNodeType();
            if (nodeType == Node.ELEMENT_NODE) {
                Element sibling = (Element) curr;
                if (!element.getTagName().equals(sibling.getTagName())) {
                    return true;
                }
                break;
            } else if (nodeType == Node.TEXT_NODE) {
                String text = curr.getNodeValue();
                if (!text.trim().isEmpty()) {
                    break;
                }
                // If there is just whitespace, continue looking for a previous sibling
            } else {
                // Any other previous node type, such as a comment, means we don't
                // continue looking: this element should not be separated
                break;
            }
            curr = curr.getPreviousSibling();
        }
        if (curr == null && depth <= 1) {
            // Insert new line inside tag if it's the first element inside the root tag
            return true;
        }

        return false;
    }

    return false;
}