//======================================================================
//======================================================================
char* XMLDocument::getValue(DOM_Node currNode, char* path, DataTypeAttribute** dtAttributes)
{
if (mDoc == NULL)
return NULL;
if (path == NULL)
return NULL;
DOM_Node child = getNode(currNode, path, dtAttributes);
if (child == NULL)
return NULL;
child = child.getFirstChild();
if (child == NULL)
return NULL;
// If siblings exist, this is not an leaf, but a branch
DOM_Node sib = child.getNextSibling();
if (sib != NULL)
return NULL;
if (child.getNodeType() != DOM_Node::TEXT_NODE && child.getNodeType() != DOM_Node::CDATA_SECTION_NODE)
return NULL;
return child.getNodeValue().transcode();
}
void RangeImpl::checkReadOnly(DOM_Node& start, DOM_Node& end,
unsigned int startOffset, unsigned int endOffset)
{
if ((start == null) || (end == null) ) return;
//if both start and end are text check and return
if (start.getNodeType() == DOM_Node::TEXT_NODE) {
if (start.fImpl->isReadOnly()) {
throw DOM_DOMException(
DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, null);
}
if (start == end)
return;
}
//set the start and end nodes to check
DOM_Node sNode = start.getFirstChild();
for(unsigned int i = 0; i<startOffset; i++)
sNode = sNode.getNextSibling();
DOM_Node eNode;
if (end.getNodeType() == DOM_Node::TEXT_NODE) {
eNode = end; //need to check only till this node
}
else { //need to check all the kids that fall before the end offset value
eNode = end.getFirstChild();
for (unsigned int i = 0; i<endOffset-1; i++)
eNode = eNode.getNextSibling();
}
//recursivly search if any node is readonly
recurseTreeAndCheck(sNode, eNode);
}
short TreeWalkerImpl::acceptNode (DOM_Node node) {
if (fNodeFilter == 0) {
if ( ( fWhatToShow & (1 << (node.getNodeType() - 1))) != 0)
{
return DOM_NodeFilter::FILTER_ACCEPT;
}
else
{
return DOM_NodeFilter::FILTER_SKIP;
}
} else {
// REVISIT: This logic is unclear from the spec!
if ((fWhatToShow & (1 << (node.getNodeType() - 1))) != 0 ) {
return fNodeFilter->acceptNode(node);
} else {
// what to show has failed!
if (fNodeFilter->acceptNode(node) == DOM_NodeFilter::FILTER_REJECT) {
return DOM_NodeFilter::FILTER_REJECT;
} else {
return DOM_NodeFilter::FILTER_SKIP;
}
}
}
}
/** The node is accepted if it passes the whatToShow and the filter. */
bool NodeIteratorImpl::acceptNode (DOM_Node node) {
if (fDetached)
throw DOM_DOMException(DOM_DOMException::INVALID_STATE_ERR, null);
if (fNodeFilter == 0) {
return ((fWhatToShow & (1 << (node.getNodeType() - 1))) != 0);
} else {
return ((fWhatToShow & (1 << (node.getNodeType() - 1))) != 0)
&& fNodeFilter->acceptNode(node) == DOM_NodeFilter::FILTER_ACCEPT;
}
}
void RangeImpl::selectNode(const DOM_Node& refNode)
{
validateNode(refNode);
if ( !isLegalContainedNode(refNode)) {
throw DOM_RangeException(
DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
}
//First check for the text type node
if (refNode.getNodeType() == DOM_Node::TEXT_NODE)
{
//The node itself is the container.
fStartContainer = refNode;
fEndContainer = refNode;
//Select all the contents of the node
fStartOffset = 0;
fEndOffset = ((DOM_Text &)refNode).getLength();
return;
}
DOM_Node parent = refNode.getParentNode();
if (parent != null ) // REVIST: what to do if it IS null?
{
fStartContainer = parent;
fEndContainer = parent;
unsigned int i = 0;
for (DOM_Node n = parent.getFirstChild(); n!=null, n!=refNode; n = n.getNextSibling()) {
i++;
}
fStartOffset = i;
fEndOffset = fStartOffset+1;
}
}
void RangeImpl::checkIndex(const DOM_Node& node, unsigned int offset) const
{
if (offset < 0) {
throw DOM_DOMException( DOM_DOMException::INDEX_SIZE_ERR, null );
}
short type = node.getNodeType();
if((type == DOM_Node::TEXT_NODE
|| type == DOM_Node::CDATA_SECTION_NODE
|| type == DOM_Node::COMMENT_NODE
|| type == DOM_Node::PROCESSING_INSTRUCTION_NODE)) {
if (offset > node.getNodeValue().length())
throw DOM_DOMException( DOM_DOMException::INDEX_SIZE_ERR, null );
else return;
}
DOM_Node child = node.getFirstChild();
unsigned int i = 0;
for (; child != null; i++) {
child = child.getNextSibling();
}
if (i < offset) {
throw DOM_DOMException( DOM_DOMException::INDEX_SIZE_ERR, null );
}
}
DOM_Node XMLDocument::getNode(DOM_Node currNode, char* path, DataTypeAttribute** dtAttributes)
{
if (path == NULL)
return NULL_DOM_Node;
char* currName = currNode.getNodeName().transcode();
if (strcmp(currName, path) == 0 && (dtAttributes == NULL || doAttributesMatch(currNode, dtAttributes))) {
delete[] currName;
return currNode;
}
delete[] currName;
char* cp = strchr(path, '.');
char pathName[256];
if (cp == NULL)
strcpy(pathName, path);
else
{
strncpy(pathName, path, cp - path);
pathName[cp - path] = '\0';
}
DOM_Node child = currNode.getFirstChild();
while (child != NULL)
{
char* childName = child.getNodeName().transcode();
if (child.getNodeType() != DOM_Node::ELEMENT_NODE)
{
child = child.getNextSibling();
delete[] childName;
continue;
}
if (strcmp(pathName, childName) == 0)
{
if (cp != NULL) {
delete[] childName;
return getNode(child, cp+1, dtAttributes);
}
if (dtAttributes != NULL)
{
if (!doAttributesMatch(child, dtAttributes))
{
child = child.getNextSibling();
delete[] childName;
continue;
}
}
delete[] childName;
return child;
}
delete[] childName;
child = child.getNextSibling();
}
return NULL_DOM_Node;
}
/**
* Utility method for traversing a single node.
* Does not properly handle a text node containing both the
* start and end offsets. Such nodes should
* have been previously detected and been routed to traverseTextNode.
*
*/
DOM_Node RangeImpl::traverseNode( DOM_Node n, bool isFullySelected, bool isLeft, int how )
{
if ( isFullySelected )
return traverseFullySelected( n, how );
if ( n.getNodeType()== DOM_Node::TEXT_NODE )
return traverseTextNode( n, isLeft, how );
return traversePartiallySelected( n, how );
}
bool RangeImpl::isValidAncestorType(const DOM_Node& node) const
{
for (DOM_Node aNode = node; aNode!=null; aNode = aNode.getParentNode()) {
short type = aNode.getNodeType();
if ( type == DOM_Node::ENTITY_NODE
|| type == DOM_Node::NOTATION_NODE
|| type == DOM_Node::DOCUMENT_TYPE_NODE)
return false;
}
return true;
}
//======================================================================
// CJM 4/17/03 ..Needed to update an attribute list... for ContentGuard
//======================================================================
bool XMLDocument::setAttributeList(char* path, DataTypeAttribute** dtAttributes)
{
if (mDoc == NULL)
return false;
if (path == NULL)
return false;
DOM_Node child = getNode(mRootNode, path, NULL);
char* value = getString(path);
if (child == NULL)
return false;
short nType = child.getNodeType();
DOM_Node parent = child.getParentNode();
if (parent == NULL)
return false;
char* childName = child.getNodeName().transcode();
DOM_NamedNodeMap nnodeMap = child.getAttributes();
parent.removeChild(child);
DOM_Element childElement = mDoc.createElement(childName);
delete[] childName;
int a = 0;
DataTypeAttribute* dtAttribute;
while ((dtAttribute = (DataTypeAttribute*)dtAttributes[a++]) != (DataTypeAttribute*)NULL)
{
childElement.setAttribute(dtAttribute->getName(), dtAttribute->getValue());
}
if (nType == DOM_Node::TEXT_NODE)
{
DOM_Text childText = mDoc.createTextNode((value == NULL)?"":value);
childElement.appendChild(childText);
}
else
{
if (nType == DOM_Node::CDATA_SECTION_NODE)
{
DOM_CDATASection childCData = mDoc.createCDATASection((value == NULL)?"":value);
childElement.appendChild(childCData);
}
}
parent.appendChild(childElement);
return true;
}
//======================================================================
//======================================================================
bool XMLDocument::setValue(DOM_Node currNode, char* path, DataTypeAttribute** dtAttributes, char* value)
{
if (mDoc == NULL)
return false;
if (path == NULL)
return false;
DOM_Node child = getNode(currNode, path, dtAttributes);
if (child == NULL)
return false;
DOM_Node parent = child.getParentNode();
if (parent == NULL)
return false;
DOM_Node grandChild = child.getFirstChild();
short nType = DOM_Node::TEXT_NODE;
if (grandChild != NULL)
{
nType = grandChild.getNodeType();
if (nType != DOM_Node::TEXT_NODE && nType != DOM_Node::CDATA_SECTION_NODE)
return false;
}
char* childName = child.getNodeName().transcode();
DOM_NamedNodeMap nnodeMap = child.getAttributes();
parent.removeChild(child);
DOM_Element childElement = mDoc.createElement(childName);
delete[] childName;
for (unsigned int i = 0; i < nnodeMap.getLength(); i++)
{
DOM_Node attNode = nnodeMap.item(i);
childElement.setAttribute(attNode.getNodeName(), attNode.getNodeValue());
}
if (nType == DOM_Node::TEXT_NODE)
{
DOM_Text childText = mDoc.createTextNode((value == NULL)?"":value);
childElement.appendChild(childText);
}
else
{
DOM_CDATASection childCData = mDoc.createCDATASection((value == NULL)?"":value);
childElement.appendChild(childCData);
}
parent.appendChild(childElement);
return true;
}
bool RangeImpl::isLegalContainedNode(const DOM_Node& node ) const {
if ( node==null )
return false;
switch( node.getNodeType() )
{
case DOM_Node::DOCUMENT_NODE:
case DOM_Node::DOCUMENT_FRAGMENT_NODE:
case DOM_Node::ATTRIBUTE_NODE:
case DOM_Node::ENTITY_NODE:
case DOM_Node::NOTATION_NODE:
return false;
}
return true;
}
bool RangeImpl::hasLegalRootContainer(const DOM_Node& node) const {
if ( node==null )
return false;
DOM_Node rootContainer = node;
for (; rootContainer.getParentNode()!=null; rootContainer = rootContainer.getParentNode())
;
switch( rootContainer.getNodeType() ) {
case DOM_Node::ATTRIBUTE_NODE:
case DOM_Node::DOCUMENT_NODE:
case DOM_Node::DOCUMENT_FRAGMENT_NODE:
return true;
}
return false;
}
void RangeImpl::surroundContents(DOM_Node& newParent)
{
if (newParent==null) return;
//check for elimination criteria
if( fDetached) {
throw DOM_DOMException(
DOM_DOMException::INVALID_STATE_ERR, null);
}
if (newParent.getOwnerDocument() !=fDocument) {
throw DOM_DOMException(
DOM_DOMException::WRONG_DOCUMENT_ERR, null);
}
int type = newParent.getNodeType();
if ( !isLegalContainedNode(newParent)
|| type == DOM_Node::DOCUMENT_TYPE_NODE)
{
throw DOM_RangeException(
DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
}
DOM_Node root = getCommonAncestorContainer();
DOM_Node realStart = fStartContainer;
DOM_Node realEnd = fEndContainer;
if (fStartContainer.getNodeType() == DOM_Node::TEXT_NODE) {
realStart = fStartContainer.getParentNode();
}
if (fEndContainer.getNodeType() == DOM_Node::TEXT_NODE) {
realEnd = fEndContainer.getParentNode();
}
if (realStart != realEnd) {
throw DOM_RangeException(
DOM_RangeException::BAD_BOUNDARYPOINTS_ERR, null);
}
DOM_DocumentFragment frag = extractContents();
insertNode(newParent);
newParent.appendChild(frag);
selectNode(newParent);
}
/**
* Utility method for traversing a single node when
* we know a-priori that the node if fully
* selected.
*
*/
DOM_Node RangeImpl::traverseFullySelected( DOM_Node n, int how )
{
switch( how )
{
case CLONE_CONTENTS:
return n.cloneNode( true );
case EXTRACT_CONTENTS:
if ( n.getNodeType()== DOM_Node::DOCUMENT_TYPE_NODE )
{
throw DOM_DOMException(
DOM_DOMException::HIERARCHY_REQUEST_ERR, null);
}
return n;
case DELETE_CONTENTS:
n.getParentNode().removeChild(n);
return null;
}
return null;
}
/**
* Utility method to retrieve a child node by index. This method
* assumes the caller is trying to find out which node is
* selected by the given index. Note that if the index is
* greater than the number of children, this implies that the
* first node selected is the parent node itself.
*
*/
DOM_Node RangeImpl::getSelectedNode( DOM_Node container, int offset )
{
if ( container.getNodeType() == DOM_Node::TEXT_NODE )
return container;
// This case is an important convenience for
// traverseRightBoundary()
if ( offset<0 )
return container;
DOM_Node child = container.getFirstChild();
while( child!=null && offset > 0 )
{
--offset;
child = child.getNextSibling();
}
if ( child!=null )
return child;
return container;
}
DOM_Node XMLDocument::clone(DOM_Node currNode)
{
switch (currNode.getNodeType())
{
case DOM_Node::ELEMENT_NODE:
{
DOM_Element elem = mDoc.createElement(currNode.getNodeName());
DOM_NamedNodeMap nnodeMap = currNode.getAttributes();
for (unsigned int i = 0; i < nnodeMap.getLength(); i++)
{
DOM_Node attNode = nnodeMap.item(i);
elem.setAttribute(attNode.getNodeName(), attNode.getNodeValue());
}
DOM_Node child = currNode.getFirstChild();
while (child != NULL)
{
DOM_Node cNode = clone(child);
if (cNode != NULL)
elem.appendChild(cNode);
child = child.getNextSibling();
}
return (DOM_Node)elem;
}
case DOM_Node::TEXT_NODE:
{
DOM_Text childText = mDoc.createTextNode(currNode.getNodeValue());
return (DOM_Node)childText;
}
case DOM_Node::CDATA_SECTION_NODE:
{
DOM_CDATASection childCData = mDoc.createCDATASection(currNode.getNodeValue());
return (DOM_Node)childCData;
}
default:
{
return NULL_DOM_Node;
}
}
}
void RangeImpl::selectNodeContents(const DOM_Node& node)
{
validateNode(node);
fStartContainer = node;
fEndContainer = node;
fStartOffset = 0;
if (node.getNodeType() == DOM_Node::TEXT_NODE ) {
fEndOffset = ((DOM_Text &)node).getLength();
return;
}
DOM_Node first = node.getFirstChild();
if (first == null) {
fEndOffset = 0;
return;
}
unsigned int i = 0;
for (DOM_Node n = first; n!=null; n = n.getNextSibling()) {
i++;
}
fEndOffset = i;
}
Components::ConfigValues*
Properties::getConfigValues()
{
char* fileName = strdup( descriptor_.c_str() );
parser_->parse( fileName );
document_ = parser_->getDocument();
DOM_Element property = document_.getDocumentElement();
Components::ConfigValues* config = new Components::ConfigValues();
int len = 0;
DOM_Node child = property.getFirstChild();
while( child != 0)
{
// simple
if( ( child.getNodeType() == DOM_Node::ELEMENT_NODE ) &&
( child.getNodeName().equals( "simple" ) ) )
{
DOM_NodeList nodeList;
DOM_Element simple = ( DOM_Element& )child;
std::string type = simple.getAttribute( "type" ).transcode();
std::string name = simple.getAttribute( "name" ).transcode();
nodeList = simple.getElementsByTagName( "value" );
DOM_Element value = ( const DOM_Element& )nodeList.item( 0 );
CORBA::Any any;
std::string val = value.getFirstChild().getNodeValue().transcode();
if( type == "boolean" )
{
CORBA::Boolean v;
if( val == "true" )
{
v = true;
}
else
{
v = false;
}
any <<= CORBA::Any::from_boolean( v );
}
if( type == "char" )
{
CORBA::Char v = val[0];
any <<= CORBA::Any::from_char( v );
}
if( type == "double" )
{
CORBA::Double v = atof( val.c_str() );
any <<= v;
}
if( type == "float" )
{
CORBA::Float v = atof( val.c_str() );
any <<= v;
}
if( type == "short" )
{
CORBA::Short v = atoi( val.c_str() );
any <<= v;
}
if( type == "long" )
{
CORBA::Long v = atol( val.c_str() );
any <<= v;
}
if( type == "objref" )
{
// TODO
}
if( type == "octet" )
{
CORBA::Octet v = val[0];
any <<= CORBA::Any::from_octet( v );
}
if( type == "string" )
{
any <<= val.c_str();
}
if( type == "ulong" )
{
CORBA::ULong v = atol( val.c_str() );
any <<= v;
}
if( type == "ushort" )
{
CORBA::UShort v = atol( val.c_str() );
any <<= v;
}
// new config entry
config->length( ++len );
( *config )[len - 1] = new ConfigValue_impl( CORBA::string_dup( name.c_str() ), any );
}
// sequence
if( ( child.getNodeType() == DOM_Node::ELEMENT_NODE ) &&
( child.getNodeName().equals( "sequence" ) ) )
{
}
// struct
if( ( child.getNodeType() == DOM_Node::ELEMENT_NODE ) &&
( child.getNodeName().equals( "struct" ) ) )
{
}
// value
if( ( child.getNodeType() == DOM_Node::ELEMENT_NODE ) &&
( child.getNodeName().equals( "valuetype" ) ) )
{
}
// next element
child = child.getNextSibling();
}
return config;
}
DOMString RangeImpl::toString() const
{
if( fDetached) {
throw DOM_DOMException(
DOM_DOMException::INVALID_STATE_ERR, null);
}
DOM_Node node = fStartContainer;
DOM_Node stopNode = fEndContainer;
DOMString tempString;
if ( (fStartContainer.getNodeType() == DOM_Node::TEXT_NODE)
|| (fStartContainer.getNodeType() == DOM_Node::CDATA_SECTION_NODE) ) {
if (fStartContainer == fEndContainer) {
tempString.appendData(fStartContainer.getNodeValue().substringData(fStartOffset, fEndOffset-fStartOffset));
return tempString;
} else {
int length = fStartContainer.getNodeValue().length();
tempString.appendData(fStartContainer.getNodeValue().substringData(fStartOffset, length - fStartOffset));
node = nextNode(node, true);
}
} else { //fStartContainer is not a TextNode
node=node.getFirstChild();
if (fStartOffset>0) { //find a first node within a range, specified by fStartOffset
unsigned int counter = 0;
while (counter<fStartOffset && node!=null) {
node=node.getNextSibling();
counter++;
}
}
if (node == null) {
node = nextNode(fStartContainer,false);
}
}
if ( fEndContainer.getNodeType()!= DOM_Node::TEXT_NODE &&
fEndContainer.getNodeType()!= DOM_Node::CDATA_SECTION_NODE ) {
int i=fEndOffset;
stopNode = fEndContainer.getFirstChild();
while( i>0 && stopNode!=null ) {
--i;
stopNode = stopNode.getNextSibling();
}
if ( stopNode == null )
stopNode = nextNode( fEndContainer, false );
}
while (node != stopNode) { //look into all kids of the Range
if (node == null) break;
if (node.getNodeType() == DOM_Node::TEXT_NODE
|| node.getNodeType() == DOM_Node::CDATA_SECTION_NODE) {
tempString.appendData(node.getNodeValue());
}
node = nextNode(node, true);
}
if (fEndContainer.getNodeType() == DOM_Node::TEXT_NODE
|| fEndContainer.getNodeType() == DOM_Node::CDATA_SECTION_NODE) {
tempString.appendData(fEndContainer.getNodeValue().substringData(0,fEndOffset));
}
return tempString;
}
void RangeImpl::insertNode(DOM_Node& newNode)
{
if (newNode == null) return; //don't have to do anything
for (DOM_Node aNode = fStartContainer; aNode!=null; aNode = aNode.getParentNode()) {
if (aNode.fImpl->isReadOnly()) {
throw DOM_DOMException(
DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, null);
}
}
if (fDocument != newNode.getOwnerDocument()) {
throw DOM_DOMException(
DOM_DOMException::WRONG_DOCUMENT_ERR, null);
}
// Prevent cycles in the tree.
//isKidOK() is not checked here as its taken care by insertBefore() function
if (isAncestorOf( newNode, fStartContainer)) {
throw DOM_DOMException(
DOM_DOMException::HIERARCHY_REQUEST_ERR, null);
}
if( fDetached) {
throw DOM_DOMException(
DOM_DOMException::INVALID_STATE_ERR, null);
}
int type = newNode.getNodeType();
if (type == DOM_Node::ATTRIBUTE_NODE
|| type == DOM_Node::ENTITY_NODE
|| type == DOM_Node::NOTATION_NODE
|| type == DOM_Node::DOCUMENT_NODE)
{
throw DOM_RangeException(
DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
}
DOM_Node parent;
DOM_Node next;
if (fStartContainer.getNodeType() == DOM_Node::TEXT_NODE) {
//set 'parent' and 'next' here
parent = fStartContainer.getParentNode();
//split the text nodes
if (fStartOffset > 0)
((DOM_Text &)fStartContainer).splitText(fStartOffset);
//update the new start information later. After inserting the first newNode
if (fStartOffset == 0)
next = fStartContainer;
else
next = fStartContainer.getNextSibling();
} // end of text handling
else {
parent = fStartContainer;
next = fStartContainer.getFirstChild();
for(unsigned int i = 0; (i < fStartOffset) && (next != null); i++) {
next=next.getNextSibling();
}
}
if (parent != null) {
if (next != null)
parent.insertBefore(newNode, next);
else
parent.appendChild(newNode);
}
}