El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Manejo de XML

Siguiente ►
►

Introducción

En este módulo, aprenderemos cómo manejar XML (Extensible Markup Language) en RPG. XML es un formato de datos ampliamente utilizado para el intercambio de información entre sistemas. La capacidad de leer y escribir XML es esencial para integrar aplicaciones RPG con otros sistemas y servicios modernos.

Objetivos

  • Comprender la estructura básica de un documento XML.
  • Aprender a leer y escribir archivos XML en RPG.
  • Utilizar herramientas y bibliotecas disponibles para manejar XML en RPG.

Estructura Básica de un Documento XML

Un documento XML está compuesto por elementos, atributos y texto. Aquí hay un ejemplo simple de un documento XML:

<?xml version="1.0" encoding="UTF-8"?>
<inventario>
    <producto>
        <id>1</id>
        <nombre>Teclado</nombre>
        <precio>29.99</precio>
    </producto>
    <producto>
        <id>2</id>
        <nombre>Ratón</nombre>
        <precio>19.99</precio>
    </producto>
</inventario>

Componentes Clave

  • Elementos: Representados por etiquetas de apertura y cierre (<producto></producto>).
  • Atributos: Información adicional dentro de una etiqueta de apertura (<producto id="1">).
  • Texto: El contenido entre las etiquetas (Teclado, 29.99).

Lectura de XML en RPG

Para leer un archivo XML en RPG, utilizaremos la API XML-INTO, que convierte un documento XML en una estructura de datos RPG.

Ejemplo de Lectura de XML

Supongamos que tenemos el archivo inventario.xml con el contenido mostrado anteriormente. Queremos leer este archivo y almacenar los datos en una estructura de datos RPG.

Definición de Estructuras de Datos

Dcl-Ds Producto Qualified;
    id      Int(10);
    nombre  Varchar(50);
    precio  Packed(7:2);
End-Ds;

Dcl-Ds Inventario Qualified;
    producto LikeDs(Producto) Dim(100);
End-Ds;

Código para Leer el Archivo XML

Dcl-S xmlFile Varchar(100) Inz('/path/to/inventario.xml');
Dcl-S xmlData Varchar(10000);

Dcl-Pr QlgRtvF;
    fileName Varchar(100);
    fileData Varchar(10000);
End-Pr;

Dcl-Pi QlgRtvF;
    fileName Varchar(100);
    fileData Varchar(10000);
End-Pi;

Dcl-Proc QlgRtvF;
    Dcl-Pi *N;
        fileName Varchar(100);
        fileData Varchar(10000);
    End-Pi;

    // Código para leer el archivo y almacenar en fileData
    // ...

End-Proc;

QlgRtvF(xmlFile: xmlData);

Xml-Into Inventario %Xml(xmlData: 'doc=file case=any');

For i = 1 to %Elem(Inventario.producto);
    Dsply ('ID: ' + %Char(Inventario.producto(i).id));
    Dsply ('Nombre: ' + Inventario.producto(i).nombre);
    Dsply ('Precio: ' + %Char(Inventario.producto(i).precio));
EndFor;

Explicación del Código

  1. Definición de Estructuras de Datos: Definimos las estructuras Producto e Inventario para almacenar los datos del XML.
  2. Lectura del Archivo XML: Utilizamos una rutina (QlgRtvF) para leer el contenido del archivo XML en la variable xmlData.
  3. Conversión de XML a Estructura de Datos: Usamos la API XML-INTO para convertir el contenido XML en la estructura de datos Inventario.
  4. Visualización de Datos: Iteramos sobre los productos en el inventario y mostramos sus detalles.

Escritura de XML en RPG

Para escribir un archivo XML en RPG, utilizaremos la API XML-SAX para generar el contenido XML a partir de una estructura de datos RPG.

Ejemplo de Escritura de XML

Supongamos que queremos crear un archivo XML con la estructura de datos Inventario que definimos anteriormente.

Código para Escribir el Archivo XML

Dcl-S xmlFile Varchar(100) Inz('/path/to/nuevo_inventario.xml');
Dcl-S xmlData Varchar(10000);

Dcl-Pr QlgWrtF;
    fileName Varchar(100);
    fileData Varchar(10000);
End-Pr;

Dcl-Pi QlgWrtF;
    fileName Varchar(100);
    fileData Varchar(10000);
End-Pi;

Dcl-Proc QlgWrtF;
    Dcl-Pi *N;
        fileName Varchar(100);
        fileData Varchar(10000);
    End-Pi;

    // Código para escribir fileData en el archivo
    // ...

End-Proc;

xmlData = '<?xml version="1.0" encoding="UTF-8"?>' +
          '<inventario>';

For i = 1 to %Elem(Inventario.producto);
    xmlData += '<producto>' +
               '<id>' + %Char(Inventario.producto(i).id) + '</id>' +
               '<nombre>' + Inventario.producto(i).nombre + '</nombre>' +
               '<precio>' + %Char(Inventario.producto(i).precio) + '</precio>' +
               '</producto>';
EndFor;

xmlData += '</inventario>';

QlgWrtF(xmlFile: xmlData);

Explicación del Código

  1. Inicialización de Variables: Definimos las variables xmlFile y xmlData para el nombre del archivo y el contenido XML, respectivamente.
  2. Generación del Contenido XML: Construimos el contenido XML concatenando las etiquetas y los valores de la estructura de datos Inventario.
  3. Escritura del Archivo XML: Utilizamos una rutina (QlgWrtF) para escribir el contenido XML en el archivo especificado.

Ejercicio Práctico

Ejercicio

  1. Crea una estructura de datos para representar un catálogo de libros con los siguientes campos: id, título, autor y precio.
  2. Escribe un programa RPG que lea un archivo XML con la información del catálogo de libros y almacene los datos en la estructura de datos.
  3. Modifica el programa para agregar un nuevo libro al catálogo y escribe el contenido actualizado en un nuevo archivo XML.

Solución

Definición de Estructuras de Datos

Dcl-Ds Libro Qualified;
    id      Int(10);
    titulo  Varchar(100);
    autor   Varchar(50);
    precio  Packed(7:2);
End-Ds;

Dcl-Ds Catalogo Qualified;
    libro LikeDs(Libro) Dim(100);
End-Ds;

Código para Leer y Escribir el Archivo XML

Dcl-S xmlFile Varchar(100) Inz('/path/to/catalogo.xml');
Dcl-S xmlData Varchar(10000);

Dcl-Pr QlgRtvF;
    fileName Varchar(100);
    fileData Varchar(10000);
End-Pr;

Dcl-Pi QlgRtvF;
    fileName Varchar(100);
    fileData Varchar(10000);
End-Pi;

Dcl-Proc QlgRtvF;
    Dcl-Pi *N;
        fileName Varchar(100);
        fileData Varchar(10000);
    End-Pi;

    // Código para leer el archivo y almacenar en fileData
    // ...

End-Proc;

QlgRtvF(xmlFile: xmlData);

Xml-Into Catalogo %Xml(xmlData: 'doc=file case=any');

For i = 1 to %Elem(Catalogo.libro);
    Dsply ('ID: ' + %Char(Catalogo.libro(i).id));
    Dsply ('Título: ' + Catalogo.libro(i).titulo);
    Dsply ('Autor: ' + Catalogo.libro(i).autor);
    Dsply ('Precio: ' + %Char(Catalogo.libro(i).precio));
EndFor;

// Agregar un nuevo libro
Catalogo.libro(3).id = 3;
Catalogo.libro(3).titulo = 'Nuevo Libro';
Catalogo.libro(3).autor = 'Autor Desconocido';
Catalogo.libro(3).precio = 15.99;

xmlData = '<?xml version="1.0" encoding="UTF-8"?>' +
          '<catalogo>';

For i = 1 to %Elem(Catalogo.libro);
    xmlData += '<libro>' +
               '<id>' + %Char(Catalogo.libro(i).id) + '</id>' +
               '<titulo>' + Catalogo.libro(i).titulo + '</titulo>' +
               '<autor>' + Catalogo.libro(i).autor + '</autor>' +
               '<precio>' + %Char(Catalogo.libro(i).precio) + '</precio>' +
               '</libro>';
EndFor;

xmlData += '</catalogo>';

QlgWrtF('/path/to/nuevo_catalogo.xml': xmlData);

Conclusión

En este módulo, hemos aprendido a manejar archivos XML en RPG, incluyendo la lectura y escritura de datos XML. Estas habilidades son esenciales para integrar aplicaciones RPG con otros sistemas y servicios modernos. Asegúrate de practicar con diferentes estructuras de datos y archivos XML para fortalecer tu comprensión y habilidades.

En el próximo módulo, exploraremos cómo integrar RPG con otros lenguajes de programación, lo que te permitirá ampliar aún más las capacidades de tus aplicaciones RPG.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados