Foro - Perl en Español

¿Y qué módulo me recomiendas?

Te comento, esto genera una estructura de jerarquías que otro programa usa para leer e interpretar, es decir, chupa esta información y la representa gráficamente.

Bien, el problema es que no trata esta jerarquía de la manera que un xml la representaría.

XML abre con un nodo raíz, para la primera rama del árbol, abre un nodo, dentro de este otro, dentro de este otro, etc. etc... así hasta llegar al ultimo nodo (como el desplegable del árbol de directorios de un Windows o Linux).

Bien, este programa lo hace de manera lineal, no en modo de arboles.

Es decir, si quiero pintar una rama desde el tronco hasta la punta, primero abro con service, digo los elementos que tiene por debajo, cierro service. Abro service, selecciono el primer elemento de los que antes dije y represento qué elementos tiene por debajo, cierro service. Vuelvo abrir service, del anterior elemento y declaro que tiene por debajo, si no tiene nada, no declaro nada, cierro service. Vuelvo abrir service y me voy al "nivel" anterior y voy con el siguiente de ese nivel, etc. así hasta terminar todas las ramas.

Como veis es un sistema del diablo que menuda tela quien lo "parió" porque lo normal sería que usara el estándar de xml que es tremendamente más sencillo para eso y viene dado de una forma "nativa" al formato del fichero, pero no.

Cuál es el principal problema de esto: que elementos que pertenecen al mismo nivel de jerarquía, no están dentro del mismo nivel de tags, con lo que tengo que construir yo esa jerarquía a nivel de hashes para luego quizás exportarlo como dios manda en su formato xml.

La opción que más se me está acercando es no usar el XML::simple ya que no me sirve, para acceder a la información del xml si, pero para parsearlo en su manera correcta no, con lo que debería de ir escaneando con bucles cada rama, indicando que busque valores de un array que sería el nivel anterior, dentro del xml, con expresiones regulares.

¿Qué os parece? ¿Sudaré tinta china?

Si el resulto de todo es un xml en forma jerárquica, entonces es natural que debas construir ese árbol.

En este problema, lo curioso es la forma de obtener las hojas y ramas de ese árbol: que está por descripción de cada nodo.

Yo creo que no sería muy complicado leer los nodos e ir agregando las ramas y nodos como nuevos nodos, y así crear una estructura jerárquica.

Es un problema muy interesante para la asignatura de Estructuras de datos...

Ahora solo nos queda por saber qué aspecto quieres para el xml de salida.

Hola explorer.

Lo he conseguido responder, he estado foreando, consultando, leyendo...llevo 2 días de terror pero aquí está:



Ahora me asalta otra duda, ya he conseguido tenerlo todo (incluso hay gente que al verlo se ha quedado bastante aturdida de como con if (/<Service>/ .. /<\/Service>/) consigo sacar todo lo que esté entre esos dos tags), lo que me falla es que quiero asignar la variable $name a la primera clave del hash %index.

Había pensado algo al estilo de esto dentro de aquí:



¿Alguna idea sobre cómo hacer eso?

Días de terror, nada (has aprendido mucho), salvo que te hayan amenazado con cortarte las manos.

La forma de leer los nodos está bien, pero resulta que es otra forma distinta de tener la información que, ya antes, XML::Simple nos ha entregado. Has creado un parser sencillo porque la estructura es sencilla.

Lo interesante es saber qué aspecto debe tener lo que quieres conseguir.

Y sobre la pregunta: no tiene sentido hablar de "primera clave" de un hash: las claves no se guardan en los hash sin ningún orden especial.

La única forma que tienes de saber ese orden sería guardándolo en varias intermedias, como muestras, o en un array.

Ahora bien... si te refieres a la primera clave que te encuentras al leer el fichero, entonces sí deberías usar esas líneas (si estás seguro que el nodo Name no volverá a salir).

Creo que hay un error a la hora de guardar los nodos hijo, dentro del if() del ServiceRef. Yo creo que debería ser:


Y entonces, sale:

Código: Seleccionar todo

$VAR1 = {
          '69970093-C777-494C-BE61-E9CDBFF99582' => {
                                                      'hijos' => [
                                                                   'opc_adm (discovered)',
                                                                   'usuario1 (discovered)',
                                                                   'usuario2(discovered)',
                                                                   'usuario3 (discovered)',
                                                                   'usuario4 (discovered)',
                                                                   'usuario5 (discovered)'
                                                                 ],
                                                      'label' => 'Virtual top node (don\'t remove)'
                                                    },
          'opc_adm (discovered)' => {
                                      'hijos' => [
                                                   'SVCDISC:System',
                                                   'SVCDISC:Applications',
                                                   'HP OpenView Operations',
                                                   'SGC'
                                                 ],
                                      'label' => 'opc_adm'
                                    },
          'nombre' => 'opc_adm (discovered)'
        };

pero yo creo que no es lo que quieres... la clave 'nombre' ha sido sobreescrita varias veces a lo largo del proceso: cada vez que aparecía un nuevo Service.

Lo dicho, necesitamos saber el aspecto de lo que quieres conseguir. O dicho de otra manera, qué es lo que debe contener cada nodo y cómo referenciar a los demás nodos hijos (¿hash de array? ¿array de array de hash?)

Sí, todo sería más fácil si supiéramos la estructura que quieres obtener. Quizás es culpa de mi español pero no comprendí tu explicación anterior. Nos muestras un ejemplo de la estructura de datos que necesitas obtener del ejemplo de XML y veremos si lo podemos hacer.

Generalmente, no creo que sea sabio parsear XML con expresiones regulares. Si el archivo que tienes no es un XML correcto, creo que sería mejor, arreglarlo y después usar un módulo.

Si el único problema es que no hay un único raíz, lo más fácil es pedir al módulo a parsear

¡Hola!

Muchísimas gracias por la ayuda que me estáis prestando, voy a tener que invitaros a algo un día de estos

Bien, al turrón: esto es lo que quiero guardar según vaya leyendo el fichero "xml":

Código: Seleccionar todo

%index   {$ID.$contador}   {"label"} = $name
            {"nivel"} = nivel en el que esta
            {"Hijos"}   {$variable que me sume uno en cada iteracion} = "ID.$contador"
            {"Hijos"}   {$variable + 1} = "ID.$contador"
            {"Hijos"}   {$variable + 2} = "ID.$contador"
            {"Hijos"}   {$variable + nveces} = "ID.$contador"
            "hijos son los serviceref que detecta por entre <service> y </service> y que empiezan por <ServiceRef> ...</..."
            
%index   {$ID.$contador}   {"label"} = $name
                  {"nivel"} = Nivel del padre mas 1

Como veis esto es la estructura de los hashes que he ideado, en cada línea porción de código entre <service> y </service> se declara primero el padre, y luego en cada ServiceRef los nombres de los hijos. Para simplificarlo, he hecho que en cada porción obtenga toda la info del padre y a su vez en cada servicef, obtenga el nombre del hijo y el nivel que tiene asignado (que es el nivel del padre + 1).
Esto me dará un hash donde tendré mi identificador interno (ID.$contador) y éste tiene anidados todos los datos de todos los hijos, con sus niveles y los label (que es el nombre original del servicio).

Esto luego lo escupiré en un XML como dios manda, jerarquizado, seguramente por los niveles, o reestructurare la información para que según los padres y el nivel en el que esté, se me quede guardado así en el hash.

Aparte de esto... ¡¡¡Os deseo feliz Navidad a todos!!!

Una idea, a ver si te sirve, al menos, de inspiración:
Supongamos que tenemos el fichero
que, como puedes ver, sigue tu descripción de tu fichero: los nodos están dentro de <Service>, y se relacionan entre sí por el el <ServiceRef> y el <Name>. En el ejemplo, he puesto cuatro niveles de profundidad.

Entonces, con el programa siguiente:sale

Código: Seleccionar todo

$VAR1 = {
          'label' => '69970093-C777-494C-BE61-E9CDBFF99582',
          'id' => 'ID0001',
          'hijo' => [
                      {
                        'label' => 'opc_adm (discovered)',
                        'id' => 'ID0002',
                        'hijo' => [
                                    {
                                      'label' => 'SVCDISC:System',
                                      'id' => 'ID0003',
                                      'hijo' => [
                                                  {
                                                    'label' => 'SVCDISC1:System',
                                                    'id' => 'ID0004',
                                                    'hijo' => [],
                                                    'nivel' => 4
                                                  },
                                                  {
                                                    'label' => 'SVCDISC1:Applications',
                                                    'id' => 'ID0005',
                                                    'hijo' => [],
                                                    'nivel' => 4
                                                  },
                                                  {
                                                    'label' => 'HP OpenView Operations1',
                                                    'id' => 'ID0006',
                                                    'hijo' => [],
                                                    'nivel' => 4
                                                  },
                                                  {
                                                    'label' => 'SGC1',
                                                    'id' => 'ID0007',
                                                    'hijo' => [],
                                                    'nivel' => 4
                                                  }
                                                ],
                                      'nivel' => 3
                                    },
                                    {
                                      'label' => 'SVCDISC:Applications',
                                      'id' => 'ID0008',
                                      'hijo' => [],
                                      'nivel' => 3
                                    },
                                    {
                                      'label' => 'HP OpenView Operations',
                                      'id' => 'ID0009',
                                      'hijo' => [],
                                      'nivel' => 3
                                    },
                                    {
                                      'label' => 'SGC',
                                      'id' => 'ID0010',
                                      'hijo' => [],
                                      'nivel' => 3
                                    }
                                  ],
                        'nivel' => 2
                      },
                      {
                        'label' => 'usuario1 (discovered)',
                        'id' => 'ID0011',
                        'hijo' => [],
                        'nivel' => 2
                      },
                      {
                        'label' => 'usuario2(discovered)',
                        'id' => 'ID0012',
                        'hijo' => [],
                        'nivel' => 2
                      },
                      {
                        'label' => 'usuario3 (discovered)',
                        'id' => 'ID0013',
                        'hijo' => [],
                        'nivel' => 2
                      },
                      {
                        'label' => 'usuario4 (discovered)',
                        'id' => 'ID0014',
                        'hijo' => [],
                        'nivel' => 2
                      },
                      {
                        'label' => 'usuario5 (discovered)',
                        'id' => 'ID0015',
                        'hijo' => [],
                        'nivel' => 2
                      }
                    ],
          'nivel' => 1
        };

que como ves, mantiene la jerarquía entre nodos y lleva la cuenta de los ID y el nivel de profundidad.

Si ahora quisiéramos sacarlo en formato XML, podríamos añadir una línea más:
con lo que sale:
que... bueno... no es muy bonito... pero al menos tiene una estructura jerárquica.

Seguro que Jenda (y otros) pueden hacerlo mejor

Bueno, después de una merecidas vacaciones vuelvo a la carga.
Edito este comentario, porque ni me había acordado que había segunda página.

Me voy a poner a echarle un vistazo, explorer, a tu código y te voy contando... en principio estaría genial que así fuera, pero estoy probando con un XML y me devuelve este error:

$VAR1 = {}; $VAR1 = { 'label' => undef, 'id' => 'ID0001', 'hijo' => [], 'nivel' => 1 };

Más bien no es un error, sino que solo lo hace la primera línea.

Aunque así sea voy a chequearlo a ver si se me ha quedado metido algún cacho turrón entre algún hash

Gracias y un saludo y feliz años, reyes, navidad... etc.

Editado:

Vale, después de muchos quebraderos y pruebas he llegado a la siguiente conclusión: este script que os pego es como creo que es la forma más sencilla y clara de sacar la info:



Lo único para lo que solicito vuestra iluminación es para la línea última: $index{"ID$contador"}{"hijos"}[hijo] = $serviceref;

Aquí como veis lo que hago es que cada vez que encuentre lo que sea entre <service> y <\service>, lo mete en un array, dentro de un hash de un hash. Bien, es la primera vez que hago esto... y creo que no estoy metiendo bien el valor de $serviceref en el array [hijo] del hash %index{"ID$contador"}{"hijos"}.

Espero vuestra ayuda, a ver si encuentro yo algo de cómo hacerlo, pero no me queda muy claro...

¡Saludos!

[hijo] es un error. Bueno, no, pero sí. No es un error porque Perl "hasta podría admitirlo", pero SEGURO que no es lo que quieres hacer.

Es decir: ¿qué sentido tiene meter una constante entre corchetes?

Los corchetes significa un array por algún lado. Y si lo que queremos es ir guardando un hijo cada vez, yo supongo que querrás poner algo como [$hijo++]. Vamos, una variable nos va colocando cada hijo en una posición dentro del array.

Nada... no tiene ningún sentido en absoluto
Por eso al final lo he hecho de la forma normal -->

Esto me mete el valor perfectamente en el array.
También aprovecho para preguntar si hay alguna forma al estilo de Data:::dumper para poder sacar la info por la salida estándar, hasta ahora lo hacía con bucles foreach() para cada nivel del hash, pero eso es un coñazo.

Tampoco he investigado mucho pero por si las moscas...
De paso, pego aquí el código de cómo lo he hecho finalmente. La verdad que creo que me ha quedado super sencillo y muy condensado.
Darme vuestras impresiones al respecto

¡¡Saludos!!