SoloCodigo

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!!!!!!!!!!

Hola!!!

Mira, la session es una interfaz verdadermante con la cual se puede interactuar. Podes setear objetos, obtenerlos y removerlos. Cada objeto de la session se identifica con una clave unica (ojo con eso). En si, la session se obtiene de HttpServletRequest haciendo:
HttpSession session = request.getSession();

Luego, para setear:
session.setAttribute("clave", tuObjeto);
Para obtener, UnaClase instancia = (UnaClase)session.getAttribute("clave");
Para eliminar: session.removeAttribute("clave");

El tiempo de vida de session se puede setear por codigo con:
session.setMaxTimeInterval() o algo asi, pero se recomienda q se haga desde web.xml (buscate en google cual es el tag porque no me lo acuerdo, pero creo q era <session> <session-timeout>... o algo asi).

Despues no hay mas magia q eso. Se puede seguir hablando mucho como por ejemplo Listeners de session (algo muy interesante): HttpSessionListener (bucsalo en google)

Bueno, con esto sobra


Salu2!!!!!!!!!!

Hola de nuevo!!!!

Si queres cargar solo numeros, yo no usaria una mascara. Haria algo muy parecido a lo puse antes. O sea, cada vez q se ingresa un caracter, checkearia si lo q tengo es un numero (usando Integer.parseInt() o lo mismo con la clase Float o Double y en caso de q entre en un NumberFormatException lo saco y si no sigo adelante) y asi poder controlar q solo se acepten numeros

Salu2!!!!!!!!

Hola!!!!!!!!

Se esta trabando porque vos le estas ordenando q se trabe. Si miras la documentacion veras esto:

waitFor()
          causes the current thread to wait, if necessary, until the process represented by this Process object has terminated

Entonces hasta q no termine lo q ejecutaste tu aplicacin no terminara...


Salu2!!!!!!!

Hola!!!!!!!

Probaste cargando en el array de Strings q te mande como ejemplo luego del nombre del .bat los tres parametros q necesitas????

Salu2!!!!!

Hola a todos!!!!!

Hay veces en las q el browser pide "reenviar la informacion, oprima reintentar o cancelar"  o un mensaje parecido a ese.
De que manera se podria evitar eso???

Estoy pidiendo esto porque estamos haciedo un desarrollo en el trabajo en JSP/STRUTS/EJB y el sector de Testing se esta quejando de eso, pero no sabemos como solucionarlo

Salu2!!!!!!!!!!!!

Hola!!!!!!!!!!!

Si queres informacion de la STL, ENTRA ACA

Salu2!!!!!!!!!

Hola!!!!!!!!!!!

Si lo que queres es que a partir de la seleccion de un combo, se cargue otro => lo q deberias hacer es q en el evento onChange() (Javascript ó si usas alguna tag library) llames a un servlet para q a partir de lo seleccionado cargues el otro.


Salu2!!!!!!!!!!!!!!

Hace una busqueda en el foro q yo puse un ejemplo de como hacerlo

Salu2!!!!!!!!!!!

Hola!!!!!!!!!

Proba con timers

Salu2!!!!!!

Hola!!!!!!!!!

Guardalos en memoria y cuando abras otra vez la ventana => mostras los ultimos q tenes en memoria

Salu2!!!!!

Hola!!!!!!!!

Te mando un ejemplo q hice para GNU/LINUX. Existe una rutina llamada MKDIR. Fijate de buscar si para WINDOWS es la misma.
Ahi va:

Espero q sirva

Salu2!!!!

Hola!!!!!1

De antemano te digo q al ResultSet lo podes meter en un Vector. Ahora, la pregunta es para q??? Si vos queres comparar, al metodo q hace la consulta le deberias pasar las opciones que ingreso el usuario y ahi validar si el tipo esta registrado o no.

Salu2!!!!!!