Templates - Plantillas String

Como nota inicial, una vez que una variable string es definida con una plantilla, sus campos pueden ser accesados por nombre:

1000 LET B$=A.NOMBRE$

Previamente habíamos dicho que la instrucción de arriba accesa el campo llamado “NOMBRE” en A$. Note que el signo “$” no es dado explícitamente después de “A”. El signo “$” al final del nombre de campo indica que nosotros queremos accesar este como un string. CUALQUIER CAMPO EN UNA PLANTILLA PUEDE SER ACCESADO COMO UN STRING AUN SI ESTE FUE DEFINIDO COMO NUMERICO. Por ejemplo:

1000 LET B$=A.TAMREG$

Esto simplemente transferiría los 2 bytes del campo llamado TAMREG$ a B$. Este también traspasaría cualquier atributo de swapping del byte. Adicionalmente, los campos numéricos también pueden accesarse como variables numéricas:

1000 LET X=A.TAMREG

ó

1000 LET X=A.TAMREG%

Estos dos ejemplos producen el mismo resultado. En el primer ejemplo Pro5 convertirá el campo TAMREG a numérico (usando una conversión similar a la función DEC()). En el segundo ejemplo, convertirá TAMREG a un entero Pro5.

Si un string es definido con una plantilla aún puede usarse como cualquier variable string:

PRINT A$(4,6)

Sin embargo, esto puede derrotar el propósito de la plantilla. Accesando al string mismo ignora la plantilla. Note el siguiente ejemplo:

1000 LET B$=A$

El contenido de A$ será copiado a B$ pero no la plantilla. B$ puede tener su propia plantilla o puede ser simplemente una variable string.

Los campos plantilla son mejores comparado a la forma de las especificaciones de substring y puede usarse en cualquier lugar donde un substring puede usarse. Si el campo es pasado a través de una instrucción CALL a un programa público, es tratado como un valor de llamada. Una simple variable string pasada a través de la instrucción ENTER también pasará su plantilla (si hay una).

La información acerca de la plantilla puede accesarse con la función FATTR(). Esta función tiene varias formas. La primera forma regresa una descripción de una plantilla string que puede usarse en una instrucción DIM:

1000 LET B$=FATTR(A$)

Este ejemplo copia la descripción de plantilla de A$, como dato, para B$. Ocurre un error si A$ no tiene una plantilla. Por ejemplo, si quiere definir B$ para que tenga los mismos campos que A$ usted seguiría esta vía:

1000 DIM B$:FATTR(A$)

Algunas veces es útil tener una simple lista de los nombres de campos de una plantilla. Esto sería hecho así:

1000 LET B$=FATTR(A$,””)

Note el segundo argumento nulo. Esto pondría en B$ una lista de nombres de campos desde A$, cada uno terminado con un avance de línea.

La información acerca de un campo específico puede ser determinada de la siguiente manera:

1000 LET B$=FATTR(A$,”TAMREG”)

Este ejemplo pondrá una descripción codificada en B$ que se describe a continuación. Vea Formato para atributos de campo en esta sección.

Finalmente, los atributos definidos por el usuario pueden accesarse:

1000 DIM A$:”TAMREG:I(2):access=5 mask=##,##0:”

1010 LET B$=FATTR(A$,”TAMREG”,”mask”)

Este ejemplo buscará la porción definida por el usuario de TAMREG para la palabra clave “mask” y retornará su valor. Se generará un error si tal atributo no fue dado.

Algunas veces es útil determinar al momento de la ejecución que campos serán accesados. Hasta ahora, un nombre de campo fue código fijo como parte de un nombre de variable. Sin embargo, los campos también pueden accesarse a través de dos funciones: FIELD() y NFIELD(). Ambas funciones toman una variable string (que contenga una plantilla), un nombre de campo ASCII, y un índice opcional (para campos del tipo arreglo):

1000 LET B$=FIELD(A$,”NOMBRE”)

1010 LET X=NFIELD(A$,”VENTAS”,4)

Estos dos ejemplos hacen lo mismo que:

1000 LET B$=A.NOMBRE$

1010 LET X=A.VENTAS[4]

La diferencia, de curso, es que la función FIELD() permite que el nombre del campo pueda determinarse en la ejecución – una herramienta útil para administradores de bases de datos y generadores de reportes. Un caso especial de la función FIELD() toma solamente una variable string:

1000 LET B$=FIELD(A$)

Esto causará que cualquier dato extra al fin de A$ sea descartado. Por ejemplo, si A$ se leyera de un archivo como en:

1000 READ RECORD (1)A$

A$ pudiera contener caracteres nulos extra usados para rellenar el registro. El uso de FIELD(A$) regresaría solamente esa porción de A$ contada por la plantilla. Esto es importante si A$ contuviera cualquier campo de largo variable. Estos campos quedarían grandes provocando que A$ convirtiera en grande. Un intento posterior de un WRITE RECORD A$ causaría que el archivo generará una condición de fin de registro a menos que los caracteres de relleno extraños fuesen removidos.

Mientras que la sintaxis de las plantillas en Pro5 se asemeja a la estructura y registros encontrados en muchos lenguajes compilados, el programador debe tener la precaución de no pensar en ellas como similares. Como Pro5 es extremadamente dinámico, así también lo son las plantillas. Un string puede ser asignado a una nueva plantilla o recibir nuevos datos en cualquier momento. Esto no se sabe sino hasta que se intenta accesar un campo, donde el campo esta o si igual existe. Por lo tanto, accesar un string a través de una plantilla puede no ser tan eficiente como usar código normal para referenciar un substring. Por ejemplo, si usamos un campo numérico en un ciclo FOR/NEXT no es tan eficiente ya que el campo debe ser ubicado y todos los accesos requieren una conversión de su forma string a una forma numérica interna. Sería mejor asignar el campo a una variable numérica y entonces usar esta variable.

Las características de plantillas están pensadas para usarse con diccionarios de datos y administradores de bases de datos donde el formato de los datos del usuario no siempre es conocido por adelantado. Como un ejemplo, considere un simple generador de reportes. El usuario ingresaría el nombre de un archivo desde el cual será producido el reporte. El programa accesaría un archivo de diccionario de datos para ubicar la plantilla deseada que describe el formato de registro del archivo ingresado. Un string se dimensiona con esta plantilla:

DIM A$:PLANTILLA$

El próximo paso sería presentar al usuario una lista de los campos que contiene el archivo. La lista de campos se puede obtener desde:

LET LISTA_CAMPOS$=FATTR(A$,””)

Una vez que los campos son seleccionados el programa los puede accesar usando las funciones FIELD() y NFIELD(). La “información de atributos” acerca de cada campo puede determinarse por:

LET TIPO_CAMPO$=FATTR(A$,NOMBRE_CAMPO$)

Una plantilla puede usarse para formatear una línea de salida en un reporte. Las plantillas también pueden usarse para accesar listas de campos y atributos. Por ejemplo, la lista de los nombres de campos retornados por FATTR() contienen varios nombres terminados con avance de línea. Esta lista sería fácil de accesar por medio de crear una plantilla para esto:

DIM LISTA_ARCHIVOS$:”NOMBRE[100]:C(32*)”

LET LISTA_ARCHIVOS$=FATTR(A$,””)

Las instrucciones de arriba definan una variable LISTA_ARCHIVOS$ con una plantilla que puede contener hasta 100 nombres y llenar esta con la lista de los nombres de campos desde A$. El tercer nombre en la lista se podría accesar por:

LET X$=LISTA_ARCHIVOS.NOMBRE$[3]

Si la lista contuviera sólo dos nombres, entonces se generaría un error. También, si la lista contuviera más de 100 nombres, sólo los primeros 100 nombres estarían accesibles. Los atributos para el tercer campo se podrían determinar por:

LET TIPO$=FATTR(A$,LISTA_ARCHIVO.NOMBRE$[3])