Curso: XML, de los datos a la presentaciónJulio de 2005

CAPTIVA · www.captiva.es

Modelos de documento (Schema)

Introducción

XML Schema Descripción formal de un documento XML en XML El más utilizado W3C XML Schema Otros Relax NG, Schematron Un XML documento que cumple con schema

instancia Métodos para asociar instancia a schema

Atributo xsi:schemaLocation lista de namespaces y schema para cada uno

Atributo xsi:noNamespaceSchemaLocation schema para elementos sin namespace

Otros prefijándoselo al parser, etc.

Introducción (II)

Schema vs DTD Tipos de datos simples y complejos (en DTD PCDATA)

para contenido y atributos Derivación y herencia de tipos Declaración de elementos y atributos sensibles al namespace Schema no dispone de ENTITIES Más sencillo en DTD.

Alternativa Xinclude Namespaces

Especificación posterior a XML 1.0 No soportado por DTDs Uso Reutilización de nombres para diferentes contextos.

P.e. <nombre>Kiko</nombre> Nombre de persona, equipo, etc.

Los schemas combinan nombre con namespace

Principios Ejemplo de XML (direccion.xml):

<?xml version="1.0"?><nombre

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="direccion-schema.xsd">Don Pimpón

</nombre> Ejemplo de Schema (direccion-schema.xsd):

<?xml version="1.0"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name=“nombre“ type="xs:string"/> </xs:schema>

Significado: El documento contiene elemento <nombre> y admite contenido de tipo

xs:string (xs namespace del propio schema). noNamespaceSchemaLocation No hemos definido un namespace para

nombre. Requiere hacer referencia al ns que lo define

Principios (II) Cómo validamos nuestros ejemplos:

Editores Jedit, Cooktop Validadores MSV (MultiSchemaValidator), XSV

Organización del documento Elemento raíz <xs:schema> Hijo de elemento raíz Definición de elementos raíz para instancias XML

Anotaciones Elementos orientados a documentación del schema <xs:annotation> A su vez <xs:annotation> contiene <xs:documentation> (hombres) ó

<xs:appinfo> (máquinas, p.e. ayuda contextual) Ejemplo<xs:annotation>

<xs:documentation xml:lang=“es-es">Ejemplo de XML schema para <a href=“http://www.captiva.es/cursoxml/”> curso XML </a>

(c) 2005 Captiva Soluciones y Seguridad S.L. </xs:documentation>

</xs:annotation>

Principios (III)

Declaración de elementos Formato

<xs:element name=“nombre-elemento" type=“tipo-contenido">

Tipos de contenidos Simples Tipos predefinidos Complejos Tipos definidos por el usuario<xs:element name=“nombre-elemento">

<xs:complexType><!-- Definición del tipo complejo --></xs:complexType>

</xs:element>

Principios (IV)

Tipo Descripción

string Cadena unicode

normalizedString Cadena con tabuladores y cambios de linea normalizados a espacios

token Igual que anterior pero con multiples espacios substituidos por uno único y eliminados los iniciales y finales

Name Nombre XML

language Mismo valor que atributo xml:lang. P.e.: en, es-es

anyURI URI

boolean true | false | 0 | 1

byte 127 <= Entero >= -128

integer Número entero positivo o negativo

decimal Numero flotante de precisión arbitraria

base64Binary Datos binarios codificados Base64

dateTime Fecha y hora

duration Cantidad de tiempo relativa en años, días, meses, etc.

ID, IDREF, IDREFS, ENTITY, ENTITIES, NOTATION, NMTOKEN, NMTOKENS

Igual que XML DTD 1.0

Algunos tipos básicos

Principios (V) Declaración de atributos

Siempre son tipos básicos no pueden contener elementos Pega Un elemento de tipo básico no puede tener atributos Se declaran mediante: <xs:attribute>

Posible definir atributos “globales” o locales a la definición de “complexType” de un elemento

Ejemplo<xs:element name=“nombre"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="language" type="xs:language"/> </xs:extension> </xs:simpleContent> </xs:complexType></xs:element>

Principios (VI) Grupos de atributos

DTDs Parameter entities Definición de un xs:attributeGroup global identificado por id único name Dentro del complex type se hace referencia al attributeGroup Ejemplo:

<xs:attributeGroup name=“idioma"><xs:attribute name=“language” type=“xs:lang”/>

</xs:attributeGroup>

...<xs:element name=“nombre"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attributeGroup ref=“idioma"/> </xs:extension> </xs:simpleContent> </xs:complexType></xs:element>

Namespaces Un namespace se identifica con una URL

Por abreviar se suele asignar un prefijo Hace referencia a elementos de ese namespace

El prefijo no identifica el namespace, es la URL ¿Cómo se asocia un Schema con un namespace?

Declaración tipica <xs:schema

xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace=“http://www.captiva.es”xmlns=“http://www.captiva.es”>

xmlns:xs = … Este documento usa namespace de XMLSchema (http://.../XMLSchema) y se usará el prefijo xs

targetNamespace = … Los elementos definidos en este schema pertenecen al namespace “http://www.captiva.es”

xmlns = … Identifica el namespace por defecto.

Namespaces (II) ¿Cómo se asocia una instancia con un namespace?

Declaración tipica <nombre

xmlns:xsi="http://www.w3.org/2001/XMLSchema“ xsi:schemaLocation=“http://www.captiva.es

direccion.xsd”xmlns=“http://www.captiva.es”

elementFormDefault="qualified" >Yo mismo</nombre> xmlns:xsi = … XMLSchema en sí es una instancia XML. La

hacemos accesible a través de prefijo “xsi” xsi:schemaLocation = “schema fich-schema.xsd”

Token list con el schema a utilizar (debe coincidir con targetSchema) y fichero que contiene la def del schema

xmlns = … Identifica el namespace por defecto. elementFormDefault = “qualified” -> Los nombres simpre

son cualificados Evita errores

Tipos Complejos Tipos complejos

Sólo para elementos Definición de nuevos tipos

xs:complexType Alternativas

Declaración global (fuera definición de cualquier elemento) Se puede referenciar a través de atributo name

Declaración dentro de definición de elementos Ejemplo:

<identificacion> <nombre>Fulano<nombre> <apellido1>de Tal</apellido1> <apellido2>y Cual</apellido2></identificacion>

<xs:element name=“identificacion”> <xs:complexType> <xs:sequence> <xs:element name=“nombre” type=“xs:string”/> <xs:element name=“apellido1” type=“xs:string”/> <xs:element name=“apellido2” type=“xs:string”/> </xs:sequence> </xs:complexType></xs:element>

Tipos Complejos (II)

Restricción de ocurrencias Equivalente a modificadores de DTDs (+ * ?) Parámetros minOccurs y maxOccurs de xs:element Ejemplo:

<xs:element name=“apellido2” type=“xs:string” minOccurs=“0”/>

Alternativas para contenido de un elemento Vacío Contenido simple Contenido mixto Cualquier tipo

Elementos vacíos

Elemento vacío <elemento /> ó <elemento></elemento> Ejemplo de elemento vacío <xhtml:img

src=“”/> Tipo complejo sin más elementos anidados Ejemplo definición de elemento img:

<xs:element name=“img“>

<xs:complexType>

<xs:attribute name=“src“ type="xs:anyURI"/>

</xs:complexType>

</xs:element>

Elementos con contenido simple

Se especifican con modificador <xs:simpleContent/> Se permite definir tipos simples derivados de los que incorpora

Schema <xs:extension base=“tipo-simple"> Declaramos un tipo complejo con contenido simple y lo usamos

para definir el elemento “nombre” con atributo “dni”:<xs:element name=“nombre”>

<xs:complexType>

<xs:simpleContent>

<xs:extension base=“xs:string”/>

<xs:attribute name=“dni” type=“xs:ID”>

<xs:extension base=“xs:string”/>

</xs:complexType>

</xs:element>

</xs:element>

Elementos con contenido simple (II)

Defininición de tipos simples En vez de definir tipo complejo con contenido simple podemos

definir tipo simple Ej:

<xs:simpleType name=“tipoMatricula">

<xs:restriction base="xs:string"/>

</xs:simpleType> Facetas

Son posibles valores para los tipos simples Para ello se emplean restricciones de valores xs:restriction

<xs:restriction base=“tipo-simple”>

<xs:nombre-faceta value=“valor-faceta”/>

</xs:restriction>

Tipos simples: Facetas

Lista de posibles facetas length (o minLength y maxLength) pattern enumeration whiteSpace maxInclusive y maxExclusive minInclusive y minExclusive totalDigits fractionDigits

Tipos simples: Facetas (II)

Espaciado Antes de “parsear” el dato se normalizan los

espacios Con whiteSpace podemos determinar cómo se

normalizan Posibles valores:

preserve Deja todos los espacios intactos replace Substituye \t \r \n por espacio (#x20) collapse Hace replace y luego substituye multiples

espacios por uno sólo

Tipos simples: Facetas (III)

Longitud Tres alternativas:

length Fija longitud exacta permitida minLength Fija longitud mínima maxLength Fija longitud máxima

Ejemplo<xs:simpleType name=“tipoNombre"> <xs:restriction base="xs:string"> <xs:minLength value=“3"/> <xs:maxLength value=“15"/> </xs:restriction> </xs:simpleType>

Ejemplo direccion-tipobasico.xml y direccion-schema-tipobasico.xsd

Tipos simples: Facetas (IV)

Enumeraciones Lista de valores válidos (DTD (a | b | c) )

<xs:simpleType name=“tipoMoneda">

<xs:restriction base="xs:string">

<xs:enumeration value=“cara"/>

<xs:enumeration value=“cruz"/>

</xs:restriction>

</xs:simpleType>

Tipos simples: Facetas (V)

Restricciones numéricas Rangos: minInclusive (<=) , minExclusive

(<), maxInclusive (>=), maxExclusive (>) Control de valores decimales: totalDigits,

fractionDigits• Ejemplo restricción decimal a XXX.XX

<xs:simpleType name=“tipoPrecio"> <xs:restriction base="xs:decimal"> <xs:totalDigits value=“5"/> <xs:fractionDigits value=“2"/> </xs:restriction> </xs:simpleType>

Tipos simples: Facetas (VI) Formato específico de cadenas

Se utiliza <xs:pattern> para especificar el patrón que ha se seguir la cadena

Algunos ejemplos de patrones: [a-z] Letras de la ‘a’ a la ‘z’ \d Dígito numérico \D Cualquier carácter que no sea un dígito . Cualquier carácter excepto CR LF \s Espacio, tabulador o CR o LF

Más información: http://www.w3.org/TR/xmlschema-2/#regexs Ejemplo definición tipo DNI:

<xs:simpleType name=“tipoDNI"> <xs:restriction base="xs:string"> <xs:pattern value=“\d\d\d\d\d\d\d\

d[TRWAGMYFPDXBNJZSQVHLCKEF]"/> </xs:restriction> </xs:simpleType>

Tipos simples: Facetas (VII)

Listas Lista de elementos de tipo básico separados por

espacios Sintaxis:

<xs:list itemType=“tipo-basico"> Atención: No va dentro de restriction. Se pueden aplicar restricciones que se aplican a

todos los elementos Ejemplo lista de DNIs:

<xs:simpleType name=“tipoListaDNI"> <xs:list itemType=“tipoDNI"></xs:simpleType>

Tipos simples: Facetas (VIII)

Uniones Alternativa entre varios tipos posibles Sintaxis:

<xs:union memberTypes=“tipo-basico1 tipo-basico2">

Atención: No va dentro de restriction Ejemplo:

<xs:simpleType name=“textoOentero">

<xs:union memberTypes=“xs:integer xs:string">

</xs:simpleType>

Elementos con contenido mixto

Contenido mixto Texto y elementos DTD Número ilimitado de combinación texto

elementos <!ELEMENT raiz (hijo | #PCDATA)*>

Schema Además control del número y secuencia de elementos

mezclados con texto ¿Cómo se permite contenido mixto?

<xs:element name=“detodounpoco"> <xs:complexType mixed="true"> <!-- Definicion del tipo --> </xs:complexType></xs:element>

Elementos con contenido mixto (II)

Mezclado de texto con secuencia de elementos Ejemplo: carta.xml y carta-schema.xsd

Ejercicio: Abrir carta.xml y validar. Después cambiar en xsd mixedContent=“false” y repetir.

<?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.captiva.es" xmlns="http://www.captiva.es" elementFormDefault="qualified"> <!-- Definicion de elementos --> <xs:element name="carta"> <xs:complexType mixed="true"> <xs:sequence> <xs:element name="saludo" type="xs:string"/> <xs:element name="cuerpo" type="xs:string"/> <xs:element name="despedida" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>

Elementos con contenido mixto (II)

Mezclado de texto con elementos alternativos En vez de mezclar con <xs:sequence> utilizamos

<xs:choice> Ejemplo

<xs:element name=“saludo”>

<xs:complexType mixed="true">

<xs:choice>

<xs:element name="hola"/>

<xs:element name=“estimado"/>

<xs:element name=“querido"/>

</xs:choice>

</xs:complexType>

</xs:element>

Elementos con contenido mixto (III)

Mezclado de texto con secuencias desordenadas Se utiliza la construcción <xs:all> Implica que todos los elementos han de estar presentes pero en cualquier

orden Ejemplo

<xs:element name=“pedido”> <xs:complexType mixed="true"> <xs:all> <xs:element name=“fruta"/> <xs:element name=“hortaliza"/> <xs:element name=“legumbre"/> </xs:all> </xs:complexType></xs:element>

Fragmento XML que es válido de acuerdo al schema<pedido>Puedes traerme 3 kg de <legumbre>alubias</legumbre>, unos 5 kg de <hortaliza>pimientos</hortaliza> y quizá también 8 kg de <fruta>naranjas</fruta></pedido>

Elementos con contenido mixto (IV)

Una vuelta más de tuerca: Agrupaciones Utlizando la construcción <xs:group> podemos combinar <xs:sequence> <xs:choice> y

<xs:all> Ejemplo

<xs:element name=“menu”> <xs:complexType mixed="true"> <xs:group> <xs:all> <xs:element name=“canapes"/> <xs:element name=“ibericos"/> <xs:element name=“pate"/> </xs:all> <xs:sequence> <xs:element name=“carne"/> <xs:element name=“pescado"/> <xs:element name=“marisco"/> </xs:sequence> <xs:choice> <xs:element name=“tarta"/> <xs:element name=“helado"/> </xs:choice> </xs:group> </xs:complexType></xs:element>

Cualquier contenido

Cualquier elemento, incluso de schemas externos Sintaxis: <xs:any> Cualquier elemento Ejemplo podemos incluir texto XHTML dentro de nuestro doc. XML:

<xs:element name=“textoXHTML" minOccurs="0"> <xs:complexType> <xs:sequence> <xs:any namespace="http://www.w3.org/1999/xhtml“ minOccurs="0" maxOccurs="unbounded“ processContents="skip"/> </xs:sequence> </xs:complexType> </xs:element>

Cualquier contenido (II)

Inclusión de declaraciones en ficheros externos Sintaxis: <xs:include schemaLocation=“otro-schema.xsd”> El fichero incluido no es un fragmento es un schema completo Para utlizar elementos definidos externamente Utilizar correctamente

namespaces Ejemplos:

carta-partida.xml se valida contra carta-partida-schema.xsd que incluye carta-partida-include-schema.xsd , donde se define el tipo tipoCarta

carta-partida-schema.xsd<?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.captiva.es" xmlns="http://www.captiva.es" elementFormDefault="qualified"> <xs:annotation> <xs:documentation> Incluimos de "carta-partida-include-schema.xsd" Allá se define "tipocarta" </xs:documentation> </xs:annotation> <xs:include schemaLocation="carta-partida-include-schema.xsd"/> <xs:element name="carta" type="tipoCarta"/> </xs:schema>

Cualquier contenido (III)

Inclusión de definiciones de otros namespaces Para ello utilizamos namespace

<xs:import namespace="http://www.w3.org/2001/03/XMLSchema/TypeLibrary" schemaLocation="http://www.w3.org/2001/03/XMLSchema/TypeLibrary.xsd"/>

Redefinición de tipos de otros schemas Se utiliza <xs:redefine schemaLocation=anyURI> Funciona como <xs:include> pero adicionalmente permite redefinir tipos Ejemplo, redefinimos tipoCarta (secuencia con saludo, cuerpo, despedida):<xs:redefine schemaLocation=“carta-partida-include-schema.xsd"> <xs:complexType name=“tipoCarta"> <xs:complexContent> <xs:extension base=“tipoCarta"> <xs:sequence> <xs:element name=“firma"/> </xs:sequence> </xs:extension> </xs:complexContent> </xs:complexType></xs:redefine>

Derivación de tipos complejos

Alternativas para derivar tipos complejos Por extensión <xs:extension>

Equivale a añadir contenidos a los contenidos de la declaración base

Ej. Añadimos código postal a tipoDireccionFisica para formar el nuevo tipo tipoDireccionPostal

<xs:complexType name=“tipoDireccionPostal"> <xs:complexContent> <xs:extension base=“tipoDireccionFisica"> <xs:sequence> <xs:element name=“CP“ type="xs:string"/> </xs:sequence> </xs:extension> </xs:complexContent> </xs:complexType>

Derivación de tipos complejos

Alternativas para derivar tipos complejos (II) Por restricción <xs:restriction>

Si el tipo derivado es subtipo del original Con tipos simples es sencilla su utilización (facets) Con tipos complejos hay que volver a definir el tipo base

eliminando los elementos o atributos que deseamos restringir

<xs:complexType nombre=“tipoNombreCompleto”> <xs:sequence> <xs:element name=“nombre” type=“xs:string”/> <xs:element name=“apellido1” type=“xs:string”/> <xs:element name=“apellido2” type=“xs:string”/> </xs:sequence></xs:complexType>

<xs:complexType nombre=“tipoNombreCorto”> <xs:complexContent> <xs:restriction base=“tipoNombreCompleto”/> <xs:sequence> <xs:element name=“nombre” type=“xs:string”/> <xs:element name=“apellido1” type=“xs:string”/> </xs:sequence> </xs:restriction> </xs:complexContent></xs:complexType>

Derivación de tipos complejos (II)

Polimorfismo Característica interesante de tipos derivados Permite instanciar objetos derivados como si fueran hijos. El atributo xsi:type permite especificar a qué tipo derivado

conforma una instancia. Ejemplo:

<nombreCompleto

xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.captiva.es nombre.xsd“

xmlns=http://www.captiva.es

xsi:type=“tipoNombreCorto”>

<nombre>Pedro</nombre>

<apellido1>Ruiz</apellido1>

</nombreCompleto>

Derivación de tipos complejos (III)

Grupos de substitución Mediante el atributo substitutionGroup de

<xs:element> podemos crear formas de llamar al mismo elemento con otro nombre.

Ejemplo trozo schema:<xs:element name=“calle” type=“xs:string”/>

<xs:element name=“Strasse” substitutionGroup=“calle”/>

Serían igualmente válidos:<calle>Madrid 43</calle>

<Strasse>Berlin 34</Strasse>

Control sobre derivación

Elementos y tipos abstractos Si atributo abstract=true en definición de elemento o tipo

No puede instanciarse el mismo Atributo final

Si atributo final de complexType puede tener los valores #all, extension, restriction para restringir la derivación. P.e.: <xs:complextType name=“nombre” final=“extension”>

Evita que se derive por extension este tipo

Facetas fijas Algunas facetas admiten atributo fixed=“true” Evita que futuras derivaciones anulen la restricción impuesta

por ella<xs:maxInclusive fixed="true" value="100">

Control sobre derivación (II) Valores únicos

El elemento xs:unique permite definir valores únicos para elementos y atributos.

Funcionamiento Se utiliza una expresión xpath para coger subcojunto del documento xs:selector Se utiliza otra expresión xpath para seleccionar el campo determinado dentro de

subgrupo xs:field Si dos campos son iguales se genera un error

Ejemplo. Vamos a limitar en “contactos” contactos con mismo nombre:

<xs:complexType name=“tipoContactos”> <element “contacto” type=“tipoNombreCompleto” maxOccurs=10/></xs:complexType>

<xs:element name=“contactos" type=“tipoContactos"> <xs:unique name=“nombre"> <xs:selector xpath=“contactos"/> <xs:field xpath=“nombre"/> </xs:unique> </xs:element>

Control sobre derivación (III)

Claves Igual que xs:unique pero no pueden ser nulas y se crean con xs:key

Referencias Con xs:keyref puede referenciarse una clave definida previamente Ejemplo:

Definimos clave única nombre del personaje Definimos campo “amigo-de” que debe apuntar a un nombre de personaje

<xs:key name=“nomPersonaje”> <xs:selector xpath=“personaje”/> <xs:field xpath=“nombre”/></xs:key>

<xs:keyref name=“nomPersonajeRef” refer=“nomPersonaje”> <xs:selector xpath=“personaje”/> <xs:field xpath=“amigo-de”/></xs:key>

<personaje> <nombre>Mortadelo</nombre> <amigo-de>Filemón Pi</amigo-de> <rasgos>camaleónico</rasgos></personaje>

Ejemplo: articulo

Articulo-schema.xsd (1/3):

<?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified"> <!-- RaÃz --> <xs:element name="articulo"> <xs:complexType> <xs:sequence> <xs:element name="titulo"/> <xs:element name="subtitulo" minOccurs="0"/> <xs:element name="autor" minOccurs="0" maxOccurs="unbounded"/> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element name="parrafo"/> <xs:element name="lista"/> </xs:choice> <xs:element name="bibliografia" minOccurs="0"/> </xs:sequence> </xs:complexType> </xs:element>

Ejemplo: articulo (II)

Articulo-schema.xsd (2/3): <xs:element name="autor" type="xs:string"/> <xs:element name="bibliografia"> <xs:complexType> <xs:sequence> <xs:element name="recurso" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> </xs:complexType> </xs:element> <xs:element name="itemlista" type="xs:string"/> <xs:element name="lista"> <xs:complexType> <xs:sequence> <xs:element name="itemlista" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="tipo" use="required"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="numerada"/> <xs:enumeration value="nonumerada"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> </xs:element>

Ejemplo: articulo (II)

Articulo-schema.xsd (3/3): <xs:element name="parrafo"> <xs:complexType mixed="true"> <xs:sequence minOccurs="0" maxOccurs="unbounded"> <xs:element name="referencia"/> </xs:sequence> </xs:complexType> </xs:element> <xs:element name="recurso"> <xs:complexType mixed="true"> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="id" type="xs:ID" use="required"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> <xs:element name="referencia"> <xs:complexType mixed="true"> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="idref" type="xs:IDREF" use="required"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> <xs:element name="subtitulo" type="xs:string"/> <xs:element name="titulo" type="xs:string"/> </xs:schema>

Ejercicio (1/3) Partir de casino.xml de 2º capítulo y modificarlo ligeramente

Añadir un elemento a cada jugador (detrás de las cartas):

<apuesta moneda=“€”>12.23

</apuesta>

Añadir al elemento “jugador” un atributo “dni” con el formato visto en los ejemplos

Crear un XML Schema que permita verificar el fichero casino.xml. Para crearlo ir definiendo primero tipos simples y luego tipos complejos De tal forma que no sea necesario definir tipos complejos dentro de

elementos La última línea del fichero ha de ser de la forma:

<xs:element name=“casino” type=“tipoCasino”/>

Ejercicio (2/3) Tipos simples a ir definiendo en orden:

tipoCadena xs:string que “colapsa” espacios

tipoNombreCarta Derivada de tipoCadena con valores: “As”, “Dos”, … ”Rey”

tipoPalo “oros”, “copas”, “espadas”, “bastos”

tipoDNI Copiar de ejemplo

tipoJuego “brisca”, “tute”, “poker”, “mus”

tipoMoneda “€”, “$”

tipoValorDinero Decimal con 2 números decimales máximo

Ejercicio (3/3) Tipos complejos (Nota Todos los atributos han de tener atributo

use=“required”) tipoCarta

Contenido: Simple de tipo “tipoNombreCarta” Atributos: “palo” de tipo “tipoPalo”

tipoDinero Contenido: Simple de tipo “tipoValorDinero” Atributos: “moneda” de tipo “tipoMoneda”

tipoJugador Contenido: Secuencia de “nombre”, “carta” (1-10), “apuesta” Atributos: “dni” de tipo “tipoDNI”

tipoMesa Contenido: Secuencia de “jugador” (2-infinito) Atributos: “juego” de tipo “tipoJuego”

tipoCasino Contenido: Secuencia de “bienvenida”, ”mesa” (1-infinito) Restricciones: El atributo “dni” de cada jugador es una clave única

xs:key Hacer pruebas sobre casino.xml (poner apuestas sin tipo de moneda, poner

formato incorrecto en campos, repetir DNIs, etc…)