Example #1
0
void
CADReader::connectevent (DOMElement* element)
throw(CADReadException)
{
	std::string element_name;
	EventConnectionData event_connection;
	DOMNode* child = element->getFirstChild();
	while (child != 0)
	{
		if (child->getNodeType() == DOMNode::ELEMENT_NODE)
		{
			element_name = XMLString::transcode(child->getNodeName());

			//
			// consumesport
			//
			if (element_name == "consumesport")
			{
				event_connection.consumer = consumesport((DOMElement*)(child));
			}

			//
			// emitsport
			//
			else if (element_name == "emitsport")
			{
				event_connection.kind = EMITTER;
				event_connection.emitter = emitsport((DOMElement*)(child));
			}

			//
			// publishesport
			//
			else if (element_name == "publishesport")
			{
				event_connection.kind = PUBLISHER;
				event_connection.emitter = publishesport((DOMElement*)(child));
			}
		}

        // get next child
	    child = child->getNextSibling();
	}

	// add new event_connection
	data_->event_connections_.push_back(event_connection);
}
	void *NclPresentationControlParser::parseCompositeRule(
		    DOMElement *parentElement, void *objGrandParent) {

		wclog << "parseCompositeRule" << endl;
		void *parentObject;
		DOMNodeList *elementNodeList;
		DOMElement *element;
		DOMNode *node;
		string elementTagName;
		void *elementObject;

		parentObject = createCompositeRule(parentElement, objGrandParent);
		if (parentObject == NULL) {
			return NULL;
		}

		elementNodeList = parentElement->getChildNodes();
		for (int i = 0; i < (int)elementNodeList->getLength(); i++) {
			node = elementNodeList->item(i);
			if (node->getNodeType() == DOMNode::ELEMENT_NODE) {
				element = (DOMElement*)node;
				elementTagName = XMLString::transcode(element->getTagName());
				wclog << ">>" << elementTagName.c_str() << ": ";
				wclog << XMLString::transcode(element->getAttribute(XMLString::transcode("id"))) << endl;

				if (XMLString::compareIString(elementTagName.c_str(),
					    "rule") == 0) {

					elementObject = parseRule(element, parentObject);
					if (elementObject != NULL) {
						addRuleToCompositeRule(parentObject, elementObject);
					}

				} else if(XMLString::compareIString(elementTagName.c_str(),
					    "compositeRule")==0) {

					elementObject = parseCompositeRule(element, parentObject);
					if (elementObject != NULL) {
						addCompositeRuleToCompositeRule(
							    parentObject, elementObject);
					}
				}
			}
		}

		return parentObject;
	}
XERCES_CPP_NAMESPACE_BEGIN

DOMDocument *
XIncludeDOMDocumentProcessor::doXIncludeDOMProcess(const DOMDocument * const source, XMLErrorReporter *errorHandler, XMLEntityHandler* entityResolver /*=NULL*/){
    XIncludeUtils xiu(errorHandler);

    DOMImplementation* impl = source->getImplementation();
    DOMDocument *xincludedDocument = impl->createDocument();
    
    try
    {
        /* set up the declaration etc of the output document to match the source */
        xincludedDocument->setDocumentURI( source->getDocumentURI());
        xincludedDocument->setXmlStandalone( source->getXmlStandalone());
        xincludedDocument->setXmlVersion( source->getXmlVersion());

        /* copy entire source document into the xincluded document. Xincluded document can
           then be modified in place */
        DOMNode *child = source->getFirstChild();
        for (; child != NULL; child = child->getNextSibling()){
            if (child->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE){
                /* I am simply ignoring these at the moment */
                continue;
            }
            DOMNode *newNode = xincludedDocument->importNode(child, true);
            xincludedDocument->appendChild(newNode);
        }

        DOMNode *docNode = xincludedDocument->getDocumentElement();
        /* parse and include the document node */
        xiu.parseDOMNodeDoingXInclude(docNode, xincludedDocument, entityResolver);

        xincludedDocument->normalizeDocument();
    }
    catch(const XMLErrs::Codes)
    {
        xincludedDocument->release();
        return NULL;
    }
    catch(...)
    {
        xincludedDocument->release();
        throw;
    }

    return xincludedDocument;
}
Example #4
0
void DeltaApplyEngine::ApplyDeltaElement(DOMNode* incDeltaElement) {
	vddprintf(("Apply delta element\n"));
	deltaElement = incDeltaElement;
	
	/* ---- Do All DELETE Operations ( including 'from' part of move ) ---- */
	
	vddprintf(("Apply Delete operations\n"));
	DOMNode* firstOp = deltaElement->getFirstChild() ;
	vddprintf(("    first sort delete operations...\n"));
	SortDeleteOperationsEngine deleteOps(xiddoc, firstOp);
	vddprintf(("    then apply all of them 1 by 1...\n"));
	while(!deleteOps.isListEmpty()) {
		DOMNode* op=deleteOps.getNextDeleteOperation();
		ApplyOperation(op);
		}

	vddprintf(("Ok, there are no more delete operations.\n"));
	
	/* ---- Do All INSERT Operations ( including 'to' part of move ) ---- */
	
	firstOp = deltaElement->getFirstChild() ;
	SortInsertOperationsEngine insertOps(xiddoc, firstOp);
	while(!insertOps.isListEmpty()) {
		DOMNode* op=insertOps.getNextInsertOperation();
		ApplyOperation(op);
		}
	
	/* ---- Do all  UPDATE  &  ATTRIBUTE  Operations ---- */

	DOMNode* child = deltaElement->getFirstChild() ;
	XMLCh iStr[100];
	XMLString::transcode("i", iStr, 99);
	XMLCh dStr[100];
	XMLString::transcode("d", dStr, 99);
	while (child != NULL) {
		if ( (!XMLString::equals(child->getLocalName(),iStr))
		
		   &&(!XMLString::equals(child->getLocalName(), dStr)) ) ApplyOperation(child);
	  child = child->getNextSibling() ;
		}
		
	/* ---- Small consistency checks ---- */

	if (moveDocument->getDocumentElement()->hasChildNodes()) THROW_AWAY(("temporary document used to move node is not empty!"));

	vddprintf(("xiddoc=%s\n",xiddoc->getXidMap().String().c_str() ));
}
Example #5
0
DOMNode* DOMElementImpl::rename(const XMLCh* namespaceURI, const XMLCh* name)
{
    DOMDocumentImpl* doc = (DOMDocumentImpl*) getOwnerDocument();

    if (!namespaceURI || !*namespaceURI) {
        fName = doc->getPooledString(name);
        fAttributes->reconcileDefaultAttributes(getDefaultAttributes());

        return this;
    }
    else {

        // create a new ElementNS
        DOMElementNSImpl* newElem = (DOMElementNSImpl*)doc->createElementNS(namespaceURI, name);

        // transfer the userData
        doc->transferUserData(castToNodeImpl(this), castToNodeImpl(newElem));

        // remove old node from parent if any
        DOMNode* parent = getParentNode();
        DOMNode* nextSib = getNextSibling();
        if (parent) {
            parent->removeChild(this);
        }

        // move children to new node
        DOMNode* child = getFirstChild();
        while (child) {
            removeChild(child);
            newElem->appendChild(child);
            child = getFirstChild();
        }

        // insert new node where old one was
        if (parent) {
            parent->insertBefore(newElem, nextSib);
        }

        // move specified attributes to new node
        newElem->fAttributes->moveSpecifiedAttributes(fAttributes);

        // and fire user data NODE_RENAMED event
        castToNodeImpl(newElem)->callUserDataHandlers(DOMUserDataHandler::NODE_RENAMED, this, newElem);

        return newElem;
    }
}
Example #6
0
Metadata::Metadata(DOMDocument *doc)
{
   DOMElement *metadataRootElem = doc->getDocumentElement();
   
   if(metadataRootElem == NULL){
   	return;
   }
   
   XMLCh *keyValStr = XMLString::transcode("keyval");
   DOMNodeList *keyValElems = metadataRootElem->getElementsByTagName(keyValStr);
   
   const XMLSize_t nodeCount = keyValElems->getLength();
   
   //cout << "Metadata::constructor:  Found " << nodeCount << " keyval elements" << endl;
   
   for(XMLSize_t i = 0; i < nodeCount; i++){
     DOMNode* currentNode = keyValElems->item(i) ;
        
     if(currentNode == NULL){
       	  continue;
     }
     	
     if( xercesc::DOMNode::ELEMENT_NODE != currentNode->getNodeType() ){
       // not an element node -> not of interest here
        continue ;
     }

     DOMElement* metadataElem = dynamic_cast< xercesc::DOMElement* >(currentNode);

     
     string key;
     read(metadataElem, "key", key);
     vector<string> values;
     readMany(metadataElem, "val", values);
     
     /*cout << "Processing DOMElement (key, values): (" << key << ", ";
     
     for(int j=0; j < values.size(); j++){
     	cout << values[j] << ", ";
     }
     
     cout << ")" << endl;*/
     
     elementMap[key] = values;
        	
   }	
}
Example #7
0
void AcsAlarmTestCase::verifyFaultStateElement(DOMDocument * doc, bool propertiesAndTimestampPopulated)
{
	// Verify that the fault-state element exists
	DOMNodeList * faultStateNodes = doc->getElementsByTagName(FAULT_STATE_TAG_NAME);
	CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; no fault-state element found",
		(NULL != faultStateNodes && faultStateNodes->getLength() == 1));

	// verify that there are the expected attributes (family, member, code) on the fault-state element
	DOMNode * faultStateItem = faultStateNodes->item(0);
	if(NULL != faultStateItem)
	{
		// verify that there are 3 attributes in total
		DOMNamedNodeMap * attributesMap = faultStateItem->getAttributes();
		CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 3 attributes",
			(NULL!= attributesMap && attributesMap->getLength() == 3));

		// check that the fault-state element has a "family" attribute
		DOMNode * familyNode = attributesMap->getNamedItem(FAMILY_TAG_NAME);
		CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 'family' attribute",
			(NULL!= familyNode));

		// verify that the value of family attribute is correct
		const XMLCh * familyNodeValue = familyNode->getNodeValue();
		CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of fault-state 'family' is not correct",
			(NULL != familyNodeValue && XMLString::equals(familyNodeValue, FAMILY_VALUE_XMLCH)));

		// check that the fault-state element has a "member" attribute
		DOMNode * memberNode = attributesMap->getNamedItem(MEMBER_TAG_NAME);
		CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 'member' attribute",
			(NULL!= memberNode));

		// verify that the value of member attribute is correct
		const XMLCh * memberNodeValue = memberNode->getNodeValue();
		CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of fault-state 'member' is not correct",
			(NULL != memberNodeValue && XMLString::equals(memberNodeValue, MEMBER_VALUE_XMLCH)));

		// check that the fault-state element has a "code" attribute
		DOMNode * codeNode = attributesMap->getNamedItem(CODE_TAG_NAME);
		CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 'code' attribute",
			(NULL!= codeNode));

		// verify that the value of code attribute is correct
		const XMLCh * codeNodeValue = codeNode->getNodeValue();
		char *codeNodeCharValue = XMLString::transcode(codeNodeValue);
		int codeNodeValueInt = atoi(codeNodeCharValue);
		XMLString::release(&codeNodeCharValue);
		CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of fault-state 'code' is not correct",
			(NULL != codeNodeValue && codeNodeValueInt == CODE_VALUE));
	}

	verifyDescriptorElement(doc);
	if(propertiesAndTimestampPopulated)
	{
		verifyUserPropertiesElement(doc);
		verifyUserTimestampElement(doc);
	}
}
static DeviceInstance extractDeviceInstance(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
    DeviceInstance deviceInstance;
    map<string, ParameterGroup> parameterGroupMap;

    DOMNode * node = domTreeWalker->getCurrentNode();
    DOMNamedNodeMap * nodeMap = node->getAttributes();

    DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
    if (nameAttribute) {
        deviceInstance.setName(XMLString::transcode(nameAttribute->getNodeValue()));
    }

    DOMNode * typenameAttribute = nodeMap->getNamedItem(XMLString::transcode("typename"));
    if (typenameAttribute) {
        deviceInstance.setDeviceTypeName(XMLString::transcode(typenameAttribute->getNodeValue()));
    }

    while (node) {
        if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ParameterGroup") == 0) {
            DOMNamedNodeMap * nodeMap = node->getAttributes();
            string name;
            DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
            if (nameAttribute) {
               name = XMLString::transcode(nameAttribute->getNodeValue());
            }

            XMLNodeFilter * nodeFilter = new XMLNodeFilter();
            DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);

            ParameterGroup pg = extractParameterGroup(domDocument, d);
            pg.setName(name);
            parameterGroupMap[name] = pg;

            d->release();
            delete nodeFilter;
        }
        node = domTreeWalker->nextNode();
    }

    ParameterGroup parameterGroup;
    parameterGroup.setName("root");
    parameterGroup.setParameterGroupMap(parameterGroupMap);
    deviceInstance.setParameterGroup(parameterGroup);

    return deviceInstance;
}
Example #9
0
//=============================================================================
// METHOD: SPELLxmlConfigReaderXC::findElementsByName
//=============================================================================
SPELLxmlNodeList SPELLxmlConfigReaderXC::findElementsByName( std::string tagName )
{
    SPELLxmlNodeList result;
    if (m_document == NULL)
    {
        THROW_EXCEPTION("Cannot find elements", "No document available", SPELL_ERROR_CONFIG);
    }

    DEBUG("[CFGR] Get elements by name: " + tagName);

    // Get the tag translation
    XMLCh* tag = XMLString::transcode(tagName.c_str());

    // Get the top-level element
    DOMElement* elementRoot = m_document->getDocumentElement();
    if( !elementRoot )
	{
    	THROW_EXCEPTION("Cannot get root element", "Empty document", SPELL_ERROR_CONFIG);
	}

    DOMNodeList* children = elementRoot->getChildNodes();

    const XMLSize_t nodeCount = children->getLength();

    // For all nodes, children of "root" in the XML tree.
    for (XMLSize_t xx = 0; xx < nodeCount; ++xx)
    {
        DOMNode* currentNode = children->item(xx);
        if (currentNode->getNodeType() && // true is not NULL
                currentNode->getNodeType() == DOMNode::ELEMENT_NODE) // is element
        {
            // Found node which is an Element. Re-cast node as element
            DOMElement* currentElement = dynamic_cast<xercesc::DOMElement*> (currentNode);
            if (XMLString::equals(currentElement->getTagName(), tag))
            {
                result.push_back( convertToNode( currentElement ) );
            }
        }
    }

    XMLString::release(&tag);

    DEBUG("[CFGR] Found " + ISTR(result.size()) + " elements");

    return result;
}
static vector<Connector> extractConnectorVector(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
    vector<Connector> connectorVector;

    DOMNode * node = domTreeWalker->getCurrentNode();
    while (node) {
        if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Connector") == 0) {
            XMLNodeFilter * nodeFilter = new XMLNodeFilter();
            DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
            Connector connector = extractConnector(domDocument, d);
            connectorVector.push_back(connector);
            d->release();
            delete nodeFilter;
        }
        node = domTreeWalker->nextNode();
    }
    return connectorVector;
}
static map<string, TUIObjectType> extractTUIObjectTypeMap(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
    map<string, TUIObjectType> tuiObjectTypeMap;

    DOMNode * node = domTreeWalker->getCurrentNode();
    while (node) {
        if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "TUIObjectType") == 0) {
            XMLNodeFilter * nodeFilter = new XMLNodeFilter();
            DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
            TUIObjectType tuiObjectType = extractTUIObjectType(domDocument, d);
            tuiObjectTypeMap[tuiObjectType.getName()] = tuiObjectType;
            d->release();
            delete nodeFilter;
        }
        node = domTreeWalker->nextNode();
    }
    return tuiObjectTypeMap;
}
Example #12
0
void
CSDReader::valuetypefactory (DOMElement* element)
throw(CSDReadException)
{
	std::string element_name;
	ValuetypeData data;
	data.repid = Qedo::transcode(element->getAttribute(X("repid")));
    DOMNode* child = element->getFirstChild();
	while (child != 0)
	{
		if (child->getNodeType() == DOMNode::ELEMENT_NODE)
		{
			element_name = Qedo::transcode(child->getNodeName());

			//
			// codebase
			//
			if (element_name == "codebase")
			{
				// todo
			}

			//
			// fileinarchive
			//
			if (element_name == "fileinarchive")
			{
				data.location = fileinarchive((DOMElement*)child);
			}

			//
			// link
			//
			if (element_name == "link")
			{
				data.location = link((DOMElement*)child);
			}
		}

		// get next child
		child = child->getNextSibling();
    }

	DEBUG_OUT2( "CSDReader: <valuetypefactory> ", data.repid );
	data_->valuetypes.push_back(data);
}
Example #13
0
void
CSDReader::softpkgref (DOMElement* element)
throw(CSDReadException)
{
	std::string element_name;
	std::string idref;
    DOMNode* child = element->getFirstChild();
	while (child != 0)
	{
		if (child->getNodeType() == DOMNode::ELEMENT_NODE)
		{
			element_name = Qedo::transcode(child->getNodeName());

			//
			// fileinarchive
			//
			if (element_name == "fileinarchive")
			{
				// todo
				//fileinarchive( (DOMElement*)child );
			}

			//
			// link
			//
			else if (element_name == "link")
			{
				// todo
				//link( (DOMElement*)child );
			}

			//
			// implref
			//
			else if (element_name == "implref")
			{
				idref = implref( (DOMElement*)child );
			}
		}

		// get next child
		child = child->getNextSibling();
    }

	data_->softpkg_dependencies.push_back( idref );
}
Example #14
0
	XmlNode addChild(const char *name) {
		XMLCh *tempStr = NULL;
		tempStr = XMLString::transcode(name);
		DOMElement *element = doc->createElement(tempStr);
		DOMNode *cnode = node->appendChild(element);
		XMLString::release(&tempStr);
		return XmlNode(cnode,doc);
	}
Example #15
0
void AcsAlarmTestCase::verifyDescriptorElement(DOMDocument * doc)
{
	// Verify the descriptor element
	DOMNodeList * descriptorNodes = doc->getElementsByTagName(DESCRIPTOR_TAG_NAME);
	CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; no descriptor element found",
		(NULL != descriptorNodes && descriptorNodes->getLength() == 1));

	// check value of descriptor
	DOMNode * descriptorElementNode = descriptorNodes->item(0);
	DOMNode * descriptorTextNode = descriptorElementNode->getFirstChild();
	CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; descriptor value is not present or null",
		(NULL != descriptorTextNode));

	const XMLCh * descriptorNodeValue = descriptorTextNode->getNodeValue();
	CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of descriptor is not correct",
		(NULL != descriptorNodeValue && XMLString::equals(descriptorNodeValue, DESCRIPTOR_VALUE_XMLCH)));
}
static ServerStartupConfig extractServerStartupConfig(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
    ServerStartupConfig serverStartupConfig;
    DOMNode * node = domTreeWalker->getCurrentNode();
    while (node) {
        if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Network") == 0) {
            DOMNamedNodeMap * nodeMap = node->getAttributes();
            DOMNode * portAttribute = nodeMap->getNamedItem(XMLString::transcode("port"));
            if (portAttribute) {
                
                serverStartupConfig.setPortNr(XMLString::parseInt(portAttribute->getNodeValue()));
            }
        }
        node = domTreeWalker->nextNode();
    }

    return serverStartupConfig;
}
Example #17
0
void
CADReader::componentfile (DOMElement* element)
throw(CADReadException)
{
	std::string element_name;
	std::string file_name;
	DOMNode* child = element->getFirstChild();
	while (child != 0)
	{
		if (child->getNodeType() == DOMNode::ELEMENT_NODE)
		{
			element_name = XMLString::transcode(child->getNodeName());
			
			//
			// fileinarchive
			//
			if (element_name == "fileinarchive")
			{
				file_name = fileinarchive((DOMElement*)(child));
			}

			//
			// codebase
			//
			else if (element_name == "codebase")
			{
				// TODO
			}

			//
			// link
			//
			else if (element_name == "link")
			{
				file_name = link((DOMElement*)(child));
			}
		}

        // get next child
	    child = child->getNextSibling();
	}

	std::string id = XMLString::transcode(element->getAttribute(X("id")));
	DEBUG_OUT2( "CADReader: <componentfile> ", file_name );
	data_->implementationMap_[id] = file_name;
}
Example #18
0
void XercesUpdateFactory::completeDeletions(DynamicContext *context)
{
  //    e. Finally, for each node marked for deletion by one of the update primitives listed above, let $N be the node that is marked
  //       for deletion, and let $P be its parent node. The following actions are applied:
  //          i. The parent property of $N is set to empty.
  //         ii. If $N is an attribute node, the attributes property of $P is modified to remove $N.
  //        iii. If $N is a non-attribute node, the children property of $P is modified to remove $N.
  //         iv. If $N is an element, attribute, or text node, and $P is an element node, then upd:removeType($P) is invoked.

  for(DOMNodeSet::iterator i = forDeletion_.begin(); i != forDeletion_.end(); ++i) {
    DOMNode *domnode = *i;

    if(domnode->getNodeType() == DOMNode::ATTRIBUTE_NODE) {
      DOMAttr *attr = (DOMAttr*)domnode;
      DOMElement *owner = attr->getOwnerElement();
      if(owner != 0) {
        owner->removeAttributeNode(attr);
        removeType(owner);
      }
    }
    else {
      DOMNode *parent = domnode->getParentNode();
      if(parent != 0) {
        parent->removeChild(domnode);
        if(domnode->getNodeType() == DOMNode::ELEMENT_NODE ||
           domnode->getNodeType() == DOMNode::TEXT_NODE ||
           domnode->getNodeType() == DOMNode::CDATA_SECTION_NODE) {
          removeType(parent);
        }
      }
    }
  }
}
Example #19
0
void XercesUpdateFactory::setTypes(DOMNode *node, const DOMNode *from)
{
  if(node->getNodeType() == DOMNode::ELEMENT_NODE) {
    const XMLCh *turi, *tname;
    XercesNodeImpl::typeUriAndName(from, turi, tname);
    XercesSequenceBuilder::setElementTypeInfo((DOMElement *)node, turi, tname);

    DOMNamedNodeMap *attrs = node->getAttributes();
    DOMNamedNodeMap *attrsfrom = from->getAttributes();
    for(unsigned int i = 0; i < attrs->getLength(); ++i) {
      DOMNode *a = attrs->item(i);
      DOMNode *afrom = attrsfrom->getNamedItemNS(a->getNamespaceURI(), Axis::getLocalName(a));
      if(afrom) setTypes(a, afrom);
    }

    DOMNode *child = node->getFirstChild();
    DOMNode *cfrom = from->getFirstChild();
    while(child) {
      if(child->getNodeType() == DOMNode::ELEMENT_NODE)
        setTypes(child, cfrom);
      child = child->getNextSibling();
      cfrom = cfrom->getNextSibling();
    }
  }
  else if(node->getNodeType() == DOMNode::ATTRIBUTE_NODE) {
    const XMLCh *turi, *tname;
    XercesNodeImpl::typeUriAndName(from, turi, tname);
    XercesSequenceBuilder::setAttributeTypeInfo((DOMAttr *)node, turi, tname);
  }
}
Example #20
0
void XercesUpdateFactory::applyRename(const PendingUpdate &update, DynamicContext *context)
{
  const XercesNodeImpl *nodeImpl = (const XercesNodeImpl*)update.getTarget()->getInterface(Item::gXQilla);
  DOMNode *domnode = const_cast<DOMNode*>(nodeImpl->getDOMNode());

  ATQNameOrDerived *qname = (ATQNameOrDerived*)update.getValue().first().get();

  if(domnode->getNodeType() == DOMNode::PROCESSING_INSTRUCTION_NODE) {
    DOMProcessingInstruction *newPI = domnode->getOwnerDocument()->
      createProcessingInstruction(qname->getName(), domnode->getNodeValue());
    domnode->getParentNode()->replaceChild(newPI, domnode);
    domnode = newPI;
  }
  else {
    // If $newName has an implied namespace binding that conflicts with an existing namespace binding
    // in the namespaces property of $target, a dynamic error is raised [err:XUDY0024].

    // If $target has a parent, and $newName has an implied namespace binding that conflicts with a
    // namespace binding in the namespaces property of parent($target), a dynamic error is raised [err:XUDY0024].

    domnode->getOwnerDocument()->renameNode(domnode, qname->getURI(), qname->getName());
    if(qname->getURI() != 0 && *qname->getURI() != 0)
      domnode->setPrefix(qname->getPrefix());

    removeType(domnode);
  }

  // Deliberately create a new XercesNodeImpl, since the PI is actually
  // replaced, not just renamed, meaning it is no longer attached to the tree
  addToPutSet(nodeImpl, &update, context);
}
void Materia::buildFromXml (DOMNode *node) {
	XMLCh* tag_codigo = XMLString::transcode("codigo");
	XMLCh* tag_nome = XMLString::transcode("nome");
	XMLCh* tag_creditos = XMLString::transcode("creditos");
	XMLCh* tag_conceito = XMLString::transcode("conceito");
	XMLCh* tag_situacao = XMLString::transcode("situacao");
	
	DOMNodeList *l_children = node->getChildNodes();
	for (XMLSize_t i = 0; i < l_children->getLength(); ++i) {
		DOMNode *n = l_children->item(i);
		const XMLCh *tag = n->getNodeName();
		if (XMLString::equals(tag, tag_codigo)) {
			this->codigo = XMLString::transcode(n->getTextContent());
		} else if (XMLString::equals(tag, tag_nome)) {
			this->nome = XMLString::transcode(n->getTextContent());
		} else if (XMLString::equals(tag, tag_creditos)) {
			this->creditos = stoi(XMLString::transcode(n->getTextContent()));
		} else if (XMLString::equals(tag, tag_conceito)) {
			this->conceito = stod(XMLString::transcode(n->getTextContent()));
		} else if (XMLString::equals(tag, tag_situacao)) {
			this->situacao = XMLString::transcode(n->getTextContent());
		}
	}
	
	XMLString::release(&tag_codigo);
	XMLString::release(&tag_nome);
	XMLString::release(&tag_creditos);
	XMLString::release(&tag_conceito);
	XMLString::release(&tag_situacao);
}
Example #22
0
void
DTMReader::mapping(DOMElement* element)
	throw(DTMReadException)
{
	DOMNode* child = element->getFirstChild();
	while (child != 0)
	{
		if (child->getNodeType() == DOMNode::ELEMENT_NODE)
		{
			// handle corba-type
			if ( !XMLString::compareString(child->getNodeName(), X("corba-type")) )
				vCorba_.push_back(get_value((DOMElement*)child));

			// handle cpp-type
			else if ( !XMLString::compareString(child->getNodeName(), X("cpp-type")) )
				vCpp_.push_back(get_value((DOMElement*)child));

			// handle cpp-native-type
			else if ( !XMLString::compareString(child->getNodeName(), X("cpp-native-type")) )
				vCppNative_.push_back(get_value((DOMElement*)child));

			// handle sql-type
			else if ( !XMLString::compareString(child->getNodeName(), X("sql-type")) )
				vSql_.push_back(get_value((DOMElement*)child));
		}

        // get next child
		child = child->getNextSibling();
    }
}
string CXmlConfig::getValue(DOMNode* parentNode, const string& itemName)
{
	string strValue;
	string strName;
	
	DOMNode* firstChildNode = NULL;
	charArrayToString(parentNode->getNodeName(), strName);
	if (strName == itemName)
	{
		firstChildNode = parentNode->getFirstChild();
		if (firstChildNode != NULL) charArrayToString(firstChildNode->getNodeValue(), strValue);
		return strValue;
	}
	
	DOMNodeList* nodeList = parentNode->getChildNodes();
	for (unsigned int i = 0; i < nodeList->getLength(); ++i)
	{
		DOMNode* nodeTemp = nodeList->item(i);
		if (nodeTemp->getNodeType() == DOMNode::ELEMENT_NODE)
		{
			charArrayToString(nodeTemp->getNodeName(), strName);
			if (strName == itemName)
			{
				firstChildNode = nodeTemp->getFirstChild();
				if (firstChildNode != NULL) charArrayToString(firstChildNode->getNodeValue(), strValue);
				break;
			}
		}
	}
	
	return strValue;
}
vector<ImportDescriptor*> SignatureSetImporter::createImportDescriptors(DOMTreeWalker* pTree, vector<string> &datasetPath)
{
   vector<ImportDescriptor*> descriptors;
   FactoryResource<DynamicObject> pMetadata;
   VERIFYRV(pMetadata.get() != NULL, descriptors);

   string datasetName = StringUtilities::toDisplayString(mDatasetNumber++);
   for (DOMNode* pChld = pTree->firstChild(); pChld != NULL; pChld = pTree->nextSibling())
   {
      if (XMLString::equals(pChld->getNodeName(), X("metadata")))
      {
         DOMElement* pElmnt = static_cast<DOMElement*>(pChld);
         string name = A(pElmnt->getAttribute(X("name")));
         string val = A(pElmnt->getAttribute(X("value")));
         pMetadata->setAttribute(name, val);
         if (name == "Name")
         {
            datasetName = val;
         }
      }
      else if (XMLString::equals(pChld->getNodeName(), X("signature_set")))
      {
         datasetPath.push_back(datasetName);
         vector<ImportDescriptor*> sub = createImportDescriptors(pTree, datasetPath);
         datasetPath.pop_back();
         descriptors.insert(descriptors.end(), sub.begin(), sub.end());
         pTree->parentNode();
      }
   }
   ImportDescriptorResource pImportDescriptor(datasetName, "SignatureSet", datasetPath);
   VERIFYRV(pImportDescriptor.get() != NULL, descriptors);
   DataDescriptor* pDataDescriptor = pImportDescriptor->getDataDescriptor();
   VERIFYRV(pDataDescriptor != NULL, descriptors);
   FactoryResource<SignatureFileDescriptor> pFileDescriptor;
   VERIFYRV(pFileDescriptor.get() != NULL, descriptors);
   pFileDescriptor->setFilename(mFilename);
   datasetPath.push_back(datasetName);
   string loc = "/" + StringUtilities::join(datasetPath, "/");
   datasetPath.pop_back();
   pFileDescriptor->setDatasetLocation(loc);
   pDataDescriptor->setFileDescriptor(pFileDescriptor.get());
   pDataDescriptor->setMetadata(pMetadata.get());
   descriptors.push_back(pImportDescriptor.release());
   return descriptors;
}
void ColladaObject::ReadRootNode(const DOMNode* node)
{
	_ASSERTE(node != NULL);

	DOMNode* currentNode = node->getFirstChild();
	while( currentNode != NULL )
	{
#if _DEBUG	// デバッグ時に名前をチェックする為に
		const XMLCh* name = currentNode->getNodeName();
#endif
		if( IsElementNode( currentNode ) )
		{
			if( Is_COLLADA_NodeName( currentNode ) )		// COLLADA要素が見つかった場合
			{
				currentNode = currentNode->getFirstChild();		// 子ノードを処理する
				continue;
			}
			else if( Is_asset_NodeName( currentNode ) )	// asset要素が見つかった場合
			{
				_ASSERTE(elemAsset == NULL);		// 必ず1つ存在するのでこの時点ではNULL

				elemAsset = new AssetElement();
				elemAsset->ReadNode( currentNode );
			}
			else if( Is_library_NodeName( currentNode ) )	// library要素が見つかった場合
			{
				LibraryElement* elemLibrary = CreateLibraryElement( currentNode );
				if( elemLibrary != NULL )
				{
					elemLibrary->ReadNode( currentNode );
					vecElemLibrary.push_back( elemLibrary );
				}
			}
			else if( Is_scene_NodeName( currentNode ) )	// scene要素が見つかった場合
			{
				_ASSERTE(elemScene == NULL);		// 0または1つ存在するのでこの時点ではNULL

				elemScene = new SceneElement();
				elemScene->ReadNode( currentNode );
			}
		}

		currentNode = currentNode->getNextSibling();	// 次の要素を処理する
	}
}
bool CConfigParser::ParseDevices(DOMNodeList* deviceNodeList, ADeviceListener& configClass)
{
	ASSERT(deviceNodeList->getLength() >= 1);
	DOMNode* deviceNode = deviceNodeList->item(0);
	DOMNodeList* devices = deviceNode->getChildNodes();
	for(unsigned long idx = 0; idx < devices->getLength(); idx++)
	{
		DOMNode* currentDevice = devices->item(idx);
		wstring deviceNodeName = currentDevice->getNodeName();
		if(deviceNodeName.compare(L"#text") == 0)
			continue;
		wstring deviceName = currentDevice->getAttributes()->getNamedItem(L"name")->getNodeValue();
		//wstring deviceType = currentDevice->getAttributes()->getNamedItem(L"type")->getNodeValue();
		wstring deviceType = deviceNodeName;
		if(deviceType.compare(L"mouse") == 0)
		{
			configClass.AddDevice(deviceName, new CMouseProc());
		}
		else
		{
			CWin32SpaceNavigatorHIDCapture* deviceToAdd = new CWin32SpaceNavigatorHIDCapture();
			if(currentDevice->hasChildNodes())
			{
				if(!ParseHIDDeviceCommands(currentDevice->getChildNodes(), deviceToAdd))
					return false;
			}
			configClass.AddDevice(deviceName, deviceToAdd);
		}
	}
	return true;
}
Example #27
0
PortData
CADReader::emitsport (DOMElement* element)
throw(CADReadException)
{
	std::string element_name;
	PortData data;
	DOMNode* child = element->getFirstChild();
	while (child != 0)
	{
		if (child->getNodeType() == DOMNode::ELEMENT_NODE)
		{
			element_name = XMLString::transcode(child->getNodeName());

			//
			// emitsidentifier
			//
			if (element_name == "emitsidentifier")
			{
				data.name = emitsidentifier((DOMElement*)(child));
			}

			//
			// componentinstantiationref
			//
			else if (element_name == "componentinstantiationref")
			{
				data.ref.kind = COMPONENTID;
				data.ref.name = componentinstantiationref((DOMElement*)(child));
			}

			//
			// findby
			//
			else if (element_name == "findby")
			{
				data.ref = findby((DOMElement*)(child));
			}
		}

        // get next child
	    child = child->getNextSibling();
	}

	return data;
}
static TUIObjectType extractTUIObjectType(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
    TUIObjectType tuiObjectType;
    DOMNode * node = domTreeWalker->getCurrentNode();
    DOMNamedNodeMap * nodeMap = node->getAttributes();
    DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
    if (nameAttribute) {
        tuiObjectType.setName(XMLString::transcode(nameAttribute->getNodeValue()));
    }

    while (node) {
        if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "PortTypeSequence") == 0) {
            XMLNodeFilter * nodeFilter = new XMLNodeFilter();
            DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
            tuiObjectType.setPortMap(extractPortMap(domDocument, d));
            d->release();
            delete nodeFilter;
        } else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Description") == 0) {
            XMLCh * textContent = XMLString::replicate(node->getTextContent());
            XMLString::trim(textContent);
            tuiObjectType.setDescription(XMLString::transcode(textContent));
            XMLString::release(&textContent);
        }
        node = domTreeWalker->nextNode();
    }
    return tuiObjectType;
}
Example #29
0
// Returns the previous logical sibling with respect to the given node.
DOMNode* DOMElementImpl::getPreviousLogicalSibling(const DOMNode* n) const
{
    DOMNode* prev = n->getPreviousSibling();
    // If "n" has no previous sibling and its parent is an entity reference node we
    // need to continue the search through the previous siblings of the entity
    // reference as these are logically siblings of the given node.
    if (prev == NULL) {
        DOMNode* parent = n->getParentNode();
        while (parent != NULL && parent->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
            prev = parent->getPreviousSibling();
            if (prev != NULL) {
                break;
            }
            parent = parent->getParentNode();
        }
    }
    return prev;
}
Example #30
0
void printTypes(const char *label, const DOMNode *node, int indent = 0)
{
  if(indent == 0) std::cerr << "\n";

  if(node->getNodeType() == DOMNode::ELEMENT_NODE) {
    const XMLCh *typeURI, *typeName;
    XercesNodeImpl::typeUriAndName(node, typeURI, typeName);
    std::cerr << label << ":" << std::string(indent * 2, ' ')
              << "name: {" << UTF8(node->getNamespaceURI()) << "}" << UTF8(Axis::getLocalName(node))
              << ", type: {" << UTF8(typeURI) << "}" << UTF8(typeName) << "\n";

    DOMNode *child = node->getFirstChild();
    while(child) {
      printTypes(label, child, indent + 1);
      child = child->getNextSibling();
    }
  }
}