IXMLDOMNodeImpl.inl
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:25k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Id: IXMLDOMNodeImpl.inl,v 1.4 2003/03/14 12:44:49 tng Exp $
  58.  */
  59. #include <xercesc/dom/deprecated/DOM_Node.hpp>
  60. #include <xercesc/dom/deprecated/DOM_Document.hpp>
  61. #include "XMLDOMNodeList.h"
  62. #include "XMLDOMNamedNodeMap.h"
  63. #include "XMLDOMUtil.h"
  64. #include <xercesc/dom/deprecated/DOM_DOMException.hpp>
  65. XERCES_CPP_NAMESPACE_USE
  66. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  67. HRESULT STDMETHODCALLTYPE IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::InterfaceSupportsErrorInfo(REFIID riid)
  68. {
  69. if(riid == *piid) return S_OK;
  70. return S_FALSE;
  71. }
  72. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  73. STDMETHODIMP
  74. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_nodeName(BSTR *pVal)
  75. {
  76. ATLTRACE(_T("IXMLDOMNodeImpl::get_nodeNamen"));
  77. if (NULL == pVal)
  78. return E_POINTER;
  79. *pVal = NULL;
  80. try
  81. {
  82. DOMString val = get_DOM_Node().getNodeName();
  83. *pVal = SysAllocStringLen(val.rawBuffer(),val.length());
  84. }
  85. catch(DOM_DOMException& ex)
  86. {
  87. return MakeHRESULT(ex);
  88. }
  89. catch(...)
  90. {
  91. return E_FAIL;
  92. }
  93. return S_OK;
  94. }
  95. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  96. STDMETHODIMP
  97. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_nodeValue(VARIANT *pVal)
  98. {
  99. ATLTRACE(_T("IXMLDOMNodeImpl::get_nodeValuen"));
  100. if (NULL == pVal)
  101. return E_POINTER;
  102. ::VariantInit(pVal);
  103. try
  104. {
  105. DOMString val = get_DOM_Node().getNodeValue();
  106. if (val != 0)
  107. {
  108. V_VT(pVal)   = VT_BSTR;
  109. V_BSTR(pVal) = SysAllocStringLen(val.rawBuffer(),val.length());
  110. }
  111. else
  112. V_VT(pVal) = VT_NULL;
  113. }
  114. catch(DOM_DOMException& ex)
  115. {
  116. return MakeHRESULT(ex);
  117. }
  118. catch(...)
  119. {
  120. return E_FAIL;
  121. }
  122. return S_OK;
  123. }
  124. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  125. STDMETHODIMP
  126. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::put_nodeValue(VARIANT newVal)
  127. {
  128. ATLTRACE(_T("IXMLDOMNodeImpl::put_nodeValuen"));
  129. try
  130. {
  131. if(V_VT(&newVal) == VT_BSTR)
  132. {
  133. get_DOM_Node().setNodeValue(V_BSTR(&newVal));
  134. }
  135. //
  136. //   coerce to BSTR or throw error
  137. //
  138. else
  139. {
  140. get_DOM_Node().setNodeValue((BSTR) (_bstr_t) newVal);
  141. }
  142. }
  143. catch(DOM_DOMException& ex)
  144. {
  145. return MakeHRESULT(ex);
  146. }
  147. catch(...)
  148. {
  149. return E_FAIL;
  150. }
  151. return S_OK;
  152. }
  153. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  154. STDMETHODIMP
  155. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_nodeType(DOMNodeType *pVal)
  156. {
  157. ATLTRACE(_T("IXMLDOMNodeImpl::get_nodeTypen"));
  158. if (NULL == pVal)
  159. return E_POINTER;
  160. *pVal = get_DOMNodeType();
  161. return S_OK;
  162. }
  163. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  164. STDMETHODIMP
  165. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_parentNode(IXMLDOMNode **pVal)
  166. {
  167. ATLTRACE(_T("IXMLDOMNodeImpl::get_parentNoden"));
  168. if (NULL == pVal)
  169. return E_POINTER;
  170. *pVal = NULL;
  171. HRESULT hr = S_OK;
  172. try
  173. {
  174. DOM_Node n = get_DOM_Node().getParentNode();
  175. if(!n.isNull()) {
  176. hr = wrapNode(m_pIXMLDOMDocument, n,IID_IXMLDOMNode,reinterpret_cast<LPVOID *> (pVal));
  177. }
  178. }
  179. catch(DOM_DOMException& ex)
  180. {
  181. return MakeHRESULT(ex);
  182. }
  183. catch(...)
  184. {
  185. return E_FAIL;
  186. }
  187. return hr;
  188. }
  189. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  190. STDMETHODIMP
  191. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_childNodes(IXMLDOMNodeList * *pVal)
  192. {
  193. ATLTRACE(_T("IXMLDOMNodeImpl::get_childNodesn"));
  194. if (NULL == pVal)
  195. return E_POINTER;
  196. *pVal = NULL;
  197. CXMLDOMNodeListObj *pObj = NULL;
  198. HRESULT hr = CXMLDOMNodeListObj::CreateInstance(&pObj);
  199. if (S_OK != hr)
  200. return hr;
  201. pObj->AddRef();
  202. pObj->SetOwnerDoc(m_pIXMLDOMDocument);
  203. try
  204. {
  205. pObj->m_container = get_DOM_Node().getChildNodes();
  206. }
  207. catch(DOM_DOMException& ex)
  208. {
  209. pObj->Release();
  210. return MakeHRESULT(ex);
  211. }
  212. catch(...)
  213. {
  214. pObj->Release();
  215. return E_FAIL;
  216. }
  217. hr = pObj->QueryInterface(IID_IXMLDOMNodeList, reinterpret_cast<LPVOID*> (pVal));
  218. if (S_OK != hr)
  219. *pVal = NULL;
  220. pObj->Release();
  221. return hr;
  222. }
  223. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  224. STDMETHODIMP
  225. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_firstChild(IXMLDOMNode **pVal)
  226. {
  227. ATLTRACE(_T("IXMLDOMNodeImpl::get_firstChildn"));
  228. if (NULL == pVal)
  229. return E_POINTER;
  230. *pVal = NULL;
  231. HRESULT hr = S_OK;
  232. try
  233. {
  234. DOM_Node n = get_DOM_Node().getFirstChild();
  235. //
  236. //   returns Nothing if no children
  237. //
  238. if(!n.isNull())
  239. hr = wrapNode(m_pIXMLDOMDocument,n,IID_IXMLDOMNode, reinterpret_cast<LPVOID *> (pVal));
  240. }
  241. catch(DOM_DOMException& ex)
  242. {
  243. return MakeHRESULT(ex);
  244. }
  245. catch(...)
  246. {
  247. return E_FAIL;
  248. }
  249. return hr;
  250. }
  251. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  252. STDMETHODIMP
  253. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_lastChild(IXMLDOMNode **pVal)
  254. {
  255. ATLTRACE(_T("IXMLDOMNodeImpl::get_lastChildn"));
  256. if (NULL == pVal)
  257. return E_POINTER;
  258. *pVal = NULL;
  259. HRESULT hr = S_OK;
  260. try
  261. {
  262. DOM_Node n = get_DOM_Node().getLastChild();
  263. if(!n.isNull())
  264. hr = wrapNode(m_pIXMLDOMDocument,n,IID_IXMLDOMNode, reinterpret_cast<LPVOID *> (pVal));
  265. }
  266. catch(DOM_DOMException& ex)
  267. {
  268. return MakeHRESULT(ex);
  269. }
  270. catch(...)
  271. {
  272. return E_FAIL;
  273. }
  274. return hr;
  275. }
  276. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  277. STDMETHODIMP
  278. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_previousSibling(IXMLDOMNode * *pVal)
  279. {
  280. ATLTRACE(_T("IXMLDOMNodeImpl::get_previousSiblingn"));
  281. if (NULL == pVal)
  282. return E_POINTER;
  283. *pVal = NULL;
  284. HRESULT hr = S_OK;
  285. try
  286. {
  287. DOM_Node n = get_DOM_Node().getPreviousSibling();
  288. if(!n.isNull())
  289. hr = wrapNode(m_pIXMLDOMDocument,n,IID_IXMLDOMNode, reinterpret_cast<LPVOID *> (pVal));
  290. }
  291. catch(DOM_DOMException& ex)
  292. {
  293. return MakeHRESULT(ex);
  294. }
  295. catch(...)
  296. {
  297. return E_FAIL;
  298. }
  299. return hr;
  300. }
  301. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  302. STDMETHODIMP
  303. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_nextSibling(IXMLDOMNode * *pVal)
  304. {
  305. ATLTRACE(_T("IXMLDOMNodeImpl::get_nextSiblingn"));
  306. if (NULL == pVal)
  307. return E_POINTER;
  308. *pVal = NULL;
  309. HRESULT hr = S_OK;
  310. try
  311. {
  312. DOM_Node n = get_DOM_Node().getNextSibling();
  313. if(!n.isNull())
  314. hr = wrapNode(m_pIXMLDOMDocument,n,IID_IXMLDOMNode, reinterpret_cast<LPVOID *> (pVal));
  315. }
  316. catch(DOM_DOMException& ex)
  317. {
  318. return MakeHRESULT(ex);
  319. }
  320. catch(...)
  321. {
  322. return E_FAIL;
  323. }
  324. return hr;
  325. }
  326. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  327. STDMETHODIMP
  328. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_attributes(IXMLDOMNamedNodeMap * *pVal)
  329. {
  330. ATLTRACE(_T("IXMLDOMNodeImpl::get_attributesn"));
  331. if (NULL == pVal)
  332. return E_POINTER;
  333. *pVal = NULL;
  334. DOM_NamedNodeMap map;
  335. try
  336. {
  337. map = get_DOM_Node().getAttributes();
  338. }
  339. catch(DOM_DOMException& ex)
  340. {
  341. return MakeHRESULT(ex);
  342. }
  343. catch(...)
  344. {
  345. return E_FAIL;
  346. }
  347. if ((map == 0) || (NODE_ELEMENT  != get_DOMNodeType()))
  348. //&&
  349. //NODE_ENTITY   != get_DOMNodeType() &&
  350. //NODE_NOTATION != get_DOMNodeType())
  351. return S_OK;
  352. CXMLDOMNamedNodeMapObj *pObj = NULL;
  353. HRESULT hr = CXMLDOMNamedNodeMapObj::CreateInstance(&pObj);
  354. if (S_OK != hr)
  355. return hr;
  356. pObj->AddRef();
  357. pObj->SetOwnerDoc(m_pIXMLDOMDocument);
  358. pObj->m_container = map;
  359. hr = pObj->QueryInterface(IID_IXMLDOMNamedNodeMap, reinterpret_cast<LPVOID*> (pVal));
  360. if (S_OK != hr)
  361. *pVal = NULL;
  362. pObj->Release();
  363. return hr;
  364. }
  365. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  366. STDMETHODIMP
  367. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::insertBefore(IXMLDOMNode *newChild, VARIANT refChild, IXMLDOMNode **outNewChild)
  368. {
  369. ATLTRACE(_T("IXMLDOMNodeImpl::insertBeforen"));
  370. if (NULL == outNewChild)
  371. return E_POINTER;
  372. *outNewChild = NULL;
  373. if (NULL == newChild)
  374. return E_INVALIDARG;
  375. if (V_VT(&refChild) != VT_DISPATCH && V_VT(&refChild) != VT_NULL)
  376. return E_INVALIDARG;
  377. if (V_VT(&refChild) == VT_NULL)
  378. return appendChild(newChild,outNewChild);
  379. CComQIPtr<IIBMXMLDOMNodeIdentity,&IID_IIBMXMLDOMNodeIdentity> pNewChild(newChild);
  380. if (!pNewChild)
  381. return E_NOINTERFACE;
  382. long id = 0;
  383. HRESULT hr = pNewChild->get_NodeId(&id);
  384. if (S_OK != hr)
  385. return hr;
  386. DOM_Node *pNewChildNode = reinterpret_cast<DOM_Node*> (id);
  387. if (NULL == pNewChildNode)
  388. return E_INVALIDARG;
  389. CComQIPtr<IIBMXMLDOMNodeIdentity,&IID_IIBMXMLDOMNodeIdentity> pRefChild(V_DISPATCH(&refChild));
  390. if (!pRefChild)
  391. return E_NOINTERFACE;
  392. id = 0;
  393. hr = pRefChild->get_NodeId(&id);
  394. if (S_OK != hr)
  395. return hr;
  396. DOM_Node *pRefChildNode = reinterpret_cast<DOM_Node*> (id);
  397. if (NULL == pRefChildNode)
  398. return E_INVALIDARG;
  399. try
  400. {
  401. DOM_Node n = get_DOM_Node().insertBefore(*pNewChildNode, *pRefChildNode);
  402. hr = wrapNode(m_pIXMLDOMDocument,n,IID_IXMLDOMNode, reinterpret_cast<LPVOID *> (outNewChild));
  403. }
  404. catch(DOM_DOMException& ex)
  405. {
  406. return MakeHRESULT(ex);
  407. }
  408. catch(...)
  409. {
  410. return E_FAIL;
  411. }
  412. return hr;
  413. }
  414. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  415. STDMETHODIMP
  416. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::replaceChild(IXMLDOMNode *newChild, IXMLDOMNode *oldChild, IXMLDOMNode * *outNewChild)
  417. {
  418. ATLTRACE(_T("IXMLDOMNodeImpl::replaceChildn"));
  419. if (NULL == outNewChild)
  420. return E_POINTER;
  421. *outNewChild = NULL;
  422. if (NULL == oldChild)
  423. return E_INVALIDARG;
  424. if (NULL == newChild)
  425. return removeChild(oldChild,outNewChild);
  426. CComQIPtr<IIBMXMLDOMNodeIdentity,&IID_IIBMXMLDOMNodeIdentity> pNewChild(newChild);
  427. if (!pNewChild)
  428. return E_NOINTERFACE;
  429. long id = 0;
  430. HRESULT hr = pNewChild->get_NodeId(&id);
  431. if (S_OK != hr)
  432. return hr;
  433. DOM_Node *pNewChildNode = reinterpret_cast<DOM_Node*> (id);
  434. if (NULL == pNewChildNode)
  435. return E_INVALIDARG;
  436. CComQIPtr<IIBMXMLDOMNodeIdentity,&IID_IIBMXMLDOMNodeIdentity> pOldChild(oldChild);
  437. if (!pOldChild)
  438. return E_NOINTERFACE;
  439. id = 0;
  440. hr = pOldChild->get_NodeId(&id);
  441. if (S_OK != hr)
  442. return hr;
  443. DOM_Node *pOldChildNode = reinterpret_cast<DOM_Node*> (id);
  444. if (NULL == pOldChildNode)
  445. return E_INVALIDARG;
  446. try
  447. {
  448. DOM_Node n = get_DOM_Node().replaceChild(*pNewChildNode, *pOldChildNode);
  449. hr = wrapNode(m_pIXMLDOMDocument,n,IID_IXMLDOMNode, reinterpret_cast<LPVOID *> (outNewChild));
  450. }
  451. catch(DOM_DOMException& ex)
  452. {
  453. return MakeHRESULT(ex);
  454. }
  455. catch(...)
  456. {
  457. return E_FAIL;
  458. }
  459. return S_OK;
  460. }
  461. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  462. STDMETHODIMP
  463. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::removeChild(IXMLDOMNode *child, IXMLDOMNode * *oldChild)
  464. {
  465. ATLTRACE(_T("IXMLDOMNodeImpl::removeChildn"));
  466. if (NULL == oldChild)
  467. return E_POINTER;
  468. *oldChild = NULL;
  469. if (NULL == child)
  470. return E_INVALIDARG;
  471. CComQIPtr<IIBMXMLDOMNodeIdentity,&IID_IIBMXMLDOMNodeIdentity> pChild(child);
  472. if (!pChild)
  473. return E_NOINTERFACE;
  474. long id = 0;
  475. HRESULT hr = pChild->get_NodeId(&id);
  476. if (S_OK != hr)
  477. return hr;
  478. DOM_Node *pChildNode = reinterpret_cast<DOM_Node*> (id);
  479. if (NULL == pChildNode)
  480. return E_INVALIDARG;
  481. try
  482. {
  483. DOM_Node n = get_DOM_Node().removeChild(*pChildNode);
  484. if(!n.isNull())
  485. hr = wrapNode(m_pIXMLDOMDocument,n,IID_IXMLDOMNode, reinterpret_cast<LPVOID *> (oldChild));
  486. }
  487. catch(DOM_DOMException& ex)
  488. {
  489. return MakeHRESULT(ex);
  490. }
  491. catch(...)
  492. {
  493. return E_FAIL;
  494. }
  495. return S_OK;
  496. }
  497. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  498. STDMETHODIMP
  499. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::appendChild(IXMLDOMNode *newChild, IXMLDOMNode * *outNewChild)
  500. {
  501. ATLTRACE(_T("IXMLDOMNodeImpl::appendChildn"));
  502. if (NULL == outNewChild)
  503. return E_POINTER;
  504. *outNewChild = NULL;
  505. if (NULL == newChild)
  506. return E_INVALIDARG;
  507. CComQIPtr<IIBMXMLDOMNodeIdentity,&IID_IIBMXMLDOMNodeIdentity> pNewChild(newChild);
  508. if (!pNewChild)
  509. return E_NOINTERFACE;
  510. long id = 0;
  511. HRESULT hr = pNewChild->get_NodeId(&id);
  512. if (S_OK != hr)
  513. return hr;
  514. DOM_Node *pNewChildNode = reinterpret_cast<DOM_Node*> (id);
  515. if (NULL == pNewChildNode)
  516. return E_INVALIDARG;
  517. try
  518. {
  519. DOM_Node n = get_DOM_Node().appendChild(*pNewChildNode);
  520. hr = wrapNode(m_pIXMLDOMDocument,n,IID_IXMLDOMNode, reinterpret_cast<LPVOID *> (outNewChild));
  521. }
  522. catch(DOM_DOMException& ex)
  523. {
  524. return MakeHRESULT(ex);
  525. }
  526. catch(...)
  527. {
  528. return E_FAIL;
  529. }
  530. return S_OK;
  531. }
  532. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  533. STDMETHODIMP
  534. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::hasChildNodes(VARIANT_BOOL *hasChild)
  535. {
  536. ATLTRACE(_T("IXMLDOMNodeImpl::hasChildNodesn"));
  537. if (NULL == hasChild)
  538. return E_POINTER;
  539. *hasChild = VARIANT_FALSE;
  540. try
  541. {
  542. *hasChild = (get_DOM_Node().hasChildNodes()) ? VARIANT_TRUE : VARIANT_FALSE;
  543. }
  544. catch(DOM_DOMException& ex)
  545. {
  546. return MakeHRESULT(ex);
  547. }
  548. catch(...)
  549. {
  550. return E_FAIL;
  551. }
  552. return S_OK;
  553. }
  554. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  555. STDMETHODIMP
  556. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_ownerDocument(IXMLDOMDocument **pVal)
  557. {
  558. ATLTRACE(_T("IXMLDOMNodeImpl::get_ownerDocumentn"));
  559. if (NULL == pVal)
  560. return E_POINTER;
  561. *pVal = NULL;
  562. if (get_DOMNodeType() != NODE_DOCUMENT)
  563. {
  564. *pVal = m_pIXMLDOMDocument;
  565. if (*pVal != NULL)
  566. (*pVal)->AddRef();
  567. }
  568. return S_OK;
  569. }
  570. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  571. STDMETHODIMP
  572. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::cloneNode(VARIANT_BOOL deep, IXMLDOMNode **pVal)
  573. {
  574. ATLTRACE(_T("IXMLDOMNodeImpl::cloneNoden"));
  575. if (NULL == pVal)
  576. return E_POINTER;
  577. *pVal = NULL;
  578. HRESULT hr = S_OK;
  579. try
  580. {
  581. hr = wrapNode(m_pIXMLDOMDocument,get_DOM_Node().cloneNode((VARIANT_TRUE == deep) ? true : false),IID_IXMLDOMNode, reinterpret_cast<LPVOID *> (pVal));
  582. }
  583. catch(DOM_DOMException& ex)
  584. {
  585. return MakeHRESULT(ex);
  586. }
  587. catch(...)
  588. {
  589. return E_FAIL;
  590. }
  591. return hr;
  592. }
  593. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  594. STDMETHODIMP
  595. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_nodeTypeString(BSTR *pVal)
  596. {
  597. ATLTRACE(_T("IXMLDOMNodeImpl::get_nodeTypeStringn"));
  598. USES_CONVERSION;
  599. if (NULL == pVal)
  600. return E_POINTER;
  601. *pVal = ::SysAllocString(g_DomNodeName[get_DOMNodeType()]);
  602. return S_OK;
  603. }
  604. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  605. STDMETHODIMP
  606. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_text(BSTR *pVal)
  607. {
  608. ATLTRACE(_T("IXMLDOMNodeImpl::get_textn"));
  609. if (NULL == pVal)
  610. return E_POINTER;
  611. DOMString val = GetText(get_DOM_Node());
  612. *pVal = SysAllocStringLen(val.rawBuffer(),val.length());
  613. return S_OK;
  614. }
  615. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  616. STDMETHODIMP
  617. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::put_text(BSTR newVal)
  618. {
  619. ATLTRACE(_T("IXMLDOMNodeImpl::put_textn"));
  620. DOMNodeType type = get_DOMNodeType();
  621. if (NODE_DOCUMENT_FRAGMENT == type ||
  622. NODE_DOCUMENT_TYPE    == type ||
  623. NODE_ENTITY    == type ||
  624. NODE_ENTITY_REFERENCE  == type ||
  625. NODE_NOTATION    == type)
  626. return E_ACCESSDENIED;
  627. try
  628. {
  629. if(NODE_ELEMENT == type)
  630. {
  631. //
  632. //   remove all child elements
  633. //
  634. DOM_Node elem = get_DOM_Node();
  635. DOM_Node child = elem.getLastChild();
  636. while(!child.isNull())
  637. {
  638. elem.removeChild(child);
  639. child = elem.getLastChild();
  640. }
  641. DOM_Document doc = elem.getOwnerDocument();
  642. elem.appendChild(doc.createTextNode(newVal));
  643. }
  644. else
  645. get_DOM_Node().setNodeValue(newVal);
  646. }
  647. catch(DOM_DOMException& ex)
  648. {
  649. return MakeHRESULT(ex);
  650. }
  651. catch(...)
  652. {
  653. return E_FAIL;
  654. }
  655. return S_OK;
  656. }
  657. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  658. STDMETHODIMP
  659. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_specified(VARIANT_BOOL *pVal)
  660. {
  661. ATLTRACE(_T("IXMLDOMNodeImpl::get_specifiedn"));
  662. *pVal = VARIANT_TRUE;
  663. return S_OK;
  664. }
  665. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  666. STDMETHODIMP
  667. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_definition(IXMLDOMNode * *pVal)
  668. {
  669. ATLTRACE(_T("IXMLDOMNodeImpl::get_definitionn"));
  670. return E_NOTIMPL;
  671. }
  672. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  673. STDMETHODIMP
  674. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_nodeTypedValue(VARIANT *pVal)
  675. {
  676. ATLTRACE(_T("IXMLDOMNodeImpl::get_nodeTypedValuen"));
  677. return get_nodeValue(pVal);
  678. }
  679. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  680. STDMETHODIMP
  681. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::put_nodeTypedValue(VARIANT newVal)
  682. {
  683. ATLTRACE(_T("IXMLDOMNodeImpl::put_nodeTypedValuen"));
  684. return put_nodeValue(newVal);
  685. }
  686. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  687. STDMETHODIMP
  688. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_dataType(VARIANT *pVal)
  689. {
  690. ATLTRACE(_T("IXMLDOMNodeImpl::get_dataTypen"));
  691. return E_NOTIMPL;
  692. }
  693. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  694. STDMETHODIMP
  695. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::put_dataType(BSTR dataTypeName)
  696. {
  697. ATLTRACE(_T("IXMLDOMNodeImpl::put_dataTypen"));
  698. return E_NOTIMPL;
  699. }
  700. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  701. STDMETHODIMP
  702. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_xml(BSTR *pVal)
  703. {
  704. ATLTRACE(_T("IXMLDOMNodeImpl::get_xmln"));
  705. if (NULL == pVal)
  706. return E_POINTER;
  707. *pVal = NULL;
  708. _bstr_t text;
  709. try {
  710. GetXML(get_DOM_Node(),text);
  711. }
  712. catch(DOM_DOMException& ex)
  713. {
  714. return MakeHRESULT(ex);
  715. }
  716. catch(...)
  717. {
  718. return E_FAIL;
  719. }
  720. *pVal = text.copy();
  721. return S_OK;
  722. }
  723. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  724. STDMETHODIMP
  725. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::transformNode(IXMLDOMNode *stylesheet, BSTR *xmlString)
  726. {
  727. ATLTRACE(_T("IXMLDOMNodeImpl::transformNoden"));
  728. return E_NOTIMPL;
  729. }
  730. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  731. STDMETHODIMP
  732. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::selectNodes(BSTR queryString, IXMLDOMNodeList * *resultList)
  733. {
  734. ATLTRACE(_T("IXMLDOMNodeImpl::selectNodesn"));
  735. return E_NOTIMPL;
  736. }
  737. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  738. STDMETHODIMP
  739. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::selectSingleNode(BSTR queryString, IXMLDOMNode * *resultNode)
  740. {
  741. ATLTRACE(_T("IXMLDOMNodeImpl::selectSingleNoden"));
  742. return E_NOTIMPL;
  743. }
  744. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  745. STDMETHODIMP
  746. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_parsed(VARIANT_BOOL *pVal)
  747. {
  748. ATLTRACE(_T("IXMLDOMNodeImpl::get_parsedn"));
  749. if (NULL == pVal)
  750. return E_POINTER;
  751. *pVal = VARIANT_TRUE;
  752. return S_OK;
  753. }
  754. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  755. STDMETHODIMP
  756. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_namespaceURI(BSTR *pVal)
  757. {
  758. ATLTRACE(_T("IXMLDOMNodeImpl::get_namespaceURIn"));
  759. if (NULL == pVal)
  760. return E_POINTER;
  761. *pVal = NULL;
  762. try {
  763. DOMString val = get_DOM_Node().getNamespaceURI();
  764. *pVal = SysAllocStringLen(val.rawBuffer(),val.length());
  765. }
  766. catch(DOM_DOMException& ex)
  767. {
  768. return MakeHRESULT(ex);
  769. }
  770. catch(...)
  771. {
  772. return E_FAIL;
  773. }
  774. return S_OK;
  775. }
  776. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  777. STDMETHODIMP
  778. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_prefix(BSTR *pVal)
  779. {
  780. ATLTRACE(_T("IXMLDOMNodeImpl::get_prefixn"));
  781. if (NULL == pVal)
  782. return E_POINTER;
  783. *pVal = NULL;
  784. try {
  785. DOMString val = get_DOM_Node().getPrefix();
  786. *pVal = SysAllocStringLen(val.rawBuffer(),val.length());
  787. }
  788. catch(DOM_DOMException& ex)
  789. {
  790. return MakeHRESULT(ex);
  791. }
  792. catch(...)
  793. {
  794. return E_FAIL;
  795. }
  796. return S_OK;
  797. }
  798. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  799. STDMETHODIMP
  800. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::get_baseName(BSTR *pVal)
  801. {
  802. ATLTRACE(_T("IXMLDOMNodeImpl::get_baseNamen"));
  803. if (NULL == pVal)
  804. return E_POINTER;
  805. *pVal = NULL;
  806. try {
  807. DOMString val = get_DOM_Node().getLocalName();
  808. *pVal = SysAllocStringLen(val.rawBuffer(),val.length());
  809. }
  810. catch(DOM_DOMException& ex)
  811. {
  812. return MakeHRESULT(ex);
  813. }
  814. catch(...)
  815. {
  816. return E_FAIL;
  817. }
  818. return S_OK;
  819. }
  820. template <class T, const IID* piid, const GUID* plibid, WORD wMajor,WORD wMinor, class tihclass>
  821. STDMETHODIMP
  822. IXMLDOMNodeImpl<T,piid,plibid,wMajor,wMinor,tihclass>::transformNodeToObject(IXMLDOMNode *stylesheet, VARIANT outputObject)
  823. {
  824. ATLTRACE(_T("IXMLDOMNodeImpl::transformNodeToObjectn"));
  825. return E_NOTIMPL;
  826. }