void DOMtoXMLElement(DOMNode* dom, XMLElement& xml)
{
xml.setName(StrX(dom->getNodeName()));
unsigned int i;
string text;
DOMNodeList* children = dom->getChildNodes();
for (i=0;children && i<children->getLength();i++) {
DOMNode* child = children->item(i);
switch (child->getNodeType()) {
case DOMNode::TEXT_NODE:
text+=StrX(child->getNodeValue());
break;
case DOMNode::ELEMENT_NODE:
{
XMLElement childElement;
DOMtoXMLElement(child, childElement);
xml.addChild(childElement);
}
break;
default:
continue;
}
}
xml.setText(text);
DOMNamedNodeMap* attrs = dom->getAttributes();
if (attrs == 0)
return;
for (i=0;i<attrs->getLength();i++) {
DOMNode* attr = attrs->item(i);
xml.setAttribute(StrX(attr->getNodeName()), StrX(attr->getNodeValue()));
}
}
std::string getAttributeByName (DOMNode* node, std::string attrName) {
cdebug << "getAttr " << attrName << std::endl;
assert (node->getNodeType () == DOMNode::ELEMENT_NODE);
std::string value = "";
if (node->hasAttributes()) {
DOMNamedNodeMap *pAttributes = node->getAttributes ();
for (unsigned int i = 0; i < pAttributes->getLength (); i++) {
DOMAttr* pAttributeNode = (DOMAttr*) pAttributes->item(i);
char* name = XMLString::transcode(pAttributeNode->getName());
if (name == attrName) {
char* tmpValue = XMLString::transcode(pAttributeNode->getValue());
value = tmpValue;
XMLString::release(&tmpValue);
}
XMLString::release(&name);
}
} else {
cdebug << "Error in file to parse" << std::endl;
throw ("Error in file to parse attributes");
}
cdebug << value << std::endl;
return value;
} /* std::string getAttributeByName (DOMNode* node, std::string attrName) */
// ----------------------------------------------------------------------------
// Base Attributes Builder
// ----------------------------------------------------------------------------
void AttributesBuilder::getAttributes()
{
if ( node_->hasAttributes() ) {
DOMNamedNodeMap* theAttributes = node_->getAttributes();
int numAttributes = theAttributes->getLength();
for (int n=0; n < numAttributes; ++n) {
DOMNode* attrib = theAttributes->item(n);
const XMLCh* xmlch_Name = attrib->getNodeName();
char* attrName = XMLString::transcode(xmlch_Name);
const XMLCh* xmlch_Value = attrib->getNodeValue();
char* attrValue = XMLString::transcode(xmlch_Value);
try {
//attrib_->update(pname.get(), pval.get());
attrib_->update(attrName, attrValue);
} catch (std::runtime_error &ex) {
std::cerr << ex.what() << std::endl
<< builderType_ << __FUNCTION__ << "(): "
<< "In space \"" << attrib_->getValAsStr("name")
<< "\", unrecognized attribute \"" << attrName << "=" << attrValue
<< "\". Ignoring it." << std::endl;
};
XMLString::release( &attrName );
XMLString::release( &attrValue );
}
}
}
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);
}
}
//=============================================================================
// METHOD: SPELLxmlConfigReaderXC::convertToNode
//=============================================================================
SPELLxmlNode* SPELLxmlConfigReaderXC::convertToNode( DOMElement* element )
{
// Create an abstract node with this name
SPELLxmlNode* node = new SPELLxmlNode( XMLString::transcode(element->getNodeName()) );
// Get any possible attributes
DOMNamedNodeMap* attrs = element->getAttributes();
XMLSize_t numAttrs = attrs->getLength();
for( XMLSize_t idx = 0; idx < numAttrs; idx++)
{
// Get the attribute node
DOMNode* attrNode = attrs->item(idx);
// Get name and value
const XMLCh* aname = attrNode->getNodeName();
const XMLCh* avalue = attrNode->getNodeValue();
// Convert name and value to strings
std::string name = "<?>";
if (aname != NULL)
{
name = XMLString::transcode(aname);
}
std::string value = "<?>";
if (avalue != NULL)
{
value = XMLString::transcode(avalue);
}
node->addAttribute( name, value );
}
// Get any possible children
DOMNodeList* children = element->getChildNodes();
XMLSize_t numChildren = children->getLength();
for( XMLSize_t idx = 0; idx < numChildren; idx++)
{
// Get the children node
DOMNode* childNode = children->item(idx);
// Process only ELEMENTs and TEXTs
if (childNode->getNodeType() && // true is not NULL
childNode->getNodeType() == DOMNode::ELEMENT_NODE) // is element
{
// For elements, recursively add children
SPELLxmlNode* child = convertToNode( dynamic_cast<xercesc::DOMElement*>(childNode) );
node->addChild(child);
}
else if (childNode->getNodeType() == DOMNode::TEXT_NODE)
{
// For text values, add the value. This code will just ignore
// carriage-return values
const XMLCh* nvalue = childNode->getNodeValue();
if (nvalue != NULL)
{
std::string thevalue = XMLString::transcode(nvalue);
SPELLutils::trim(thevalue, " \n\r\t");
node->setValue( thevalue );
}
}
}
return node;
}
void AcsAlarmTestCase::verifyUserTimestampElement(DOMDocument * doc)
{
// Verify the user-timestamp element
DOMNodeList * userTimestampNodes = doc->getElementsByTagName(USER_TIMESTAMP_TAG_NAME);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; no user-properties element found",
(NULL != userTimestampNodes && userTimestampNodes->getLength() == 1));
// verify that there are 2 attributes
DOMNamedNodeMap * attributesMap = userTimestampNodes->item(0)->getAttributes();
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; user-timestamp element does not contain 2 attributes",
(NULL!= attributesMap && attributesMap->getLength() == 2));
// check for seconds attribute
DOMNode * secondsValueNode = attributesMap->getNamedItem(SECONDS_TAG_NAME);
const XMLCh * secondsValue = secondsValueNode->getNodeValue();
char *secondsCharValue = XMLString::transcode(secondsValue);
int secondsIntValue = atoi(secondsCharValue);
XMLString::release(&secondsCharValue);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; user-timestamp element, 'seconds' attribute value is not correct",
(NULL!= secondsValue && secondsIntValue == SECONDS_VALUE));
// check for microseconds attribute
DOMNode * microsecondsValueNode = attributesMap->getNamedItem(MICROSECONDS_TAG_NAME);
const XMLCh * microsecondsValue = microsecondsValueNode->getNodeValue();
char *microsecondsCharValue = XMLString::transcode(microsecondsValue);
int microsecondsIntValue = atoi(microsecondsCharValue);
XMLString::release(µsecondsCharValue);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; user-timestamp element, 'microseconds' attribute value is not correct",
(NULL!= microsecondsValue && microsecondsIntValue == MICROSECONDS_VALUE));
}
bool
XMLExtServiceHelper::parseExtServicesReq( DOMNode* cur, DOMNode* out,
DOMDocument* reply,
bool indent,
const HttpHeader& inHeaders )
{
// Attributes
DOMNamedNodeMap* attributes = cur->getAttributes();
// Language of the request.
LangTypes::language_t lang = LangTypes::english;
// Semi-optional crc
MC2String crc;
for( int i = 0, n = attributes->getLength(); i < n; ++i ) {
DOMNode* attrib = attributes->item( i );
if ( XMLString::equals( attrib->getNodeName(), "language" ) ) {
lang = m_xmlParserThread->getStringAsLanguage(
XMLUtility::getChildTextStr( *attrib ).c_str() );
} else if ( XMLString::equals( attrib->getNodeName(), "crc" ) ) {
crc = XMLUtility::getChildTextStr( *attrib );
}
}
// Make the answer.
appendExternalSearchDesc( out,
reply,
cur,
crc,
lang,
1,
indent );
return true;
}
EppCommandInfoLaunchRegistration* EppCommandInfoLaunchRegistration::fromXML( const DOMNode& root )
{
EppCommandInfoLaunchRegistration* cmd = new EppCommandInfoLaunchRegistration();
if( cmd == null )
{
return null;
}
DOMNodeList* list = root.getChildNodes();
DOMNamedNodeMap* attrs = root.getAttributes();
for( unsigned int i = 0; i < list->getLength(); i++ )
{
DOMNode* node = list->item(i);
DOMString name = node->getLocalName();
if( name.isNull() )
{
name = node->getNodeName();
}
if( name.isNull() )
{
continue;
}
if( (name.length() > 7) && name.substringData(0, 7).equals("launch:") )
{
name = name.substringData(7, name.length() - 7);
}
if( name.equals("phase") )
{
EppLaunchPhase *_pptr = EppLaunchPhase::fromXML(*node);
if( null != _pptr )
{
cmd->_phase = *_pptr;
delete _pptr;
}
_pptr = null;
}
else if ( name.equals("applicationID") )
{
cmd->_appId = EppUtil::getText(*node);
}
}
for( unsigned int i = 0;i<attrs->getLength();i++ )
{
DOMNode* attr = attrs->item(i);
if( XS(attr->getNodeName()).equals("includeMark") )
{
DOMString _v = attr->getNodeValue();
if( _v.length() > 0 )
{
if( _v.equals("true") )
{
cmd->includeMark(true);
}
}
break;
}
}
return cmd;
}
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);
}
}
void *PointSet::read(DOMNode *node) {
unsigned int i; // variable to counter
DOMNodeList *children; // variable to hold the node children
DOMNamedNodeMap *attributes; // variable to hold the node attributes
attributes = node->getAttributes();
for (i = 0; i < attributes->getLength(); i++) {
if (!strcmp(XMLString::transcode(attributes->item(i)->getNodeName()) , "DEF")) {
setLink(XMLString::transcode(attributes->item(i)->getNodeValue()),this);
}// else
//if (!strcmp(XMLString::transcode(attributes->item(i)->getNodeName()) , "USE")) {
// return(getLink(XMLString::transcode(attributes->item(i)->getNodeValue())));
//}
}
children = node->getChildNodes();
if (children != NULL) {
for (i = 0; i < children->getLength (); i++) {
if (!strcmp (XMLString::transcode(children->item(i)->getNodeName()),"Coordinate")) {
coordinate = Coordinate::get(children->item(i));
coordinateNumber = coordinate->getNumberOfElements();
} else
if (!strcmp (XMLString::transcode(children->item(i)->getNodeName()),"Color")) {
color = Color::get(children->item(i));
colorNumber = color->getNumberOfElements();
}
}
}
#ifdef DEBUG
float sizes[2];
float step;
glGetFloatv(GL_POINT_SIZE_RANGE,sizes);
glGetFloatv(GL_POINT_SIZE_GRANULARITY,&step);
cout << "Max and Min point size " << sizes[0] << " , " << sizes[1] << " Granularity " << step << endl;
#endif
if(colorNumber) {
if(colorNumber==3) {
cout << "Three colors selected" << endl;
} else
if(colorNumber!=coordinateNumber) {
cerr << "Color and coordinate not matching" << endl;
}
}
#ifdef DEBUG
cout << "Coordinate Number " << coordinateNumber << endl;
cout << "Color Number " << colorNumber << endl;
#endif
return(NULL);
}
//
// domCheckSum - Compute the check sum for a DOM node.
// Works recursively - initially called with a document node.
//
void ThreadParser::domCheckSum(const DOMNode *node)
{
const XMLCh *s;
DOMNode *child;
DOMNamedNodeMap *attributes;
switch (node->getNodeType() )
{
case DOMNode::ELEMENT_NODE:
{
s = node->getNodeName(); // the element name
attributes = node->getAttributes(); // Element's attributes
int numAttributes = attributes->getLength();
int i;
for (i=0; i<numAttributes; i++)
domCheckSum(attributes->item(i));
addToCheckSum(s); // Content and Children
for (child=node->getFirstChild(); child!=0; child=child->getNextSibling())
domCheckSum(child);
break;
}
case DOMNode::ATTRIBUTE_NODE:
{
s = node->getNodeName(); // The attribute name
addToCheckSum(s);
s = node->getNodeValue(); // The attribute value
if (s != 0)
addToCheckSum(s);
break;
}
case DOMNode::TEXT_NODE:
case DOMNode::CDATA_SECTION_NODE:
{
s = node->getNodeValue();
addToCheckSum(s);
break;
}
case DOMNode::ENTITY_REFERENCE_NODE:
case DOMNode::DOCUMENT_NODE:
{
// For entity references and the document, nothing is dirctly
// added to the checksum, but we do want to process the chidren nodes.
//
for (child=node->getFirstChild(); child!=0; child=child->getNextSibling())
domCheckSum(child);
break;
}
}
}
bool XmlParser::nodesMatch(DOMElement *mergeEl, DOMElement *patchEl) {
DualString mergeTagName(mergeEl->getTagName());
DualString patchTagName(patchEl->getTagName());
if (verbose) {
cerr << "Comparing Tag \'" << mergeTagName.asCString() << "\' to \'" << patchTagName.asCString();
}
if (!XMLString::equals(mergeTagName.asXMLString(), patchTagName.asXMLString())) {
if (verbose) {
cerr << "\' - false\n";
}
return false;
}
if (verbose) {
cerr << "\' - equal\n";
}
DOMNamedNodeMap *patchAttributes = patchEl->getAttributes();
unsigned attributeCount = patchAttributes->getLength();
for (unsigned attrIndex = 0; attrIndex < attributeCount; attrIndex++) {
DOMNode *attribute = patchAttributes->item(attrIndex);
DualString attributeName(attribute->getNodeName());
if (XMLString::equals(attributeName.asXMLString(), attr_merge_actions.asXMLString())) {
if (verbose) {
cerr << "Skipping attribute \'" << attributeName.asCString() << "\'\n";
}
continue;
}
if (verbose) {
cerr << "Checking for attribute \'" << attributeName.asCString();
}
if (!mergeEl->hasAttribute(attributeName.asXMLString())) {
if (verbose) {
cerr << "\' - Not present\n";
}
return false;
}
if (verbose) {
cerr << "\' - Present";
}
DualString patchAttributeValue(attribute->getNodeValue());
DualString mergeAttributeValue(mergeEl->getAttribute(attributeName.asXMLString()));
if (!XMLString::equals(patchAttributeValue.asXMLString(), mergeAttributeValue.asXMLString())) {
if (verbose) {
cerr << "\' - Not equal\n";
}
return false;
}
if (verbose) {
cerr << "\' - Equal (" << patchAttributeValue.asCString() << ")\n";
}
}
return true;
}
bool DataSource::parserDataSource(XSchema* pschema,xercesc::DOMElement* element)
{
this->parentschema=pschema;
if(element)
{
DOMNamedNodeMap *attributes;
DOMNodeList *children =element->getChildNodes();
DOMNode *tmpnode;
std::string tmpstr=XMLString::transcode(element->getNodeName());
if(tmpstr!="DataSource")
{
return false;
}
attributes=element->getAttributes();
if(attributes)
{
for(int j=0;j<attributes->getLength();j++)
{
tmpnode=attributes->item(j);
tmpstr=XMLString::transcode(tmpnode->getNodeName());
if(tmpstr == "type")
{
this->type_ = (DataSource::CUBETYPE) atoi(XMLString::transcode(tmpnode->getNodeValue()));
}
else if(tmpstr=="url")
{
this->_URL=XMLString::transcode(tmpnode->getNodeValue());
}
else if(tmpstr=="passWord")
{
this->_psword=XMLString::transcode(tmpnode->getNodeValue());
}
else if(tmpstr=="userName")
{
this->_UserName =XMLString::transcode(tmpnode->getNodeValue());
}
}
}
else
{
return false;
}
}
else
{
return false;
}
return true;
}
void AcsAlarmTestCase::verifyUserTimestampElement(DOMDocument * doc)
{
// Verify the user-timestamp element
DOMNodeList * userTimestampNodes = doc->getElementsByTagName(USER_TIMESTAMP_TAG_NAME);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; no user-properties element found",
(NULL != userTimestampNodes && userTimestampNodes->getLength() == 1));
// verify that there are 2 attributes
DOMNamedNodeMap * attributesMap = userTimestampNodes->item(0)->getAttributes();
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; user-timestamp contain attributes",
(NULL!= attributesMap && attributesMap->getLength() == 0));
}
const XMLCh* DOMNodeImpl::lookupNamespacePrefix(const XMLCh* const namespaceURI, bool useDefault, DOMElement *el) const {
DOMNode *thisNode = castToNode(this);
const XMLCh* ns = thisNode->getNamespaceURI();
// REVISIT: if no prefix is available is it null or empty string, or
// could be both?
const XMLCh* prefix = thisNode->getPrefix();
if (ns != 0 && XMLString::equals(ns,namespaceURI)) {
if (useDefault || prefix != 0) {
const XMLCh* foundNamespace = el->lookupNamespaceURI(prefix);
if (foundNamespace != 0 && XMLString::equals(foundNamespace, namespaceURI)) {
return prefix;
}
}
}
if (thisNode->hasAttributes()) {
DOMNamedNodeMap *nodeMap = thisNode->getAttributes();
if(nodeMap != 0) {
int length = nodeMap->getLength();
for (int i = 0;i < length;i++) {
DOMNode *attr = nodeMap->item(i);
const XMLCh* attrPrefix = attr->getPrefix();
const XMLCh* value = attr->getNodeValue();
ns = attr->getNamespaceURI();
if (ns != 0 && XMLString::equals(ns, XMLUni::fgXMLNSURIName)) {
// DOM Level 2 nodes
if ((useDefault && XMLString::equals(attr->getNodeName(), XMLUni::fgXMLNSString)) ||
(attrPrefix != 0 && XMLString::equals(attrPrefix, XMLUni::fgXMLNSString)) &&
XMLString::equals(value, namespaceURI)) {
const XMLCh* localname= attr->getLocalName();
const XMLCh* foundNamespace = el->lookupNamespaceURI(localname);
if (foundNamespace != 0 && XMLString::equals(foundNamespace, namespaceURI)) {
return localname;
}
}
}
}
}
}
DOMNode *ancestor = getElementAncestor(thisNode);
if (ancestor != 0) {
return castToNodeImpl(ancestor)->lookupNamespacePrefix(namespaceURI, useDefault, el);
}
return 0;
}
Inline *Inline::get(DOMNode *node) {
unsigned int i; // variable to counter
DOMNamedNodeMap *attributes; // variable to hold the node attributes
char DEF2[256]; // temporary variable to hold the DEF name
strcpy(DEF2,""); // reseting the variable
Inline *inline2 = NULL; // temporary variable
attributes = node->getAttributes();
for (i = 0; i < attributes->getLength(); i++) {
if (!strcmp(XMLString::transcode(attributes->item(i)->getNodeName()) , "DEF")) {
strcpy(DEF2,XMLString::transcode (attributes->item(i)->getNodeValue()));
break;
} else
if (!strcmp(XMLString::transcode(attributes->item(i)->getNodeName()) , "USE")) {
inline2 = (Inline *)getLink(XMLString::transcode(attributes->item(i)->getNodeValue()));
if( inline2->ami("Inline") ) {
cout << "USE of a different DEF type" << endl;
}
return(inline2);
}
}
// verificar se o USE ta retornando NULL
inline2 = new Inline();
if(inline2==NULL) {
cerr << "Error on getting Group" << endl;
}
if(strcmp(DEF2,"")) {
#ifdef DEBUG3
cout << "DEF : " << DEF2 << endl;
#endif
strcpy(inline2->DEF,DEF2);
setLink(inline2->DEF,inline2);
}
inline2->read(node);
return inline2;
}
XMLNode *JobXML::deepCopyElement( XMLNode **copy, const XMLNode *original )
{
// add the element to the copy
char *nodeName = XMLString::transcode( original->getNodeName() );
XMLNode *newElement = AddElement( (*copy), nodeName );
XMLString::release( &nodeName );
// add its attributes
if ( original->hasAttributes() )
{
DOMNamedNodeMap *attributes = original->getAttributes();
for( unsigned int i=0; i<attributes->getLength(); i++ )
{
DOMAttr *attr = (DOMAttr*)attributes->item( i );
char *key = XMLString::transcode( attr->getName() );
char *val = XMLString::transcode( attr->getValue() );
SetAttribute( newElement, key, val );
XMLString::release( &key );
XMLString::release( &val );
}
}
// recursively copy all child elements
int childElementCount=0;
XMLNode *itr = original->getFirstChild();
for ( ; itr != NULL; itr = itr->getNextSibling() )
{
if ( itr->getNodeType() == XMLNode::ELEMENT_NODE )
{
deepCopyElement( &newElement, itr );
childElementCount++;
}
}
// if no child elements, copy this element's text content and we are done
if ( childElementCount == 0 )
{
char *content = XMLString::transcode( original->getTextContent() );
SetContent( newElement, content );
XMLString::release( &content );
}
return newElement;
}
Anchor *Anchor::get(DOMNode *node) {
unsigned int i; // variable to counter
DOMNamedNodeMap *attributes; // variable to hold the node attributes
Anchor *anchor;
attributes = node->getAttributes();
for (i = 0; i < attributes->getLength(); i++) {
if (!strcmp(XMLString::transcode(attributes->item(i)->getNodeName()) , "USE")) {
return((Anchor *)getLink(XMLString::transcode(attributes->item(i)->getNodeValue())));
}
}
anchor = new Anchor();
anchor->read(node);
return anchor;
}
// ---------------------------------------------------------------------------
//
// Recursively Count up the total number of child Elements under the specified Node.
// Process attributes of the node, if any.
//
// ---------------------------------------------------------------------------
static int countChildElements(DOMNode *n, bool printOutEncounteredEles)
{
DOMNode *child;
int count = 0;
if (n) {
if (n->getNodeType() == DOMNode::ELEMENT_NODE)
{
if(printOutEncounteredEles) {
char *name = XMLString::transcode(n->getNodeName());
cout <<"----------------------------------------------------------"<<endl;
cout <<"Encountered Element : "<< name << endl;
XMLString::release(&name);
if(n->hasAttributes()) {
// get all the attributes of the node
DOMNamedNodeMap *pAttributes = n->getAttributes();
int nSize = pAttributes->getLength();
cout <<"\tAttributes" << endl;
cout <<"\t----------" << endl;
for(int i=0; i<nSize; ++i) {
DOMAttr *pAttributeNode = (DOMAttr*) pAttributes->item(i);
// get attribute name
char *name = XMLString::transcode(pAttributeNode->getName());
cout << "\t" << name << "=";
XMLString::release(&name);
// get attribute type
name = XMLString::transcode(pAttributeNode->getValue());
cout << name << endl;
XMLString::release(&name);
}
}
}
++count;
}
for (child = n->getFirstChild(); child != 0; child=child->getNextSibling())
count += countChildElements(child, printOutEncounteredEles);
}
return count;
}
PointSet *PointSet::get(DOMNode *node) {
unsigned int i; // variable to counter
DOMNamedNodeMap *attributes; // variable to hold the node attributes
PointSet *pointSet;
attributes = node->getAttributes();
for (i = 0; i < attributes->getLength(); i++) {
if (!strcmp(XMLString::transcode(attributes->item(i)->getNodeName()) , "USE")) {
return((PointSet *)getLink(XMLString::transcode(attributes->item(i)->getNodeValue())));
}
}
pointSet = new PointSet();
pointSet->read(node);
return pointSet;
}
NurbsCurve *NurbsCurve::get(DOMNode *node) {
NurbsCurve *nurbsCurve;
unsigned int i; // variable to counter
DOMNamedNodeMap *attributes; // variable to hold the node attributes
attributes = node->getAttributes();
for (i = 0; i < attributes->getLength(); i++) {
if (!strcmp(XMLString::transcode(attributes->item(i)->getNodeName()) , "USE")) {
return((NurbsCurve *)getLink(XMLString::transcode(attributes->item(i)->getNodeValue())));
}
}
nurbsCurve = new NurbsCurve();
nurbsCurve->read(node);
return nurbsCurve;
}
// ---------------------------------------------------------------------------
// utility func to extract a DOMNodes Base attr value if present
// ---------------------------------------------------------------------------
static const XMLCh *
getBaseAttrValue(DOMNode *node){
if (node->getNodeType() == DOMNode::ELEMENT_NODE){
DOMElement *elem = (DOMElement *)node;
if(elem->hasAttributes()) {
/* get all the attributes of the node */
DOMNamedNodeMap *pAttributes = elem->getAttributes();
XMLSize_t nSize = pAttributes->getLength();
for(XMLSize_t i=0;i<nSize;++i) {
DOMAttr *pAttributeNode = (DOMAttr*) pAttributes->item(i);
/* get attribute name */
if (XMLString::equals(pAttributeNode->getName(), XIncludeUtils::fgXIBaseAttrName)){
/*if (namespace == XMLUni::fgXMLString){
}*/
return pAttributeNode->getValue();
}
}
}
}
return NULL;
}
void SYSTEM::CConfigItem::RemoveAllAttributes()
{
if(((DOMElement*)itemElement)->hasAttributes())
{
DOMNamedNodeMap *pAttributes = ((DOMElement*)itemElement)->getAttributes();
XMLSize_t count = pAttributes->getLength();
DOMAttr* pNode = NULL;
for (XMLSize_t i = 0 ; i < count ; ++i)
{
pNode = (DOMAttr*)pAttributes->item(0);
if( m_curValue != NULL )
XMLString::release(&m_curValue);
if(!pNode) //属性名称不存在
m_curValue = NULL;
else
m_curValue = XMLString::transcode(pNode->getName());/*DOMAttr **/
((DOMElement*)itemElement)->removeAttribute(pNode->getName());
}
}
}
void DWXML::printElement(xercesc::DOMElement *element)
{
int k;
DOMNamedNodeMap *attributes;
DOMNodeList *children =element->getChildNodes();
DOMNode *tmpnode;
std::cout<<"< "<<XMLString::transcode(element->getNodeName());
attributes=element->getAttributes();
int r= children->getLength();
if(attributes)
{
for(int j=0;j<attributes->getLength();j++)
{
tmpnode=attributes->item(j);
std::cout<<" "<<XMLString::transcode(tmpnode->getNodeName());
std::cout<<"=";
std::cout<<" "<<XMLString::transcode(tmpnode->getNodeValue());
}
}
std::cout<<" >";
if(element->hasChildNodes())
{
std::cout<<std::endl;
std::cout<<"children.length:"<<r<<std::endl;
for( k=0;k<children->getLength();k++)
{
std::cout<<k<<"="<<"type: "<<children->item(k)->getNodeType()<<std::endl;;
if(children->item(k)->getNodeType()==1)
{
printElement((DOMElement *)children->item(k));
}
else if(children->item(k)->getNodeType()== 3)
{
cout<<" "<<XMLString::transcode(children->item(k)->getNodeValue());
}
}
}
}
Triggerconf::STRING_LIST Triggerconf::getConfigAttributeNames (string module, string submodule, string configname)
{
STRING_LIST ret;
if (! existsConfigElement (module, submodule, configname)) return ret;
DOMNode* node = selectConfigElement (module, submodule, configname);
if (node == NULL || node->getNodeType () != DOMNode::ELEMENT_NODE) return ret;
DOMElement* elem = (DOMElement*) node;
DOMNamedNodeMap* attributes = elem->getAttributes ();
for (unsigned int i=0; i<attributes->getLength (); i++) {
DOMNode* attr = attributes->item (i);
const XMLCh* xname = attr->getNodeName ();
char* cname = XMLString::transcode (xname);
ret.push_back (cname);
XMLString::release (&cname);
}
return ret;
}
EppLaunchPhase* EppLaunchPhase::fromXML( const DOMNode& root )
{
DOMNamedNodeMap* attrs = root.getAttributes();
EppLaunchPhase *_ret = new EppLaunchPhase();
if( null == _ret )
return null;
{
DOMNode* node = (DOMNode*)&root;
DOMString name = node->getLocalName();
if( name.isNull() )
{
name = node->getNodeName();
}
if( name.isNotNull() )
{
if( name.substringData(0, 7).equals("launch:") )
{
name = name.substringData(7, name.length() - 7);
}
if( name.equals("phase") )
{
_ret->_phase = EppUtil::getText(*node);
}
}
}
for( unsigned int i = 0; i<attrs->getLength(); i++ )
{
DOMNode* attr = attrs->item(i);
DOMString _v = attr->getNodeValue();
if( XS(attr->getNodeName()).equals("name") )
{
_ret->_sub_phase = attr->getNodeValue();
break;
}
}
return _ret;
}
// ---------------------------------------------------------------------------
// GeneralAttributeCheck: Validation methods
// ---------------------------------------------------------------------------
void
GeneralAttributeCheck::checkAttributes(const DOMElement* const elem,
const unsigned short elemContext,
TraverseSchema* const schema,
const bool isTopLevel,
ValueVectorOf<DOMNode*>* const nonXSAttList)
{
if (nonXSAttList)
nonXSAttList->removeAllElements();
if (elem == 0 || !fAttMap || elemContext>=E_Count)
return;
const XMLCh* elemName = elem->getLocalName();
if (!XMLString::equals(SchemaSymbols::fgURI_SCHEMAFORSCHEMA, elem->getNamespaceURI())) {
schema->reportSchemaError
(
elem
, XMLUni::fgXMLErrDomain
, XMLErrs::ELTSchemaNS
, elemName
);
}
const XMLCh* contextStr = (isTopLevel) ? fgGlobal : fgLocal;
DOMNamedNodeMap* eltAttrs = elem->getAttributes();
int attrCount = eltAttrs->getLength();
XMLByte attList[A_Count];
memset(attList, 0, sizeof(attList));
for (int i = 0; i < attrCount; i++) {
DOMNode* attribute = eltAttrs->item(i);
const XMLCh* attName = attribute->getNodeName();
// skip namespace declarations
if (XMLString::equals(attName, XMLUni::fgXMLNSString)
|| XMLString::startsWith(attName, XMLUni::fgXMLNSColonString))
continue;
// Bypass attributes that start with xml
// add this to the list of "non-schema" attributes
if ((*attName == chLatin_X || *attName == chLatin_x)
&& (*(attName+1) == chLatin_M || *(attName+1) == chLatin_m)
&& (*(attName+2) == chLatin_L || *(attName+2) == chLatin_l)) {
if (nonXSAttList)
nonXSAttList->addElement(attribute);
continue;
}
// for attributes with namespace prefix
const XMLCh* attrURI = attribute->getNamespaceURI();
if (attrURI != 0 && *attrURI) {
// attributes with schema namespace are not allowed
// and not allowed on "documentation" and "appInfo"
if (XMLString::equals(attrURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) ||
XMLString::equals(elemName, SchemaSymbols::fgELT_APPINFO) ||
XMLString::equals(elemName, SchemaSymbols::fgELT_DOCUMENTATION)) {
schema->reportSchemaError(elem, XMLUni::fgXMLErrDomain,
XMLErrs::AttributeDisallowed, attName, contextStr, elemName);
}
else if (nonXSAttList)
{
nonXSAttList->addElement(attribute);
}
continue;
}
int attNameId = A_Invalid;
attName = attribute->getLocalName();
bool bContinue=false; // workaround for Borland bug with 'continue' in 'catch'
try {
attNameId= fAttMap->get(attName, fMemoryManager);
}
catch(const OutOfMemoryException&)
{
throw;
}
catch(...) {
schema->reportSchemaError(elem, XMLUni::fgXMLErrDomain,
XMLErrs::AttributeDisallowed, attName, contextStr, elemName);
bContinue=true;
}
if(bContinue)
continue;
if (fgElemAttTable[elemContext][attNameId] & Att_Mask) {
attList[attNameId] = 1;
validate
(
elem
, attName
, attribute->getNodeValue()
, fgElemAttTable[elemContext][attNameId] & DV_Mask
, schema
);
}
else {
schema->reportSchemaError(elem, XMLUni::fgXMLErrDomain,
XMLErrs::AttributeDisallowed, attName, contextStr, elemName);
}
}
// ------------------------------------------------------------------
// Check for required attributes
// ------------------------------------------------------------------
for (unsigned int j=0; j < A_Count; j++) {
if ((fgElemAttTable[elemContext][j] & Att_Required) && attList[j] == 0) {
schema->reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeRequired,
fAttNames[j], contextStr, elemName);
}
}
}
void *NurbsCurve::read(DOMNode *node) {
unsigned int i; //* variable to counter
DOMNamedNodeMap *attributes; //* variable to hold the node attributes
char *ctemp; //* temporary variable
attributes = node->getAttributes();
for (i = 0; i < attributes->getLength(); i++) {
if (!strcmp(XMLString::transcode(attributes->item(i)->getNodeName()) , "DEF")) {
strcpy(this->DEF,XMLString::transcode (attributes->item(i)->getNodeValue()));
setLink(XMLString::transcode(attributes->item(i)->getNodeValue()),this);
} else
if (!strcmp(XMLString::transcode(attributes->item(i)->getNodeName()) , "USE")) {
return(getLink(XMLString::transcode(attributes->item(i)->getNodeValue())));
}
}
for (i = 0; i < attributes->getLength(); i++) {
if ( !strcmp(XMLString::transcode (attributes->item(i)->getNodeName()) , "tessellation")) {
} else
if ( !strcmp(XMLString::transcode (attributes->item(i)->getNodeName()) , "containerField")) {
} else
if ( !strcmp(XMLString::transcode (attributes->item(i)->getNodeName()) , "order")) {
} else
if ( !strcmp(XMLString::transcode (attributes->item(i)->getNodeName()) , "controlPoint")) {
numberOfPoints=0;
ctemp = strtok(XMLString::transcode (attributes->item(i)->getNodeValue())," ");
while (ctemp != NULL) {
points[numberOfPoints][0] = atof(ctemp);
ctemp = strtok(NULL," ");
points[numberOfPoints][1] = atof(ctemp);
ctemp = strtok(NULL," ");
points[numberOfPoints++][2] = atof(ctemp);
ctemp = strtok(NULL," ");
#ifdef DEBUG
cout << "Points : " << points[numberOfPoints-1][0] << " , " <<
points[numberOfPoints-1][1] << " , " <<
points[numberOfPoints-1][2] << endl;
#endif
}
}
}
#ifdef DEBUG
cout << "Number of Points : " << numberOfPoints << endl;
#endif
controlPoint = new float[3*numberOfPoints];
unsigned int f;
for(f=0;f<routeStruct::routeCount;f++) {
if (!strcmp (x3d::my_x3d->routeTable[f]->toNode,DEF)) {
if(!strcmp(x3d::my_x3d->routeTable[f]->toField,"set_controlPoint")) {
if((*x3d::my_x3d->routeTable[f]->field2)==NULL) {
(*x3d::my_x3d->routeTable[f]->field2) = new float[3*numberOfPoints];
}
delete controlPoint;
controlPoint = (float *)(*x3d::my_x3d->routeTable[f]->field2);
}
}
}
return(NULL);
}
void XmlTag::construct(XmlTag * parent, DOMNode * n, bool logging)
{
this->parent = parent;
this->name = "unknown";
if (parent == NULL)
{
if (logging)
{
pLogEngine l (LogEngine::create (LOG_DEVELOPER, "XmlTag"));
this->log = l;
}
}
else
{
if (logging) this->log = parent->log;
}
if (n == NULL)
{
if (logging) log->__format(LOG_ERROR, "Empty tag (%s)!", getFullName().c_str());
return;
}
if (n->getNodeType() != DOMNode::ELEMENT_NODE)
{
if (logging) log->__format(LOG_ERROR, "This (%s) is not a tag!", getFullName().c_str());
}
assignXmlString (name, n->getNodeName());
//fill tag attributes map
if (!n->hasAttributes())
{
if (logging) log->__format(LOG_WARNING, "No attributes in this tag (%s)!", getFullName().c_str() );
}
else
{
std::string attributeName = "";
std::string attributeData = "";
DOMNamedNodeMap *attList = n->getAttributes ();
int size = attList->getLength ();
for (int i = 0; i < size; ++i)
{
DOMAttr *attNode = (DOMAttr *) attList->item (i);
assignXmlString (attributeName, attNode->getName ());
assignXmlString (attributeData, attNode->getValue ());
if ( (attributeName != "") && (attributeData != "") )
{
attributes[attributeName] = attributeData;
attributesRead[attributeName] = false;
}
}
}
//fill child tags map
if (n->hasChildNodes())
{
std::string childTagName;
for (n = n->getFirstChild (); n != 0; n = n->getNextSibling ())
{
if (n) if (n->getNodeType() == DOMNode::ELEMENT_NODE)
{
assignXmlString (childTagName, n->getNodeName());
//XmlTag * tmpTag = new XmlTag(this, n, logging);
XmlTag * tmpTag = new XmlTag(this, n);
tags.push_back(tmpTag);
}
}
}
}
bool XCube::parserCube(XSchema* pschema,xercesc::DOMElement* element)
{
this->_parentschema=pschema;
if(element)
{
DOMNamedNodeMap *attributes;
DOMNodeList *children =element->getChildNodes();
DOMNode *tmpnode;
std::string tmpstr=XMLString::transcode(element->getNodeName());
if(tmpstr!="Cube")
{
return false;
}
attributes=element->getAttributes();
if(attributes)
{
for(int j=0;j<attributes->getLength();j++)
{
tmpnode=attributes->item(j);
tmpstr=XMLString::transcode(tmpnode->getNodeName());
if(tmpstr=="name")
{
this->_name=XMLString::transcode(tmpnode->getNodeValue());
}
else if(tmpstr=="tableName")
{
this->_fact=XMLString::transcode(tmpnode->getNodeValue());
}
}
}
else
{
return false;
}
if(element->hasChildNodes())
{
for(int k=0;k<children->getLength();k++)
{
if(children->item(k)->getNodeType()==1)
{
DOMElement* tmpelement=(DOMElement*)children->item(k);
tmpstr=XMLString::transcode(tmpelement->getNodeName());
if(tmpstr=="Dimension")
{
Dimension *dimension=new Dimension;
if(dimension->parserDimension(this,tmpelement))
{
this->_dimensions.push_back(dimension);
}
else
{
return false;
}
}
else if(tmpstr=="DimensionUsage")
{
Dimension* dimension=NULL;
attributes=tmpelement->getAttributes();
if(attributes)
{
for(int j=0;j<attributes->getLength();j++)
{
DOMNode *tmpnode=attributes->item(j);
tmpstr=XMLString::transcode(tmpnode->getNodeName());
// std::string dname1=XMLString::transcode(tmpnode->getNodeValue());
if(tmpstr=="source")
{
std::string dname=XMLString::transcode(tmpnode->getNodeValue());
dimension=this->getSchema()->getShareDimension(dname);
}
}
if(dimension)
{
Dimension *tmpdmen=new Dimension;
*tmpdmen=*dimension;
for(int j=0;j<attributes->getLength();j++)
{
DOMNode *tmpnode=attributes->item(j);
tmpstr=XMLString::transcode(tmpnode->getNodeName());
if(tmpstr=="name")
{
std::string dname=XMLString::transcode(tmpnode->getNodeValue());
tmpdmen->setName(dname);
}
else if(tmpstr=="foreignKey")
{
std::string fkey=XMLString::transcode(tmpnode->getNodeValue());
tmpdmen->setForeignKey(fkey);
}
}
tmpdmen->setCubeDimension(this);
this->_dimensions.push_back(tmpdmen);
}
}
}
else if(tmpstr=="Measure")
{
Measure *measure=new Measure;
if(measure->parserMeasure(this,tmpelement))
{
this->_measures.push_back(measure);
}
else
{
return false;
}
}
else if(tmpstr=="CalculatedMember")
{
calcMember *calmember=new calcMember;
if(calmember->parserCalMember(this,tmpelement))
{
this->_calcmembers.push_back(calmember);
}
else
{
return false;
}
}
}
}
}
else
{
return false;
}
}
else
{
return false;
}
return true;
}
