bool CXmlUtil::NewXMLFile(XMLDOMDocumentPtr& doc,
const wchar_t* pszRootName,
const wchar_t* pszEncoding,
const wchar_t* pszNameSpace,
const wchar_t* comment)
{
LocalHResult hr;
doc = NULL;
if (FAILED(hr = doc.CreateInstance(CLSID_XmlDocument60))
&& FAILED(hr = doc.CreateInstance(CLSID_XmlDocument40)))
{
#ifdef X3LOG_WARNING2
X3LOG_WARNING2(L"@ConfigXml:IDS_CREATEINSTANCE_FAIL", L"CLSID_XmlDocument");
#endif
return false;
}
XMLDOMNodePtr pDocNode (doc);
std::wstring strHeader = L"version=\"1.0\" encoding=\"";
strHeader += pszEncoding;
strHeader += L"\"";
XMLDOMProcessingInstructionPtr pHeader;
hr = doc->createProcessingInstruction(
_bstr_t(L"xml"), _bstr_t(strHeader.c_str()), &pHeader);
hr = pDocNode->appendChild(pHeader, NULL);
if (IsNotEmpty(comment))
{
XMLDOMComment* pComment = NULL;
hr = doc->createComment(_bstr_t(comment), &pComment);
if (pComment != NULL)
{
hr = doc->appendChild(XMLDOMNodePtr(pComment), NULL);
pComment->Release();
}
}
// Create root node
if (IsNotEmpty(pszRootName))
{
VARIANT type;
V_VT(&type) = VT_INT;
V_INT(&type) = XML::NODE_ELEMENT;
XMLDOMNodePtr pRoot;
hr = doc->createNode(type, _bstr_t(pszRootName), _bstr_t(pszNameSpace), &pRoot);
hr = pDocNode->appendChild(pRoot, NULL);
}
return true;
}
bool CXmlUtil::SaveXMLFile(const XMLDOMDocumentPtr& doc,
const wchar_t* filename,
IXmlFileCrypt* pCryptHandler)
{
LocalHResult hr = E_INVALIDARG;
if (!IsNotEmpty(filename))
return false;
VARIANT vt;
V_VT(&vt) = VT_BSTR;
V_BSTR(&vt) = ::SysAllocString(filename);
try
{
hr = doc->save(vt);
}
catch (...)
{
hr = E_FAIL;
}
if (vt.bstrVal != NULL)
{
::SysFreeString(vt.bstrVal);
}
if (SUCCEEDED(hr) && pCryptHandler)
{
pCryptHandler->CryptFile(filename);
}
return SUCCEEDED(hr);
}
long CXmlUtil::FindElementByAttr(XMLDOMElementPtr& outEle,
const XMLDOMElementPtr& parent,
const wchar_t* pszElement,
const wchar_t* pszAttr1,
const wchar_t* value1,
const wchar_t* pszAttr2,
const wchar_t* value2)
{
NL(pszAttr1); NL(value1); NL(pszAttr2); NL(value2);
XMLDOMElementPtr ele;
long i = GetChildCount(parent, pszElement);
outEle = NULL;
while (--i >= 0)
{
if (GetChild(ele, parent, pszElement, i))
{
if (_wcsicmp(GetAttribute(ele, pszAttr1).c_str(), value1) == 0
&& (!IsNotEmpty(pszAttr2) || _wcsicmp(
GetAttribute(ele, pszAttr2).c_str(), value2) == 0))
{
outEle = ele;
break;
}
}
}
return i;
}
// Tendo o pai como referência, o mesmo é comparado com seus filhos e trocado
// caso a sua prioridade seja maior que a de um deles.
void DownwardsMin(Heap *intervals, int position) {
//Assume que o filho de menor valor é o da esquerda.
int lowest_son_position = 2*position+1;
bool stop = false;
// Enquanto o vetor ainda estiver sendo percorrido e o pai
// não ser menor que ambos seus filhos...
while((!stop) && (lowest_son_position < (*intervals).size)) {
// Caso os filhos da direita e esquerda existirem e o valor atual do
// filho de menor valor for maior que o do irmão, significa que a
// posição do filho de menor valor é a posição do irmão.
int father_value = (*intervals).node[position].min;
if(BrotherHasLowerValue((*intervals), lowest_son_position)){
lowest_son_position += 1;
// Garante que o valor a ser utilizado é o correto.
AssignValues(&(*intervals).node[lowest_son_position]);
}
// Caso o pai possua prioridade maior que a do filho de menor prioridade,
// troca os valores de ambos entre si. A verificação é feita para ambos
// os extremos do intervalo.
if((father_value > (*intervals).node[lowest_son_position].min)
&& IsNotEmpty((*intervals).node[lowest_son_position].min)) {
SwapValues(&(*intervals).node[position].min,
&(*intervals).node[lowest_son_position].min);
} else if ((father_value > (*intervals).node[lowest_son_position].max)
&& IsNotEmpty((*intervals).node[lowest_son_position].max)) {
SwapValues(&(*intervals).node[position].min,
&(*intervals).node[lowest_son_position].max);
//Caso o pai esteja na posição correta, interrompe o loop.
} else {
stop = true;
}
position = lowest_son_position;
lowest_son_position = (2 * lowest_son_position) + 1;
//Ajusta os valores máximo e mínimo, caso necessário.
AssignValues(&(*intervals).node[position]);
}
AssignValues(&(*intervals).node[position]);
}
int main() {
int initial_number_of_elements;
// Cria um novo heap a partir da entrada.
scanf("%d", &initial_number_of_elements);
Heap interval_heap;
interval_heap = CreateHeap(initial_number_of_elements);
// Realiza as operações requisitadas;
char operator;
scanf("%c", &operator);
while ((operator != 'f') && (operator != 'F')) {
if(operator == 'm'){
int value_removed = RemoveLowestPriority(&interval_heap);
if(IsNotEmpty(value_removed)) {
printf("%d\n", value_removed);
}
} else if(operator == 'M') {
int value_removed = RemoveHighestPriority(&interval_heap);
if(IsNotEmpty(value_removed)) {
printf("%d\n", value_removed);
}
} else if(operator == 'i') {
int priority_new_element;
scanf("%d", &priority_new_element);
interval_heap = InsertNewElement(interval_heap, priority_new_element);
}
// for(int i = 0; i < interval_heap.size; i++) {
// printf("min = %d // max = %d\n", interval_heap.node[i].min, interval_heap.node[i].max);
// }
// printf("--------------------------------------\n");
scanf("%c", &operator);
}
printf("\n");
printf("Min-heap:");
PreOrderMin(interval_heap, 0);
printf(" \n");
printf("Max-heap:");
PreOrderMax(interval_heap, 0);
printf(" \n");
return 0;
}
bool CXmlUtil::LoadXMLFile(XMLDOMDocumentPtr& doc,
const wchar_t* filename,
IXmlFileCrypt* pCryptHandler)
{
LocalHResult hr;
if (!IsNotEmpty(filename))
return false;
if (pCryptHandler && pCryptHandler->Decrypt(doc, filename))
{
ASSERT(doc != NULL);
return true;
}
doc = NULL;
if (FAILED(hr = doc.CreateInstance(CLSID_XmlDocument60))
&& FAILED(hr = doc.CreateInstance(CLSID_XmlDocument40)))
{
#ifdef X3LOG_WARNING2
X3LOG_WARNING2(L"@ConfigXml:IDS_CREATEINSTANCE_FAIL", L"CLSID_XmlDocument");
#endif
return false;
}
VARIANT vt;
V_VT(&vt) = VT_BSTR;
V_BSTR(&vt) = ::SysAllocString(filename);
try
{
VARIANT_BOOL bLoad = VARIANT_FALSE;
hr = doc->put_async(VARIANT_FALSE);
if (FAILED(hr = doc->load(vt, &bLoad)) || !bLoad)
{
OutputParseError(doc, filename);
doc = NULL;
}
}
catch (...)
{
hr = E_FAIL;
}
if (vt.bstrVal != NULL)
::SysFreeString(vt.bstrVal);
return SUCCEEDED(hr) && (doc != NULL);
}
bool CXmlUtil::SetAttribute(const XMLDOMDocumentPtr&,
const XMLDOMElementPtr& ele,
const wchar_t* name,
const wchar_t* value)
{
LocalHResult hr;
bool bRet = false;
if (IsNotEmpty(name) && ele != NULL)
{
hr = ele->setAttribute(_bstr_t(name), _variant_t(value));
bRet = SUCCEEDED(hr);
}
return bRet;
}
bool CXmlUtil::DelAttribute(const XMLDOMElementPtr& ele,
const wchar_t* name)
{
LocalHResult hr;
XMLDOMAttributePtr node = NULL;
if (ele != NULL && IsNotEmpty(name))
hr = ele->getAttributeNode(_bstr_t(name), &node);
if (node != NULL)
{
XMLDOMElementPtr pItem(node);
return SUCCEEDED(hr = ele->removeChild(pItem, NULL));
}
return false;
}
bool CXmlUtil::AddChild(XMLDOMElementPtr& outEle,
const XMLDOMDocumentPtr& doc,
const XMLDOMElementPtr& ele,
const wchar_t* pszChildName)
{
LocalHResult hr;
XMLDOMElementPtr pRet = NULL;
outEle = NULL;
if (doc != NULL && ele != NULL && IsNotEmpty(pszChildName))
hr = doc->createElement(_bstr_t(pszChildName), &pRet);
if (pRet != NULL)
{
hr = ele->appendChild(pRet, NULL);
outEle = pRet;
}
return outEle != NULL;
}
static long GetChildIndex(const XMLDOMElementPtr& ele,
const wchar_t* pszChildName,
long nMaxIndex,
XMLDOMNodePtr& pRet)
{
LocalHResult hr;
pRet = NULL;
if (!IsNotEmpty(pszChildName) || NULL == ele)
return 0;
long n = 0, nCount = 0;
XMLDOMNodeListPtr nl;
hr = ele->get_childNodes(&nl);
if (nl != NULL)
{
hr = nl->get_length(&n);
for (int i = 0; i < n; i++)
{
XMLDOMNodePtr node;
hr = nl->get_item(i, &node);
if (NULL == node)
continue;
BSTR bstr = NULL;
hr = node->get_nodeName(&bstr);
if (bstr != NULL && _wcsicmp(bstr, pszChildName) == 0)
{
nCount++;
if (nCount > nMaxIndex)
{
pRet = node;
::SysFreeString(bstr);
break;
}
}
::SysFreeString(bstr);
}
}
return nCount;
}
bool CXmlUtil::CreateNodeComment(const XMLDOMDocumentPtr& doc,
const XMLDOMElementPtr& ele,
const wchar_t* comment)
{
LocalHResult hr;
if (doc != NULL && ele != NULL && IsNotEmpty(comment))
{
XMLDOMComment* pComment = NULL;
hr = doc->createComment(_bstr_t(comment), &pComment);
if (pComment != NULL)
{
hr = ele->appendChild(XMLDOMNodePtr(pComment), NULL);
pComment->Release();
return true;
}
}
return false;
}
bool CXmlUtil::CreateDocComment(const XMLDOMDocumentPtr& doc,
const wchar_t* comment)
{
LocalHResult hr;
if (doc != NULL && IsNotEmpty(comment))
{
XMLDOMElementPtr ele;
hr = doc->get_documentElement(&ele);
XMLDOMComment* pComment = NULL;
hr = doc->createComment(_bstr_t(comment), &pComment);
if (pComment != NULL)
{
hr = doc->insertBefore(XMLDOMNodePtr(pComment), _variant_t(ele), NULL);
pComment->Release();
return true;
}
}
return false;
}
bool CXmlUtil::GetChildOrAdd(XMLDOMElementPtr& outEle,
const XMLDOMDocumentPtr& doc,
const XMLDOMElementPtr& parent,
const wchar_t* pszChildName)
{
LocalHResult hr;
outEle = NULL;
if (!IsNotEmpty(pszChildName) || NULL == parent)
return false;
XMLDOMNodePtr pRet = NULL;
GetChildIndex(parent, pszChildName, 0, pRet);
outEle = pRet;
if (NULL == outEle)
{
hr = doc->createElement(_bstr_t(pszChildName), &outEle);
hr = parent->appendChild(outEle, NULL);
}
return outEle != NULL;
}
std::wstring CXmlUtil::GetAttribute(const XMLDOMElementPtr& ele,
const wchar_t* name,
const wchar_t* defaultText)
{
NL(defaultText);
std::wstring strValue (defaultText);
XMLDOMAttributePtr node = NULL;
LocalHResult hr;
if (IsNotEmpty(name) && ele != NULL)
hr = ele->getAttributeNode(_bstr_t(name), &node);
if (node != NULL)
{
BSTR bstr = NULL;
hr = node->get_text(&bstr);
if (bstr != NULL)
{
strValue = bstr;
::SysFreeString(bstr);
}
}
return strValue;
}
bool IsNotSchemaEmpty(const SqlId& table, const SqlBool& cond, Sql& cursor)
{
return IsNotEmpty(Select(1).FromSchema(table).Where(cond), cursor);
}
bool IsNotEmpty(const SqlVal& table, SqlId column, const Value& value, Sql& cursor)
{
return IsNotEmpty(table, column == value, cursor);
}
bool IsNotEmpty(const SqlVal& table, const SqlBool& cond, Sql& cursor)
{
return IsNotEmpty(Select(1).From(table).Where(cond), cursor);
}
