mirror of
https://github.com/php/doc-es.git
synced 2026-03-25 16:02:13 +01:00
39e1e6438d
git-svn-id: https://svn.php.net/repository/phpdoc/es/trunk@329481 c90b9560-bf6c-de11-be94-00142212c4b1
813 lines
26 KiB
XML
813 lines
26 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
|
<!-- $Revision$ -->
|
|
<!-- EN-Revision: ba28df480003640b326c0cf5472e940983a374e1 Maintainer: seros Status: ready -->
|
|
<!-- Reviewed: no -->
|
|
|
|
<chapter xml:id="sdo.examples" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
|
&reftitle.examples;
|
|
<section xml:id="sdo.examples-basic">
|
|
<title>Uso básico</title>
|
|
<para>
|
|
En los ejemplos de abajo se asume un SDO creado con el esquema
|
|
y la información de ejemplo mostrados abajo, usando el Servicio de Acceso a Datos de XML.
|
|
</para>
|
|
<para>
|
|
El documento de ejemplo de abajo describe una compañía única,
|
|
llamada 'MegaCorp', la cual contiene un único departamento,
|
|
llamado 'Tecnologías Avanzadas'.
|
|
El departamento de Tecnologías Avanzadas contiene tres empleados.
|
|
El empleadoDelMes de la compañía hace referencia al segundo empleado,
|
|
'Jane Doe'.
|
|
</para>
|
|
<para>
|
|
<programlisting role="xml">
|
|
<![CDATA[
|
|
<?xml version="1.0" encoding="UTF-8" ?>
|
|
<compañía xmlns="ENCompañía" nombre="MegaCorp"
|
|
empleadoDelMes="E0003">
|
|
<departamentos nombre="Tecnologías Avanzadas" ubicación="NY" número="123">
|
|
<empleados nombre="John Jones" NS="E0001"/>
|
|
<empleados nombre="Jane Doe" NS="E0003"/>
|
|
<empleados nombre="Al Smith" NS="E0004" director="true"/>
|
|
</departamentos>
|
|
</compañía>
|
|
]]>
|
|
</programlisting>
|
|
</para>
|
|
<para>El elemento raíz del esquema es una compañía. La compañía contiene departamentos, y
|
|
cada departamento contiene empleados. Cada elemento tiene varios atributos para almacenar
|
|
cosas como el nombre, el número de serie, etc. Finalmente, la compañía también tiene el atributo
|
|
IDREF que identifica uno de los empleados como el 'empleadoDelMes'.
|
|
</para>
|
|
<para>
|
|
<programlisting role="xml">
|
|
<![CDATA[
|
|
<xsd:schema
|
|
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
|
|
xmlns:sdo="commonj.sdo"
|
|
xmlns:sdoxml="commonj.sdo/xml"
|
|
xmlns:compañía="ENCompañía"
|
|
targetNamespace="ENCompañía">
|
|
<xsd:element name="compañía" type="compañía:TipoCompañía"/>
|
|
<xsd:complexType name="TipoCompañía">
|
|
<xsd:sequence>
|
|
<xsd:element name="departamentos" type="compañía:TipoDepartamento"
|
|
maxOccurs="unbounded"/>
|
|
</xsd:sequence>
|
|
<xsd:attribute name="nombre" type="xsd:string"/>
|
|
<xsd:attribute name="empleadoDelMes" type="xsd:IDREF"
|
|
sdoxml:propertyType="compañía:TipoEmpleado"/>
|
|
</xsd:complexType>
|
|
<xsd:complexType name="TipoDepartamento">
|
|
<xsd:sequence>
|
|
<xsd:element name="empleados" type="compañía:TipoEmpleado"
|
|
maxOccurs="unbounded"/>
|
|
</xsd:sequence>
|
|
<xsd:attribute name="nombre" type="xsd:string"/>
|
|
<xsd:attribute name="ubicación" type="xsd:string"/>
|
|
<xsd:attribute name="número" type="xsd:int"/>
|
|
</xsd:complexType>
|
|
<xsd:complexType name="TipoEmpleado">
|
|
<xsd:attribute name="nombre" type="xsd:string"/>
|
|
<xsd:attribute name="NS" type="xsd:ID"/>
|
|
<xsd:attribute name="director" type="xsd:boolean"/>
|
|
</xsd:complexType>
|
|
</xsd:schema>
|
|
]]>
|
|
</programlisting>
|
|
</para>
|
|
<para>El Servicio de Acceso a Datos XML hace que el esquema se corresponda con un SDO. Los atributos como "nombre"
|
|
se convierten en propiedades primitivas, la secuencia de empleados se convierte en una relación
|
|
de contención polievaluada, etc. Observe que las relaciones de contención están
|
|
expresadas como un tipo complejo dentro de otro, mientras que las referencias de no contención están
|
|
expresadas en términos de ID e IDREF, con un atributo especial,
|
|
<command>sdoxml:propertyType</command>, que especifica el tipo de la
|
|
referencia de no contención.
|
|
</para>
|
|
</section>
|
|
|
|
<section xml:id="sdo.sample.getset">
|
|
<title>Establecer y obtener valores de propiedades</title>
|
|
<para> En los siguientes ejemplos se asume que
|
|
<command>$compañía</command> es la raíz de un árbol de objetos de datos creados desde el
|
|
esquema y el documento de ejemplo mostrado arriba.
|
|
</para>
|
|
<para>
|
|
<example>
|
|
<title>Acceso mediante el nombre de la propiedad</title>
|
|
<para>
|
|
Se puede acceder a las propiedades de los objetos de datos usando la sintaxis de acceso
|
|
de la propiedad del objeto. Lo siguiente esteblece el nombre de la compañía a 'Acme'.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.propname">
|
|
<![CDATA[
|
|
<?php
|
|
$compañía->nombre = 'Acme';
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Acceso mediante el nombre de la propiedad como índice de array</title>
|
|
<para>También se puede acceder a las propiedades usando la sintaxis de array asociativo. La forma
|
|
más sencilla utiliza el nombre de la propiedad como índice del array. Por ejemplo, lo siguiente establece
|
|
el nombre de la compañía y obtiene el empleadoDelMes.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.simplexpath">
|
|
<![CDATA[
|
|
<?php
|
|
$compañía['nombre'] = 'UltraCorp';
|
|
$edm = $compañía['empleadoDelMes'];
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Iteración sobre objetos de datos</title>
|
|
<para>
|
|
Se pueden recorrer las propiedades de un objeto de datos usando &foreach;.
|
|
Lo siguiente recorre las propiedades del empleado del mes.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.doiter">
|
|
<![CDATA[
|
|
<?php
|
|
$edm = $compañía->empleadoDelMes;
|
|
foreach ($edm as $nombre => $valor) {
|
|
echo "$nombre: $valor\n";
|
|
}
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
<para>
|
|
lo que imprimirá:
|
|
</para>
|
|
<programlisting xml:id="sdo.examples.doiter-output">
|
|
<![CDATA[
|
|
nombre: Jane Doe
|
|
NS: E0003
|
|
]]>
|
|
</programlisting>
|
|
<para>
|
|
La propiedad 'director' no se muestra porque no ha sido establecida.
|
|
</para>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Acceso a propiedades polievaluadas mediante el nombre</title>
|
|
<para>Se puede acceder a las propiedaes polievaluadas de un objeto de datos usando la sintaxis
|
|
de nombre de la propiedad del objeto. Lo siguiente obtiene la lista de departamentos.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.mvpname">
|
|
<![CDATA[
|
|
<?php
|
|
$departamentos = $compañía->departamentos;
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Acceso a elementos de propiedades polievaluadas</title>
|
|
<para>
|
|
Se puede acceder a elementos de propiedades polievaluadas usando la sintaxis
|
|
de array. Lo siguiente accede al primer departamento de la compañía.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.mvaccess">
|
|
<![CDATA[
|
|
<?php
|
|
$dpto_ta = $compañía->departamentos[0];
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Iteración sobre propiedades polievaluadas</title>
|
|
<para>
|
|
Las propiedades polievaluadas también se pueden recorrer usando
|
|
&foreach;. Lo siguiente recorre los departamentos de la compañía.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.mvpiter">
|
|
<![CDATA[
|
|
<?php
|
|
foreach ($compañía->departamentos as $departamento) {
|
|
// ...
|
|
}
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
<para>
|
|
Cada iteración asignará el siguiente departamento de la
|
|
lista a la variable <command>$departamento</command>.
|
|
</para>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Acceso a propiedades encadenadas</title>
|
|
<para>Se pueden encadenar referencias a propiedades en una única línea.
|
|
Lo siguiente establece y obtiene el nombre del primer departamento.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.nestedprop">
|
|
<![CDATA[
|
|
<?php
|
|
$compañía->departamentos[0]->nombre = 'Tecnologías Emergentes';
|
|
$nombre_dpto = $compañía->departamentos[0]->nombre;
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
<para>Usando la sintaxis de array asociativo, lo anterior es equivalente a</para>
|
|
<programlisting role="php" xml:id="sdo.examples.chainarray">
|
|
<![CDATA[
|
|
<?php
|
|
$compañía['departamentos'][0]['nombre'] = 'Tecnologías Emergentes';
|
|
$nombre_dpto = $compañía['departamentos'][0]['nombre'];
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
<para>En cualquier caso, la variable nombre_dpto es establecida a 'Tecnologías Emergentes'.
|
|
</para>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Navegación mediante XPath</title>
|
|
<para>El índice de un array asociativo puede ser una expresión como la usada con XPath. Las
|
|
expresiones válidas están definidas por un subconjunto incrementado de XPath.
|
|
</para>
|
|
<para>
|
|
Están admitidas las dos formas de indexar propiedades polievaluadas.
|
|
La primera es la sintaxis de array estándar de XPath con el índice
|
|
comenzando por uno, la segunda es una extensión de SDO para XPath con un índice
|
|
comenzando por cero. La sintaxis estándar es:
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.xpath1nav">
|
|
<![CDATA[
|
|
<?php
|
|
$jane_doe = $compañía["departamentos[1]/empleados[2]"];
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
<para>y la sintaxis de extensión para XPath de SDO es:</para>
|
|
<programlisting role="php" xml:id="sdo.examples.xpath0nav">
|
|
<![CDATA[
|
|
<?php
|
|
$jane_doe = $compañía["departamentos.0/empleados.1"];
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
<para>
|
|
Ambos ejemplos obtienen el segundo empleado del primer departamento.
|
|
</para>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Consulta mediante XPath</title>
|
|
<para>
|
|
Se puede usar XPath para consultar e identificar partes de un objeto de datos basados
|
|
en datos de instancia. Lo siguiente recupera el director del
|
|
departamento 'Tecnologías Avanzadas'.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.xpathquery">
|
|
<![CDATA[
|
|
<?php
|
|
$director_ta =
|
|
$compañía["departamentos[nombre='Tecnologías Avanzadas']/empleados[director=true]"];
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Crear objetos de datos hijos</title>
|
|
<para>
|
|
Un objeto de datos puede ser una fábrica para sus objetos de datos hijos.
|
|
Un objeto de datos hijo es automáticamente parte del grafo de datos.
|
|
Lo siguiente añade un nuevo empleado al departamento
|
|
'Tecnologías Avanzadas'.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.create">
|
|
<![CDATA[
|
|
<?php
|
|
$dpto_ta = $compañía["departamentos[nombre='Tecnologías Avanzadas']"];
|
|
$nuevo_contrato = $dpto_ta->createDataObject('empleados');
|
|
$nuevo_contrato->nombre = 'John Johnson';
|
|
$nuevo_contrato->NS = 'E0005';
|
|
$nuevo_contrato->director = false;
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Desestablecer una propiedad primitiva</title>
|
|
<para>
|
|
Se pueden usar las funciones <function>isset</function> y
|
|
<function>unset</function> para comprobar y eliminar elementos
|
|
de un objeto de datos.
|
|
</para>
|
|
<para>
|
|
Lo siguiente limpia el nombre del primer departamento.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.unsetprim">
|
|
<![CDATA[
|
|
<?php
|
|
unset($compañía->departamentos[0]->nombre);
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Desestablecer un objeto de datos</title>
|
|
<para>
|
|
unset también se puede usar para eliminar un objeto de datos de un árbol.
|
|
El siguiente ejemplo muestra a John Jones abandonando la compañía.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.unsetdo">
|
|
<![CDATA[
|
|
<?php
|
|
unset($compañía->departamentos[0]->empleados[0]);
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Desestablecer una referencia a un objeto de datos</title>
|
|
<para>
|
|
Lo siguiente elimina el 'empleadoDelMes' de la compañía.
|
|
Si este fuera una relación de contención, el
|
|
empleado sería eliminado de la compañía
|
|
(¡probablemente no sería una buena idea echar al mejor empleado de cada mes!),
|
|
pero ya que es una referencia de no contención,
|
|
el empleado al que hace referencia permanecerá en el
|
|
departamento de la compañía,
|
|
pero ya no será accesible mediante la propiedad empleadoDelMes.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.unsetrefdo">
|
|
<![CDATA[
|
|
<?php
|
|
if (isset($compañía->empleadoDelMes)) {
|
|
unset($compañía->empleadoDelMes);
|
|
}
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Acceso mediante el índice de propiedad</title>
|
|
<para> Se pueden acceder a las propiedades de objetos de datos mediante sus índices de propiedad usando la sintaxis
|
|
de array. El índice de propiedad es la posición en la que la definición de la propiedad
|
|
aparece en el modelo (en este caso el esquema xml). Se puede ver en el esquema de
|
|
arriba que el atributo del nombre de la compañía es la segunda propiedad de la compañía (la
|
|
interfaz de SDO no hace distinción entre atributos XML y elementos). Lo siguiente
|
|
establece el nombre de la compañía a 'Acme', con el mismo resultado que en el
|
|
<link linkend="sdo.examples.propname">Acceso mediante el nombre de la propiedad</link>
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.propindex">
|
|
<![CDATA[
|
|
<?php
|
|
$compañía[1] = 'Acme';
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
<para>Usar directamente el índice de esta manera puede ser delicado. Normalmente se
|
|
debería prefereir la sintaxis de nombre de propiedad, aunque el índice de propiedad
|
|
puede ser necesario en casos especiales.
|
|
</para>
|
|
</example>
|
|
</para>
|
|
|
|
</section>
|
|
|
|
<section xml:id="sdo.sample.sequence">
|
|
<title>Trabajar con objetos de datos secuenciados</title>
|
|
<para>
|
|
Los objetos de datos sencuenciados son SDOs que pueden rastrear el orden
|
|
de las propiedades de un objeto de datos. También pueden
|
|
contener elementos de texto no estructurado (un elemento de texto que no
|
|
pertenece a ninguna de las propiedades del SDO). Los objetos de datos secuenciados son
|
|
útiles para trabajar con documentos XML que permiten texto no estructurado (es decir,
|
|
mixed=true) o si los elementos pueden estar intercalados (
|
|
<![CDATA[<A/><B/><A/>]]>). Esto puede ocurrir, por ejemplo, cuando
|
|
el esquema define maxOccurs>1 en un
|
|
elemento que es de tipo complejo (complexType) con un indicador de orden de elección.
|
|
</para>
|
|
<para>
|
|
En los ejemplos de abajo se asume que existe un SDO creado con el siguiente esquema
|
|
y la siguiente información de ejemplo, usando el Servicio de Acceso a Datos XML.
|
|
</para>
|
|
<para>
|
|
El esquema de abajo describe el formato de una carta. La carta puede
|
|
contener opcionalmente tres propiedades: fecha, nombre, y apellido.
|
|
El estado del esquema es <command>mixed="true"</command>, lo que significa que
|
|
se puede intercalar texto no estructurado entre las tres propiedades.
|
|
</para>
|
|
<para>
|
|
<programlisting role="xml">
|
|
<![CDATA[
|
|
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
|
|
xmlns:carta="http://esquemaCarta"
|
|
targetNamespace="http://esquemaCarta">
|
|
<xsd:element name="cartas" type="carta:ModeloCarta"/>
|
|
<xsd:complexType name="ModeloCarta" mixed="true">
|
|
<xsd:sequence>
|
|
<xsd:element name="fecha" minOccurs="0" type="xsd:string"/>
|
|
<xsd:element name="nombre" minOccurs="0" type="xsd:string"/>
|
|
<xsd:element name="apellido" minOccurs="0" type="xsd:string"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
</xsd:schema>
|
|
]]>
|
|
</programlisting>
|
|
</para>
|
|
|
|
<para>
|
|
Lo siguiente es un documento carta de ejemplo. Contiene las
|
|
tres propiedades de la carta: fecha, nombre y apellido; y tiene
|
|
elementos de texto no esctrucrado para la dirección y el cuerpo de la carta.
|
|
</para>
|
|
<para>
|
|
<programlisting role="xml">
|
|
<![CDATA[
|
|
<carta:cartas xmlns:carta="http://esquemaCarta">
|
|
<fecha>1 de marzo de 2005</fecha>
|
|
Mutual of Omaha
|
|
Wild Kingdom, USA
|
|
Querida
|
|
<nombre>Casy</nombre>
|
|
<apellido>Crocodile</apellido>
|
|
Por favor, compre más repelente de tiburones.
|
|
Su prima ha vencido.
|
|
</carta:cartas>
|
|
]]>
|
|
</programlisting>
|
|
</para>
|
|
<para>
|
|
Cuando se carga, el objeto de datos carta tendrá la secuencia y
|
|
los índices de propiedades mostrados en la tabla de abajo:
|
|
<informaltable>
|
|
<tgroup cols="3">
|
|
<thead>
|
|
<row>
|
|
<entry>Índice de Secuencia</entry>
|
|
<entry>Índice de Propiedad:Nombre</entry>
|
|
<entry>Valor</entry>
|
|
</row>
|
|
</thead>
|
|
<tbody>
|
|
<row>
|
|
<entry>0</entry>
|
|
<entry>0:fecha</entry>
|
|
<entry>1 de marzo de 2005</entry>
|
|
</row>
|
|
<row>
|
|
<entry>1</entry>
|
|
<entry>-</entry>
|
|
<entry>Mutual of Omaha</entry>
|
|
</row>
|
|
<row>
|
|
<entry>2</entry>
|
|
<entry>-</entry>
|
|
<entry>Wild Kingdom, USA</entry>
|
|
</row>
|
|
<row>
|
|
<entry>3</entry>
|
|
<entry>-</entry>
|
|
<entry>Querida</entry>
|
|
</row>
|
|
<row>
|
|
<entry>4</entry>
|
|
<entry>1:nombre</entry>
|
|
<entry>Casy</entry>
|
|
</row>
|
|
<row>
|
|
<entry>5</entry>
|
|
<entry>2:apellido</entry>
|
|
<entry>Crocodile</entry>
|
|
</row>
|
|
<row>
|
|
<entry>6</entry>
|
|
<entry>-</entry>
|
|
<entry>Por favor, compre más repelente de tiburones.</entry>
|
|
</row>
|
|
<row>
|
|
<entry>7</entry>
|
|
<entry>-</entry>
|
|
<entry>Su prima ha vencido.</entry>
|
|
</row>
|
|
</tbody>
|
|
</tgroup>
|
|
</informaltable>
|
|
</para>
|
|
|
|
<para>
|
|
Para asegurarse de que los índices de secuencia se mantienen, los objetos de datos secuenciados
|
|
deberían ser manipulados mediante la interfaz SDO_Sequence.
|
|
Esto permite que los datos de instancias de objetos de datos sean manipulados
|
|
en términos de índice de secuencia en lugar de índice de propiedad
|
|
(mostrado en la tabla de arriba).
|
|
En los siguientes ejemplos se asume que la carta de ejemplo ha sido
|
|
cargada en un objeto de datos al que hace referencia la variable
|
|
<command>$carta</command>.
|
|
<example>
|
|
<title>Obtener la interfaz SDO_Sequence</title>
|
|
<para>
|
|
Se obtiene una secuencia de objetos de datos usando el método
|
|
<function>getSequence</function>.
|
|
Lo siguiente obtiene la
|
|
secuencia para el objeto de datos carta.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.seqinterface">
|
|
<![CDATA[
|
|
<?php
|
|
$secuencia_carta = $carta->getSequence();
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
<para>
|
|
En todos los ejemplos subsiguientes se asume que la variable
|
|
<command>$secuencia_carta</command>
|
|
ha sido asignada a la secuencia del objeto de datos carta.
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Obtener/establecer valores de secuencias</title>
|
|
<para>
|
|
Se pueden obtener y establecer valores individuales (incluyendo texto no estructurado)
|
|
usando el índice de secuencia.
|
|
Lo siguiente establece el nombre a 'Snappy' y obtiene los últimos
|
|
valores de la secuencia (el texto no estructurado, 'Su prima ha vencido.').
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.getsetseq">
|
|
<![CDATA[
|
|
<?php
|
|
$secuencia_carta[4] = 'Snappy';
|
|
$texto = $secuencia_carta[count($secuencia_carta) - 1];
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Iteración sobre secuencias</title>
|
|
<para>
|
|
Se pueden recorrer valores individuales de la secuencia usando &foreach;.
|
|
Lo siguiente recorre los valores individuales en el orden de la secuencia.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.seqiter">
|
|
<![CDATA[
|
|
<?php
|
|
foreach ($carta->getSequence() as $valor) {
|
|
// ...
|
|
}
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Secuencias contra Objetos de Datos</title>
|
|
<para>
|
|
Al establecer valores a través de la interfaz del objeto de datos, puede resultar que el
|
|
valor no sea parte de la secuencia. Un valor establecido a través del objeto de
|
|
datos sólo será accesible a través de la secuencia si la propiedad ya
|
|
era parte de la secuencia. El siguiente ejemplo establece el
|
|
apellido a través del objeto de datos y lo obtiene a través de la secuencia.
|
|
Esto es correcto, ya que apellido ya existe en la secuencia. Si
|
|
no se hubiera establecido anteriormente, apellido sería establecido a
|
|
'Smith', pero no sería parte de la secuencia.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.seqvsdo">
|
|
<![CDATA[
|
|
<?php
|
|
$carta[2] = 'Smith';
|
|
$apellido = $secuencia_carta[5];
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Añadir elementos a una secuencia</title>
|
|
<para>
|
|
Se pueden añadir nuevos valores a una secuencia usando el método
|
|
<function>SDO_Sequence::insert</function>.
|
|
En los siguientes ejemplos se asume que las propiedades 'nombre' y
|
|
'apellido' no estaban establecidas inicialmente.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.seqadd">
|
|
<![CDATA[
|
|
<?php
|
|
// Añadir un valor de nombre a la secuencia
|
|
// valor: 'Smith'
|
|
// índice de secuencia: NULL (añadido)
|
|
// identificador de propiedad: 1 (índice de la propiedad nombre)
|
|
$secuencia_carta->insert('Smith', NULL, 1);
|
|
|
|
// Añadir un valor de apellido a la secuencia
|
|
// valor: 'Jones'
|
|
// índice de secuencia: NULL (añadido)
|
|
// identificador de propiedad: 'apellido' (nombre de la propiedad apellido)
|
|
$secuencia_carta->insert('Jones', NULL, 'apellido');
|
|
|
|
// Añadir texto no estructurado
|
|
// valor: 'Cancelar suscripción.'
|
|
// índice de secuencia: ausente (añadido)
|
|
// identificador de propiedad: ausente (texto no estructurado)
|
|
$secuencia_carta->insert('Cancelar suscripción.');
|
|
|
|
// Insertar nuevo texto no estructurado. Los valores de secuencia subsiguientes
|
|
// son aumentados.
|
|
// valor: 'Por medio de:'
|
|
// índice de secuencia: 1 (insertado como segundo elemento)
|
|
// identificador de propiedad: ausente (texto no estructurado)
|
|
$secuencia_carta->insert('Por medio de:', 1);
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Eliminar elementos de una secuencia</title>
|
|
<para>
|
|
Se pueden usar las funciones <function>isset</function> y
|
|
<function>unset</function> para comprobar y eliminar elementos
|
|
de una secuencia (Nota: <function>unset</function> actualmente
|
|
deja los valores del objeto de datos, pero este comportamiento es probable
|
|
que se cambie para que tambíen se eliminen los datos del mismo).
|
|
Una secuencia se comporta como una lista contigua; por lo tanto, eliminar
|
|
elementos de la mitad de la lista moverá hacia abajo las entradas en índices más
|
|
altos. El siguiente ejemplo comprueba si el primer elemento de la
|
|
secuencia está establecido, en cuyo caso los desestablece.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.seqremove">
|
|
<![CDATA[
|
|
<?php
|
|
if (isset($secuencia_carta[0])) {
|
|
unset($secuencia_carta[0]);
|
|
}
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
|
|
</section>
|
|
|
|
|
|
<section xml:id="sdo.sample.reflection">
|
|
<title>Reflexión sobre Objetos de Datos de Servicio</title>
|
|
<para>
|
|
Los SDOs son conscientes de la estructura que representan y para la que
|
|
fueron creados (el modelo). Por ejemplo, un SDO Compañía creado usando
|
|
<link linkend="sdo.examples">el esquema XML Compañía</link> de arriba
|
|
solamente le estaría permitido contener objetos de datos TipoDepartamento,
|
|
los cuales a su vez sólo pueden contener objetos de datos TipoEmpleado.
|
|
</para>
|
|
<para>
|
|
A veces es útil poder acceder a la información del modelo en
|
|
tiempo de ejecución. Por ejemplo, para generar automáticamente
|
|
una interfaz de usuario y rellenar un objeto de datos. A la información
|
|
del modelo se accede usando reflexión.
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Reflexión sobre un objeto de datos</title>
|
|
<para>
|
|
El siguiente ejemplo muestra cómo se puede usar la reflexión en un objeto de datos
|
|
Empleado vacío.
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.reflection">
|
|
<![CDATA[
|
|
<?php
|
|
// Crear el objeto de datos empleado (p.ej. desde un Servicio de Acceso a Datos XML)
|
|
$empleado = ...;
|
|
$reflexión = new SDO_Model_ReflectionDataObject($empleado);
|
|
print($reflexión);
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
&example.outputs;
|
|
|
|
<screen>
|
|
<![CDATA[
|
|
object(SDO_Model_ReflectionDataObject)#4 { - ROOT OBJECT - Type {
|
|
ENCompañía:TipoEmpleado[3] { commonj.sdo:String $nombre;
|
|
commonj.sdo:String $NS; commonj.sdo:Boolean $director; } }
|
|
]]>
|
|
</screen>
|
|
<para>
|
|
Al usar print con SDO_Model_ReflectionDataObject se escribe el modelo
|
|
del objeto de datos. Se puede observar que el tipo
|
|
ENCompañía:TipoEmpleado tiene tres propiedades, y que pueden verse sus nombres
|
|
junto con sus tipos. Observe que los tipos primitivos
|
|
están enumerados como tipos de SDO (p.ej. espacio de nombres commonj.sdo, tipo String).
|
|
Esto es nada más y nada menos que el modelo del SDO, y cuando estos tipos aparecen
|
|
en una aplicación, pueden ser tratados como sus tipos equivalentes de
|
|
PHP (p.ej., string y booleano).
|
|
</para>
|
|
</example>
|
|
</para>
|
|
|
|
<para>
|
|
<example>
|
|
<title>Acceder a la información del tipo</title>
|
|
<para>
|
|
Se puede consultar la información del tipo de un objeto de datos usando reflexión.
|
|
El siguiente ejemplo comprueba el tipo que corresponde a un objeto de datos,
|
|
en vez de un tipo primitivo, y luego recorre las propiedades del
|
|
tipo, escribiendo el nombre de cada propiedad ($tipo y $propiedad
|
|
son objetos SDO_Model_Type y SDO_Model_Property, respectivamente).
|
|
</para>
|
|
<programlisting role="php" xml:id="sdo.examples.reflection.type">
|
|
<![CDATA[
|
|
<?php
|
|
// Crear el objeto de datos empleado (p.ej. desde un Servicio de Acceso a Datos XML)
|
|
$empleado = ...;
|
|
$reflexión = new SDO_Model_ReflectionDataObject($empleado);
|
|
$tipo = $reflexión->getType();
|
|
if (! $tipo->isDataType()) {
|
|
foreach ($tipo->getProperties() as $propiedad) {
|
|
print $propiedad->getName() . "\n";
|
|
}
|
|
}
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
&example.outputs;
|
|
<screen>
|
|
<![CDATA[
|
|
nombre
|
|
NS
|
|
director
|
|
]]>
|
|
</screen>
|
|
</example>
|
|
</para>
|
|
|
|
</section>
|
|
</chapter>
|
|
|
|
<!-- Keep this comment at the end of the file
|
|
Local variables:
|
|
mode: sgml
|
|
sgml-omittag:t
|
|
sgml-shorttag:t
|
|
sgml-minimize-attributes:nil
|
|
sgml-always-quote-attributes:t
|
|
sgml-indent-step:1
|
|
sgml-indent-data:t
|
|
indent-tabs-mode:nil
|
|
sgml-parent-document:nil
|
|
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
|
|
sgml-exposed-tags:nil
|
|
sgml-local-catalogs:nil
|
|
sgml-local-ecat-files:nil
|
|
End:
|
|
vim600: syn=xml fen fdm=syntax fdl=2 si
|
|
vim: et tw=78 syn=sgml
|
|
vi: ts=1 sw=1
|
|
-->
|
|
|