Accesor de nodo raiz para xml::Document

[Eduardo Ramos Testillano]

Hola,

Actualmente, con una instancia 'xml::Document' correspondiente a un cierto fichero xml parseado, no podemos acceder al contenido del mismo a no ser que conservemos el puntero al nodo raiz. En general tenemos acceso al nodo raiz porque al analizar el xml estamos en el mismo ámbito de código que donde se hace el parseo previo. Esta es quizá la forma más común de uso.

Al no tener un método 'xml::Document::getRootNode()' o similar, si queremos acceder al documento xml en cualquier sitio sin re-parsear, tenemos que mantener:

   xml::DocumentFile a_miXml;
   const xml::Node* a_raizXml; // obtenido cuando se hizo el parseo


El método 'getRootNode' podría devolver un NULL en caso de no haberse parseado nada o el puntero a la raiz de un documento xml parseado.
Sería una puerta de acceso a la versatilidad de 'xml::Node', extendiendo la accesibilidad del 'xml::Document' que ya podría usarse como un contenedor autónomo de los datos xml que representa y no sólo como una herramienta auxiliar para sacar datos tras el parseo y volcarlos en algún otro lugar.


Un saludo

--

[Cisco]

Hola.

El xml::Document no sabe nada sobre su nodo raíz, como tu dices es un
mero contenedor y creo que es lo que debe seguir siendo, ya sabes el
lema "Haz sólo una cosa, pero hazla bien". El que sabe algo de esto es
el xml::Parser.

El método xml::Document::parse se añadió no hace mucho para facilitar
el análisis de los documentos XML. Para que el programador no tuviera
que instanciar manualmente el xml::Parse, no obstante, en la
implementación del método se tiene que hacer.

El caso es que si hay alguien que sepa algo del root será el
xml::Parser que se utiliza en el método xml::Document::parse. El
problema de añadir el método xml::Document::getRootNode es que sólo
tendría sentido invocarlo después de haber invocado a
xml::Document::parse; y se podría indicar en el documentación y tal y
tal, pero todos sabemos que el caso que se le hace a ésta.

En resumen que creo que no es buena idea añadir el nuevo método que
solicitas.

Un saludo.

>  image_jpeg_part
> 8KViewDownload

[Eduardo Ramos Testillano]

Hola,

Logicamente, al usar el xml::Parser, no hay nada que hacer. Pero entiendo que si lo haces dentro del metodo 'xml::Document::parse', esta claro que podrias almacenar el root node. Dicho root node seria NULL en el constructor del Document, y si el getRootNode() devolviera NULL, sería suficiente para saber que aún no ha sido parseado dicho documento. Es una pena tener que "arrastrar" el root node con el Document, para poder analizar este.

un saludo

--

[Cisco]

No es un problema de implementación, yo lo veo como un problema de
usabilidad.

Creo que lo más adecuado es analizar el documento XML una sola vez,
obtener el nodo root sobre un xml::Node y desde
ese momento el xml::Document no se vuelve a tratar (aunque tiene que
estar en el ámbito para que el xml::Node siga siendo
válido), y si necesitas acceder al contenido el documento XML lo más
óptimo es usar el xml::Node obtenido en el análisis inicial.

Analizar el documento cada vez que tienes que acceder al root, es un
fallo de diseño grave ya que como podrás imaginar el análisis
no es nada trivial.

Un saludo.

On Aug 11, 11:06 am, Eduardo Ramos Testillano <era...@tid.es> wrote:
> Hola,
> Logicamente, al usar el xml::Parser, no hay nada que hacer. Pero entiendo que si lo haces dentro del metodo 'xml::Document::parse', esta claro que podrias almacenar el root node. Dicho root node seria NULL en el constructor del Document, y si el getRootNode() devolviera NULL, sería suficiente para saber que aún no ha sido parseado dicho documento. Es una pena tener que "arrastrar" el root node con el Document, para poder analizar este.
> un saludo
> El 11/08/2010 10:42, Cisco escribió:Hola. El xml::Document no sabe nada sobre su nodo raíz, como tu dices es un mero contenedor y creo que es lo que debe seguir siendo, ya sabes el lema "Haz sólo una cosa, pero hazla bien". El que sabe algo de esto es el xml::Parser. El método xml::Document::parse se añadió no hace mucho para facilitar el análisis de los documentos XML. Para que el programador no tuviera que instanciar manualmente el xml::Parse, no obstante, en la implementación del método se tiene que hacer. El caso es que si hay alguien que sepa algo del root será el xml::Parser que se utiliza en el método xml::Document::parse. El problema de añadir el método xml::Document::getRootNode es que sólo tendría sentido invocarlo después de haber invocado a xml::Document::parse; y se podría indicar en el documentación y tal y tal, pero todos sabemos que el caso que se le hace a ésta. En resumen que creo que no es buena idea añadir el nuevo método que solicitas. Un saludo. On Aug 9, 9:40 am, Eduardo Ramos Testillano<era...@tid.es>wrote:Hola, Actualmente, con una instancia 'xml::Document' correspondiente a un cierto fichero xml parseado, no podemos acceder al contenido del mismo a no ser que conservemos el puntero al nodo raiz. En general tenemos acceso al nodo raiz porque al analizar el xml estamos en el mismo ámbito de código que donde se hace el parseo previo. Esta es quizá la forma más común de uso. Al no tener un método 'xml::Document::getRootNode()' o similar, si queremos acceder al documento xml en cualquier sitio sin re-parsear, tenemos que mantener:    xml::DocumentFile a_miXml;    const xml::Node* a_raizXml; // obtenido cuando se hizo el parseo El método 'getRootNode' podría devolver un NULL en caso de no haberse parseado nada o el puntero a la raiz de un documento xml parseado. Sería una puerta de acceso a la versatilidad de 'xml::Node', extendiendo la accesibilidad del 'xml::Document' que ya podría usarse como un contenedor autónomo de los datos xml que representa y no sólo como una herramienta auxiliar para sacar datos tras el parseo y volcarlos en algún otro lugar. Un saludo--  image_jpeg_part 8KViewDownload--
>
>
>

>  firma.jpg
> 8KViewDownload

[Eduardo Ramos Testillano]

Hola, estos serían los pocos cambios necesarios para meter la funcionalidad que te comento. No se si te la he transmitido convenientemente, pero creo que con el código fuente está claro lo que quiero decir:


La clase nemesis::xml::Document tendría un nuevo atributo:

private:
   const nemesis::xml::Node * a_rootNode;

Y un accesor publico:

   const nemesis::xml::Node * getRootNode () const throw () { return a_rootNode; }

El constructor pondría dicha variable a NULL (valor previo a cualquier analisis):

Document::Document () :
   nemesis::DataBlock (true),
   a_handle (NULL),
   a_encoding (NULL),
   a_version (NULL),
   a_contentIsCString (false),
   a_asCString (NULL),
   a_parser (NULL),
   a_rootNode (NULL)
{;}

Y simplemente tendrias que modificar los metodos 'parse' de esta manera:

const xml::Node* Document::parse ()
   throw (RuntimeException)
{
   if (a_parser == NULL)
      a_parser = new Parser;
  
   return (a_rootNode = a_parser->apply (*this));
}

const xml::Node* Document::parse (const xml::DTD& dtd)
   throw (RuntimeException)
{
   if (a_parser == NULL)
      a_parser = new Parser;
  
   return (a_rootNode = a_parser->apply (*this, dtd));
}


He hecho una clase en la suite NexusPL (nexus::xml::DocumentFile) que proporciona esta funcionalidad mediante herencia de la homóloga de nemesisRD, pero preferiría "cargarme" mi official.ss/libNexus.xml.b/hdrs/nexus.xml.DocumentFile.h y usar directamente tu nemesis.


Un saludo

--
Has recibido este mensaje porque estás suscrito al grupo "NemesisRD 1.x" de Grupos de Google.
Para publicar una entrada en este grupo, envía un correo electrónico a nemesi...@googlegroups.com.
Para anular tu suscripción a este grupo, envía un correo electrónico a nemesisrd-1x...@googlegroups.com
Para tener acceso a más opciones, visita el grupo en http://groups.google.com/group/nemesisrd-1x?hl=es.

--

[Cisco]

Hola.

Supongo que podrás comprender que no es un problema de no saber cómo
implementar lo que proponías, es un problema
de dejar claras las atribuciones de cada clase y para mi las
nemesis::xml::Document son meros contenedores; si tu quieres
verlo de otra forma creo que lo más sencillo es hacer lo que has
hecho, heredar y ajustar el comportamiento para que se adapte
a tus gustos/necesidades ya que la simplicidad y potencia del modelo
que ofrezco no sólo lo permite sino que lo favorece.

Un saludo.

On Sep 15, 5:27 pm, Eduardo Ramos Testillano <era...@tid.es> wrote:
> Hola, estos serían los pocos cambios necesarios para meter la funcionalidad que te comento. No se si te la he transmitido convenientemente, pero creo que con el código fuente está claro lo que quiero decir:La clase nemesis::xml::Document tendría un nuevo atributo:private:
>    const nemesis::xml::Node * a_rootNode;
> Y un accesor publico:
>   const nemesis::xml::Node * getRootNode () const throw () { return a_rootNode; }
> El constructor pondría dicha variable a NULL (valor previo a cualquier analisis):
> Document::Document () :
>    nemesis::DataBlock (true),
>    a_handle (NULL),
>    a_encoding (NULL),
>    a_version (NULL),
>    a_contentIsCString (false),
>    a_asCString (NULL),
>    a_parser (NULL),
>    a_rootNode (NULL)
> {;}
> Y simplemente tendrias que modificar los metodos 'parse' de esta manera:
> const xml::Node* Document::parse ()
>    throw (RuntimeException)
> {
>    if (a_parser == NULL)
>       a_parser = new Parser;
>   

>    return(a_rootNode =a_parser->apply (*this));

> }
> const xml::Node* Document::parse (const xml::DTD& dtd)
>    throw (RuntimeException)
> {
>    if (a_parser == NULL)
>       a_parser = new Parser;
>   

>    return(a_rootNode =a_parser->apply (*this, dtd));

> }
> He hecho una clase en la suite NexusPL (nexus::xml::DocumentFile) que proporciona esta funcionalidad mediante herencia de la homóloga de nemesisRD, pero preferiría "cargarme" mi official.ss/libNexus.xml.b/hdrs/nexus.xml.DocumentFile.h y usar directamente tu nemesis.
> Un saludo
> El 11/08/2010 11:06, Eduardo Ramos Testillano escribió:Hola,
> Logicamente, al usar el xml::Parser, no hay nada que hacer. Pero entiendo que si lo haces dentro del metodo 'xml::Document::parse', esta claro que podrias almacenar el root node. Dicho root node seria NULL en el constructor del Document, y si el getRootNode() devolviera NULL, sería suficiente para saber que aún no ha sido parseado dicho documento. Es una pena tener que "arrastrar" el root node con el Document, para poder analizar este.
> un saludo
> El 11/08/2010 10:42, Cisco escribió:Hola. El xml::Document no sabe nada sobre su nodo raíz, como tu dices es un mero contenedor y creo que es lo que debe seguir siendo, ya sabes el lema "Haz sólo una cosa, pero hazla bien". El que sabe algo de esto es el xml::Parser. El método xml::Document::parse se añadió no hace mucho para facilitar el análisis de los documentos XML. Para que el programador no tuviera que instanciar manualmente el xml::Parse, no obstante, en la implementación del método se tiene que hacer. El caso es que si hay alguien que sepa algo del root será el xml::Parser que se utiliza en el método xml::Document::parse. El problema de añadir el método xml::Document::getRootNode es que sólo tendría sentido invocarlo después de haber invocado a xml::Document::parse; y se podría indicar en el documentación y tal y tal, pero todos sabemos que el caso que se le hace a ésta. En resumen que creo que no es buena idea añadir el nuevo método que solicitas. Un saludo. On Aug 9, 9:40 am, Eduardo Ramos Testillano<era...@tid.es>wrote:Hola, Actualmente, con una instancia 'xml::Document' correspondiente a un cierto fichero xml parseado, no podemos acceder al contenido del mismo a no ser que conservemos el puntero al nodo raiz. En general tenemos acceso al nodo raiz porque al analizar el xml estamos en el mismo ámbito de código que donde se hace el parseo previo. Esta es quizá la forma más común de uso. Al no tener un método 'xml::Document::getRootNode()' o similar, si queremos acceder al documento xml en cualquier sitio sin re-parsear, tenemos que mantener:    xml::DocumentFile a_miXml;    const xml::Node* a_raizXml; // obtenido cuando se hizo el parseo El método 'getRootNode' podría devolver un NULL en caso de no haberse parseado nada o el puntero a la raiz de un documento xml parseado. Sería una puerta de acceso a la versatilidad de 'xml::Node', extendiendo la accesibilidad del 'xml::Document' que ya podría usarse como un contenedor autónomo de los datos xml que representa y no sólo como una herramienta auxiliar para sacar datos tras el parseo y volcarlos en algún otro lugar. Un saludo--  image_jpeg_part 8KViewDownload--
>

> --
> Has recibido este mensaje porque estás suscrito al grupo "NemesisRD 1.x" de Grupos de Google.

> Para publicar una entrada en este grupo, envía un correo electrónico anemes...@googlegroups.com.
> Para anular tu suscripción a este grupo, envía un correo electrónico anemesisrd-1...@googlegroups.com

> Para tener acceso a más opciones, visita el grupo enhttp://groups.google.com/group/nemesisrd-1x?hl=es.--
>
>
>

>  image_jpeg_part
> 8KViewDownload
>
>  firma.jpg
> 8KViewDownload

[Eduardo Ramos Testillano]

En primer lugar, obviamente no dudo que seas capaz de implementar algo determinado. Simplemente intentaba dejar clara mi propuesta aunque ya veo por lo que dices, que me explique perfectamente en anteriores emails.

Por otra parte, siempre he entendido que una clase contenedor debe permitir acceder con autonomia a aquello que contiene. Tu implementacion no lo facilita porque aunque ya haya sido analizada, la unica manera para acceder al nodo raiz y desde ahí a todo lo demás, es volver a analizarla, lo cual penaliza el procesamiento. Eso, o arrastrar junto a ella dicho nodo raiz, dando lugar a un codigo farragoso.

En cualquier caso, no tengo ningun problema en usar mi recubrimiento, simplemente opino que era mejor bajarlo a nemesis, porque a veces el uso de tu clase no se limita al caso más usual de analisis inicial/unico, sino que puede usarse, precisamente, como un contenedor.

Un saludo

--

[Cisco]

El método nemesis::xml::Document::parse tienes un análisis directo y
simple; si necesitas algo más complejo tu mismo has demostrado
que se puede conseguir combinando elementos simples y bien definidos.

Pero tu solución a un problema concreto de tu aplicación no tiene
porqué ser una imposición al resto de los que sólo requerimos una
funcionamiento más simple y óptimo.

Un saludo.

> El 16/09/2010 7:24, Cisco escribió:Hola. Supongo que podrás comprender que no es un problema de no saber cómo implementar lo que proponías, es un problema de dejar claras las atribuciones de cada clase y para mi las nemesis::xml::Document son meros contenedores; si tu quieres verlo de otra forma creo que lo más sencillo es hacer lo que has hecho, heredar y ajustar el comportamiento para que se adapte a tus gustos/necesidades ya que la simplicidad y potencia del modelo que ofrezco no sólo lo permite sino que lo favorece. Un saludo. On Sep 15, 5:27 pm, Eduardo Ramos Testillano<era...@tid.es>wrote:Hola, estos serían los pocos cambios necesarios para meter la funcionalidad que te comento. No se si te la he transmitido convenientemente, pero creo que con el código fuente está claro lo que quiero decir:La clase nemesis::xml::Document tendría un nuevo atributo:private:    const nemesis::xml::Node * a_rootNode; Y un accesor publico:   const nemesis::xml::Node * getRootNode () const throw () { return a_rootNode; } El constructor pondría dicha variable a NULL (valor previo a cualquier analisis): Document::Document () :    nemesis::DataBlock (true),    a_handle (NULL),    a_encoding (NULL),    a_version (NULL),    a_contentIsCString (false),    a_asCString (NULL),    a_parser (NULL),    a_rootNode (NULL) {;} Y simplemente tendrias que modificar los metodos 'parse' de esta manera: const xml::Node* Document::parse ()    throw (RuntimeException) {    if (a_parser == NULL)       a_parser = new Parser;       return(a_rootNode =a_parser->apply (*this)); } const xml::Node* Document::parse (const xml::DTD& dtd)    throw (RuntimeException) {    if (a_parser == NULL)       a_parser = new Parser;       return(a_rootNode =a_parser->apply (*this, dtd)); } He hecho una clase en la suite NexusPL (nexus::xml::DocumentFile) que proporciona esta funcionalidad mediante herencia de la homóloga de nemesisRD, pero preferiría "cargarme" mi official.ss/libNexus.xml.b/hdrs/nexus.xml.DocumentFile.h y usar directamente tu nemesis. Un saludo El 11/08/2010 11:06, Eduardo Ramos Testillano escribió:Hola, Logicamente, al usar el xml::Parser, no hay nada que hacer. Pero entiendo que si lo haces dentro del metodo 'xml::Document::parse', esta claro que podrias almacenar el root node. Dicho root node seria NULL en el constructor del Document, y si el getRootNode() devolviera NULL, sería suficiente para saber que aún no ha sido parseado dicho documento. Es una pena tener que "arrastrar" el root node con el Document, para poder analizar este. un saludo El 11/08/2010 10:42, Cisco escribió:Hola. El xml::Document no sabe nada sobre su nodo raíz, como tu dices es un mero contenedor y creo que es lo que debe seguir siendo, ya sabes el lema "Haz sólo una cosa, pero hazla bien". El que sabe algo de esto es el xml::Parser. El método xml::Document::parse se añadió no hace mucho para facilitar el análisis de los documentos XML. Para que el programador no tuviera que instanciar manualmente el xml::Parse, no obstante, en la implementación del método se tiene que hacer. El caso es que si hay alguien que sepa algo del root será el xml::Parser que se utiliza en el método xml::Document::parse. El problema de añadir el método xml::Document::getRootNode es que sólo tendría sentido invocarlo después de haber invocado a xml::Document::parse; y se podría indicar en el documentación y tal y tal, pero todos sabemos que el caso que se le hace a ésta. En resumen que creo que no es buena idea añadir el nuevo método que solicitas. Un saludo. On Aug 9, 9:40 am, Eduardo Ramos Testillano<era...@tid.es>wrote:Hola, Actualmente, con una instancia 'xml::Document' correspondiente a un cierto fichero xml parseado, no podemos acceder al contenido del mismo a no ser que conservemos el puntero al nodo raiz. En general tenemos acceso al nodo raiz porque al analizar el xml estamos en el mismo ámbito de código que donde se hace el parseo previo. Esta es quizá la forma más común de uso. Al no tener un método 'xml::Document::getRootNode()' o similar, si queremos acceder al documento xml en cualquier sitio sin re-parsear, tenemos que mantener:    xml::DocumentFile a_miXml;    const xml::Node* a_raizXml; // obtenido cuando se hizo el parseo El método ' getRootNode' podría devolver un NULL en caso de no haberse parseado nada o el puntero a la raiz de un documento xml parseado. Sería una puerta de acceso a la versatilidad de 'xml::Node', extendiendo la accesibilidad del 'xml::Document' que ya podría usarse como un contenedor autónomo de los datos xml que representa y no sólo como una herramienta auxiliar para sacar datos tras el parseo y volcarlos en algún otro lugar. Un saludo--  image_jpeg_part 8KViewDownload-- -- Has recibido este mensaje porque estás suscrito al grupo "NemesisRD 1.x" de Grupos de Google. Para publicar una entrada en este grupo, envía un correo electrónicoanem...@googlegroups.com. Para anular tu suscripción a este grupo, envía un correo electrónicoanemesisrd...@googlegroups.comPara tener acceso a más opciones, visita el grupo enhttp://groups.google.com/group/nemesisrd-1x?hl=es.--  image_jpeg_part 8KViewDownload  firma.jpg 8KViewDownload--
>
>
>
>  firma.jpg
> 8KViewDownload