Java Element类代码示例

import org.w3c.dom.Element; //导入依赖的package包/类
public KalturaRule(Element node) throws KalturaApiException {
    NodeList childNodes = node.getChildNodes();
    for (int i = 0; i < childNodes.getLength(); i++) {
        Node aNode = childNodes.item(i);
        String nodeName = aNode.getNodeName();
        String txt = aNode.getTextContent();
        if (nodeName.equals("message")) {
            this.message = ParseUtils.parseString(txt);
            continue;
        } else if (nodeName.equals("actions")) {
            this.actions = ParseUtils.parseArray(KalturaAccessControlAction.class, aNode);
            continue;
        } else if (nodeName.equals("conditions")) {
            this.conditions = ParseUtils.parseArray(KalturaCondition.class, aNode);
            continue;
        } else if (nodeName.equals("contexts")) {
            this.contexts = ParseUtils.parseArray(KalturaAccessControlContextTypeHolder.class, aNode);
            continue;
        } else if (nodeName.equals("stopProcessing")) {
            this.stopProcessing = ParseUtils.parseBool(txt);
            continue;
        } 
    }
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
/**
 * tableRule tag:
 * <tableRule name="sharding-by-month">
 * <rule>
 * <columns>create_date</columns>
 * <algorithm>partbymonth</algorithm>
 * </rule>
 * </tableRule>
 *
 * @param root
 * @throws SQLSyntaxErrorException
 */
private void loadTableRules(Element root) throws SQLSyntaxErrorException {
    NodeList list = root.getElementsByTagName("tableRule");
    for (int i = 0, n = list.getLength(); i < n; ++i) {
        Node node = list.item(i);
        if (node instanceof Element) {
            Element e = (Element) node;
            String name = e.getAttribute("name");
            if (StringUtil.isEmpty(name)) {
                throw new ConfigException("name is null or empty");
            }
            if (tableRules.containsKey(name)) {
                throw new ConfigException("table rule " + name + " duplicated!");
            }
            NodeList ruleNodes = e.getElementsByTagName("rule");
            int length = ruleNodes.getLength();
            if (length > 1) {
                throw new ConfigException("only one rule can defined :" + name);
            }
            //rule has only one element now. Maybe it will not contains one rule in feature
            //RuleConfig:rule->function
            RuleConfig rule = loadRule((Element) ruleNodes.item(0));
            tableRules.put(name, new TableRuleConfig(name, rule));
        }
    }
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
public static Element nextElement(Iterator iter) {
    while (iter.hasNext()) {
        Node n = (Node) iter.next();
        if (n instanceof Text) {
            Text t = (Text) n;
            if (t.getData().trim().length() == 0)
                continue;
            fail("parsing.nonWhitespaceTextFound", t.getData().trim());
        }
        if (n instanceof Comment)
            continue;
        if (!(n instanceof Element))
            fail("parsing.elementExpected");
        return (Element) n;
    }

    return null;
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
/**  Start a session with Kaltura's server.   The result KS is the session key that
you should pass to all services that requires a ticket.     */
 public String start(String secret, String userId, KalturaSessionType type, int partnerId, int expiry, String privileges) throws KalturaApiException {
     KalturaParams kparams = new KalturaParams();
     kparams.add("secret", secret);
     kparams.add("userId", userId);
     kparams.add("type", type);
     kparams.add("partnerId", partnerId);
     kparams.add("expiry", expiry);
     kparams.add("privileges", privileges);
     this.kalturaClient.queueServiceCall("session", "start", kparams);
     if (this.kalturaClient.isMultiRequest())
         return null;
     Element resultXmlElement = this.kalturaClient.doQueue();
     String resultText = resultXmlElement.getTextContent();
     return ParseUtils.parseString(resultText);
 }
 

import org.w3c.dom.Element; //导入依赖的package包/类
@Override
protected void writeDefinitionToXML(Element typeElement) {

	Element childTypesElement = XMLTools.addTag(typeElement, ELEMENT_CHILD_TYPES);
	for (ParameterType type : types) {
		Element childTypeElement = XMLTools.addTag(childTypesElement, ELEMENT_CHILD_TYPE);
		type.writeDefinitionToXML(childTypeElement);
	}

	// now default list
	Element defaultEntriesElement = XMLTools.addTag(typeElement, ELEMENT_DEFAULT_ENTRIES);
	for (Object defaultValue : defaultValues) {
		Element defaultEntryElement = XMLTools.addTag(defaultEntriesElement, ELEMENT_DEFAULT_ENTRY);
		if (defaultValue != null && defaultValue instanceof String) {
			defaultEntryElement.setTextContent(defaultValue.toString());
		} else {
			defaultEntriesElement.setAttribute(ATTRIBUTE_IS_NULL, "true");
		}
	}
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
public static Map<String,Object> getMapFromXML(String xmlString) throws ParserConfigurationException, IOException, SAXException {

        //这里用Dom的方式解析回包的最主要目的是防止API新增回包字段
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        InputStream is =  IOUtils.toInputStream(xmlString);
        Document document = builder.parse(is);
        //获取到document里面的全部结点
        NodeList allNodes = document.getFirstChild().getChildNodes();
        Node node;
        Map<String, Object> map = new HashMap<String, Object>();
        int i=0;
        while (i < allNodes.getLength()) {
            node = allNodes.item(i);
            if(node instanceof Element){
                map.put(node.getNodeName(),node.getTextContent());
            }
            i++;
        }
        return map;

    }
 

import org.w3c.dom.Element; //导入依赖的package包/类
/**
 * @param root
 */
public void ExportCustomProperties(Document doc)
{
	Element eForm = doc.getDocumentElement() ;
	if (!m_csCustomOnloadMethod.equals(""))
	{
		eForm.setAttribute("customOnload", m_csCustomOnloadMethod) ;
	}
	if (!m_csCustomSubmitMethod.equals(""))
	{
		eForm.setAttribute("customSubmit", m_csCustomSubmitMethod) ;
	}
	if (!m_csDefaultCursor.equals(""))
	{
		eForm.setAttribute("defaultCursor", m_csDefaultCursor) ;
	}
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
public KalturaCountryRestriction(Element node) throws KalturaApiException {
    super(node);
    NodeList childNodes = node.getChildNodes();
    for (int i = 0; i < childNodes.getLength(); i++) {
        Node aNode = childNodes.item(i);
        String nodeName = aNode.getNodeName();
        String txt = aNode.getTextContent();
        if (nodeName.equals("countryRestrictionType")) {
            this.countryRestrictionType = KalturaCountryRestrictionType.get(ParseUtils.parseInt(txt));
            continue;
        } else if (nodeName.equals("countryList")) {
            this.countryList = ParseUtils.parseString(txt);
            continue;
        } 
    }
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
public KalturaConversionAttribute(Element node) throws KalturaApiException {
    NodeList childNodes = node.getChildNodes();
    for (int i = 0; i < childNodes.getLength(); i++) {
        Node aNode = childNodes.item(i);
        String nodeName = aNode.getNodeName();
        String txt = aNode.getTextContent();
        if (nodeName.equals("flavorParamsId")) {
            this.flavorParamsId = ParseUtils.parseInt(txt);
            continue;
        } else if (nodeName.equals("name")) {
            this.name = ParseUtils.parseString(txt);
            continue;
        } else if (nodeName.equals("value")) {
            this.value = ParseUtils.parseString(txt);
            continue;
        } 
    }
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
private Schema visitRoot(Node root, String nameSchema){
	Schema s = new Schema(nameSchema);
	types = new SetAssociativeArray();
	dummyNr = 0;
	//process the complexType nodes under the schema node
	NodeList children = root.getChildNodes();
	int nr=children.getLength();
	for(int j=0; j<nr; j++){
		if (children.item(j).getNodeName().equalsIgnoreCase("xs:complexType")){
			Node nodeCT = children.item(j);
			String name = getAttr("name",nodeCT);
			vtools.dataModel.schema.Element eCT = processComplexTypeNode(nodeCT,name,false);
			types.add(eCT.getLabel(), eCT.getType().clone());
		}	
	}
	//process the element nodes under the schema node
	for(int j=0; j<nr; j++){
		if (children.item(j).getNodeName().equalsIgnoreCase("xs:element")){
			vtools.dataModel.schema.Element elem = processElementNode(children.item(j));
			s.addRootElement(elem);
		}
	}
	
	return s;
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
/**
 * Build single metadata resolver.
 *
 * @param metadataFilterChain the metadata filters chained together
 * @param resource the resource
 * @param document the xml document to parse
 * @return list of resolved metadata from resources.
 * @throws IOException the iO exception
 */
private List<MetadataResolver> buildSingleMetadataResolver(final MetadataFilter metadataFilterChain,
                                         final Resource resource, final Document document) throws IOException {
    final List<MetadataResolver> resolvers = new ArrayList<>();
    final Element metadataRoot = document.getDocumentElement();
    final DOMMetadataResolver metadataProvider = new DOMMetadataResolver(metadataRoot);

    metadataProvider.setParserPool(this.configBean.getParserPool());
    metadataProvider.setFailFastInitialization(true);
    metadataProvider.setRequireValidMetadata(this.requireValidMetadata);
    metadataProvider.setId(metadataProvider.getClass().getCanonicalName());
    if (metadataFilterChain != null) {
        metadataProvider.setMetadataFilter(metadataFilterChain);
    }
    logger.debug("Initializing metadata resolver for [{}]", resource.getURL());

    try {
        metadataProvider.initialize();
    } catch (final ComponentInitializationException ex) {
        logger.warn("Could not initialize metadata resolver. Resource will be ignored", ex);
    }
    resolvers.add(metadataProvider);
    return resolvers;
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
private void unmarshalParams(Element paramsElem) {
    String prefixListAttr = paramsElem.getAttributeNS(null, "PrefixList");
    this.inclusiveNamespaces = prefixListAttr;
    int begin = 0;
    int end = prefixListAttr.indexOf(' ');
    List<String> prefixList = new ArrayList<String>();
    while (end != -1) {
        prefixList.add(prefixListAttr.substring(begin, end));
        begin = end + 1;
        end = prefixListAttr.indexOf(' ', begin);
    }
    if (begin <= prefixListAttr.length()) {
        prefixList.add(prefixListAttr.substring(begin));
    }
    this.params = new ExcC14NParameterSpec(prefixList);
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
@Override
public Element parseModel(Document doc){
	Element process=doc.createElement("process");
	if(StringHelper.isNotEmpty(name)){
		process.setAttribute("name", name);
	}
	process.setAttribute("xmlns", "http://jbpm.org/4.4/jpdl");
	if(StringHelper.isNotEmpty(key)){
		process.setAttribute("key", key);
	}
	if(StringHelper.isNotEmpty(version)){
		process.setAttribute("version", version);
	}
	if(StringHelper.isNotEmpty(description)){
		Element desc=doc.createElement("description");
		desc.setTextContent(description);
		process.appendChild(desc);
	}
	return process;
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
/**
 * Find all direct child elements of an element.
 * More useful than {@link Element#getElementsByTagNameNS} because it does
 * not recurse into recursive child elements.
 * Children which are all-whitespace text nodes or comments are ignored; others cause
 * an exception to be thrown.
 * @param parent a parent element in a DOM tree
 * @return a list of direct child elements (may be empty)
 * @throws IllegalArgumentException if there are non-element children besides whitespace
 */
static List<Element> findSubElements(Element parent) throws IllegalArgumentException {
    NodeList l = parent.getChildNodes();
    List<Element> elements = new ArrayList<>(l.getLength());
    for (int i = 0; i < l.getLength(); i++) {
        Node n = l.item(i);
        if (n.getNodeType() == Node.ELEMENT_NODE) {
            elements.add((Element)n);
        } else if (n.getNodeType() == Node.TEXT_NODE) {
            String text = ((Text)n).getNodeValue();
            if (text.trim().length() > 0) {
                throw new IllegalArgumentException("non-ws text encountered in " + parent + ": " + text); // NOI18N
            }
        } else if (n.getNodeType() == Node.COMMENT_NODE) {
            // OK, ignore
        } else {
            throw new IllegalArgumentException("unexpected non-element child of " + parent + ": " + n); // NOI18N
        }
    }
    return elements;
}
 

import org.w3c.dom.Element; //导入依赖的package包/类
private Element createGraphElement(Element root) {
	Element graphEl = doc.createElement("graph");
	root.appendChild(graphEl);

	if (network.getEdgeCount(true) > network.getEdgeCount(false)) {
		graphEl.setAttribute("edgedefault", "directed");
	} else {
		graphEl.setAttribute("edgedefault", "undirected");
	}

	// Create nodes
	createNodes(graphEl);

	// Create edges
	createEdges(graphEl);

	return graphEl;
}