Hola!!!
Mira, hace unos meses q no programo en C/C++ pero encontre un ejemplo de uso de libxml2 (bajo Linux) y te lo mando. La verdad es q la funcion q decis no la use, por eso te paso el ejemplo de lo q hice para q t sirva de ayuda en algo:
Antes q nada, perdon por los q lean esto tan largo y por los errores q pude haber hecho y por el coding style q no me gustaaaa
<code>
#include "CXMLParserServidor.h"
//******************************************************
// Constructor de la clase CXMLParserServidor
//******************************************************
CXMLParserServidor::CXMLParserServidor()
{
}
//******************************************************
// Getea el atributo Comando
//******************************************************
CComando* CXMLParserServidor::getComando() const
{
return this->Comando;
}
//******************************************************
// Setea el atributo Comando
//******************************************************
void CXMLParserServidor::setComando(CComando* Comando)
{
this->Comando = Comando;
}
//******************************************************
// Parsea un string y lo setea en el atributo Comando
//******************************************************
void CXMLParserServidor::ParsearString(TString StringAParsear)
{
int LongitudAParsear = StringAParsear.size();
xmlDocPtr Documento;
xmlNodePtr NodoActual;
// Obtengo el documento a parsear en formato string
Documento = xmlParseMemory(StringAParsear.c_str(), LongitudAParsear);
if (Documento == NULL)
{
cout << "Documento = null" << endl;
return;
}
// Obtengo el nodo raiz
NodoActual = xmlDocGetRootElement(Documento);
if (NodoActual == NULL)
{
cout << "NodoActual = null" << endl;
return;
}
// Verifico que el primer nodo sea correcto para el caso en particular
if (xmlStrcmp(NodoActual->name, (const xmlChar *) "MENSAJE"))
{
cout << "El documento no es correcto" << endl;
xmlFreeDoc(Documento);
return;
}
// Obtengo el nodo hijo del raiz
NodoActual = NodoActual->children;
while (NodoActual != NULL)
{
// Parseo los Nodos
parsearNodos(NodoActual);
NodoActual = NodoActual->next;
}
cout << "Termine de parsear" << endl;
// Libero el documento
xmlFreeDoc(Documento);
xmlFreeNode(NodoActual);
return;
}
//******************************************************
// Parsea los nodos hijos del tag <MENSAJE>
//******************************************************
void CXMLParserServidor::parsearNodos(xmlNodePtr NodoActual)
{
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "NOMBREARCHIVOBUSCADO"))
{
// Aca leo el contenido del XML del tag <COMANDO> y lo cargo
// en el atributo Comando
this->Comando->setNombreArchivoBuscado(getNombreArchivoBuscado(NodoActual));
}
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "COMANDO"))
{
// Aca leo el contenido del XML del tag <COMANDO> y lo cargo
// en el atributo Comando
getComandoDelXML(NodoActual);
}
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "NOMBRE"))
{
// Aca leo el contenido del XML del tag <NOMBRE> y lo cargo
// en el atributo Comando
this->Comando->setNombre(this->getNombreDelXML(NodoActual));
}
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "APELLIDO"))
{
// Aca leo el contenido del XML del tag <APELLIDO> y lo cargo
// en el atributo Comando
this->Comando->setApellido(this->getApellidoDelXML(NodoActual));
}
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "NICK"))
{
// Aca leo el contenido del XML del tag <NICK> y lo cargo
// en el atributo Comando
this->Comando->setNick(this->getNickDelXML(NodoActual));
}
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "PASSWORD"))
{
// Aca leo el contenido del XML del tag <PASSWORD> y lo cargo
// en el atributo Comando
this->Comando->setPassword(this->getPasswordDelXML(NodoActual));
}
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "CLAVE"))
{
// Aca leo el contenido del XML del tag <CLAVE> y lo cargo
// en el atributo Comando
this->Comando->setClave(this->getClaveDelXML(NodoActual));
}
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "ID"))
{
// Aca leo el contenido del XML del tag <COMANDO> y lo cargo
// en el atributo Comando
this->Comando->setIdUsuario(this->getIdDelXML(NodoActual));
}
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "IDUSUARIOBUSCADO"))
{
// Aca leo el contenido del XML del tag <COMANDO> y lo cargo
// en el atributo Comando
this->Comando->setIdUsuarioBuscado(this->getIdUsuarioBuscadoDelXML(NodoActual));
}
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "LISTADEARCHIVOS"))
{
// Entro un nivel, al nivel del tag <LISTADEARCHIVOS>
xmlNodePtr NodoActualListaDeArchivos;
NodoActualListaDeArchivos = NodoActual->children;
while (NodoActualListaDeArchivos != NULL)
{
// Aca recorro por lo q esta dentro del tag <LISTADEARCHIVOS>
// Comienzo a meterme otro nivel, el cual comienza en este tag
parsearListaDeArchivos(NodoActualListaDeArchivos);
NodoActualListaDeArchivos = NodoActualListaDeArchivos->next;
}
xmlFreeNode(NodoActualListaDeArchivos);
}
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "LISTADEPALABRAS"))
{
xmlNodePtr NodoActualListaDePalabras;
NodoActualListaDePalabras = NodoActual->children;
// Entro un nivel, al nivel del tag <LISTADEPALABRAS>
while (NodoActualListaDePalabras != NULL)
{
// Aca recorro por lo q esta dentro del tag <LISTADEPALABRAS>
// Comienzo a meterme otro nivel, el cual comienza en este tag
parsearListaDePalabras(NodoActualListaDePalabras);
NodoActualListaDePalabras = NodoActualListaDePalabras->next;
}
xmlFreeNode(NodoActualListaDePalabras);
}
}
//******************************************************
// Parsea el tag <LISTADEARCHIVOS>
//******************************************************
void CXMLParserServidor::parsearListaDeArchivos(xmlNodePtr NodoActual)
{
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "ARCHIVO"))
{
// Aca leo el contenido del XML del tag <ARCHIVO> y lo cargo
// en el atributo Comando
this->Comando->agregarNodoListaDeArchivos(this->getArchivoDelXML(NodoActual));
}
}
//******************************************************
// Parsea el tag <LISTADEPALABRAS>
//******************************************************
void CXMLParserServidor::parsearListaDePalabras(xmlNodePtr NodoActual)
{
if (!xmlStrcmp(NodoActual->name, (const xmlChar *) "PALABRA"))
{
// Aca leo el contenido del XML del tag <PALABRA> y lo cargo
// en el atributo Comando
getPalabraDelXML(NodoActual);
}
}
//******************************************************
// Parsea el tag <COMANDO>
//******************************************************
void CXMLParserServidor::getComandoDelXML(xmlNodePtr NodoActual)
{
xmlChar* Contenido;
xmlAttr* Atributo;
// Obtengo el puntero a atributos del nodo actual
Atributo = (xmlAttr *)NodoActual->properties;
// Recorro los atributos del tag <COMANDO>
while (Atributo != NULL)
{
if (!xmlStrcmp(Atributo->name, (const xmlChar *) "VALOR"))
{
// Obtengo la propiedad Valor del presente tag
Contenido = xmlGetProp(NodoActual, Atributo->name);
this->Comando->setComando((char*)(Contenido));
xmlFree(Contenido);
}
Atributo = Atributo->next;
}
// Libero el puntero a Atributo
xmlFreeProp(Atributo);
}
//******************************************************
// Parsea el tag <PALABRA>
//******************************************************
void CXMLParserServidor::getPalabraDelXML(xmlNodePtr NodoActual)
{
xmlChar* Contenido;
// Obtengo el contenido del presente tag
Contenido = xmlNodeGetContent(NodoActual);
this->Comando->agregarPalabraListaDePalabras((char*)(Contenido));
xmlFree(Contenido);
}
//******************************************************
// Escribe un XML en memoria (en un string de la STL)
// a partir de un CComando
//******************************************************
void CXMLParserServidor::ParsearComando()
{
xmlDocPtr Documento;
Documento = NuevoDocumento("MENSAJE");
// Agrego los nodos que colgaran del tag <MENSAJE>
AgregarNodos(Documento);
xmlChar** buffer = (xmlChar**)xmlMemMalloc(sizeof(xmlChar*));
int* x;
// Guardo en memoria el XML
xmlDocDumpMemoryEnc(Documento, buffer, x ,(const char *)("ISO-8859-1"));
// Guardo en archivo el XML
xmlSaveFile((const char*)("holahola.xml"), Documento);
this->setStringParseo((char*)(*buffer));
}
//******************************************************
// Escribe el tag <COMANDO> en el XML
//******************************************************
void CXMLParserServidor::AgregarComando(xmlNodePtr NodoActual)
{
xmlSetProp(NodoActual, (const xmlChar *)("VALOR"), (const xmlChar *)(this->Comando->getComando().c_str() ) );
}
//******************************************************
// Escribe el tag <CLAVE> en el XML
//******************************************************
void CXMLParserServidor::AgregarClave(xmlNodePtr NodoActual)
{
xmlNodeAddContent(NodoActual, (const xmlChar *)(this->Comando->getClave().c_str() ));
}
//******************************************************
// Escribe el tag <LISTADEARCHIVOS> en el XML
//******************************************************
void CXMLParserServidor::AgregarListaDeArchivos(xmlNodePtr Nodo)
{
for (int i = 0; i < (this->Comando->getListaDeArchivos().getLongitud()); i++)
{
xmlNodePtr NodoAux = xmlNewChild(Nodo, NULL, (const xmlChar *)("ARCHIVO"), NULL);
// Agrego el tag <ARCHIVO>
AgregarArchivo(NodoAux, i);
}
}
//******************************************************
// Escribe el tag <LISTADEPALABRAS> en el XML
//******************************************************
void CXMLParserServidor::AgregarListaDePalabras(xmlNodePtr Nodo)
{
for (int i = 0; i < (this->Comando->getListaDePalabras().getLongitud()); i++)
{
xmlNodePtr NodoAux = xmlNewChild(Nodo, NULL, (const xmlChar *)("PALABRA"), NULL);
// Agrego el tag <PALABRA>
AgregarPalabra(NodoAux, i);
}
}
//******************************************************
// Escribe el tag <ARCHIVO> en el XML
//******************************************************
void CXMLParserServidor::AgregarArchivo(xmlNodePtr Nodo, int i)
{
TString Operacion;
xmlNodePtr NodoAltas;
xmlNodePtr NodoAlta;
xmlNodePtr NodoBajas;
xmlNodePtr NodoBaja;
xmlNodePtr NodoModificaciones;
xmlNodePtr NodoModificacion;
CNodoListaArchivos NodoLista = (this->Comando->getListaDeArchivos().getNodoListaArchivos(i));
//Tag <ATRIBUTOS>
xmlNodePtr NodoAuxAtr = xmlNewChild(Nodo, NULL, (const xmlChar *)("ATRIBUTOS"), NULL);
xmlChar* NormaString = xmlXPathCastNumberToString(NodoLista.getArchivo().getNorma());
xmlSetProp(NodoAuxAtr, (const xmlChar *)("NOMBRE"), (const xmlChar *)(NodoLista.getArchivo().getNombre().c_str() ) );
xmlSetProp(NodoAuxAtr, (const xmlChar *)("TAMANIO"), (const xmlChar *)(NodoLista.getArchivo().getTamanio().c_str() ) );
xmlSetProp(NodoAuxAtr, (const xmlChar *)("FECHAMODIF"), (const xmlChar *)(NodoLista.getArchivo().getFechaModificacion().c_str() ) );
xmlSetProp(NodoAuxAtr, (const xmlChar *)("NORMA"), (const xmlChar *)(NormaString) );
//Fin tag <ATRIBUTOS>
//Tag <OPERACION>
xmlNodePtr NodoAux = xmlNewChild(Nodo, NULL, (const xmlChar *)("OPERACION"), NULL);
switch (NodoLista.getOperacion())
{
case 'C': Operacion = "CREAR"; break;
case 'E': Operacion = "ELIMINAR"; break;
case 'M': Operacion = "ABMS"; break;
case 'P': Operacion = "MODIFICAR"; break;
case 'F': Operacion = "MODIFICARYABMS"; break;
case 'N': Operacion = "NADA"; break;
default : break;
};
xmlNodeAddContent(NodoAux, (const xmlChar *)(Operacion.c_str() ));
//Fin tag <OPERACION>
//Tag <ABM>
if (NodoLista.tieneListasABM() == true)
{
xmlNodePtr NodoABM = xmlNewChild(Nodo, NULL, (const xmlChar *)("ABM"), NULL);
if (NodoLista.getLongitudListaAltas() > 0)
{
CListaDeABM ListaA = NodoLista.getListaDeABMAltas();
NodoAltas = xmlNewChild(NodoABM, NULL, (const xmlChar *)("ALTAS"), NULL);
NodoAlta = xmlNewChild(NodoAltas, NULL, (const xmlChar *)("ALTA"), NULL);
for (short j = 0; j < ListaA.getLongitud(); j++)
{
xmlSetProp(NodoAlta, (const xmlChar *)("PALABRA"), (const xmlChar *)(ListaA.getABM(j).getPalabra().c_str() ) );
xmlSetProp(NodoAlta, (const xmlChar *)("FRECUENCIA"), (const xmlChar *)(ListaA.getABM(j).getFrecuenciaString().c_str() ) );
}
}
if (NodoLista.getLongitudListaBajas() > 0)
{
CListaDeABM ListaB = NodoLista.getListaDeABMBajas();
NodoBajas = xmlNewChild(NodoABM, NULL, (const xmlChar *)("BAJAS"), NULL);
NodoBaja = xmlNewChild(NodoBajas, NULL, (const xmlChar *)("BAJA"), NULL);
for (short j = 0; j < ListaB.getLongitud(); j++)
{
xmlSetProp(NodoBaja, (const xmlChar *)("PALABRA"), (const xmlChar *)(ListaB.getABM(j).getPalabra().c_str() ) );
xmlSetProp(NodoBaja, (const xmlChar *)("FRECUENCIA"), (const xmlChar *)(ListaB.getABM(j).getFrecuenciaString().c_str() ) );
}
}
if (NodoLista.getLongitudListaModificaciones() > 0)
{
CListaDeABM ListaM = NodoLista.getListaDeABMModificaciones();
NodoModificaciones = xmlNewChild(NodoABM, NULL, (const xmlChar *)("MODIFICACIONES"), NULL);
NodoModificacion = xmlNewChild(NodoModificaciones, NULL, (const xmlChar *)("MODIFICACION"), NULL);
for (short j = 0; j < ListaM.getLongitud(); j++)
{
xmlSetProp(NodoModificacion, (const xmlChar *)("PALABRA"), (const xmlChar *)(ListaM.getABM(j).getPalabra().c_str() ) );
xmlSetProp(NodoModificacion, (const xmlChar *)("FRECUENCIA"), (const xmlChar *)(ListaM.getABM(j).getFrecuenciaString().c_str() ) );
}
}
}
//Fin tag <ABM>
}
//******************************************************
// Escribe el tag <PALABRA> en el XML
//******************************************************
void CXMLParserServidor::AgregarPalabra(xmlNodePtr Nodo, int i)
{
xmlNodeAddContent(Nodo, (const xmlChar *)(this->Comando->getListaDePalabras().getPalabra(i).c_str() ));
}
//******************************************************
// Agrego un los tags
//******************************************************
void CXMLParserServidor::AgregarNodos(xmlDocPtr Documento)
{
xmlNodePtr Raiz;
xmlNodePtr Nodo;
// La raiz del documento se la asigno a Raiz
Raiz = xmlDocGetRootElement(Documento);
if (this->Comando->getNombreArchivoBuscado().size() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("NOMBREARCHIVOBUSCADO"), NULL);
AgregarNombreArchivoBuscado(Nodo, this->Comando->getNombreArchivoBuscado());
}
if (this->Comando->getComando().size() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("COMANDO"), NULL);
AgregarComando(Nodo);
}
if (this->Comando->getApellido().size() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("APELLIDO"), NULL);
AgregarApellido(Nodo, this->Comando->getApellido());
}
if (this->Comando->getClave().size() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("CLAVE"), NULL);
AgregarClave(Nodo);
}
if (this->Comando->getIdUsuario() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("ID"), NULL);
AgregarId(Nodo, this->Comando->getIdUsuario());
}
if (this->Comando->getIdUsuarioBuscado() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("IDUSUARIOBUSCADO"), NULL);
AgregarIdUsuarioBuscado(Nodo, this->Comando->getIdUsuarioBuscado());
}
if (this->Comando->getNick().size() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("NICK"), NULL);
AgregarNick(Nodo, this->Comando->getNick());
}
if (this->Comando->getNombre().size() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("NOMBRE"), NULL);
AgregarNombre(Nodo, this->Comando->getNombre());
}
if (this->Comando->getPassword().size() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("PASSWORD"), NULL);
AgregarPassword(Nodo, this->Comando->getPassword());
}
if (this->Comando->getListaDeArchivos().getLongitud() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("LISTADEARCHIVOS"), NULL);
AgregarListaDeArchivos(Nodo);
}
if (this->Comando->getListaDePalabras().getLongitud() > 0)
{
Nodo = xmlNewChild(Raiz, NULL, (const xmlChar *)("LISTADEPALABRAS"), NULL);
AgregarListaDePalabras(Nodo);
}
}
//******************************************************
// Obtengo el string parseado o a parsear
//******************************************************
TString CXMLParserServidor::getStringParseo() const
{
return this->StringParseo;
}
//******************************************************
// Setea el string a parsear
//******************************************************
void CXMLParserServidor::setStringParseo(TString StringParseo)
{
this->StringParseo = StringParseo;
}
//******************************************************
// Destuctor de la clase CXMLPParser
//******************************************************
CXMLParserServidor::~CXMLParserServidor()
{
}
</code>
Salu2!!!!!!!!!!
