home *** CD-ROM | disk | FTP | other *** search
/ Internet Magazine 2003 October / INTERNET108.ISO / pc / software / windows / building / xmlspy / xmlspyentcomplete5.exe / Data1.cab / _D49DB9E53AE04065A6A514AB3D2D4425 < prev    next >
Encoding:
Text File  |  2003-05-21  |  10.7 KB  |  416 lines
  1. ////////////////////////////////////////////////////////////////////////
  2. //
  3. // Node.cpp
  4. //
  5. // This file was generated by XMLSPY 5 Enterprise Edition.
  6. //
  7. // YOU SHOULD NOT MODIFY THIS FILE, BECAUSE IT WILL BE
  8. // OVERWRITTEN WHEN YOU RE-RUN CODE GENERATION.
  9. //
  10. // Refer to the XMLSPY Documentation for further details.
  11. // http://www.altova.com/xmlspy
  12. //
  13. ////////////////////////////////////////////////////////////////////////
  14.  
  15.  
  16. #include "StdAfx.h"
  17. #include "SchemaTypes.h"
  18. #include "XmlException.h"
  19. #include "Node.h"
  20. #include "Doc.h"
  21.  
  22.  
  23. namespace altova {
  24.  
  25.  
  26. //#define ADJUST_LOCAL_NAMES
  27.  
  28.  
  29. #ifdef ADJUST_LOCAL_NAMES
  30.  
  31. #define Q2L(x) Q2LHelper(x).GetData()
  32.  
  33. class Q2LHelper
  34. {
  35. public:
  36.     Q2LHelper(const XMLCh* szQName)
  37.     {
  38.         int nPos = xercesc::XMLString::indexOf(szQName, L':');
  39.         if (nPos != -1)
  40.             m_szLocalName = xercesc::XMLString::replicate(szQName + nPos + 1);
  41.         else
  42.             m_szLocalName = xercesc::XMLString::replicate(szQName);
  43.     }
  44.  
  45.     ~Q2LHelper()
  46.     {
  47.         xercesc::XMLString::release(&m_szLocalName);
  48.     }
  49.  
  50.     const XMLCh* GetData() const
  51.     {
  52.         return m_szLocalName;
  53.     }
  54.  
  55. protected:
  56.     XMLCh* m_szLocalName;
  57. };
  58.  
  59. #else
  60.  
  61. #define Q2L(x) x
  62.  
  63. #endif
  64.  
  65.  
  66. CNode::CNode()
  67. {
  68.     m_pDOMNode = CDoc::CreateFragment();
  69. }
  70.  
  71.  
  72. CNode::CNode(xercesc::DOMNode* pThisNode)
  73. {
  74.     m_pDOMNode = pThisNode;
  75. }
  76.  
  77.  
  78. CNode::CNode(xercesc::DOMDocument* pDOMDocument)
  79. {
  80.     m_pDOMNode = pDOMDocument->getDocumentElement();
  81. }
  82.  
  83.  
  84. CNode::~CNode()
  85. {
  86.     CDoc::ReleaseFragment(m_pDOMNode);
  87. }
  88.  
  89.  
  90. tstring CNode::GetNodeName()
  91. {
  92.     return XC2TS(m_pDOMNode->getNodeName());
  93. }
  94.  
  95.  
  96. tstring CNode::GetNodeValue()
  97. {
  98.     return XC2TS(m_pDOMNode->getNodeValue());
  99. }
  100.  
  101.  
  102. xercesc::DOMNode* CNode::GetDOMNode()
  103. {
  104.     return m_pDOMNode;
  105. }
  106.  
  107.  
  108. void CNode::MapPrefix(const tstring& sPrefix, const tstring& sURI)
  109. {
  110.     if (sURI.empty())
  111.         return;
  112.  
  113.     xercesc::DOMElement* pElement = reinterpret_cast<xercesc::DOMElement*>(m_pDOMNode);
  114.     tstring sTmp;
  115.  
  116.     if (sPrefix.empty())
  117.         sTmp = _T("xmlns");
  118.     else
  119.         sTmp = _T("xmlns:") + sPrefix;
  120.  
  121.     pElement->setAttribute(X(sTmp), X(sURI));
  122. }
  123.  
  124.  
  125. tstring CNode::InternalGetNodeValue(ENodeType eNodeType, xercesc::DOMNode* pNode)
  126. {
  127.     if (pNode == NULL)
  128.         return _T("");
  129.     if (eNodeType == Element)
  130.         return XC2TS(pNode->getFirstChild()->getNodeValue());
  131.     else
  132.         return XC2TS(pNode->getNodeValue());
  133. }
  134.  
  135.  
  136. tstring CNode::InternalGetElementValue()
  137. {
  138.     //return m_pDOMNode->getTextContent();
  139.     return InternalGetNodeValue(Element, m_pDOMNode);
  140. }
  141.  
  142.  
  143. void CNode::InternalSetElementValue(const tstring& sValue)
  144. {
  145.     m_pDOMNode->setTextContent(X(sValue));
  146. }
  147.  
  148.  
  149. bool CNode::InternalNamesMatch(xercesc::DOMNode* pNode, const tstring& sNamespaceURI, const tstring& sName)
  150. {
  151.     tstring sNodeURI;
  152.     tstring sNodeName;
  153.     if (pNode->getNamespaceURI())
  154.         sNodeURI = XC2TS(pNode->getNamespaceURI());
  155.     if (pNode->getLocalName())
  156.         sNodeName = XC2TS(pNode->getLocalName());
  157.     return sNamespaceURI == sNodeURI && sName == sNodeName;
  158. }
  159.  
  160.  
  161. int CNode::ChildCountInternal(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName)
  162. {
  163.     if (eNodeType == Element)
  164.     {
  165.         int nCount = 0;
  166.  
  167.         for (xercesc::DOMNode* pNode = m_pDOMNode->getFirstChild(); pNode != NULL; pNode = pNode->getNextSibling())
  168.             if (InternalNamesMatch(pNode, sNamespaceURI, sName))
  169.                 nCount++;
  170.  
  171.         return nCount;
  172.     }
  173.     else
  174.         return (static_cast<xercesc::DOMElement*>(m_pDOMNode))->hasAttributeNS(X(sNamespaceURI), Q2L(X(sName))) ? 1 : 0;
  175. }
  176.  
  177.  
  178. bool CNode::InternalHasChild(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName)
  179. {
  180.     if (eNodeType == Element)
  181.     {
  182.         for (xercesc::DOMNode* pNode = m_pDOMNode->getFirstChild(); pNode != NULL; pNode = pNode->getNextSibling())
  183.             if (InternalNamesMatch(pNode, sNamespaceURI, sName))
  184.                 return true;
  185.         
  186.         return false;
  187.     }
  188.     else
  189.         return (static_cast<xercesc::DOMElement*>(m_pDOMNode))->hasAttributeNS(X(sNamespaceURI), Q2L(X(sName)));
  190. }
  191.  
  192.  
  193. xercesc::DOMNode* CNode::InternalCreate(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, const tstring& sValue)
  194. {
  195.     if (eNodeType == Element)
  196.     {
  197.         xercesc::DOMElement* pElement = m_pDOMNode->getOwnerDocument()->createElementNS(X(sNamespaceURI), X(sName));
  198.         pElement->appendChild(m_pDOMNode->getOwnerDocument()->createTextNode(X(sValue)));
  199.         return pElement;
  200.     }
  201.     else
  202.     {
  203.         xercesc::DOMAttr* pAttribute = m_pDOMNode->getOwnerDocument()->createAttributeNS(X(sNamespaceURI), X(sName));
  204.         pAttribute->setNodeValue(X(sValue));
  205.         return pAttribute;
  206.     }
  207. }
  208.  
  209.  
  210. xercesc::DOMNode* CNode::InternalAppend(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, const tstring& sValue)
  211. {
  212.     if (eNodeType == Element)
  213.         return m_pDOMNode->appendChild(InternalCreate(eNodeType, sNamespaceURI, sName, sValue));
  214.     else
  215.         return m_pDOMNode->getAttributes()->setNamedItemNS(InternalCreate(eNodeType, sNamespaceURI, sName, sValue));
  216. }
  217.  
  218.  
  219. xercesc::DOMNode* CNode::InternalAppendNode(const tstring& sNamespaceURI, const tstring& sName, CNode& rNode)
  220. {
  221.     xercesc::DOMNode* pOldNode = rNode.m_pDOMNode;
  222.     rNode.m_pDOMNode = m_pDOMNode->appendChild(InternalAdopt(rNode.m_pDOMNode, sNamespaceURI, sName));
  223.     CDoc::ReleaseFragment(pOldNode);
  224.     return rNode.m_pDOMNode;
  225. }
  226.  
  227.  
  228. xercesc::DOMNode* CNode::InternalGetAt(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, int nIndex)
  229. {
  230.     if (eNodeType == Element)
  231.     {
  232.         int nCount = 0;
  233.  
  234.         for (xercesc::DOMNode* pNode = m_pDOMNode->getFirstChild(); pNode != NULL; pNode = pNode->getNextSibling())
  235.             if (InternalNamesMatch(pNode, sNamespaceURI, sName))
  236.                 if (nCount++ == nIndex)
  237.                     return pNode;
  238.  
  239.         throw std::exception("Index out of range");
  240.     }
  241.     else
  242.     {
  243.         xercesc::DOMAttr* pAttr = static_cast<xercesc::DOMAttr*>(m_pDOMNode->getAttributes()->getNamedItemNS(X(sNamespaceURI), Q2L(X(sName))));
  244.         if (pAttr != NULL)
  245.             return pAttr;
  246.         else
  247.             throw std::exception("Index out of range");
  248.     }
  249. }
  250.  
  251.  
  252. xercesc::DOMNode* CNode::InternalGet(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName)
  253. {
  254.     return InternalGetAt(eNodeType, sNamespaceURI, sName, 0);
  255. }
  256.  
  257.  
  258. xercesc::DOMNode* CNode::InternalInsertAt(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, int nIndex, const tstring& sValue)
  259. {
  260.     if (eNodeType == Element)
  261.         return m_pDOMNode->insertBefore(
  262.                 InternalCreate(eNodeType, sNamespaceURI, sName, sValue),
  263.                 InternalGetAt(eNodeType, sNamespaceURI, sName, nIndex)
  264.                 );
  265.     else
  266.         return InternalAppend(eNodeType, sNamespaceURI, sName, sValue);
  267. }
  268.  
  269.  
  270. xercesc::DOMNode* CNode::InternalInsertNodeAt(const tstring& sNamespaceURI, const tstring& sName, int nIndex, CNode& rNode)
  271. {
  272.     rNode.m_pDOMNode = m_pDOMNode->insertBefore(
  273.             InternalAdopt(rNode.m_pDOMNode, sNamespaceURI, sName),
  274.             InternalGetAt(Element, sNamespaceURI, sName, nIndex)
  275.             );
  276.  
  277.     return rNode.m_pDOMNode;
  278. }
  279.  
  280.  
  281. xercesc::DOMNode* CNode::InternalReplaceAt(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, int nIndex, const tstring& sValue)
  282. {
  283.     if (eNodeType == Element)
  284.         return m_pDOMNode->replaceChild(
  285.                 InternalCreate(eNodeType, sNamespaceURI, sName, sValue),
  286.                 InternalGetAt(eNodeType, sNamespaceURI, sName, nIndex)
  287.                 );
  288.     else
  289.         return InternalAppend(eNodeType, sNamespaceURI, sName, sValue);
  290. }
  291.  
  292.  
  293. xercesc::DOMNode* CNode::InternalReplaceNodeAt(const tstring& sNamespaceURI, const tstring& sName, int nIndex, CNode& rNode)
  294. {
  295.     xercesc::DOMNode* pOldNode = rNode.m_pDOMNode;
  296.     rNode.m_pDOMNode = m_pDOMNode->replaceChild(
  297.             InternalAdopt(rNode.m_pDOMNode, sNamespaceURI, sName),
  298.             InternalGetAt(Element, sNamespaceURI, sName, nIndex)
  299.             );
  300.     CDoc::ReleaseFragment(pOldNode);
  301.  
  302.     return rNode.m_pDOMNode;
  303. }
  304.  
  305.  
  306. xercesc::DOMNode* CNode::InternalRemoveAt(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, int nIndex)
  307. {
  308.     if (eNodeType == Element)
  309.         return m_pDOMNode->removeChild(InternalGetAt(eNodeType, sNamespaceURI, sName, nIndex));
  310.     else
  311.         return m_pDOMNode->getAttributes()->removeNamedItemNS(X(sNamespaceURI), Q2L(X(sName)));
  312. }
  313.  
  314.  
  315. xercesc::DOMElement* CNode::InternalAdopt(xercesc::DOMNode* pElement, const tstring& sNamespaceURI, const tstring& sName)
  316. {
  317.     xercesc::DOMDocument* pDoc = m_pDOMNode->getOwnerDocument();
  318.     xercesc::DOMElement* pNewElement = pDoc->createElementNS(X(sNamespaceURI), X(sName));
  319.  
  320.     while (xercesc::DOMNode* pNode = pElement->getFirstChild())
  321.     {
  322.         pNewElement->appendChild(pDoc->importNode(pNode, true));
  323.         pElement->removeChild(pNode);
  324.     }
  325.  
  326.     xercesc::DOMNamedNodeMap* pSrcAttributes = pElement->getAttributes();
  327.     xercesc::DOMNamedNodeMap* pDstAttributes = pNewElement->getAttributes();
  328.     while (pSrcAttributes->getLength() > 0)
  329.     {
  330.         xercesc::DOMNode* pNode = pSrcAttributes->item(0);
  331.         pDstAttributes->setNamedItemNS(pDoc->importNode(pNode, true));
  332.         pSrcAttributes->removeNamedItemNS(pNode->getNamespaceURI(), Q2L(pNode->getLocalName()));
  333.     }
  334.  
  335.     return pNewElement;
  336. }
  337.  
  338.  
  339. void CNode::DeclareNamespace(xercesc::DOMElement* pElement, const tstring& sPrefix, const tstring& sURI)
  340. {
  341.     if (sURI.empty())
  342.         return;
  343.  
  344.     tstring sTmp;
  345.  
  346.     if (sPrefix.empty())
  347.         sTmp = _T("xmlns");
  348.     else
  349.         sTmp = _T("xmlns:") + sPrefix;
  350.  
  351.     xercesc::DOMNamedNodeMap* pAttrs = pElement->getAttributes();
  352.     for (int i = 0; i < pAttrs->getLength(); i++)
  353.     {
  354.         xercesc::DOMAttr* pAttr = reinterpret_cast<xercesc::DOMAttr*>(pAttrs->item(i));
  355.         if (xercesc::XMLString::equals(pAttr->getValue(), X(sURI)))
  356.             return;
  357.     }
  358.  
  359.     pElement->setAttribute(X(sTmp), X(sURI));
  360. }
  361.  
  362.  
  363. const XMLCh* CNode::LookupPrefix(xercesc::DOMNode* pNode, const XMLCh* szURI)
  364. {
  365.     if (pNode == NULL)
  366.         return NULL;
  367.  
  368.     if (szURI == NULL || *szURI == 0)
  369.         return NULL;
  370.  
  371.     if (pNode->getNodeType() == xercesc::DOMNode::ELEMENT_NODE)
  372.     {
  373.         xercesc::DOMNamedNodeMap* pAttrs = pNode->getAttributes();
  374.         if (pAttrs != NULL)
  375.         {
  376.             XMLSize_t len = pAttrs->getLength();
  377.             for (int i = 0; i < len; i++)
  378.             {
  379.                 xercesc::DOMAttr* pAttr = reinterpret_cast<xercesc::DOMAttr*>(pAttrs->item(i));
  380.                 const XMLCh* szName = pAttr->getName();
  381.                 const XMLCh* szValue = pAttr->getValue();
  382.                 if (xercesc::XMLString::equals(szValue, szURI))
  383.                 {
  384.                     if (xercesc::XMLString::stringLen(szName) < 6)
  385.                         return NULL;
  386.                     else
  387.                         return szName + 6;
  388.                 }
  389.             }
  390.         }
  391.         return LookupPrefix(pNode->getParentNode(), szURI);
  392.     }
  393.     else if (pNode->getNodeType() == xercesc::DOMNode::ATTRIBUTE_NODE)
  394.     {
  395.         return LookupPrefix(reinterpret_cast<xercesc::DOMAttr*>(pNode)->getOwnerElement(), szURI);
  396.     }
  397.     else
  398.     {
  399.         return NULL;
  400.     }
  401. }
  402.  
  403.  
  404. void CNode::InternalAdjustPrefix(xercesc::DOMNode* pDOMNode, bool bQualified)
  405. {
  406.     if (pDOMNode != NULL && bQualified)
  407.     {
  408.         const XMLCh* szPrefix = LookupPrefix(pDOMNode, pDOMNode->getNamespaceURI());
  409.         if (szPrefix)
  410.             pDOMNode->setPrefix(szPrefix);
  411.     }
  412. }
  413.  
  414.  
  415. } // namespace altova
  416.