mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 07:23:34 +08:00
905 lines
22 KiB
C++
905 lines
22 KiB
C++
//---------------------------------------------------------------------------
|
|
|
|
#pragma hdrstop
|
|
|
|
#include "stdafx.h"
|
|
#include "XMLWrapper.h"
|
|
//---------------------------------------------------------------------------
|
|
|
|
using namespace XML;
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLDocumentWrapper::XMLDocumentWrapper()
|
|
{
|
|
if ( FAILED(CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_ALL,
|
|
IID_IXMLDOMDocument, (void **) &m_pXmlDoc)) )
|
|
{
|
|
m_pXmlDoc = NULL;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLDocumentWrapper::XMLDocumentWrapper(IXMLDOMDocument * pDoc, bool addRef)
|
|
{
|
|
if ( ((m_pXmlDoc = pDoc) != 0) && addRef )
|
|
m_pXmlDoc->AddRef();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLDocumentWrapper::XMLDocumentWrapper(const XMLDocumentWrapper& Doc)
|
|
{
|
|
if ( (m_pXmlDoc = Doc.m_pXmlDoc) != 0 )
|
|
m_pXmlDoc->AddRef();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLDocumentWrapper& XMLDocumentWrapper::operator=(IXMLDOMDocument * pDoc)
|
|
{
|
|
if ( m_pXmlDoc )
|
|
m_pXmlDoc->Release();
|
|
|
|
m_pXmlDoc = pDoc;
|
|
|
|
return *this;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLDocumentWrapper& XMLDocumentWrapper::operator=(const XMLDocumentWrapper& Doc)
|
|
{
|
|
if ( Doc.m_pXmlDoc )
|
|
Doc.m_pXmlDoc->AddRef();
|
|
|
|
if ( m_pXmlDoc )
|
|
m_pXmlDoc->Release();
|
|
|
|
m_pXmlDoc = Doc.m_pXmlDoc;
|
|
|
|
return *this;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLDocumentWrapper::~XMLDocumentWrapper()
|
|
{
|
|
if ( m_pXmlDoc )
|
|
m_pXmlDoc->Release();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLDocumentWrapper::Load(BSTR path)
|
|
{
|
|
if ( ! m_pXmlDoc )
|
|
return false;
|
|
|
|
VARIANT vtPath;
|
|
vtPath.vt = VT_BSTR;
|
|
vtPath.bstrVal = SysAllocString(path);
|
|
|
|
VARIANT_BOOL success;
|
|
|
|
try
|
|
{
|
|
m_pXmlDoc->put_async(VARIANT_FALSE);
|
|
m_pXmlDoc->load(vtPath, &success);
|
|
}
|
|
catch(...)
|
|
{
|
|
}
|
|
|
|
VariantClear(&vtPath);
|
|
|
|
|
|
return (VARIANT_TRUE == success);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLDocumentWrapper::LoadXML(BSTR xml)
|
|
{
|
|
if ( ! xml )
|
|
{
|
|
Clear();
|
|
return true;
|
|
}
|
|
|
|
VARIANT_BOOL success = VARIANT_FALSE;
|
|
|
|
if ( m_pXmlDoc )
|
|
{
|
|
try
|
|
{
|
|
m_pXmlDoc->loadXML(xml, &success);
|
|
}
|
|
catch(...)
|
|
{
|
|
}
|
|
}
|
|
|
|
return (VARIANT_TRUE == success);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLDocumentWrapper::Save(BSTR path)
|
|
{
|
|
if ( ! m_pXmlDoc )
|
|
return false;
|
|
|
|
VARIANT vtPath;
|
|
vtPath.vt = VT_BSTR;
|
|
|
|
bool success = false;
|
|
|
|
try
|
|
{
|
|
if ( 0 == SysStringLen(path) )
|
|
{
|
|
m_pXmlDoc->get_url(&vtPath.bstrVal);
|
|
}
|
|
else
|
|
{
|
|
vtPath.bstrVal = SysAllocString(path);
|
|
}
|
|
|
|
success = SUCCEEDED(m_pXmlDoc->save(vtPath));
|
|
}
|
|
catch(...)
|
|
{
|
|
}
|
|
|
|
VariantClear(&vtPath);
|
|
|
|
|
|
return success;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLDocumentWrapper::GetXML(BSTR * xmlString)
|
|
{
|
|
if ( ! m_pXmlDoc )
|
|
return false;
|
|
|
|
return SUCCEEDED(m_pXmlDoc->get_xml(xmlString));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void XMLDocumentWrapper::Clear()
|
|
{
|
|
if ( m_pXmlDoc )
|
|
{
|
|
IXMLDOMElement * pRootNode = NULL;
|
|
m_pXmlDoc->get_documentElement(&pRootNode);
|
|
|
|
if ( pRootNode )
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
m_pXmlDoc->removeChild(pRootNode, &pNode);
|
|
|
|
if ( pNode )
|
|
pNode->Release();
|
|
|
|
pRootNode->Release();
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLDocumentWrapper::GetRootNode()
|
|
{
|
|
IXMLDOMElement * pNode = NULL;
|
|
|
|
if ( m_pXmlDoc )
|
|
m_pXmlDoc->get_documentElement(&pNode);
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLDocumentWrapper::AppendNode(BSTR nodeName)
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pXmlDoc )
|
|
{
|
|
VARIANT vtType;
|
|
vtType.vt = VT_I2;
|
|
vtType.iVal = NODE_ELEMENT;
|
|
|
|
IXMLDOMNode * pNewNode = NULL;
|
|
m_pXmlDoc->createNode(vtType, nodeName, NULL, &pNewNode);
|
|
|
|
if ( pNewNode )
|
|
{
|
|
m_pXmlDoc->appendChild(pNewNode, &pNode);
|
|
pNewNode->Release();
|
|
}
|
|
}
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLDocumentWrapper::CreateNode(BSTR nodeName)
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pXmlDoc )
|
|
{
|
|
VARIANT vtType;
|
|
vtType.vt = VT_I2;
|
|
vtType.iVal = NODE_ELEMENT;
|
|
|
|
m_pXmlDoc->createNode(vtType, nodeName, NULL, &pNode);
|
|
}
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper::XMLNodeWrapper() : m_pXmlNode(NULL)
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper::XMLNodeWrapper(IXMLDOMNode * pNode, bool addRef)
|
|
{
|
|
if ( ((m_pXmlNode = pNode) != 0) && addRef )
|
|
m_pXmlNode->AddRef();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper::XMLNodeWrapper(const XMLNodeWrapper& Node)
|
|
{
|
|
if ( (m_pXmlNode = Node.m_pXmlNode) != 0 )
|
|
m_pXmlNode->AddRef();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper::~XMLNodeWrapper()
|
|
{
|
|
if ( m_pXmlNode )
|
|
m_pXmlNode->Release();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper& XMLNodeWrapper::operator=(IXMLDOMNode * pNode)
|
|
{
|
|
if ( m_pXmlNode )
|
|
m_pXmlNode->Release();
|
|
|
|
m_pXmlNode = pNode;
|
|
|
|
return *this;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper& XMLNodeWrapper::operator=(const XMLNodeWrapper& Node)
|
|
{
|
|
if ( Node.m_pXmlNode )
|
|
Node.m_pXmlNode->AddRef();
|
|
|
|
if ( m_pXmlNode )
|
|
m_pXmlNode->Release();
|
|
|
|
m_pXmlNode = Node.m_pXmlNode;
|
|
|
|
return *this;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int XMLNodeWrapper::GetNodesCount()
|
|
{
|
|
long length = 0;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
IXMLDOMNodeList * pNodeList = NULL;
|
|
m_pXmlNode->get_childNodes(&pNodeList);
|
|
|
|
if ( pNodeList )
|
|
{
|
|
pNodeList->get_length(&length);
|
|
pNodeList->Release();
|
|
}
|
|
}
|
|
|
|
return length;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeWrapper::GetParent()
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pXmlNode )
|
|
m_pXmlNode->get_parentNode(&pNode);
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::GetName(BSTR * name)
|
|
{
|
|
if ( ! m_pXmlNode )
|
|
return false;
|
|
|
|
return SUCCEEDED(m_pXmlNode->get_baseName(name));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeWrapper::GetNode(BSTR nodeName)
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
try
|
|
{
|
|
if ( m_pXmlNode )
|
|
m_pXmlNode->selectSingleNode(nodeName, &pNode);
|
|
}
|
|
catch(...)
|
|
{
|
|
}
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeWrapper::GetNode(int nodeIndex)
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
IXMLDOMNodeList * pNodeList = NULL;
|
|
if ( S_OK == m_pXmlNode->get_childNodes(&pNodeList) && pNodeList )
|
|
{
|
|
pNodeList->get_item(nodeIndex, &pNode);
|
|
pNodeList->Release();
|
|
}
|
|
}
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeWrapper::FindNode(BSTR searchString)
|
|
{
|
|
return GetNode(searchString);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeWrapper::GetPreviousSibling()
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pXmlNode )
|
|
m_pXmlNode->get_previousSibling(&pNode);
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeWrapper::GetNextSibling()
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pXmlNode )
|
|
m_pXmlNode->get_nextSibling(&pNode);
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::GetXML(BSTR * xmlString)
|
|
{
|
|
if ( ! m_pXmlNode )
|
|
return false;
|
|
|
|
return SUCCEEDED(m_pXmlNode->get_xml(xmlString));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::GetText(BSTR * text)
|
|
{
|
|
if ( ! m_pXmlNode )
|
|
return false;
|
|
|
|
return SUCCEEDED(m_pXmlNode->get_text(text));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::SetText(BSTR text)
|
|
{
|
|
if ( ! m_pXmlNode )
|
|
return false;
|
|
|
|
return SUCCEEDED(m_pXmlNode->put_text(text));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeWrapper::AppendNode(BSTR nodeName)
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
IXMLDOMDocument * pDoc = NULL;
|
|
m_pXmlNode->get_ownerDocument(&pDoc);
|
|
|
|
if ( pDoc )
|
|
{
|
|
VARIANT vtType;
|
|
vtType.vt = VT_I2;
|
|
vtType.iVal = NODE_ELEMENT;
|
|
|
|
IXMLDOMNode * pNewNode = NULL;
|
|
pDoc->createNode(vtType, nodeName, NULL, &pNewNode);
|
|
|
|
if ( pNewNode )
|
|
{
|
|
m_pXmlNode->appendChild(pNewNode, &pNode);
|
|
pNewNode->Release();
|
|
}
|
|
pDoc->Release();
|
|
}
|
|
}
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeWrapper::AppendNode(const XMLNodeWrapper& Node)
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
if ( Node.m_pXmlNode )
|
|
{
|
|
IXMLDOMNode * pNewNode = NULL;
|
|
Node.m_pXmlNode->cloneNode(VARIANT_TRUE, &pNewNode);
|
|
|
|
if ( pNewNode )
|
|
{
|
|
m_pXmlNode->appendChild(pNewNode, &pNode);
|
|
pNewNode->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeWrapper::RemoveNode(const XMLNodeWrapper& Node)
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pXmlNode )
|
|
m_pXmlNode->removeChild(Node.m_pXmlNode, &pNode);
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
void XMLNodeWrapper::RemoveNodes(BSTR searchString)
|
|
{
|
|
if ( ! m_pXmlNode )
|
|
return;
|
|
|
|
IXMLDOMNodeList * pNodeList = NULL;
|
|
m_pXmlNode->selectNodes(searchString, &pNodeList);
|
|
|
|
if ( pNodeList )
|
|
{
|
|
long cntNodes;
|
|
pNodeList->get_length(&cntNodes);
|
|
|
|
try
|
|
{
|
|
for ( int i = 0; i < cntNodes; ++i )
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
pNodeList->get_item(i, &pNode);
|
|
|
|
if ( pNode )
|
|
{
|
|
IXMLDOMNode * pParentNode = NULL;
|
|
pNode->get_parentNode(&pParentNode);
|
|
|
|
if ( pParentNode )
|
|
{
|
|
pParentNode->removeChild(pNode, NULL);
|
|
pParentNode->Release();
|
|
}
|
|
|
|
pNode->Release();
|
|
}
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
}
|
|
|
|
pNodeList->Release();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeListWrapper XMLNodeWrapper::FindNodes(BSTR searchString)
|
|
{
|
|
IXMLDOMNodeList * pNodeList = NULL;
|
|
|
|
if ( m_pXmlNode )
|
|
m_pXmlNode->selectNodes(searchString, &pNodeList);
|
|
|
|
return XMLNodeListWrapper(pNodeList);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int XMLNodeWrapper::GetAttributesCount()
|
|
{
|
|
long count = 0;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
IXMLDOMNamedNodeMap * pAttribs = NULL;
|
|
m_pXmlNode->get_attributes(&pAttribs);
|
|
|
|
if ( pAttribs )
|
|
{
|
|
pAttribs->get_length(&count);
|
|
pAttribs->Release();
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::GetAttributeValue(int index, BSTR * value)
|
|
{
|
|
HRESULT hRes = E_FAIL;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
IXMLDOMNamedNodeMap * pAttribs = NULL;
|
|
m_pXmlNode->get_attributes(&pAttribs);
|
|
|
|
if ( pAttribs )
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
pAttribs->get_item(index, &pNode);
|
|
|
|
if ( pNode )
|
|
{
|
|
IXMLDOMAttribute * pAttr = NULL;
|
|
pNode->QueryInterface(IID_IXMLDOMAttribute, (void **) &pAttr);
|
|
|
|
if ( pAttr )
|
|
{
|
|
hRes = pAttr->get_text(value);
|
|
pAttr->Release();
|
|
}
|
|
|
|
pNode->Release();
|
|
}
|
|
|
|
pAttribs->Release();
|
|
}
|
|
}
|
|
|
|
return SUCCEEDED(hRes);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::GetAttributeValue(int index, tagVARIANT * value)
|
|
{
|
|
HRESULT hRes = E_FAIL;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
IXMLDOMNamedNodeMap * pAttribs = NULL;
|
|
m_pXmlNode->get_attributes(&pAttribs);
|
|
|
|
if ( pAttribs )
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
pAttribs->get_item(index, &pNode);
|
|
|
|
if ( pNode )
|
|
{
|
|
IXMLDOMAttribute * pAttr = NULL;
|
|
pNode->QueryInterface(IID_IXMLDOMAttribute, (void **) &pAttr);
|
|
|
|
if ( pAttr )
|
|
{
|
|
hRes = pAttr->get_value(value);
|
|
pAttr->Release();
|
|
}
|
|
|
|
pNode->Release();
|
|
}
|
|
|
|
pAttribs->Release();
|
|
}
|
|
}
|
|
|
|
return SUCCEEDED(hRes);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::GetAttributeName(int index, BSTR * name)
|
|
{
|
|
HRESULT hRes = E_FAIL;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
IXMLDOMNamedNodeMap * pAttribs = NULL;
|
|
m_pXmlNode->get_attributes(&pAttribs);
|
|
|
|
if ( pAttribs )
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
pAttribs->get_item(index, &pNode);
|
|
|
|
if ( pNode )
|
|
{
|
|
IXMLDOMAttribute * pAttr = NULL;
|
|
pNode->QueryInterface(IID_IXMLDOMAttribute, (void **) &pAttr);
|
|
|
|
if ( pAttr )
|
|
{
|
|
hRes = pAttr->get_name(name);
|
|
pAttr->Release();
|
|
}
|
|
|
|
pNode->Release();
|
|
}
|
|
|
|
pAttribs->Release();
|
|
}
|
|
}
|
|
|
|
return SUCCEEDED(hRes);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::GetAttributeValue(BSTR valueName, BSTR * value, BSTR defaultValue)
|
|
{
|
|
HRESULT hRes = E_FAIL;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
IXMLDOMNamedNodeMap * pAttribs = NULL;
|
|
m_pXmlNode->get_attributes(&pAttribs);
|
|
|
|
if ( pAttribs )
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
pAttribs->getNamedItem(valueName, &pNode);
|
|
|
|
if ( pNode )
|
|
{
|
|
hRes = pNode->get_text(value);
|
|
pNode->Release();
|
|
}
|
|
|
|
pAttribs->Release();
|
|
}
|
|
}
|
|
|
|
if ( S_OK != hRes )
|
|
{
|
|
//SysFreeString(*value);
|
|
*value = SysAllocString(defaultValue);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::GetAttributeValue(BSTR valueName, tagVARIANT * value)
|
|
{
|
|
HRESULT hRes = E_FAIL;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
IXMLDOMElement * pElem = NULL;
|
|
m_pXmlNode->QueryInterface(IID_IXMLDOMElement, (void **) &pElem);
|
|
|
|
if ( pElem )
|
|
{
|
|
hRes = pElem->getAttribute(valueName, value);
|
|
pElem->Release();
|
|
}
|
|
}
|
|
|
|
return SUCCEEDED(hRes);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::SetAttributeValue(BSTR valueName, tagVARIANT value)
|
|
{
|
|
HRESULT hRes = E_FAIL;
|
|
|
|
if ( m_pXmlNode )
|
|
{
|
|
IXMLDOMElement * pElem = NULL;
|
|
m_pXmlNode->QueryInterface(IID_IXMLDOMElement, (void **) &pElem);
|
|
|
|
if ( pElem )
|
|
{
|
|
hRes = pElem->setAttribute(valueName, value);
|
|
pElem->Release();
|
|
}
|
|
}
|
|
|
|
return SUCCEEDED(hRes);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::SetAttributeValue(BSTR valueName, int value)
|
|
{
|
|
VARIANT vtValue;
|
|
vtValue.vt = VT_I4;
|
|
vtValue.lVal = value;
|
|
|
|
bool bRes = SetAttributeValue(valueName, vtValue);
|
|
|
|
VariantClear(&vtValue);
|
|
return bRes;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::SetAttributeValue(BSTR valueName, double value)
|
|
{
|
|
VARIANT vtValue;
|
|
vtValue.vt = VT_R8;
|
|
vtValue.dblVal = value;
|
|
|
|
bool bRes = SetAttributeValue(valueName, vtValue);
|
|
|
|
VariantClear(&vtValue);
|
|
return bRes;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeWrapper::SetAttributeValue(BSTR valueName, BSTR value)
|
|
{
|
|
VARIANT vtValue;
|
|
vtValue.vt = VT_BSTR;
|
|
vtValue.bstrVal = SysAllocString(value);
|
|
|
|
bool bRes = SetAttributeValue(valueName, vtValue);
|
|
|
|
VariantClear(&vtValue);
|
|
return bRes;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeListWrapper::XMLNodeListWrapper() : m_pNodeList(NULL)
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeListWrapper::XMLNodeListWrapper(IXMLDOMNodeList * pNodeList, bool addRef)
|
|
{
|
|
if ( ((m_pNodeList = pNodeList) != 0) && addRef )
|
|
m_pNodeList->AddRef();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeListWrapper::XMLNodeListWrapper(const XMLNodeListWrapper& NodeList)
|
|
{
|
|
if ( (m_pNodeList = NodeList.m_pNodeList) != 0 )
|
|
m_pNodeList->AddRef();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeListWrapper::~XMLNodeListWrapper()
|
|
{
|
|
if ( m_pNodeList )
|
|
m_pNodeList->Release();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeListWrapper& XMLNodeListWrapper::operator=(IXMLDOMNodeList * pNodeList)
|
|
{
|
|
if ( m_pNodeList )
|
|
m_pNodeList->Release();
|
|
|
|
m_pNodeList = pNodeList;
|
|
|
|
return *this;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeListWrapper& XMLNodeListWrapper::operator=(const XMLNodeListWrapper& NodeList)
|
|
{
|
|
if ( NodeList.m_pNodeList )
|
|
NodeList.m_pNodeList->AddRef();
|
|
|
|
if ( m_pNodeList )
|
|
m_pNodeList->Release();
|
|
|
|
m_pNodeList = NodeList.m_pNodeList;
|
|
|
|
return *this;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
int XMLNodeListWrapper::GetCount()
|
|
{
|
|
long length = 0;
|
|
|
|
if ( m_pNodeList )
|
|
m_pNodeList->get_length(&length);
|
|
|
|
return length;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeListWrapper::GetNode(int index)
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pNodeList )
|
|
m_pNodeList->get_item(index, &pNode);
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool XMLNodeListWrapper::Start()
|
|
{
|
|
if ( ! m_pNodeList )
|
|
return false;
|
|
|
|
return SUCCEEDED(m_pNodeList->reset());
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
XMLNodeWrapper XMLNodeListWrapper::Next()
|
|
{
|
|
IXMLDOMNode * pNode = NULL;
|
|
|
|
if ( m_pNodeList )
|
|
m_pNodeList->nextNode(&pNode);
|
|
|
|
return XMLNodeWrapper(pNode);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void XML::DeleteEmptyNodes(XMLNodeWrapper node)
|
|
{
|
|
for ( int i = node.GetNodesCount() - 1; i >= 0; --i )
|
|
{
|
|
XMLNodeWrapper currNode = node.GetNode(i);
|
|
|
|
DeleteEmptyNodes(currNode);
|
|
|
|
wchar_t * text = NULL;
|
|
currNode.GetText(&text);
|
|
|
|
if ( currNode.GetNodesCount() == 0 && currNode.GetAttributesCount() == 0 && SysStringLen(text) == 0 )
|
|
{
|
|
node.RemoveNode(currNode);
|
|
}
|
|
|
|
SysFreeString(text);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|