Bloques de establecimiento de valor

Un bloque de establecimiento de valor es un área de código en la que puede establecer los valores de propiedad y de campo. Para obtener más información, consulte la sección Visión general de las propiedades de EGL.

Un bloque de establecimiento de valor está disponible cuando se lleva a cabo cualquiera de las acciones siguientes:

En los dos últimos casos, solo puede asignar valores a campos.

Nota: Se aplica una restricción a los campos de estructuras fijas. Puede utilizar bloques de establecimiento de valor para asignar los valores de las propiedades de nivel de campo primitivo, pero no para establecer los valores de los mismos campos.

Bloques de establecimiento de valor para situaciones elementales

Considere las reglas que se aplican en los casos más elementales:
  • Cada bloque de establecimiento de valor empieza con una llave de apertura ({), incluye una lista de entradas separadas por comas o una sola entrada y finaliza con una llave de clausura (})
  • Las entradas están todas en dos formatos:
    • Cada entrada se compone de un par identificador y valor como por ejemplo inputRequired = yes
    • Cada entrada contiene valores que se asignan de forma posicional, cuando se asignan valores sucesivos a elementos sucesivos de una matriz.

En todos los casos, el bloque de establecimiento de valor está en el ámbito del componente, la variable o el campo que se modifica. Las variaciones de la sintaxis se ilustran mejor mediante un ejemplo.

El primer ejemplo muestra un componente dataItem que tiene dos propiedades (inputRequired y align) :
  // el ámbito del bloque de establecimiento de valor es myPart
  DataItem myPart INT 
    { 
    inputRequired = yes, 
    align = left 
    } 
  end
El ejemplo siguiente muestra una variable de tipo primitivo.
   // el ámbito es myVariable
   myVariable INT
   {
      inputRequired = yes,
      align = left
   };
El siguiente ejemplo muestra una declaración de componente de registro SQL, que incluye dos propiedades de registro (tableNames y keyItems):
  // El ámbito es ExampleRecordPart
  Record ExampleRecordPart type SQLRecord
    { tableNames = [["myTable"]],
      keyItems = ["myKey"] }
    myKey CHAR(10);
    myOtherKey CHAR(10);
    myContent01 CHAR(60);
    myContent02 CHAR(60);
  end 
El ejemplo siguiente muestra una declaración de variable que utiliza el componente anterior como un tipo, altera temporalmente una de las dos propiedades de registro y establece dos campos en el registro:
  // El ámbito es myRecord
  myRecord ExampleRecordPart 
    {
      keyItems = ["myOtherKey"],
      myContent01 = "abc",
      myContent02 = "xyz"
    };
Los ejemplos adicionales incluyen declaraciones de variable y sentencias de asignación:
  // el ejemplo muestra el único caso en el que 
  // puede alterarse temporalmente una propiedad de registro en una 
  // declaración de variable.   
  // el ámbito es myRecord
  myRecord ExampleRecordPart {keyItems = ["myOtherKey"]};

  // el ámbito es myInteger, que es una matriz
  myInteger INT[5] {1,2,3,4,5};

  // estas sentencias de asignación 
  // no tiene bloques de establecimiento de valor
  myRecord02.myContent01 = "abc";
  myRecord02.myContent02 = "xyz";

  // esta sentencia de asignación abreviada
  // es equivalente a las dos anteriores y
  // el ámbito es myRecord02
  myRecord02
    {
      myContent01="abc",
      myContent02="xyz"
    };

  // Esta sentencia de asignación abreviada 
  // restablece los primeros cuatro elementos de la matriz
  // declarada anteriormente
  myInteger{6,7,8,9};

La sentencia de asignación abreviada no está disponible para campos en una estructura fija.

Bloques de establecimiento de valor para un campo de un campo

Cuando está asignando valores para un campo de un campo, se utiliza una sintaxis en la que el bloque de establecimiento de valor está en un ámbito tal que las entradas solo están modificando el campo de interés.

Considere las definiciones de componente siguientes:
  record myBasicRecPart03 type basicRecord
    myInt04 INT;
  end

  record myBasicRecPart02 type basicRecord
    myInt03 INT;
    myRec03 myBasicRecPart03;
  end

  record myBasicRecPart type basicRecord  
    myInt01 INT;
    myInt02 INT;
    myRec02 myBasicRecPart02;
 end
Puede asignar un valor de propiedad para cualquier campo de la manera siguiente:
  • Cree un bloque de establecimiento de valor para el registro
  • Incorpore una serie de nombres de campo para restringir el ámbito
  • Cree el bloque de establecimiento de valor específico del campo

La sintaxis para asignar un valor de propiedad puede tener tres formas, tal como se muestra en los ejemplos siguientes, aplicables al campo myInt04:

  // sintaxis con puntos, tal como se describe en 
  // Referencias a variables en EGL.
  myRecB myBasicRecPart 
  { 
    myRec02.myRec03.myInt04{ align = left } 
  };

  // sintaxis con corchetes, tal como se describe en 
  // Sintaxis con corchetes para acceso dinámico.
  // No puede utilizar esta sintaxis para
  // campos en estructuras fijas.
  myRecC myBasicRecPart 
  { 
    myRec02["myRec03"]["myInt04"]{ align = left } 
  };

  // sintaxis con llaves 
  myRecA myBasicRecPart 
  { 
    myRec02 {myRec03 { myInt04 { align = left }}}
  };
Incluso en casos complejos, se utiliza una coma para separar una entrada de la siguiente en un bloque de establecimiento de valor, pero tiene que tener en cuenta el nivel de anidación de un bloque dado:
  // sintaxis con puntos
  myRecB myBasicRecPart 
  { 
    myInt01 = 4,
    myInt02 = 5,
    myRec02.myRec03.myInt04{ align = left }, 
    myRec02.myInt03 = 6
  };

  // sintaxis con corchetes
  myRecC myBasicRecPart 
  { 
    myInt01 = 4,
    myInt02 = 5,
    myRec02["myRec03"]["myInt04"]{ align = left }, 
    myRec02["myInt03"] = 6
  };

  // sintaxis con llaves; 
  // aunque esta utilización es mucho más difícil de mantener
  myRecA myBasicRecPart 
  { 
    myInt01 = 4,
    myInt02 = 5,
    myRec02 
      {
        myRec03 
          { myInt04 
            { action = label5 }},
        myInt03 = 6
      }
  };

Utilización de "this"

En una declaración de variable o una sentencia de asignación, puede tener un contenedor (como por ejemplo un registro SQL) que incluya un campo (como por ejemplo keyItems) cuyo nombre coincida con el de una propiedad de registro. Para referirse al campo en lugar de a la propiedad, utilice this, que establece el ámbito correcto para el bloque de establecimiento de valor o para una entrada en el bloque de establecimiento de valor.

Considere la declaración de registro siguiente:
  Record ExampleRecordPart type SQLRecord
    { tableNames = [["myTable"]],
      keyItems = ["myKey"] }
    myKey CHAR(10);
    myOtherKey CHAR(10);
    keyItems CHAR(60);
  end 
La declaración de registro siguiente establece primero un valor para la propiedad keyItems, y después establece un valor para el campo del mismo nombre:
  myRecord ExampleRecordPart
  { 
     keyItems = ["myOtherKey"],
     this.keyItems = "abc"
  };

La sección siguiente proporciona un ejemplo adicional en una declaración de matriz.

Bloques de establecimiento de valor, matrices y elementos de matriz

Cuando declara una matriz dinámica, puede especificar el número inicial de elementos, como en este ejemplo:
  col1 ConsoleField[5];
Las asignaciones de un bloque de establecimiento de valor hacen referencia a las propiedades y los campos predefinidos en cada uno de los elementos iniciales de tipo ConsoleField, aunque no a ningún elemento añadido posteriormente:
  col1 ConsoleField[5]
  { 
    position = [1,1],
    color = red
  };
Para asignar valores a un elemento determinado en una declaración de variable, cree un bloque de establecimiento de valor cuyo ámbito sea ese elemento. Tal como se muestra en el ejemplo siguiente, especifique el ámbito utilizando la palabra clave this con índice entre corchetes:
  // asignar valores al segundo y cuarto elemento
  col1 ConsoleField[5]
  {
    this[2] { color = blue }, 
    this[4] { color = blue }
  };

Para conocer más detalles acerca de la utilización de la palabra clave this, consulte la sección Ámbito de reglas y "this" en EGL.

Puede utilizar entradas posicionales en un bloque de establecimiento de valor para asignar valores a elementos sucesivos de una matriz de cualquiera de los tipos siguientes (esto sólo es relevante al procesar informes o crear formularios de consola):
  • ConsoleField
  • Menu
  • MenuItem
  • Prompt
  • Report
  • ReportData
El ejemplo siguiente puede estar en una sentencia OpenUI. El ámbito de cada bloque de establecimiento de valor incorporado es un elemento de matriz específico:
   new Menu
   {
     labelText = "Universe",
     MenuItems = 

     // valor de propiedad es una matriz dinámica
     [ 
       new MenuItem 
       { name = "Expand", 
          labelText = "Expand" },
       new MenuItem 
       { name = "Collapse", 
          labelText = "Collapse" }
     ]
   }

Ejemplo con una propiedad compleja

Para repasar una sintaxis que constituye una ampliación de lo anterior, fíjese en la propiedad compleja @ProgramLinkData. Esta propiedad incluye los campos de propiedad programName y linkParms; linkParms toma una matriz de campos de propiedad, cada uno de la propiedad compleja @LinkParameter.

Puede definir un componente DataItem de la forma siguiente:
  DataItem Prog1LinkItem char(9)
     {  @ProgramLinkData 
        { 
          programName = “my.company.sys1.PROG1”, 
          linkParms = 
          [ @LinkParameter {name=“parm1”, value=”abc”}, 
            @LinkParameter {name=”parm2”,value=”efg”} ] 
        }
     } 
  end
Puede añadir otra propiedad después del bloque set-value que define @ProgramLinkData, pero primero debe añadir una coma para separar ambas propiedades:
  DataItem Prog1LinkItem char(9)
     {  @ProgramLinkData 
        { 
          programName = “my.company.sys1.PROG1”, 
          linkParms = 
          [ @LinkParameter {name=“parm1”, value=”abc”}, 
            @LinkParameter {name=”parm2”,value=”efg”} ] 
        },
        displayName = “Go to Program02”
     } 
  end

Ejemplos adicionales

Observe los componentes siguientes:
  Record Point
				x, y INT;
  end

  Record Rectangle
    topLeft, bottomRight Point;
  end
El código siguiente es válido:
  Function test()
    screen Rectangle
    {
      topLeft{x=1, y=1},
      bottomRight{x=80, y=24}
    };
  
    // cambie x, y en el código utilizando una sentencia 
    // equivalente al código siguiente:
    //   screen.topLeft.x = 1;
    //   screen.topLeft.y = 2;
    screen.topLeft{x=1, y=2};
  end
A continuación, inicialice una matriz de elementos dinámica de tipo Point en la misma función:
  pts Point[2]
  {
    this[1]{x=1, y=2},
    this[2]{x=2, y=3}
  };
Establezca el valor de cada elemento que está ahora en la matriz y establezca el primer elemento en un valor distinto:
  pts{ x=1, y=1 };
  pts[1]{x=10, y=20};

En el ejemplo anterior, se utiliza pts[1] en lugar de this[1] porque el nombre de matriz no es ambiguo.

A continuación, observe otra matriz dinámica de tipo Point:
  points Point[];
La sentencia de asignación siguiente no surte efecto porque no existen elementos:
  points{x=1, y=1};
En contraste, la sentencia de asignación siguiente causa una excepción de fuera de límites porque se hace referencia a un elemento determinado que no existe:
  points[1]{x=10, y=20};
Puede añadir elementos a la matriz y utilizar una sola sentencia para establecer valores en todos los elementos:
  points.resize(2);
  points{x=1, y=1};
Comentarios
(C) Copyright IBM Corporation 2000, 2005. Reservados todos los derechos.