Java Code Examples for org.w3c.dom.Element

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;
        } 
    }
}
 

/**
 * 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));
        }
    }
}
 

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;
}
 

/**  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);
 }
 

@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");
		}
	}
}
 

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;

    }
 

/**
 * @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) ;
	}
}
 

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;
        } 
    }
}
 

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;
        } 
    }
}
 

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;
}
 

/**
 * 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;
}
 

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);
}
 

@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;
}
 

/**
 * 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;
}
 

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;
}
 

ShortcutWizard(AntProjectCookie project, Element target, ShortcutIterator it) {
    this.project = project;
    this.target = target;
    this.it = it;
    it.initialize(this);
    setPanelsAndSettings(it, this);
    setTitle(NbBundle.getMessage(ShortcutWizard.class, "TITLE_wizard"));
    putProperty(WizardDescriptor.PROP_AUTO_WIZARD_STYLE, Boolean.TRUE); // NOI18N
    putProperty(WizardDescriptor.PROP_CONTENT_DISPLAYED, Boolean.TRUE); // NOI18N
    putProperty(WizardDescriptor.PROP_CONTENT_NUMBERED, Boolean.TRUE); // NOI18N
    String desc = target.getAttribute("description"); // NOI18n
    putProperty(PROP_DISPLAY_NAME, desc);
    // XXX deal with toolbar short desc somehow: #39985
    // Need to have another field in toolbar panel, and also patch AntActionInstance
    // to respond to Action.SHORT_DESCRIPTION, presumably as the <description>.
}
 

public static void addConnectionDetailsToDefFile(String filePath, Map<String,String> connDet ){
	Document doc = getXmlDocument(filePath);
	Element newConnection= doc.createElement("DBConnectionDefinition");
	newConnection.appendChild(doc.createElement("connectionName"));
		newConnection.getLastChild().appendChild(doc.createTextNode(connDet.get("CONNECTIONNAME")));
	newConnection.appendChild(doc.createElement("connectionType"));
		newConnection.getLastChild().appendChild(doc.createTextNode(connDet.get("CONNECTIONTYPE")));		
	newConnection.appendChild(doc.createElement("dbType"));
		newConnection.getLastChild().appendChild(doc.createTextNode(connDet.get("DBTYPE")));
	newConnection.appendChild(doc.createElement("serviceName"));
		newConnection.getLastChild().appendChild(doc.createTextNode(connDet.get("SERVICENAME")));
	newConnection.appendChild(doc.createElement("host"));
		newConnection.getLastChild().appendChild(doc.createTextNode(connDet.get("HOST")));
	newConnection.appendChild(doc.createElement("userName"));
		newConnection.getLastChild().appendChild(doc.createTextNode(connDet.get("USERNAME")));
	
	getElementByTagName(doc,"DBConnectionDefinition").getParentNode().appendChild(newConnection); 	
	//getElementByTagName(doc,"ROOT").appendChild(newConnection);	
	storeXmlDocToFile(filePath, doc);		
	showMeTheDoc(newConnection, 1);
}
 

public void testCreateCompletion() throws Exception {
    HintContext c = TestUtil.createCompletion("<fooHERE/>");
    assertHintContext(c, Node.ELEMENT_NODE, "foo", null, "foo");
    assertTrue("right type acc. to instanceof", c instanceof Element);
    c = TestUtil.createCompletion("<foo/>");
    assertNull("no hint here", c);
    c = TestUtil.createCompletion("<foo><barHERE/></foo>");
    assertHintContext(c, Node.ELEMENT_NODE, "bar", null, "bar");
    Node n = c.getParentNode();
    assertEquals("parent is an element", Node.ELEMENT_NODE, n.getNodeType());
    assertEquals("parent is <foo>", "foo", n.getNodeName());
    c = TestUtil.createCompletion("<foo><bar attrHERE='whatever'/></foo>");
    assertHintContext(c, Node.ATTRIBUTE_NODE, "attr", null, "attr");
    Element owner = ((Attr)c).getOwnerElement();
    assertEquals("parent is <bar>", "bar", owner.getNodeName());
    c = TestUtil.createCompletion("<foo><bar attr='somethingHERE'/></foo>");
    assertHintContext(c, Node.ATTRIBUTE_NODE, null, "something", "something");
    owner = ((Attr)c).getOwnerElement();
    assertEquals("parent is <bar>", "bar", owner.getNodeName());
    c = TestUtil.createCompletion("<foo>somethingHERE</foo>");
    assertHintContext(c, Node.TEXT_NODE, null, "something", "something");
    n = c.getParentNode();
    assertEquals("parent is an element", Node.ELEMENT_NODE, n.getNodeType());
    assertEquals("parent is <foo>", "foo", n.getNodeName());
}
 

private List<Element> getAttributeElements(Document doc, String path) {
    Element parent = findPath(doc, path);

    List<Element> attributes = new ArrayList<Element>();

    if (parent != null) {
        for (Element f : getElementChildren(parent)) {
            String tag = f.getTagName();
            if (ATTR.equals(tag)) { // NOI18N
                attributes.add(f);
            }
        }
    }

    return attributes;
}
 

/**
 * @see <a
 * href="http://www.w3.org/TR/2008/REC-ElementTraversal-20081222/#attribute-lastElementChild">
 * Element Traversal Specification</a>
 */
@Override
public final Element getLastElementChild() {
    Node n = getLastChild();
    while (n != null) {
        switch (n.getNodeType()) {
            case Node.ELEMENT_NODE:
                return (Element) n;
            case Node.ENTITY_REFERENCE_NODE:
                final Element e = getLastElementChild(n);
                if (e != null) {
                    return e;
                }
                break;
        }
        n = n.getPreviousSibling();
    }
    return null;
}
 

private String getRobotCoordinateZ(Element info, String tagcoordinate, String tagdimension){
      String valuez = "";        
NodeList coordinateNmElmntLst = info.getElementsByTagName(tagcoordinate);
Node coordinateNode = coordinateNmElmntLst.item(0);
if (coordinateNode.getNodeType() == Node.ELEMENT_NODE){
 Element coorInfo = (Element) coordinateNode;			  			  
 //Obtain information about z coordinate for the current robot 
 NodeList zNmElmntLst = coorInfo.getElementsByTagName(tagdimension);
 Element zNmElmnt = (Element) zNmElmntLst.item(0);
 NodeList zNm = zNmElmnt.getChildNodes();					  
 valuez = ((Node)zNm.item(0)).getNodeValue();				  
}
return valuez;
}
 

private void migrateOperatorRevenueAttribute(Element element) {
    if (!element
            .hasAttribute(BillingShareResultXmlTags.ATTRIBUTE_NAME_OPERATOR_REVENUE)) {
        element.setAttribute(
                BillingShareResultXmlTags.ATTRIBUTE_NAME_OPERATOR_REVENUE,
                "0.00");
    }
}
 

/**  Add new Entry Distribution     */
public KalturaEntryDistribution add(KalturaEntryDistribution entryDistribution) throws KalturaApiException {
    KalturaParams kparams = new KalturaParams();
    kparams.add("entryDistribution", entryDistribution);
    this.kalturaClient.queueServiceCall("contentdistribution_entrydistribution", "add", kparams);
    if (this.kalturaClient.isMultiRequest())
        return null;
    Element resultXmlElement = this.kalturaClient.doQueue();
    return ParseUtils.parseObject(KalturaEntryDistribution.class, resultXmlElement);
}
 

private static Class<?> ensureType(String pType, Element pSource) {
	Class<?> tType = cObjectTypes.get(pType);
	if (tType != null) {
		return tType;
	}
	if (pType.endsWith("_list")) {
		pType = pType.replace("_list", "");
		if (cAsList.containsKey(pType)) {
			tType = Object.class;
		}
	}
	if (pType.endsWith("[]")) {
		pType = pType.replace("[]", "");
	}
	if (tType == null && pType.startsWith("com.")) {
		cObjectTypes.put(pType, tType = find(pType));
	}
	else if (tType == null) {
		int tPos = pType.indexOf(":");
		String tSimpleName = pType.substring(tPos + 1);
		String tNamespace = tPos == -1 ? "" : pType.substring(0, tPos);
		for (Map.Entry<String, String> tPackage : cSearchPackages.entrySet()) {
			if (tNamespace.equals(tPackage.getValue())) {
				tType = find(tPackage.getKey() + "." + tSimpleName);
				if (tType != null) {
					cObjectTypes.put(pType, tType);
					break;
				}
			}
		}
	}
	if (tType == null) {
		error("Type not found: " + pType, pSource);
	}
	return tType;
}
 

public @Override Set<? extends Trigger> annotationProcessingEnabled() {
    Set<Trigger> result = triggerCache;
    if (result != null) {
        return result;
    }
    result = EnumSet.noneOf(Trigger.class);
    if (ap != null) {
        for (Element e : XMLUtil.findSubElements(ap)) {
            if (e.getLocalName().equals(EL_SCAN_TRIGGER)) {
                result.add(Trigger.ON_SCAN);
            } else if (e.getLocalName().equals(EL_EDITOR_TRIGGER)) {
                result.add(Trigger.IN_EDITOR);
            }
        }
    }
    if (result.size() == 1 && result.contains(Trigger.IN_EDITOR)) {
        //Contains only editor-trigger
        //Add required scan-trigger and log
        result.add(Trigger.ON_SCAN);
        LOG.log(
            Level.WARNING, 
            "Project {0} project.xml contains annotation processing editor-trigger only. The scan-trigger is required as well, adding it into the APQ.Result.", //NOI18N
            FileUtil.getFileDisplayName(helper.getProjectDirectory()));
    }
    synchronized (LCK) {
        if (triggerCache == null) {
            triggerCache = result;
        }
    }
    return result;
}
 

private Element makeSolutionElement(Document root) {
	//TODO: non sono compresi i risultati aggregati (quelli che prendo sono giusti?? gli aggregati sono gli ultimi??)
	Element result_element = root.createElement("solutions");
	result_element.setAttribute("ok", "true");
	result_element.setAttribute("solutionMethod", "analytical");
	for (int i = 0; i < stations; i++) {
		Element stationresults_element = (Element) result_element.appendChild(root.createElement("stationresults"));
		stationresults_element.setAttribute("station", this.stationNames[i]);
		for (int j = 0; j < classes; j++) {
			Element classesresults_element = (Element) stationresults_element.appendChild(root.createElement("classresults"));
			classesresults_element.setAttribute("customerclass", classNames[j]);

			Element Q_element = (Element) classesresults_element.appendChild(root.createElement("measure"));
			Q_element.setAttribute("measureType", "Queue length");
			Q_element.setAttribute("successful", "true");
			Q_element.setAttribute("meanValue", Double.toString(this.queueLen[i][j]));

			Element X_element = (Element) classesresults_element.appendChild(root.createElement("measure"));
			X_element.setAttribute("measureType", "Throughput");
			X_element.setAttribute("successful", "true");
			X_element.setAttribute("meanValue", Double.toString(this.throughput[i][j]));

			Element R_element = (Element) classesresults_element.appendChild(root.createElement("measure"));
			R_element.setAttribute("measureType", "Response time");
			R_element.setAttribute("successful", "true");
			R_element.setAttribute("meanValue", Double.toString(this.resTimes[i][j]));

			Element U_element = (Element) classesresults_element.appendChild(root.createElement("measure"));
			U_element.setAttribute("measureType", "Utilization");
			U_element.setAttribute("successful", "true");
			U_element.setAttribute("meanValue", Double.toString(this.util[i][j]));
		}
	}
	return result_element;
}
 

protected void processMetadataToLO(Object o, PropBagEx xml)
{
	PropBagEx element = new PropBagEx((Element) o);
	try
	{
		String xsltName = getProfile().getAttribute("schemaInputTransform"); //$NON-NLS-1$
		if( xsltName != null && !xsltName.isEmpty() )
		{
			xml.append("item/oai", element); //$NON-NLS-1$

			LOGGER.info(CurrentLocale.get(KEY_PFX + "log.transform.before")); //$NON-NLS-1$
			LOGGER.info(xml.toString());

			xml.setXML(transformSchema(xml, xsltName));

			LOGGER.info(CurrentLocale.get(KEY_PFX + "log.transform.after")); //$NON-NLS-1$
			LOGGER.info(xml.toString());
		}
		else
		{
			new OAIDublinCore().processMetadataToLO(element, xml);
		}
	}
	catch( Exception e )
	{
		e.printStackTrace();
		throw new RuntimeException(e);
	}
}
 

/** {@inheritDoc} */
protected void marshallElementContent(XMLObject xmlObject, Element domElement) throws MarshallingException {
    AttributeValueType attributeValue = (AttributeValueType) xmlObject;
    
    if(attributeValue.getValue() != null){
        XMLHelper.appendTextContent(domElement, attributeValue.getValue());
    }
}
 

/**
 * Parses xml from String.
 *
 * @param xml String containing xml.
 * @return XML DOM element.
 */
private static Element parse(String xml) {
    try {
        DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
        return builder.parse(new InputSource(new StringReader(xml))).getDocumentElement();
    }
    catch (Throwable e) {
        throw new IllegalArgumentException("Failed to parse persistence settings:" +
            SystemHelper.LINE_SEPARATOR + xml, e);
    }
}
 

/**
 * Returns the KeyInfo child. If we are in signing mode and the KeyInfo
 * does not exist yet, it is created on demand and added to the Signature.
 * <br>
 * This allows to add arbitrary content to the KeyInfo during signing.
 *
 * @return the KeyInfo object
 */
public KeyInfo getKeyInfo() {
    // check to see if we are signing and if we have to create a keyinfo
    if (this.state == MODE_SIGN && this.keyInfo == null) {

        // create the KeyInfo
        this.keyInfo = new KeyInfo(this.doc);

        // get the Element from KeyInfo
        Element keyInfoElement = this.keyInfo.getElement();
        Element firstObject =
            XMLUtils.selectDsNode(
                this.constructionElement.getFirstChild(), Constants._TAG_OBJECT, 0
            );

        if (firstObject != null) {
            // add it before the object
            this.constructionElement.insertBefore(keyInfoElement, firstObject);
            XMLUtils.addReturnBeforeChild(this.constructionElement, firstObject);
        } else {
            // add it as the last element to the signature
            this.constructionElement.appendChild(keyInfoElement);
            XMLUtils.addReturnToElement(this.constructionElement);
        }
    }

    return this.keyInfo;
}
 

public void marshal(Node parent, String dsPrefix, DOMCryptoContext context)
    throws MarshalException
{
    Document ownerDoc = DOMUtils.getOwnerDocument(parent);

    // create KeyValue element
    Element kvElem = DOMUtils.createElement(ownerDoc, "KeyValue",
                                            XMLSignature.XMLNS, dsPrefix);
    marshalPublicKey(kvElem, ownerDoc, dsPrefix, context);

    parent.appendChild(kvElem);
}
 

@Test
public void run_shouldCallInboundMessageValidatorWithAttributeQuery() throws Exception {
    when(attributeQueryRequestClient.sendQuery(any(Element.class), anyString(), any(SessionId.class), any(URI.class))).thenReturn(matchingServiceResponse);
    Response response = aResponse().build();
    when(elementToResponseTransformer.apply(matchingServiceResponse)).thenReturn(response);

    executeAttributeQueryRequest.execute(sessionId, attributeQueryContainerDto);

    verify(matchingRequestSignatureValidator).validate(attributeQuery, AttributeAuthorityDescriptor.DEFAULT_ELEMENT_NAME);
}
 

/**  Create a new Partner object     */
public KalturaPartner register(KalturaPartner partner, String cmsPassword, int templatePartnerId) throws KalturaApiException {
    KalturaParams kparams = new KalturaParams();
    kparams.add("partner", partner);
    kparams.add("cmsPassword", cmsPassword);
    kparams.add("templatePartnerId", templatePartnerId);
    this.kalturaClient.queueServiceCall("partner", "register", kparams);
    if (this.kalturaClient.isMultiRequest())
        return null;
    Element resultXmlElement = this.kalturaClient.doQueue();
    return ParseUtils.parseObject(KalturaPartner.class, resultXmlElement);
}
 

Element toElement() {
    Element result =
        XMLUtils.createElementInEncryptionSpace(
            contextDocument, EncryptionConstants._TAG_CIPHERDATA
        );
    if (cipherType == VALUE_TYPE) {
        result.appendChild(((CipherValueImpl) cipherValue).toElement());
    } else if (cipherType == REFERENCE_TYPE) {
        result.appendChild(((CipherReferenceImpl) cipherReference).toElement());
    }

    return result;
}
 

/**
 * Extract location information from an Element node, and create a
 * new SimpleLocator object from such information. Returning null means
 * no information can be retrieved from the element.
 */
public SimpleLocator element2Locator(Element e) {
    if (!( e instanceof ElementImpl))
        return null;

    SimpleLocator l = new SimpleLocator();
    return element2Locator(e, l) ? l : null;
}
 

private Target(Target parent, Element src, SCD scd) {
    if(parent==null) {
        this.nextSibling = topLevel;
        topLevel = this;
    } else {
        this.nextSibling = parent.firstChild;
        parent.firstChild = this;
    }
    this.src = src;
    this.scd = scd;
}
 

/** {@inheritDoc} */
protected void marshallAttributes(XMLObject xmlObject, Element domElement) throws MarshallingException {
    Password password = (Password) xmlObject;
    if (!DatatypeHelper.isEmpty(password.getType())) {
        domElement.setAttributeNS(null, Password.TYPE_ATTRIB_NAME, password.getType());
    }
    super.marshallAttributes(xmlObject, domElement);
}
 

/** 
 * Sets the namespace to specific element. 
 * 
 * @param element the element to set 
 * @param namespace the namespace to set 
 * @param schemaLocation the XML schema file location URI 
 */  
public static void setNamespace(Element element, String namespace,  
        String schemaLocation) {  
    element.setAttributeNS(XMLConstants.XMLNS_ATTRIBUTE_NS_URI,  
            XMLConstants.XMLNS_ATTRIBUTE, namespace);  
    element.setAttributeNS(XMLConstants.XMLNS_ATTRIBUTE_NS_URI, XMLNS_XSI,  
            XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI);  
    element.setAttributeNS(XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI,  
            XSI_SCHEMA_LOCATION, schemaLocation);  
}
 

public static int getLine(Element fieldElement) throws ClassCastException {
	int line = -1;
	String fieldName = fieldElement.getAttribute("name");
	if (fieldName.indexOf(Parameter.JavelinField.getName()) != 0)
		throw new ClassCastException("[ComparableFieldElement] The object trying to be compared with is not a ComparableFieldElement.");
	String ln = fieldName.substring(fieldName.indexOf("l", 8)+1);
	line = Integer.parseInt(ln);
	return line;
}
 

private void doPopulateUnapproved(Map<String, ModuleInfo> moduleRATInfo, Element rootElement, XPath path) throws XPathExpressionException {
    NodeList evaluate = (NodeList) path.evaluate("descendant::resource[license-approval/@name=\"false\"]", rootElement, XPathConstants.NODESET);
    for (int i = 0; i < evaluate.getLength(); i++) {
        String resources = relativize(evaluate.item(i).getAttributes().getNamedItem("name").getTextContent());
        String moduleName = getModuleName(resources);
        if (!moduleRATInfo.containsKey(moduleName)) {
            moduleRATInfo.get(NOT_CLUSTER).addUnapproved(resources);
        } else {
            moduleRATInfo.get(moduleName).addUnapproved(resources);
        }
    }
}
 

/** {@inheritDoc} */
protected void marshallElementContent(XMLObject samlObject, Element domElement) throws MarshallingException {
    OrganizationURL url = (OrganizationURL) samlObject;

    if (url.getURL() != null) {
        XMLHelper.appendTextContent(domElement, url.getURL().getLocalString());
    }
}
 

private void doAddItem(Element element, CEntityResourceForm form)
{
	String col = element.getAttribute("col") ;
	String line = element.getAttribute("line") ;
	String length = element.getAttribute("length") ;
	if (col != null && !col.equals(""))
	{
		if (line != null && !line.equals(""))
		{
			if (length != null && !length.equals(""))
			{
				int c = Integer.parseInt(col);
				int l = Integer.parseInt(line) ;
				int s = Integer.parseInt(length) ;
				
				Node n = element.getFirstChild() ;
				while (n.getNodeType() != Node.ELEMENT_NODE)
				{
					n = n.getNextSibling() ;
				}
				if (n != null)
				{
					form.AddItem(c, l, s, (Element)n) ;
				}
			}
		}
	}
	
}
 

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    builder.getRawBeanDefinition().setBeanClass(RedisClient.class);
    if (helper.hasAttribute(element, HOST_ATTRIBUTE)) {
        helper.addConstructorArgs(element,
                HOST_ATTRIBUTE, String.class, builder);
        helper.addConstructorArgs(element,
                PORT_ATTRIBUTE, int.class, builder);
        helper.addConstructorArgs(element,
                CONNECTION_TIMEOUT_ATTRIBUTE, int.class, builder);
        helper.addConstructorArgs(element,
                COMMAND_TIMEOUT_ATTRIBUTE, int.class, builder);
    } else {
        BeanDefinitionBuilder b
                = helper.createBeanDefinitionBuilder(element,
                        parserContext,
                        RedisClientConfig.class);
        String configId = helper.getId(null, b, parserContext);
        helper.parseAttributes(element, parserContext, b);
        BeanComponentDefinition def
                = helper.registerBeanDefinition(b, configId,
                        null, parserContext);
        helper.addConstructorArgs(def, RedisClientConfig.class, builder);
    }
    builder.setDestroyMethodName("shutdown");
    parserContext.getDelegate().parseQualifierElements(element,
            builder.getRawBeanDefinition());
}
 

private void parserFieldMixCommonFirst(BeanDefinitionBuilder builder, List<Element> eles)
{
	if (!CollectionUtils.isEmpty(eles)) {

		Field[] firstFields = new Field[eles.size()];
		for (int i = 0; i < eles.size(); i++) {
			firstFields[i] = parserField(eles.get(i),true);
		}
		builder.addPropertyValue("firstFields", firstFields);
	}
}
 

/**
 * {@inheritDoc}
 */
protected void marshallAttributes(XMLObject samlObject, Element domElement) throws MarshallingException {
    ServiceName name = (ServiceName) samlObject;

    if (name.getName() != null) {
        Attr attribute = XMLHelper.constructAttribute(domElement.getOwnerDocument(), SAMLConstants.XML_NS,
                ServiceName.LANG_ATTRIB_NAME, SAMLConstants.XML_PREFIX);
        attribute.setValue(name.getName().getLanguage());
        domElement.setAttributeNodeNS(attribute);
    }
}
 

/**
 * {@inheritDoc}
 * This method only visits the element which has the specified identifier.
 */
@Override
public void walkTree(Element start, Visitor visitor) {
    Document doc = start.getOwnerDocument();
    Element found = doc.getElementById(this.identifier);
    if (found == null) {
        return;
    }
    if (Elements.isRoot(start) || Elements.hasDescendant(start, found)) {
        visitor.visit(found);
    }
}
 

/**
 * スキーマなしBoxへのインストールでACL_URLのBoxが正しくない場合にバリデートがfalseで返却されること.
 */
@Test
@Ignore
public void スキーマなしBoxへのインストールでACL_URLのBoxが正しくない場合にバリデートがfalseで返却されること() {
    // デフォルトBoxではない
    final String baseUrl = "https://baseserver/testcell1/__role/_a_/col1/";
    final String schemaUrl = null;
    try {
        DocumentBuilderFactory dbfactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docbuilder;
        docbuilder = dbfactory.newDocumentBuilder();
        Document document = docbuilder.newDocument();
        Element element = document.createElement("acl");
        element.setAttribute("xml:base", baseUrl);

        assertFalse(BarFileUtils.aclNameSpaceValidate("90_rootprops.xml", element, schemaUrl));
        return;
    } catch (ParserConfigurationException e) {
        fail("DOM Parsing Error: " + e.getMessage());
    } catch (PersoniumCoreException dce) {
        String code = dce.getCode();
        assertEquals(PersoniumCoreException.BarInstall.JSON_FILE_FORMAT_ERROR.getCode(), code);
        return;
    } catch (Exception ex) {
        fail("Unexpected exception");
    }
    fail("PersoniumCoreExceptionが返却されない");
}
 

private void saveBlockedProcessesToFile(List<DBBlocksJournalProcess> processes) throws ParserConfigurationException, IOException, SAXException {

        String fileName = String.format("%s-%s.xml", this.model.getName(), dateUtils.dateToString(blocksJournalCreateDate));
        Path blocksJournalsDirPath = PathBuilder.getInstance().getBlocksJournalsDir();
        Path currentJournalPath = Paths.get(blocksJournalsDirPath.toString(), fileName);
        File currentJournalFile = currentJournalPath.toFile();

        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();

        boolean fileExists = currentJournalFile.exists();
        Document document;
        Element rootElement;
        if (fileExists) {
            document = documentBuilder.parse(currentJournalFile);
            rootElement = document.getDocumentElement();
        } else {
            document = documentBuilder.newDocument();
            rootElement = document.createElement("blocksJournal");
        }
        DBBlocksJournalProcessSerializer serializer = new DBBlocksJournalProcessSerializer();
        processes.forEach(journalProcess -> {
            Element el = serializer.serialize(document, journalProcess);
            rootElement.appendChild(el);
        });
        if (!fileExists) {
            document.appendChild(rootElement);
        }
        XmlDocumentWorker documentWorker = new XmlDocumentWorker();
        documentWorker.save(document, currentJournalFile);
    }
 

BaseComponent anchor(Element el) {
    final Optional<String> href = XML.attrValue(el, "href");
    final Optional<BaseComponent> content = nonEmptyContent(el);
    final String type = XML.attrValue(el, "type").orElse("url");
    final Renderable<URI> uri;

    try {
        switch(type) {
            case "user":
                uri = new UserURI(href.orElse(""));
                break;

            case "home":
                uri = Renderable.of(Links.homeUri(href.orElse("/")));
                break;

            case "url":
                uri = Renderable.of(new URI(href.orElseThrow(() -> new MissingException("attribute", "href"))));
                break;

            default:
                throw new ValueException("Unknown anchor type '" + type + "'");
        }
    } catch(URISyntaxException e) {
        throw new ValueException(e.getMessage());
    }

    return new LinkComponent(uri, content);
}
 

/**  Convert entry     */
public int convert(String entryId, int conversionProfileId, ArrayList<KalturaConversionAttribute> dynamicConversionAttributes) throws KalturaApiException {
    KalturaParams kparams = new KalturaParams();
    kparams.add("entryId", entryId);
    kparams.add("conversionProfileId", conversionProfileId);
    kparams.add("dynamicConversionAttributes", dynamicConversionAttributes);
    this.kalturaClient.queueServiceCall("document", "convert", kparams);
    if (this.kalturaClient.isMultiRequest())
        return 0;
    Element resultXmlElement = this.kalturaClient.doQueue();
    String resultText = resultXmlElement.getTextContent();
    return ParseUtils.parseInt(resultText);
}
 

@Test
public void documentToDocumentNoTransformer() throws Exception
{
	Document resultDoc = fluentXmlTransformer
			.transform(sourceDocumentRule.asDocument())
			.toDocument();

	Element root = resultDoc.getDocumentElement();

	assertThat(root.getLocalName(), is("source"));
}
 

/**
 * Method itemKeyValue
 *
 * @param i
 * @return the asked KeyValue element, null if the index is too big
 * @throws XMLSecurityException
 */
public KeyValue itemKeyValue(int i) throws XMLSecurityException {
    Element e =
        XMLUtils.selectDsNode(
            this.constructionElement.getFirstChild(), Constants._TAG_KEYVALUE, i);

    if (e != null) {
        return new KeyValue(e, this.baseURI);
    }
    return null;
}
 

public static Element createTextElementWithNamespacedContent(final Document document, final String qName, final String prefix,
                                                             final String namespace, final String contentWithoutPrefix, final Optional<String> namespaceURI) {

    String content = createPrefixedValue(XmlMappingConstants.PREFIX, contentWithoutPrefix);
    Element element = createTextElement(document, qName, content, namespaceURI);
    String prefixedNamespaceAttr = createPrefixedValue(XMLNS_ATTRIBUTE_KEY, prefix);
    element.setAttributeNS(XMLNS_URI, prefixedNamespaceAttr, namespace);
    return element;
}
 

/** {@inheritDoc} */
protected void marshallElementContent(XMLObject xmlObject, Element domElement) throws MarshallingException {
    StatusMessageType message = (StatusMessageType)xmlObject;

    if(message.getValue() != null){
        XMLHelper.appendTextContent(domElement, message.getValue());
    }        
}
 

public AndParameterCondition(Element element) throws XMLException {
	super(element);
}
 

protected static void setRoot(Element pRoot) {
    cRoot = pRoot;
}
 

/** {@inheritDoc} */
public Element getDOM() {
    return dom;
}
 

@Override
protected void ToXmlValores(Document doc, Element me) {
    super.ToXmlValores(doc, me);
    me.appendChild(util.XMLGenerate.ValorString(doc, "AtributosOcultos", getAtributosOcultos()));
}
 

protected Element ExportCustom(Document root)
{
	Element e = root.createElement("NextSentence") ;
	return e ;
}
 

/**
 * Creates a DOM representation of this object
 * @return a DOM representation of this object
 */
public Document createDocument() {
	Document root;
	try {
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		root = dbf.newDocumentBuilder().newDocument();
	} catch (ParserConfigurationException pce) {
		throw new RuntimeException(pce);
	}

	/* model */
	Element modelElement = root.createElement("model");

	modelElement.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
	modelElement.setAttribute("xsi:noNamespaceSchemaLocation", "JMTmodel.xsd");
	modelElement.setAttribute("jaba", "true");

	root.appendChild(modelElement);

	/* description */
	if (!description.equals("")) {
		Element descriptionElement = root.createElement("description");
		descriptionElement.appendChild(root.createCDATASection(description));
		modelElement.appendChild(descriptionElement);
	}

	/* parameters */
	Element parametersElement = root.createElement("parameters");
	modelElement.appendChild(parametersElement);

	/* classes */
	Element classes_element = root.createElement("classes");
	parametersElement.appendChild(classes_element);
	classes_element.setAttribute("number", Integer.toString(classes));
	for (int i = 0; i < classes; i++) {

		//NEW
		//@author Stefano Omini
		//TODO: controllare se va
		classes_element.appendChild(makeClassElement(root, i));
		//end NEW
	}

	/* stations */
	Element stationsElement = root.createElement("stations");
	parametersElement.appendChild(stationsElement);
	stationsElement.setAttribute("number", Integer.toString(stations));
	for (int i = 0; i < stations; i++) {
		stationsElement.appendChild(makeStationElement(root, i));
	}

	//OLD
	//if (hasResults) modelElement.appendChild(makeSolutionElement(root));

	//NEW
	//@author Stefano Omini
	//todo eliminato il salvataggio dei risultati
	//if (hasResults && resultsOK) modelElement.appendChild(makeSolutionElement(root));
	//end NEW

	return root;

}