void
CADReader::componentassembly (DOMElement* element)
throw(CADReadException)
{
std::string element_name;
DOMNode* child = element->getFirstChild();
while (child != 0)
{
if (child->getNodeType() == DOMNode::ELEMENT_NODE)
{
element_name = XMLString::transcode(child->getNodeName());
//
// description
//
if (element_name == "description")
{
description((DOMElement*)(child));
}
//
// componentfiles
//
else if (element_name == "componentfiles")
{
componentfiles((DOMElement*)(child));
}
//
// partitioning
//
else if (element_name == "partitioning")
{
partitioning((DOMElement*)(child));
}
//
// connections
//
else if (element_name == "connections")
{
connections((DOMElement*)(child));
}
//
// extension
//
else if (element_name == "extension")
{
extension((DOMElement*)(child));
}
}
// get next child
child = child->getNextSibling();
}
}
long SYSTEM::CConfigItem::GetChildCount()
{
int iCount=0;
DOMNode *child = ((DOMElement*)itemElement)->getFirstChild();
if(!child)
{
return 0;
}
while (child != 0) {
if(child->getNodeType()==DOMNode::TEXT_NODE)
{
child = child->getNextSibling();
continue;
}
iCount++;
child = child->getNextSibling();
}
return iCount;
}
bool ScaleBarObjectImp::fromXml(DOMNode* pDocument, unsigned int version)
{
if (pDocument == NULL)
{
return false;
}
bool bSuccess = FilledObjectImp::fromXml(pDocument, version);
if (bSuccess == true)
{
mpGroup->removeAllObjects(true);
DOMNode* pObjectNode = pDocument->getFirstChild();
while (pObjectNode != NULL)
{
if (XMLString::equals(pObjectNode->getNodeName(), X("objects")))
{
DOMNode* pGroupNode = pObjectNode->getFirstChild();
while (pGroupNode != NULL)
{
if (XMLString::equals(pGroupNode->getNodeName(), X("Graphic")))
{
DOMElement* pElement(static_cast<DOMElement*> (pGroupNode));
string type(A(pElement->getAttribute(X("type"))));
GraphicObjectType objectType = StringUtilities::fromXmlString<GraphicObjectType>(type);
if (objectType == GROUP_OBJECT)
{
bSuccess = mpGroup->fromXml(pGroupNode, version);
break;
}
}
pGroupNode = pGroupNode->getNextSibling();
}
}
pObjectNode = pObjectNode->getNextSibling();
}
}
return bSuccess;
}
ComponentInstanceData
CADReader::componentinstantiation (DOMElement* element)
throw(CADReadException)
{
std::string element_name;
ComponentInstanceData data;
data.id = XMLString::transcode(element->getAttribute(X("id")));
DOMNode* child = element->getFirstChild();
while (child != 0)
{
if (child->getNodeType() == DOMNode::ELEMENT_NODE)
{
element_name = XMLString::transcode(child->getNodeName());
//
// usagename
//
if (element_name == "usagename")
{
data.usage_name = usagename((DOMElement*)(child));
}
//
// componentproperties
//
else if (element_name == "componentproperties")
{
data.comp_prop = componentproperties((DOMElement*)(child));
}
//
// registercomponent
//
else if (element_name == "registercomponent")
{
registercomponent((DOMElement*)(child));
}
//
// extension
//
else if (element_name == "extension")
{
extension((DOMElement*)(child));
}
}
// get next child
child = child->getNextSibling();
}
return data;
}
static DOMElement *getExpectedChildElement(DOMNode *parent, string childName) {
for(DOMNode *child = parent->getFirstChild(); child; child = child->getNextSibling()) {
if(child->getNodeType() == DOMNode::ELEMENT_NODE && child->getLocalName() && XercesString(child->getLocalName()) == childName) {
DOMElement *childElement = dynamic_cast<DOMElement*>(child);
CHECK(childElement);
return childElement;
}
}
throw runtime_error((string)XercesString(parent->getLocalName()) + " missing expected child element " + childName);
}
vector<ImportDescriptor*> LayerImporter::getImportDescriptors(const string& filename, bool reportErrors)
{
vector<ImportDescriptor*> descriptors;
if (!filename.empty())
{
MessageLog* pLog = NULL;
if (reportErrors == true)
{
Service<MessageLogMgr> pLogMgr;
pLog = pLogMgr->getLog();
}
XmlReader xml(pLog);
XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* pDoc = xml.parse(filename, "metadata");
DOMElement* pRootElement = NULL;
if (pDoc != NULL)
{
pRootElement = pDoc->getDocumentElement();
}
if (pRootElement != NULL)
{
for (DOMNode* pChild = pRootElement->getFirstChild();
pChild != NULL;
pChild = pChild->getNextSibling())
{
if (pChild->getNodeType() == DOMNode::ELEMENT_NODE)
{
DOMElement* pChildElement = static_cast<DOMElement*>(pChild);
string cNodeName = A(pChildElement->getNodeName());
ImportDescriptor* pImportDescriptor = ModelImporter::populateImportDescriptor(pChildElement, filename);
if (pImportDescriptor != NULL)
{
DataDescriptor* pDataDescriptor = pImportDescriptor->getDataDescriptor();
if (NULL != pDataDescriptor)
{
DynamicObject* pMetadataZ = pDataDescriptor->getMetadata();
VERIFYRV(pMetadataZ, descriptors);
if (!pMetadataZ->getAttributeByPath("Layer/Import Options/Use Pixel Coordinates").isValid())
{
pMetadataZ->setAttributeByPath("Layer/Import Options/Use Pixel Coordinates", false);
}
}
descriptors.push_back(pImportDescriptor);
}
}
}
}
}
return descriptors;
}
DOMNode* DomSerializer::FindElementByName(DOMNode *node, CStdString name)
{
DOMNode *child = node->getFirstChild();
while(child)
{
if (XMLStringToLocal(child->getNodeName()) == name && child->getNodeType() == DOMNode::ELEMENT_NODE)
{
return child;
}
child = child->getNextSibling();
}
return NULL;
}
static vector<DOMElement*> getChildElements(DOMElement *parent) {
vector<DOMElement*> ret;
for(DOMNode *child = parent->getFirstChild(); child; child = child->getNextSibling()) {
if(child->getNodeType() == DOMNode::ELEMENT_NODE) {
DOMElement *childElement = dynamic_cast<DOMElement*>(child);
CHECK(childElement);
ret.push_back(childElement);
}
}
return ret;
}
DOMNode* getTagByName (DOMNode* node, std::string tagName) {
assert (node->getNodeType () == DOMNode::ELEMENT_NODE);
DOMNode* tag = 0;
DOMNode* CurNode = node->getFirstChild ();
while (CurNode != 0) {
if (std::string (XMLString::transcode (CurNode->getNodeName())) == tagName) {
cdebug << "Found..." << XMLString::transcode (CurNode->getNodeName()) << std::endl;
return CurNode;
}
CurNode = CurNode->getNextSibling ();
}
throw ("Not found");
} /* DOMNode* getTagByName (DOMNode* node, std::string tagName) */
void
CADReader::connections (DOMElement* element)
throw(CADReadException)
{
std::string element_name;
DOMNode* child = element->getFirstChild();
while (child != 0)
{
if (child->getNodeType() == DOMNode::ELEMENT_NODE)
{
element_name = XMLString::transcode(child->getNodeName());
//
// connectinterface
//
if (element_name == "connectinterface")
{
connectinterface((DOMElement*)(child));
}
//
// connectevent
//
if (element_name == "connectevent")
{
connectevent((DOMElement*)(child));
}
//
// connecthomes
//
if (element_name == "connecthomes")
{
connecthomes((DOMElement*)(child));
}
//
// extension
//
if (element_name == "extension")
{
extension((DOMElement*)(child));
}
}
// get next child
child = child->getNextSibling();
}
}
XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ParameterGrp::FindNextElement(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *Prev, const char* Type) const
{
DOMNode *clChild = Prev;
if (!clChild) return 0l;
while ((clChild = clChild->getNextSibling())!=0) {
if (clChild->getNodeType() == DOMNode::ELEMENT_NODE) {
// the right node Type
if (!strcmp(Type,StrX(clChild->getNodeName()).c_str())) {
return (DOMElement*)clChild;
}
}
}
return NULL;
}
void Normalizer::printEntityRefNodes(DOMElement *ele) {
DOMNode *child = ele->getFirstChild();
while(child != 0) {
if(child->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
XERCES_STD_QUALIFIER cout << "start of entity ref node" << XERCES_STD_QUALIFIER endl;
DOMNode *entChild = ((DOMEntityReference*)child)->getFirstChild();
while(entChild != 0) {
serializeNode(entChild);
entChild = entChild->getNextSibling();
}
XERCES_STD_QUALIFIER cout << "\nend of entity ref node\n\n" << XERCES_STD_QUALIFIER endl;
}
if(child->getNodeType() == DOMNode::ELEMENT_NODE) {
printEntityRefNodes((DOMElement*)child);
}
child = child->getNextSibling();
}
}
// Finds and returns the last child element node.
DOMElement* XUtil::getNextSiblingElement(const DOMNode* const node)
{
// search for node
DOMNode* sibling = node->getNextSibling();
while (sibling != 0)
{
if (sibling->getNodeType() == DOMNode::ELEMENT_NODE)
return (DOMElement*)sibling;
sibling = sibling->getNextSibling();
}
// not found
return 0;
}
bool ConfigurationFileHandler::getSubAlgorithm(std::string algorithm, std::string subalgorithm, std::string* result){
#ifdef BRICS_XERCES_ENABLE
if (errorsOccured) {
return false;
}
DOMNode* current = NULL;
DOMNode* attributeNode = NULL;
XMLCh* algorithmName = XMLString::transcode(algorithm.c_str());
XMLCh* subAlgorithmName = XMLString::transcode(subalgorithm.c_str());
XMLCh* implementationString = XMLString::transcode("implementation");
bool subAlgorithmFound = false;
DOMDocument* doc = parser->getDocument();
DOMNodeList* root = doc->getElementsByTagName(algorithmName);
if (root->getLength() > 1) {
LOG(WARNING) << "More than one " << algorithm << " found, taking the first one";
} else if(root->getLength() < 1) {
LOG(WARNING) << "No algorithm called " << algorithm << " found.";
return false; //TODO release resouces
}
current = root->item(0);
//search in children notes
for (current = current->getFirstChild()->getNextSibling(); current!=NULL; current = current->getNextSibling()) {
string nodeName = XMLString::transcode(current->getNodeName());
if (nodeName.compare(subalgorithm) == 0) {
DOMNamedNodeMap* attributesList = current->getAttributes();
attributeNode = attributesList->getNamedItem(implementationString);
if (attributeNode != 0) {
*result = XMLString::transcode(attributeNode->getNodeValue());
subAlgorithmFound = true;
break; //take only first found
}
}
}
XMLString::release(&algorithmName);
XMLString::release(&subAlgorithmName);
XMLString::release(&implementationString);
return subAlgorithmFound;
#else
return false;
#endif
}
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;
}
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
CCDReader::corbacomponent (DOMElement* element)
throw(CCDReadException)
{
std::string repid_of_home;
DOMNode* child = element->getFirstChild();
while (child != 0)
{
if (child->getNodeType() == DOMNode::ELEMENT_NODE)
{
//
// homerepid
//
if (!XMLString::compareString(child->getNodeName(), X("homerepid")))
{
data_->home_repid = homerepid((DOMElement*)child);
}
//
// homefeatures
//
else if (!XMLString::compareString(child->getNodeName(), X("homefeatures")))
{
}
//
// componentkind
//
else if (!XMLString::compareString(child->getNodeName(), X("componentkind")))
{
componentkind( (DOMElement*)child );
}
//
// componentfeatures
//
else if (!XMLString::compareString(child->getNodeName(), X("componentfeatures")))
{
componentfeatures( (DOMElement*) child);
}
}
// get next child
child = child->getNextSibling();
}
}
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() ));
}
BehaviorRequestPtr BML::parse_bml_event( DOMElement* elem, const std::string& unique_id, BehaviorSyncPoints& behav_syncs, bool required, BmlRequestPtr request, SmartBody::SBScene* scene ) {
const XMLCh* tag = elem->getTagName();
// message (the event behavior) can be retrieved either via the attribute, or via the text content.
std::string msg = xml_parse_string( BMLDefs::ATTR_MESSAGE, elem, "");
std::string spNameOld = xml_parse_string( BMLDefs::ATTR_STROKE, elem, ""); // if 'stroke' is used, assume old-style command sent via VHMSG
std::string spNameNew = xml_parse_string( BMLDefs::ATTR_START, elem, ""); // if 'start' is used, assume Python style internally only
std::string localId = xml_parse_string( BMLDefs::ATTR_ID, elem, "");
DOMNode* child = elem->getFirstChild();
while (child)
{
DOMNode::NodeType type = child->getNodeType();
if (type == DOMNode::CDATA_SECTION_NODE)
{
child->normalize();
DOMText* textNode = dynamic_cast<DOMText*>(child);
const XMLCh* messageData = textNode->getNodeValue();
msg = xml_utils::xml_translate_string(messageData);
break;
}
child = child->getNextSibling();
}
if (msg != "" )
{
if (spNameNew.size() > 0)
{
// new style event sent via Python
return BehaviorRequestPtr( new EventRequest( unique_id, localId, "", msg, behav_syncs, spNameNew ) );
}
else
{
// old style command send via vhmsg
return BehaviorRequestPtr( new EventRequest( unique_id, localId, msg, "", behav_syncs, spNameOld ) );
}
}
else
{
xml_parse_error( BMLDefs::ATTR_MESSAGE, elem );
return BehaviorRequestPtr(); // a.k.a., NULL
}
}
void
CSDReader::idl (DOMElement* element)
throw(CSDReadException)
{
std::string element_name;
IDLData data;
data_->repid = Qedo::transcode(element->getAttribute(X("id")));
DOMNode* child = element->getFirstChild();
while (child != 0)
{
if (child->getNodeType() == DOMNode::ELEMENT_NODE)
{
element_name = Qedo::transcode(child->getNodeName());
//
// link
//
if (element_name == "link")
{
data.kind = LINK;
data.location = link((DOMElement*)child);
data_->idl = data;
}
//
// fileinarchive
//
if (element_name == "fileinarchive")
{
data.kind = FILEINARCHIVE;
data.location = fileinarchive((DOMElement*)child);
data_->idl = data;
}
//
// repository
//
if (element_name == "repository")
{
// todo
}
}
// get next child
child = child->getNextSibling();
}
}
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);
}
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 );
}
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;
}
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(); // 次の要素を処理する
}
}
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;
}
SYSTEM::IConfigItemPtr SYSTEM::CConfigItem::GetFirstChild()
{
DOMNode *FirstChild = ((DOMElement*)itemElement)->getFirstChild();
if(FirstChild == NULL)
return NULL;
while(FirstChild != NULL && FirstChild->getNodeType() == DOMNode::TEXT_NODE)
FirstChild = FirstChild->getNextSibling();
if(FirstChild == NULL)
return NULL;
CConfigItem* item = new CConfigItem;
item->itemElement = FirstChild;
item->doc = doc;
return IConfigItemPtr((IConfigItem*)item);
}
SYSTEM::IConfigItemPtr SYSTEM::CConfigItem::GetPreviousSibling()
{
DOMNode *sbliding = ((DOMElement*)itemElement)->getPreviousSibling();
if(sbliding == NULL)
return NULL;
while(sbliding != NULL && sbliding->getNodeType() == DOMNode::TEXT_NODE)
sbliding = sbliding->getNextSibling();
if(sbliding == NULL)
return NULL;
CConfigItem* item = new CConfigItem;
item->itemElement =sbliding;
item->doc = this->doc;
return IConfigItemPtr((IConfigItem*)item);
}
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();
}
}
}
virtual XPathValue value(const DOMNode& node,
ExecutionContext<string_type, string_adaptor>& context,
DOMSink<string_type, string_adaptor>& sink) const
{
if(select_)
return select_->evaluate(node, context.xpathContext());
execute_children(node, context);
if(sink.node() == 0)
return StringValue::createValue(string_adaptor::empty_string());
NodeSet nodeset;
for(DOMNode n = sink.node().getFirstChild(); n != 0; n = n.getNextSibling())
nodeset.push_back(n);
return NodeSetValue::createValue(nodeset);
} // value
// Returns the next logical sibling with respect to the given node.
DOMNode* DOMElementImpl::getNextLogicalSibling(const DOMNode* n) const
{
DOMNode* next = n->getNextSibling();
// If "n" has no following sibling and its parent is an entity reference node we
// need to continue the search through the following siblings of the entity
// reference as these are logically siblings of the given node.
if (next == NULL) {
DOMNode* parent = n->getParentNode();
while (parent != NULL && parent->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
next = parent->getNextSibling();
if (next != NULL) {
break;
}
parent = parent->getParentNode();
}
}
return next;
}
