home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 79 / IOPROG_79.ISO / soft / Tools / XMLSPYEnt2004 / XMLSPYEntComplete2004.exe / Data1.cab / _4D8E6D856AB043C59756C36CC6F7F4D1 < prev    next >
Encoding:
Text File  |  2003-10-06  |  10.8 KB  |  422 lines
  1. ////////////////////////////////////////////////////////////////////////
  2. //
  3. // Node.cpp
  4. //
  5. // This file was generated by [=$Host].
  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 [=$HostShort] Documentation for further details.
  11. // [=$HostURL]
  12. //
  13. ////////////////////////////////////////////////////////////////////////
  14.  
  15.  
  16. #include "StdAfx.h"
  17. #include "..\\Altova\\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.     {
  131.         xercesc::DOMNode* pChildNode = pNode->getFirstChild();
  132.         if (pChildNode)
  133.             return XC2TS(pChildNode->getNodeValue());
  134.         else
  135.             return _T("");
  136.     }
  137.     else
  138.         return XC2TS(pNode->getNodeValue());
  139. }
  140.  
  141.  
  142. tstring CNode::InternalGetElementValue()
  143. {
  144.     //return m_pDOMNode->getTextContent();
  145.     return InternalGetNodeValue(Element, m_pDOMNode);
  146. }
  147.  
  148.  
  149. void CNode::InternalSetElementValue(const tstring& sValue)
  150. {
  151.     m_pDOMNode->appendChild(m_pDOMNode->getOwnerDocument()->createTextNode(X(sValue)));
  152. }
  153.  
  154.  
  155. bool CNode::InternalNamesMatch(xercesc::DOMNode* pNode, const tstring& sNamespaceURI, const tstring& sName)
  156. {
  157.     tstring sNodeURI;
  158.     tstring sNodeName;
  159.     if (pNode->getNamespaceURI())
  160.         sNodeURI = XC2TS(pNode->getNamespaceURI());
  161.     if (pNode->getLocalName())
  162.         sNodeName = XC2TS(pNode->getLocalName());
  163.     return sNamespaceURI == sNodeURI && sName == sNodeName;
  164. }
  165.  
  166.  
  167. int CNode::ChildCountInternal(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName)
  168. {
  169.     if (eNodeType == Element)
  170.     {
  171.         int nCount = 0;
  172.  
  173.         for (xercesc::DOMNode* pNode = m_pDOMNode->getFirstChild(); pNode != NULL; pNode = pNode->getNextSibling())
  174.             if (InternalNamesMatch(pNode, sNamespaceURI, sName))
  175.                 nCount++;
  176.  
  177.         return nCount;
  178.     }
  179.     else
  180.         return (static_cast<xercesc::DOMElement*>(m_pDOMNode))->hasAttributeNS(X(sNamespaceURI), Q2L(X(sName))) ? 1 : 0;
  181. }
  182.  
  183.  
  184. bool CNode::InternalHasChild(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName)
  185. {
  186.     if (eNodeType == Element)
  187.     {
  188.         for (xercesc::DOMNode* pNode = m_pDOMNode->getFirstChild(); pNode != NULL; pNode = pNode->getNextSibling())
  189.             if (InternalNamesMatch(pNode, sNamespaceURI, sName))
  190.                 return true;
  191.         
  192.         return false;
  193.     }
  194.     else
  195.         return (static_cast<xercesc::DOMElement*>(m_pDOMNode))->hasAttributeNS(X(sNamespaceURI), Q2L(X(sName)));
  196. }
  197.  
  198.  
  199. xercesc::DOMNode* CNode::InternalCreate(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, const tstring& sValue)
  200. {
  201.     if (eNodeType == Element)
  202.     {
  203.         xercesc::DOMElement* pElement = m_pDOMNode->getOwnerDocument()->createElementNS(X(sNamespaceURI), X(sName));
  204.         pElement->appendChild(m_pDOMNode->getOwnerDocument()->createTextNode(X(sValue)));
  205.         return pElement;
  206.     }
  207.     else
  208.     {
  209.         xercesc::DOMAttr* pAttribute = m_pDOMNode->getOwnerDocument()->createAttributeNS(X(sNamespaceURI), X(sName));
  210.         pAttribute->setNodeValue(X(sValue));
  211.         return pAttribute;
  212.     }
  213. }
  214.  
  215.  
  216. xercesc::DOMNode* CNode::InternalAppend(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, const tstring& sValue)
  217. {
  218.     if (eNodeType == Element)
  219.         return m_pDOMNode->appendChild(InternalCreate(eNodeType, sNamespaceURI, sName, sValue));
  220.     else
  221.         return m_pDOMNode->getAttributes()->setNamedItemNS(InternalCreate(eNodeType, sNamespaceURI, sName, sValue));
  222. }
  223.  
  224.  
  225. xercesc::DOMNode* CNode::InternalAppendNode(const tstring& sNamespaceURI, const tstring& sName, CNode& rNode)
  226. {
  227.     xercesc::DOMNode* pOldNode = rNode.m_pDOMNode;
  228.     rNode.m_pDOMNode = m_pDOMNode->appendChild(InternalAdopt(rNode.m_pDOMNode, sNamespaceURI, sName));
  229.     CDoc::ReleaseFragment(pOldNode);
  230.     return rNode.m_pDOMNode;
  231. }
  232.  
  233.  
  234. xercesc::DOMNode* CNode::InternalGetAt(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, int nIndex)
  235. {
  236.     if (eNodeType == Element)
  237.     {
  238.         int nCount = 0;
  239.  
  240.         for (xercesc::DOMNode* pNode = m_pDOMNode->getFirstChild(); pNode != NULL; pNode = pNode->getNextSibling())
  241.             if (InternalNamesMatch(pNode, sNamespaceURI, sName))
  242.                 if (nCount++ == nIndex)
  243.                     return pNode;
  244.  
  245.         throw std::exception("Index out of range");
  246.     }
  247.     else
  248.     {
  249.         xercesc::DOMAttr* pAttr = static_cast<xercesc::DOMAttr*>(m_pDOMNode->getAttributes()->getNamedItemNS(X(sNamespaceURI), Q2L(X(sName))));
  250.         if (pAttr != NULL)
  251.             return pAttr;
  252.         else
  253.             throw std::exception("Index out of range");
  254.     }
  255. }
  256.  
  257.  
  258. xercesc::DOMNode* CNode::InternalGet(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName)
  259. {
  260.     return InternalGetAt(eNodeType, sNamespaceURI, sName, 0);
  261. }
  262.  
  263.  
  264. xercesc::DOMNode* CNode::InternalInsertAt(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, int nIndex, const tstring& sValue)
  265. {
  266.     if (eNodeType == Element)
  267.         return m_pDOMNode->insertBefore(
  268.                 InternalCreate(eNodeType, sNamespaceURI, sName, sValue),
  269.                 InternalGetAt(eNodeType, sNamespaceURI, sName, nIndex)
  270.                 );
  271.     else
  272.         return InternalAppend(eNodeType, sNamespaceURI, sName, sValue);
  273. }
  274.  
  275.  
  276. xercesc::DOMNode* CNode::InternalInsertNodeAt(const tstring& sNamespaceURI, const tstring& sName, int nIndex, CNode& rNode)
  277. {
  278.     rNode.m_pDOMNode = m_pDOMNode->insertBefore(
  279.             InternalAdopt(rNode.m_pDOMNode, sNamespaceURI, sName),
  280.             InternalGetAt(Element, sNamespaceURI, sName, nIndex)
  281.             );
  282.  
  283.     return rNode.m_pDOMNode;
  284. }
  285.  
  286.  
  287. xercesc::DOMNode* CNode::InternalReplaceAt(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, int nIndex, const tstring& sValue)
  288. {
  289.     if (eNodeType == Element)
  290.         return m_pDOMNode->replaceChild(
  291.                 InternalCreate(eNodeType, sNamespaceURI, sName, sValue),
  292.                 InternalGetAt(eNodeType, sNamespaceURI, sName, nIndex)
  293.                 );
  294.     else
  295.         return InternalAppend(eNodeType, sNamespaceURI, sName, sValue);
  296. }
  297.  
  298.  
  299. xercesc::DOMNode* CNode::InternalReplaceNodeAt(const tstring& sNamespaceURI, const tstring& sName, int nIndex, CNode& rNode)
  300. {
  301.     xercesc::DOMNode* pOldNode = rNode.m_pDOMNode;
  302.     rNode.m_pDOMNode = m_pDOMNode->replaceChild(
  303.             InternalAdopt(rNode.m_pDOMNode, sNamespaceURI, sName),
  304.             InternalGetAt(Element, sNamespaceURI, sName, nIndex)
  305.             );
  306.     CDoc::ReleaseFragment(pOldNode);
  307.  
  308.     return rNode.m_pDOMNode;
  309. }
  310.  
  311.  
  312. xercesc::DOMNode* CNode::InternalRemoveAt(ENodeType eNodeType, const tstring& sNamespaceURI, const tstring& sName, int nIndex)
  313. {
  314.     if (eNodeType == Element)
  315.         return m_pDOMNode->removeChild(InternalGetAt(eNodeType, sNamespaceURI, sName, nIndex));
  316.     else
  317.         return m_pDOMNode->getAttributes()->removeNamedItemNS(X(sNamespaceURI), Q2L(X(sName)));
  318. }
  319.  
  320.  
  321. xercesc::DOMElement* CNode::InternalAdopt(xercesc::DOMNode* pElement, const tstring& sNamespaceURI, const tstring& sName)
  322. {
  323.     xercesc::DOMDocument* pDoc = m_pDOMNode->getOwnerDocument();
  324.     xercesc::DOMElement* pNewElement = pDoc->createElementNS(X(sNamespaceURI), X(sName));
  325.  
  326.     while (xercesc::DOMNode* pNode = pElement->getFirstChild())
  327.     {
  328.         pNewElement->appendChild(pDoc->importNode(pNode, true));
  329.         pElement->removeChild(pNode);
  330.     }
  331.  
  332.     xercesc::DOMNamedNodeMap* pSrcAttributes = pElement->getAttributes();
  333.     xercesc::DOMNamedNodeMap* pDstAttributes = pNewElement->getAttributes();
  334.     while (pSrcAttributes->getLength() > 0)
  335.     {
  336.         xercesc::DOMNode* pNode = pSrcAttributes->item(0);
  337.         pDstAttributes->setNamedItemNS(pDoc->importNode(pNode, true));
  338.         pSrcAttributes->removeNamedItemNS(pNode->getNamespaceURI(), Q2L(pNode->getLocalName()));
  339.     }
  340.  
  341.     return pNewElement;
  342. }
  343.  
  344.  
  345. void CNode::DeclareNamespace(xercesc::DOMElement* pElement, const tstring& sPrefix, const tstring& sURI)
  346. {
  347.     if (sURI.empty())
  348.         return;
  349.  
  350.     tstring sTmp;
  351.  
  352.     if (sPrefix.empty())
  353.         sTmp = _T("xmlns");
  354.     else
  355.         sTmp = _T("xmlns:") + sPrefix;
  356.  
  357.     xercesc::DOMNamedNodeMap* pAttrs = pElement->getAttributes();
  358.     for (int i = 0; i < pAttrs->getLength(); i++)
  359.     {
  360.         xercesc::DOMAttr* pAttr = reinterpret_cast<xercesc::DOMAttr*>(pAttrs->item(i));
  361.         if (xercesc::XMLString::equals(pAttr->getValue(), X(sURI)))
  362.             return;
  363.     }
  364.  
  365.     pElement->setAttribute(X(sTmp), X(sURI));
  366. }
  367.  
  368.  
  369. const XMLCh* CNode::LookupPrefix(xercesc::DOMNode* pNode, const XMLCh* szURI)
  370. {
  371.     if (pNode == NULL)
  372.         return NULL;
  373.  
  374.     if (szURI == NULL || *szURI == 0)
  375.         return NULL;
  376.  
  377.     if (pNode->getNodeType() == xercesc::DOMNode::ELEMENT_NODE)
  378.     {
  379.         xercesc::DOMNamedNodeMap* pAttrs = pNode->getAttributes();
  380.         if (pAttrs != NULL)
  381.         {
  382.             XMLSize_t len = pAttrs->getLength();
  383.             for (int i = 0; i < len; i++)
  384.             {
  385.                 xercesc::DOMAttr* pAttr = reinterpret_cast<xercesc::DOMAttr*>(pAttrs->item(i));
  386.                 const XMLCh* szName = pAttr->getName();
  387.                 const XMLCh* szValue = pAttr->getValue();
  388.                 if (xercesc::XMLString::equals(szValue, szURI))
  389.                 {
  390.                     if (xercesc::XMLString::stringLen(szName) < 6)
  391.                         return NULL;
  392.                     else
  393.                         return szName + 6;
  394.                 }
  395.             }
  396.         }
  397.         return LookupPrefix(pNode->getParentNode(), szURI);
  398.     }
  399.     else if (pNode->getNodeType() == xercesc::DOMNode::ATTRIBUTE_NODE)
  400.     {
  401.         return LookupPrefix(reinterpret_cast<xercesc::DOMAttr*>(pNode)->getOwnerElement(), szURI);
  402.     }
  403.     else
  404.     {
  405.         return NULL;
  406.     }
  407. }
  408.  
  409.  
  410. void CNode::InternalAdjustPrefix(xercesc::DOMNode* pDOMNode, bool bQualified)
  411. {
  412.     if (pDOMNode != NULL && bQualified)
  413.     {
  414.         const XMLCh* szPrefix = LookupPrefix(pDOMNode, pDOMNode->getNamespaceURI());
  415.         if (szPrefix)
  416.             pDOMNode->setPrefix(szPrefix);
  417.     }
  418. }
  419.  
  420.  
  421. } // namespace altova
  422.