Typedef

Una definición de tipo (typedef) es un componente que se utiliza como modelo de formato. Utilice el mecanismo typedef en los siguientes casos:

A menudo, las typedef identifican una agrupación abstracta. Por ejemplo, puede declarar un componente de registro llamado address y dividir dicha información en streetAddress1, streetAddress2 y city. Si un registro de personal incluye los elementos de estructura workAddress y homeAddress, cada uno de estos elementos de estructura puede señalar al formato del componente de registro llamado address. Esta utilización de typedef asegura que los formatos de dirección sean iguales.

Dentro del conjunto de normas descritas en esta página, puede señalar al formato de un componente al declarar otro componente o al declarar una variable.

Cuando declare un componente, no es necesario que utilice un componente como una typedef, pero quizás desee hacerlo, como en los ejemplos que se muestran más adelante. Tampoco es necesario que utilice una typedef cuando declare una variable que tiene las características de un elemento de datos; en su lugar, puede especificar todas las características de la variable, sin hacer referencia a un componente.

Una typedef siempre está en vigor cuando se declara una variable que es más compleja que un elemento de datos. Por ejemplo, si declara una variable llamada myRecord y señala al formato de un componente llamado myRecordPart, EGL crea un modelo de la variable declarada en dicho componente. Si, en cambio, señala al formato de un componente llamado myRecordPart02, la variable se llama myRecord pero tiene todas las características del componente llamado myRecordPart02.

La tabla y las secciones siguientes proporcionan detalles sobre las typedef en diferentes contextos.

Entrada que señala a una typedef Tipo de componente al que la typedef puede hacer referencia
parámetro de función u otra variable de función un componente de registro o componente dataItem
parámetro de programa componente dataItem, componente form, componente record
variable de programa (no parámetro) componente dataItem, componente record
elemento de estructura componente dataItem, componente record

Componente dataItem como una typedef

Puede utilizar un componente de elemento de datos (dataItem) como una typedef en las siguientes situaciones:
  • Al declarar una variable o parámetro
  • Al declarar un elemento de estructura, que es una subunidad de un componente de registro, componente de formulario o componente dataTable
Se aplican las siguientes normas:
  • Si un elemento de estructura es el padre de otros elementos de estructura que están listados en la misma declaración, el elemento de estructura sólo puede señalar al formato de un componente dataItem, como en el siguiente ejemplo:
      DataItem myPart CHAR(20) end
    
      Record myRecordPart type basicRecord
        10 mySI myPart; // myPart actúa como una typedef
          20 a CHAR(10);
          20 b CHAR(10);
      end
    El componente de registro anterior es equivalente a la siguiente declaración:
      Record myRecordPart type basicRecord
        10 mySI CHAR(20);
          20 a CHAR(10);
          20 b CHAR(10);
      end
  • No se puede utilizar un componente de dataItem como una typedef y además especificar la longitud o tipo primitivo de la entidad que señala a la typedef, como en el siguiente ejemplo:
      DataItem myPart HEX(20) end
    
      // NO válido porque mySI tiene un tipo primitivo
      // y señala al formato de un componente (a myPart, en este caso)
      Record myRecordPart type basicRecord
        10 mySI CHAR(20) myPart;
      end
  • Una declaración de variable que no hace referencia a un componente de registro señala al formato de un componente de dataItem o bien tiene características primitivas. (Un parámetro de programa también puede hacer referencia a un componente de formulario). Sin embargo, un componente dataItem no puede señalar al formato de otro componente dataItem ni a ningún otro componente.
  • Un componente de registro SQL sólo puede utilizar los siguientes tipos de componentes como typedef:
    • Otro componente de registro SQL
    • Un componente dataItem

Componente de registro como una typedef

Puede utilizar un componente de registro como una typedef en las siguientes situaciones:
  • Al declarar un elemento de estructura
  • Al declarar una variable (incluido un parámetro), en cuyo caso la variable refleja la typedef de las siguientes maneras:
    • Formato
    • Tipo de registro (por ejemplo, indexedRecord o serialRecord)
    • Valores de propiedad (por ejemplo, el valor de la propiedad file)

Cuando declare un elemento de estructura que señala al formato de otro componente, especifique si la typedef añade un nivel de jerarquía, como se ilustra más adelante.

Se aplican las siguientes normas:
  • Un componente de registro puede ser una typedef cuando se utiliza un elemento de estructura para facilitar la reutilización:
      Record address type basicRecord
        10 streetAddress1 CHAR(30);
        10 streetAddress2 CHAR(30);
        10 city CHAR(20);
      end
    
      Record record1 type serialRecord
      {
        fileName = "myFile"
      }
        10 person CHAR(30);
        10 homeAddress address;
      end

    El segundo componente de registro es equivalente a la siguiente declaración:

      Record record1 type serialRecord
        { fileName = "myFile" }
        10 person CHAR(30);
        10 homeAddress;
          20 streetAddress1 CHAR(30);
          20 streetAddress2 CHAR(30);
          20 city CHAR(20);
      end

    Si un elemento de estructura utiliza la sintaxis anterior para señalar al formato de un componente de estructura, EGL añade un nivel jerárquico al componente de estructura que incluye el elemento de estructura. Por este motivo, la estructura interna del ejemplo anterior tiene una jerarquía de elementos de estructura, donde person está en un nivel distinto de streetAddress1.

  • En algunos casos, es preferible una organización plana de la estructura; y un registro SQL que está en un objeto de E/S para el acceso a la base de datos relacional debe tener una organización de este tipo.
    • En el ejemplo anterior, si sustituye la palabra embed para el nombre de elemento de estructura de un componente de registro (en este caso, homeAddress) y a continuación de esta palabra añade el nombre del componente de registro que actúa como una typedef (en este caso, address), las declaraciones del componente tienen el siguiente aspecto:
        Record address type basicRecord
          10 streetAddress1 CHAR(30);
          10 streetAddress2 CHAR(30);
          10 city CHAR(20);
        end
      
        Record record1 type serialRecord
        {
          fileName = "myFile"
        }
          10 person CHAR(30);
          10 embed address;
        end

      La estructura interna del componente de registro ahora es plana:

        Record record1 type serialRecord
        {
          fileName = "myFile"
        }
          10 person CHAR(30);
          10 streetAddress1 CHAR(30);
          10 streetAddress2 CHAR(30);
          10 city CHAR(20);
        end
      El único motivo por el que se utiliza la palabra embed en lugar de un nombre de elemento de estructura es para no tener que añadir un nivel de jerarquía. Un elemento de estructura identificado mediante la palabra embed tiene las siguientes restricciones:
      • Puede señalar al formato de un componente de registro, pero no a un componente dataItem
      • No puede especificar una matriz ni incluir una especificación de tipo primitivo
    • A continuación, considere el caso en que un componente de registro es una typedef cuando declara estructuras idénticas en dos registros:
        Record common type serialRecord
        {
          fileName = "mySerialFile"
        }
          10 a BIN(10);
          10 b CHAR(10);
        end
      
        Record recordA type indexedRecord
        {
          fileName = "myFile",
          keyItem = "a"
        }
          embed common; // acepta la estructura de common, 
                        // no las propiedades
        end
      
        Record recordB type relativeRecord
        {
          fileName = "myOtherFile",
          keyItem = "a"
        }
          embed common;
        end

      Los dos últimos componentes de registro son equivalentes a las siguientes declaraciones:

        Record recordA type indexedRecord
        {
          fileName = "myFile",
          keyItem = "a"
        }
          10 a BIN(10);
          10 b CHAR(10);
        end
      
        Record recordB type relativeRecord
        {
          fileName = "myOtherFile",
          keyItem = "a"
        }
          10 a BIN(10);
          10 b CHAR(10);
        end
  • Puede utilizar un componente de registro varias veces como una typedef al declarar una serie de elementos de estructura. Esta reutilización tiene sentido, por ejemplo, si declara un componente de registro de personal que incluye una dirección particular y una dirección de trabajo. Un registro básico podría proporcionar el mismo formato en dos ubicaciones de la estructura:
      Record address type basicRecord
        10 streetAddress1 CHAR(30);
        10 streetAddress2 CHAR(30);
        10 city CHAR(20);
      end
    
      Record record1 type serialRecord
      {
        fileName = "myFile"
      }
        10 person CHAR(30);
        10 homeAddress address;
        10 workAddress address;
      end

    El componente de registro es equivalente a la siguiente declaración:

      Record record1 type serialRecord
      {
        fileName = "myFile"
      }
        10 person CHAR(30);
        10 homeAddress;
          20 streetAddress1 CHAR(30);
          20 streetAddress2 CHAR(30);
          20 city CHAR(20);
        10 workAddress;
          20 streetAddress1 CHAR(30);
          20 streetAddress2 CHAR(30);
          20 city CHAR(20);
      end
  • No se puede utilizar un componente de registro como una typedef y además especificar la longitud o tipo primitivo de la entidad que señala a la typedef, como en el siguiente ejemplo:
      Record myTypedef type basicRecord
        10 next01 HEX(20);
        10 next02 HEX(20);
      end
    
      // no válido porque myFirst tiene un
      // tipo primitivo y señala al formato de un componente
      Record myStruct02 type serialRecord
      {
        fileName = "myFile"
      }
        10 myFirst HEX(40) myTypedef;
      end
    Sin embargo, considere el siguiente caso:
      Record myTypedef type basicRecord
        10 next01 HEX(20);
        10 next02 HEX(20);
      end
    
      Record myStruct02 type basicRecord
        10 myFirst myTypedef;
      end
    La segunda estructura es equivalente a la siguiente declaración:
      Record myStruct02 type basicRecord
        10 myFirst;
          20 next01 HEX(20);
          20 next02 HEX(20);
      end

    El tipo primitivo de cualquier elemento de estructura que tenga elementos de estructura subordinados es CHAR por omisión, y la longitud de dicho elemento de estructura es el número de bytes representado por los elementos de estructura subordinados, independientemente de los tipos primitivos de dichos elementos de estructura. Para obtener información detallada, consulte la sección Estructura.

  • Se aplican las siguientes restricciones en relación con los registros SQL:
    • Si un componente de registro SQL utiliza otro componente de registro SQL como una typedef, cada elemento que proporciona la typedef incluye un prefijo de cuatro bytes. Sin embargo, si un registro no SQL utiliza un componente de registro SQL como una typedef, no se incluye ningún prefijo. Para obtener información general, consulte la sección Componentes internos de un registro SQL.
    • Un componente de registro SQL sólo puede utilizar los siguientes tipos de componentes como typedef:
      • Otro componente de registro SQL
      • Un componente dataItem
  • Finalmente, ni una estructura ni un elemento de estructura puede ser una typedef

Formulario como una typedef

Sólo puede utilizar un componente de formulario como una typedef cuando declare un parámetro de programa.

Condiciones de uso | Comentarios
(C) Copyright IBM Corporation 2000, 2005. Reservados todos los derechos.