/*
Function name : CXML::CreateCommentNode
Description : This helper function creates a comment for the node supplied as argumnet
Return type : bool
Argument : IXMLDOMNode **pParentNode
Argument : CString csComment
*/
bool CXML::CreateCommentNode(IXMLDOMNode **ppParentNode,CString &rcsComment)
{
if(rcsComment.IsEmpty())
return false;
if(!(*ppParentNode))
return false;
IXMLDOMNode * pNode = NULL;
_variant_t vtNodeType((long)VT_I4,NODE_COMMENT);
_bstr_t bstrNameSpace("");
m_hr = m_pXMLDoc->createNode(vtNodeType,bstrNameSpace,bstrNameSpace,&pNode);
if(!SUCCEEDED(m_hr))
return false;
_variant_t vtComment(rcsComment);
m_hr = pNode->put_nodeValue(vtComment);
if(!SUCCEEDED(m_hr))
{
pNode->Release();
return false;
}
IXMLDOMNode * pINewNode = NULL;
bool bRet = AddNode(&m_pICurrentNode,&pNode,&pINewNode,NODE_COMMENT);
if(pNode)
pNode->Release();
if(pINewNode)
pINewNode->Release();
return bRet;
}
bool CNtlXMLDoc::GetDataWithXPath(WCHAR* pwszXPath, WCHAR* pwszResultData, int nBufferSizeInWChars)
{
if (NULL == pwszXPath || NULL == pwszResultData || 0 >= nBufferSizeInWChars)
return false;
IXMLDOMNode* pNode = NULL;
m_pXMLDocument->selectSingleNode(pwszXPath, &pNode);
if(!pNode)
return false;
BSTR bstr = NULL;
if (FAILED(pNode->get_text(&bstr)))
{
::SysFreeString(bstr);
pNode->Release();
return false;
}
wcscpy_s(pwszResultData, nBufferSizeInWChars, bstr);
::SysFreeString(bstr);
pNode->Release();
return true;
}
/*
Function name : CXML::PreviousSibling
Description : This will move the current node to the previous sibling of the current node.
Return type : bool
Tested : Ok
*/
bool CXML::PreviousSibling()
{
if(!m_pICurrentNode)
return false;
IXMLDOMNode * pITempNode = m_pICurrentNode;
IXMLDOMNode * pNode = NULL;
pITempNode->AddRef();
m_hr = pITempNode ->get_previousSibling(&pNode);
pITempNode->Release();
if (!SUCCEEDED(m_hr) || !pNode)
return false;
if(m_pICurrentNode)
{
m_pICurrentNode->Release();
m_pICurrentNode= NULL;
}
m_pICurrentNode = pNode;
m_pICurrentNode->AddRef();
pNode->Release();
return true;
}
/*
Function name : CXML::DeleteNode
Description : This function will delete the current node
Return type : bool
Tested : Ok
*/
bool CXML::DeleteNode()
{
if(!m_pICurrentNode)
return false;
IXMLDOMNode * pNode = NULL;
m_hr = m_pICurrentNode->get_nextSibling(&pNode);
if (!SUCCEEDED(m_hr))
return false;
if(!pNode)
{
m_hr = m_pICurrentNode->get_parentNode(&pNode);
if (!SUCCEEDED(m_hr))
return false;
}
if(!pNode)
return false;
Delete(&m_pICurrentNode);
if(m_pICurrentNode)
{
m_pICurrentNode->Release();
m_pICurrentNode = NULL;
}
m_pICurrentNode = pNode;
m_pICurrentNode->AddRef();
pNode->Release();
return true;
}
/*
Function name : CXML::CreateTextNode
Description : This helper function create an attribute to the node supplied as argumnet
Return type : bool
Argument : IXMLDOMNode **pParentNode
Argument : CString csAttribute
Argument : CString csValue
*/
bool CXML::RemoveAttributeNode(IXMLDOMNode **pParentNode,CString csAttribute)
{
IXMLDOMNode * pNode = NULL;
if(csAttribute.IsEmpty())
return false;
if(!(*pParentNode))
return false;
IXMLDOMNamedNodeMap * pAttributes = NULL;
m_hr = (*pParentNode)->get_attributes(&pAttributes);
if(!SUCCEEDED(m_hr) || !pAttributes)
return false;
IXMLDOMNode *pRemovedNode = NULL;
_bstr_t bstrAttribute(csAttribute);
m_hr = pAttributes->removeNamedItem(bstrAttribute,&pRemovedNode);
pAttributes->Release();
if(!SUCCEEDED(m_hr) || !pRemovedNode)
return false;
pRemovedNode->Release();
return true;
}
CXmlElement* CXmlElement::AddElement(LPWSTR pwszName)
{
HRESULT hr = S_OK;
CXmlElement *pElement = NULL;
IXMLDOMElement *pIElement = NULL;
BSTR bstrName = ::SysAllocString(pwszName);
if (NULL != m_pIDoc)
{
hr = m_pIDoc->createElement(bstrName, &pIElement);
if (SUCCEEDED(hr))
{
IXMLDOMNode *pNewNode = NULL;
hr = m_pIElement->appendChild(pIElement, &pNewNode);
if (SUCCEEDED(hr))
{
pElement = new CXmlElement(m_pIDoc, pIElement);
pNewNode->Release();
pNewNode = NULL;
}
pIElement->Release();
pIElement = NULL;
}
}
::SysFreeString(bstrName);
return pElement;
}
std::wstring CXmlNode::GetAttribute(LPCTSTR lpAttributeName)
{
IXMLDOMNamedNodeMap* lpNamedNodeMap;
IXMLDOMNode* lpXMLNode;
BSTR bstrValue;
std::wstring strValue;
HRESULT hr;
if (NULL == lpAttributeName || NULL == m_pXMLNode)
return _T("");
lpNamedNodeMap = NULL;
hr = m_pXMLNode->get_attributes(&lpNamedNodeMap);
if (hr == S_OK)
{
lpXMLNode = NULL;
hr = lpNamedNodeMap->getNamedItem((WCHAR *)lpAttributeName, &lpXMLNode);
if (hr == S_OK)
{
hr = lpXMLNode->get_text(&bstrValue);
if (hr == S_OK)
{
strValue = (WCHAR *)bstrValue;
::SysFreeString(bstrValue);
}
lpXMLNode->Release();
}
lpNamedNodeMap->Release();
}
return strValue;
}
// return "" if no value at path
std::string lvDCOMInterface::doXPATH(const std::string& xpath)
{
if (m_pxmldom == NULL)
{
throw std::runtime_error("m_pxmldom is NULL");
}
epicsGuard<epicsMutex> _lock(m_lock);
std::map<std::string,std::string>::const_iterator it = m_xpath_map.find(xpath);
if (it != m_xpath_map.end())
{
return it->second;
}
IXMLDOMNode *pNode = NULL;
std::string S_res;
BSTR bstrValue = NULL;
HRESULT hr = m_pxmldom->selectSingleNode(_bstr_t(xpath.c_str()), &pNode);
if (SUCCEEDED(hr) && pNode != NULL)
{
hr=pNode->get_text(&bstrValue);
if (SUCCEEDED(hr))
{
S_res = envExpand(CW2CT(bstrValue));
SysFreeString(bstrValue);
}
pNode->Release();
}
// else
// {
// throw std::runtime_error("doXPATH: cannot find " + xpath);
// }
m_xpath_map[xpath] = S_res;
return S_res;
}
bool CXML::GetNodeAttributeValue(IXMLDOMNode ** ppNode,CString csAttributeName,CString &rcsValue)
{
IXMLDOMNode *pNodeAttribute = NULL;
IXMLDOMNamedNodeMap *pNodeMap = NULL;
CString csTemp;
if(!ppNode || !(*ppNode))
return false;
m_hr = (*ppNode)->get_attributes(&pNodeMap);
if (SUCCEEDED(m_hr) == 0 || pNodeMap == NULL)
return false;
_bstr_t bstrAttributeName(csAttributeName);
m_hr = pNodeMap->getNamedItem (bstrAttributeName,&pNodeAttribute);
pNodeMap->Release();
if (SUCCEEDED(m_hr) == 0 || (pNodeAttribute == NULL))
return false;
_variant_t vtAttributeVal;
m_hr = pNodeAttribute->get_nodeValue(&vtAttributeVal);
pNodeAttribute->Release();
if (SUCCEEDED(m_hr) == 0)
return false;
rcsValue = vtAttributeVal.bstrVal;
return true;
}
/*
Function name : CXML::MoveToParentNode
Description : This function will move to the n th parent the current node.
Return type : bool
Argument : UINT nNthParent
Tested : Ok
*/
bool CXML::MoveToParentNode(UINT nNthParent)
{
if(!m_pICurrentNode)
return false;
IXMLDOMNode * pITempNode = m_pICurrentNode;
IXMLDOMNode * pNode = NULL;
pITempNode->AddRef();
for(UINT i=0;i<nNthParent;++i)
{
if(pNode)
{
pNode ->Release();
pNode = NULL;
}
m_hr = pITempNode ->get_parentNode(&pNode);
if (!SUCCEEDED(m_hr) || !pNode)
{
pITempNode->Release();
return false;
}
if(pITempNode)
{
pITempNode->Release();
pITempNode = NULL;
}
pITempNode = pNode;
pITempNode->AddRef();
}
if(pNode)
{
pITempNode->Release();
m_pICurrentNode->Release();
m_pICurrentNode = pNode;
m_pICurrentNode->AddRef();
pNode->Release();
pNode= NULL;
}
return true;
}
/*
Function name : CXML::CreateAttributeNode
Description :
Return type : bool
Argument : IXMLDOMNode **pParentNode
Argument : CString csAttribute
Argument : CString csValue
Tested : Ok
*/
bool CXML::CreateAttributeNode(IXMLDOMNode **pParentNode,CString csAttribute,CString csValue)
{
IXMLDOMNode * pNode = NULL;
if(csAttribute.IsEmpty())
return false;
if(!(*pParentNode))
return false;
_variant_t vtNodeType((long)NODE_ATTRIBUTE);
_bstr_t bstrName(csAttribute);
_bstr_t bstrNameSpace("");
m_hr = m_pXMLDoc->createNode(vtNodeType,bstrName,bstrNameSpace,&pNode);
if(!SUCCEEDED(m_hr))
return false;
IXMLDOMNamedNodeMap * pAttributes = NULL;
m_hr = (*pParentNode)->get_attributes(&pAttributes);
if(!SUCCEEDED(m_hr) || !pAttributes)
{
pNode->Release();
return false;
}
IXMLDOMNode *pNewNode = NULL;
m_hr = pAttributes->setNamedItem(pNode,&pNewNode);
pNode->Release();
pAttributes->Release();
if(!SUCCEEDED(m_hr) || !pNewNode)
return false;
_variant_t vtValue(csValue);
m_hr = pNewNode->put_nodeValue(vtValue);
pNewNode->Release();
if(!SUCCEEDED(m_hr) || !pNewNode)
return false;
return true;
}
bool CXML::SetAttributeValue(CString csPathToNode,CString csAttributeName,CString csValue,bool bCurrentNodeAsBase)
{
IXMLDOMNode * pNode = NULL;
if(!GetNode(&pNode,csPathToNode,NULL,NULL,bCurrentNodeAsBase))
return false;
if(RemoveAttributeNode(&pNode,csAttributeName))
if(CreateAttributeNode(&pNode,csAttributeName,csValue))
{
pNode->Release();
m_pIRootNode->Release();
return true;
}
pNode->Release();
return false;
}
IXMLDOMNode *CXML::NextChildNode(IXMLDOMNode **ppNode)
{
if(!(*ppNode))
return NULL;
IXMLDOMNode * pNode = NULL;
IXMLDOMNodeList * pChildList = NULL;
// Get the list of child nodes of the current node
m_hr = (*ppNode)->get_childNodes(&pChildList);
if (!SUCCEEDED(m_hr))
return NULL;
// loop through the childs
DOMNodeType nodeType;
while(true)
{
// Get the node type of each child, if it is of NODE_ELEMENT type set it as current node
m_hr = pChildList->nextNode(&pNode);
if(!SUCCEEDED(m_hr))
{
pChildList->Release();
return NULL;
}
if(!pNode) break;
m_hr = pNode->get_nodeType(&nodeType);
if(!SUCCEEDED(m_hr))
{
pChildList->Release();
pNode->Release();
return NULL;
}
if(nodeType == NODE_ELEMENT)
break;
if(pNode)
pNode->Release();
}
if(pChildList)
pChildList->Release();
return pNode;
}
/**
* получение xml-узла из списка по его имени
* @param NodeName имя искомого узла
* @param pIDOMNodeList дескриптор списка
* @return дескриптор нужного узла, или NULL в случае неудачи
* @see ConfGetNodeByName()
* @see ConfGetNodeText()
* @see ConfGetTextByName()
*/
IXMLDOMNode * ConfGetListNodeByName(BSTR NodeName, IXMLDOMNodeList *pIDOMNodeList)
{
IXMLDOMNode *Ret = NULL;
LONG len = 0;
if (pIDOMNodeList == NULL)
{
return NULL;
}
HRESULT hr = pIDOMNodeList->get_length(&len);
if (SUCCEEDED(hr))
{
pIDOMNodeList->reset();
for (int i = 0; i < len; i++)
{
IXMLDOMNode *pIDOMChildNode = NULL;
hr = pIDOMNodeList->get_item(i, &pIDOMChildNode);
if (SUCCEEDED(hr))
{
BSTR ChildNodeName = NULL;
hr = pIDOMChildNode->get_nodeName(&ChildNodeName);
if (SUCCEEDED(hr))
{
if (!wcscmp(NodeName, ChildNodeName))
{
Ret = pIDOMChildNode;
}
}
if (ChildNodeName)
{
SysFreeString(ChildNodeName);
}
if (Ret)
{
return Ret;
}
pIDOMChildNode->Release();
pIDOMChildNode = NULL;
}
else
{
DbgMsg(__FILE__, __LINE__, "pIDOMNodeList->get_item() ERROR 0x%.8x\n", hr);
}
}
}
else
{
DbgMsg(__FILE__, __LINE__, "pIDOMNodeList->get_length() ERROR 0x%.8x\n", hr);
}
return NULL;
}
/*
Function name : CXML::GoToNode
Description : Moves to the node having the specified text
Return type : bool
Argument : CString csPathToNode
Argument : CString csNodeText
Argument : bool bCurrentNodeAsBase
Tested : Not working
*/
bool CXML::GoToNodeEx(CString csPathToNode,CString csNodeText,bool bCurrentNodeAsBase)
{
CString csPath;
IXMLDOMNode *pBaseNode = NULL;
if(bCurrentNodeAsBase)
{
if(!m_pICurrentNode) return false;
pBaseNode = m_pICurrentNode;
pBaseNode->AddRef();
csPath.Format("./%s[.= \"%s\"]",csPathToNode,csNodeText);
}
else
{
if(!m_pIRootNode) return false;
pBaseNode = m_pIRootNode;
pBaseNode->AddRef();
csPath.Format("/%s[.= \"%s\"]",csPathToNode,csNodeText);
}
BSTR bstrPath = csPath.AllocSysString();
IXMLDOMNode * pNode = NULL;
m_hr = pBaseNode->selectSingleNode(bstrPath,&pNode);
pBaseNode->Release();
SysFreeString(bstrPath);
if(!SUCCEEDED(m_hr) || !pNode)
return false;
if(m_pICurrentNode)
{
m_pICurrentNode->Release();
m_pICurrentNode = NULL;
}
m_pICurrentNode = pNode;
m_pICurrentNode->AddRef();
pNode->Release();
return true;
}
//uvolni referenci alokovanou pro ItemData
void CXMLTree::OnDeleteitem(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
IXMLDOMNode * np = (IXMLDOMNode *) pNMTreeView->itemOld.lParam;
if (np != NULL) np->Release();
*pResult = 0;
}
/*
Function name : CXML::CreateAttribute
Description : This function adds an attribute to the given node
: with attributes and value and the text supplied
Return type : bool
Argument : CString csPathToNode
Argument : CString csAttribute
Argument : CString csValue
Argument : bool bCurrentNodeAsBase
*/
bool CXML::CreateAttribute(CString csPathToNode,CString csAttribute,CString csValue,bool bCurrentNodeAsBase)
{
IXMLDOMNode * pNode = NULL;
if(!GetNode(&pNode,csPathToNode,NULL,NULL,bCurrentNodeAsBase))
return false;
bool bRet = CreateAttributeNode(&pNode,csAttribute,csValue);
pNode->Release();
return bRet;
}
/*
Function name : CXML::Delete
Description : This helper function delete the node supplied node
Return type : bool
Argument : IXMLDOMNode **ppRemoveNode
Tested : Ok
*/
bool CXML::Delete(IXMLDOMNode **ppRemoveNode)
{
if(!(*ppRemoveNode)) return false;
IXMLDOMNode * pParentNode = NULL;
IXMLDOMNode * pRemovedNode = NULL;
m_hr = (*ppRemoveNode)->get_parentNode(&pParentNode );
if(!SUCCEEDED(m_hr) || !pParentNode)
return false;
m_hr = pParentNode->removeChild(*ppRemoveNode,&pRemovedNode);
pParentNode->Release();
if(!SUCCEEDED(m_hr) || !pRemovedNode)
return false;
pRemovedNode->Release();
return true;
}
bool CXML::GetAttributeValue(CString csPathToNode,CString csAttributeName,CString &rcsValue,bool bCurrentNodeAsBase )
{
IXMLDOMNode *pNode = NULL;
if(!GetNode(&pNode,csPathToNode,NULL,NULL,bCurrentNodeAsBase ))
return false;
bool bRet = GetNodeAttributeValue(&pNode,csAttributeName,rcsValue);
if(pNode)
pNode->Release();
return bRet;
}
bool SettingsXML::SetAttr(IXMLDOMNode* apNode, IXMLDOMNamedNodeMap* apAttrs, const wchar_t* asName, const wchar_t* asValue)
{
bool lbRc = false;
HRESULT hr = S_OK;
IXMLDOMNode *pValue = NULL;
IXMLDOMAttribute *pIXMLDOMAttribute = NULL;
BSTR bsText = NULL;
bsText = ::SysAllocString(asName);
hr = apAttrs->getNamedItem(bsText, &pValue);
BSTR bsValue = ::SysAllocString(asValue);
wchar_t* pszEsc = wcschr(bsValue, (wchar_t)27);
if (pszEsc != NULL)
{
_ASSERTE(wcschr(bsValue, (wchar_t)27) == NULL); // У DOM сносит крышу, если писать "ESC" в значение
while ((pszEsc = wcschr(bsValue, (wchar_t)27)) != NULL)
{
*pszEsc = L'?';
}
}
if (FAILED(hr) || !pValue)
{
hr = mp_File->createAttribute(bsText, &pIXMLDOMAttribute);
_ASSERTE(hr == S_OK);
if (SUCCEEDED(hr) && pIXMLDOMAttribute)
{
VARIANT vtValue; vtValue.vt = VT_BSTR; vtValue.bstrVal = bsValue;
hr = pIXMLDOMAttribute->put_nodeValue(vtValue);
_ASSERTE(hr == S_OK);
hr = apAttrs->setNamedItem(pIXMLDOMAttribute, &pValue); //-V519
_ASSERTE(hr == S_OK);
lbRc = SUCCEEDED(hr);
}
}
else if (SUCCEEDED(hr) && pValue)
{
hr = pValue->put_text(bsValue);
_ASSERTE(hr == S_OK);
lbRc = SUCCEEDED(hr);
}
::SysFreeString(bsText); bsText = NULL;
::SysFreeString(bsValue); bsValue = NULL;
if (pValue) { pValue->Release(); pValue = NULL; }
if (pIXMLDOMAttribute) { pIXMLDOMAttribute->Release(); pIXMLDOMAttribute = NULL; }
return lbRc;
}
// FindElements
UINT COpcXmlDocument::FindElements(const COpcString& cXPath, COpcXmlElementList& cElements)
{
cElements.RemoveAll();
// check if document exists.
if (m_ipDocument == NULL)
{
return 0;
}
// search for matching nodes.
IXMLDOMNodeList* ipNodes = NULL;
BSTR bstrQuery = SysAllocString(cXPath);
HRESULT hResult = m_ipDocument->selectNodes(bstrQuery, &ipNodes);
SysFreeString(bstrQuery);
if (FAILED(hResult))
{
return 0;
}
// add found nodes to element list.
do
{
IXMLDOMNode* ipNode = NULL;
hResult = ipNodes->nextNode(&ipNode);
if (hResult != S_OK || ipNode == NULL)
{
break;
}
COpcXmlElement cElement(ipNode);
ipNode->Release();
if (cElement != NULL)
{
cElements.Append(cElement);
}
}
while (SUCCEEDED(hResult));
if (ipNodes != NULL)
{
ipNodes->Release();
}
// return the number of elements found.
return cElements.GetSize();
}
// New
bool COpcXmlDocument::New()
{
HRESULT hResult = S_OK;
IXMLDOMProcessingInstruction* ipHeader = NULL;
IXMLDOMNode* ipResult = NULL;
BSTR bstrDocType = SysAllocString(TAG_DOCTYPE);
BSTR bstrFormat = SysAllocString(TAG_FORMAT);
TRY
{
// create new document instance.
if (!Init())
{
THROW_(hResult, E_FAIL);
}
// add document header.
hResult = m_ipDocument->createProcessingInstruction(bstrDocType, bstrFormat, &ipHeader);
if (FAILED(hResult))
{
THROW();
}
hResult = m_ipDocument->appendChild(ipHeader, &ipResult);
if (FAILED(hResult))
{
THROW();
}
}
CATCH
{
Clear();
}
FINALLY
{
// release memory.
if (ipHeader != NULL) ipHeader->Release();
if (ipResult != NULL) ipResult->Release();
SysFreeString(bstrDocType);
SysFreeString(bstrFormat);
}
return SUCCEEDED(hResult);
}
/**
* получение значения подузла по его имени
* @param pIDOMNode дескриптор родительского узла
* @param name имя дочернего узла, значение которого необходимо получить
* @param val адресс указателя на unicode-строку, в которую будет записано значение
* @return TRUE если всё ОК, FALSE в случае ошибки
* @see ConfGetListNodeByNameA()
* @see ConfGetListNodeByName()
* @see ConfGetNodeByName()
* @see ConfGetNodeText()
* @see ConfGetTextByName()
*/
BOOL ConfAllocGetTextByNameW(IXMLDOMNode *pIDOMNode, PWSTR name, PWSTR *value)
{
BOOL bRet = FALSE;
IXMLDOMNode *pIDOMChildNode = ConfGetNodeByName(name, pIDOMNode);
if (pIDOMChildNode)
{
bRet = ConfGetNodeTextW(pIDOMChildNode, value);
pIDOMChildNode->Release();
}
return bRet;
}
void SettingsXML::AppendText(IXMLDOMNode* apFrom, BSTR asText)
{
if (!asText || !*asText)
return;
VARIANT vtType;
IXMLDOMNode* pChild = NULL;
IXMLDOMNode *pIXMLDOMNode = NULL;
vtType.vt = VT_I4; vtType.lVal = NODE_TEXT;
HRESULT hr = mp_File->createNode(vtType, L"", L"", &pChild);
if (SUCCEEDED(hr) && pChild)
{
hr = pChild->put_text(asText);
hr = apFrom->appendChild(pChild, &pIXMLDOMNode); //-V519
pChild->Release(); pChild = NULL;
if (SUCCEEDED(hr) && pIXMLDOMNode)
{
pIXMLDOMNode->Release(); pIXMLDOMNode = NULL;
}
}
}
bool CXML::AddNodeText(CString csPathToNode,CString csNodeText,bool bCurrentNodeAsBase )
{
if(csPathToNode.IsEmpty() || csNodeText.IsEmpty())
return false;
IXMLDOMNode *pNode = NULL;
if(!GetNode(&pNode,csPathToNode,NULL,NULL,bCurrentNodeAsBase))
return false;
bool bRet = CreateNodeText(&pNode,csNodeText);
if(pNode)
pNode->Release();
return bRet;
}
bool CXML::DeleteNode(CString csPathToNode,bool bCurrentNodeAsBase)
{
if(csPathToNode.IsEmpty()) return false;
IXMLDOMNode * pRemoveNode = NULL;
if(!GetNode(&pRemoveNode,csPathToNode,NULL,NULL,bCurrentNodeAsBase))
return false;
bool bRet = Delete(&pRemoveNode);
pRemoveNode->Release();
return bRet;
}
bool lvDCOMInterface::doXPATHbool(const std::string& xpath)
{
if (m_pxmldom == NULL)
{
throw std::runtime_error("m_pxmldom is NULL");
}
epicsGuard<epicsMutex> _lock(m_lock);
std::map<std::string,bool>::const_iterator it = m_xpath_bool_map.find(xpath);
if (it != m_xpath_bool_map.end())
{
return it->second;
}
IXMLDOMNode *pNode = NULL;
bool res = false;
BSTR bstrValue = NULL;
std::string bool_str;
HRESULT hr = m_pxmldom->selectSingleNode(_bstr_t(xpath.c_str()), &pNode);
if (SUCCEEDED(hr) && pNode != NULL)
{
hr=pNode->get_text(&bstrValue);
if (SUCCEEDED(hr))
{
bool_str = envExpand(CW2CT(bstrValue));
if (bool_str.size() == 0)
{
res = false;
}
// allow true / yes / non_zero_number
// note: atol() returns 0 for non numeric strings, so OK in a test for "true"
else if ( (bool_str[0] == 't') || (bool_str[0] == 'T') || (bool_str[0] == 'y') || (bool_str[0] == 'Y') || (atol(bool_str.c_str()) != 0) )
{
res = true;
}
else
{
res = false;
}
SysFreeString(bstrValue);
}
pNode->Release();
}
// else
// {
// throw std::runtime_error("doXPATHbool: cannot find " + xpath);
// }
m_xpath_bool_map[xpath] = res;
return res;
}
bool CXML::DeleteNode(CString csPathToNode,CString csAttribute,CString csValue,bool bUseBase)
{
if(csPathToNode.IsEmpty()) return false;
IXMLDOMNode * pRemoveNode = NULL;
if(!GetNode(&pRemoveNode,csPathToNode,csAttribute,csValue,bUseBase))
return false;
bool bRet = Delete(&pRemoveNode);
if(pRemoveNode)
pRemoveNode->Release();
return bRet;
}
//--------------------------------------------------------------------------------------
BOOL ConfGetNodeAttributeW(IXMLDOMNode *pIDOMNode, PWSTR name, PWSTR *value)
{
BOOL bRet = FALSE;
IXMLDOMNamedNodeMap *pIXMLDOMNamedNodeMap = NULL;
// query attributes map
HRESULT hr = pIDOMNode->get_attributes(&pIXMLDOMNamedNodeMap);
if (SUCCEEDED(hr) && pIXMLDOMNamedNodeMap)
{
IXMLDOMNode *pIDOMAttrNode = NULL;
// query attribute node
hr = pIXMLDOMNamedNodeMap->getNamedItem(name, &pIDOMAttrNode);
if (SUCCEEDED(hr) && pIDOMAttrNode)
{
VARIANT varValue;
hr = pIDOMAttrNode->get_nodeValue(&varValue);
if (FAILED(hr))
{
DbgMsg(__FILE__, __LINE__, "pIDOMAttrNode->get_nodeValue() ERROR 0x%.8x\n", hr);
goto free;
}
BSTR val = _bstr_t(varValue);
DWORD Len = (wcslen((PWSTR)val) + 1) * sizeof(WCHAR);
if (*value = (PWSTR)M_ALLOC(Len))
{
ZeroMemory(*value, Len);
wcscpy(*value, (PWSTR)val);
bRet = TRUE;
}
else
{
DbgMsg(__FILE__, __LINE__, "M_ALLOC() ERROR %d\n", GetLastError());
}
free:
pIDOMAttrNode->Release();
pIDOMAttrNode = NULL;
}
pIXMLDOMNamedNodeMap->Release();
pIXMLDOMNamedNodeMap = NULL;
}
return bRet;
}
BSTR SettingsXML::GetAttr(IXMLDOMNode* apNode, IXMLDOMNamedNodeMap* apAttrs, const wchar_t* asName)
{
HRESULT hr = S_OK;
IXMLDOMNode *pValue = NULL;
BSTR bsText = NULL;
bsText = ::SysAllocString(asName);
hr = apAttrs->getNamedItem(bsText, &pValue);
::SysFreeString(bsText); bsText = NULL;
if (SUCCEEDED(hr) && pValue)
{
hr = pValue->get_text(&bsText);
pValue->Release(); pValue = NULL;
}
return bsText;
}
