I have the following design problem. Maybe somebody can help
Suppose there is this concept of a Leaf
that can be an array of one three varieties determined by a type
attribute called tid.
One type is a string of length 32,
the other an integer, and the other a double.
This is what I have now (together with its validating schema)
note.xml
1 <?xml version="1.0"?>
2 <note
3 xmlns="//LHickey/D/gfx/xml/examples"
4 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5 xsi:schemaLocation="//LHickey/D/gfx/xml/examples note.xsd">
6
7
8 <Leaf tid="A32" name="Clawsons">
9 <A32Leaf tid="A32" len="4">
10 <title>clawsons best </title>
11 <a32arrayelement xsi:nil="true" />
12 <a32arrayelement xsi:nil="true" />
13 <a32arrayelement>abcdef</a32arrayelement>
14 <a32arrayelement>
01234567890123456789012345678912
</a32arrayelement>
15 </A32Leaf>
16 </Leaf>
17
18 <Leaf tid="Int" name="Fred">
19 <ILeaf tid="Int" len="4">
20 <title> howdy fred </title>
21 <iarrayelement>1</iarrayelement>
22 <iarrayelement>2</iarrayelement>
23 <iarrayelement>3</iarrayelement>
24 <iarrayelement xsi:nil="true"/>
25 </ILeaf>
26 </Leaf>
27
28 <Leaf tid="Dbl" name="Wilma">
29 <DLeaf tid="Dbl" len="4">
30 <title> howdy wilma </title>
31 <darrayelement>1</darrayelement>
32 <darrayelement>2</darrayelement>
33 <darrayelement>3</darrayelement>
34 <darrayelement xsi:nil="true"/>
35 </DLeaf>
36 </Leaf>
37
38 <Leaf tid="Dbl" name="Thing"/>
39
40 </note>
This says that a Leaf is a container for one of three types (A32Leaf tid="A32")
or (ILeaf tid="Int"), or (DLeaf tid="Dbl").
I really want Leaf to BE one of one of the three types. Note in the note.xml above,
we have tid duplicated in the Leaf emement ,and in each of the contained elements.
Here is the schema for this thing
note.xsd
1 <?xml version="1.0" encoding="utf-8"?>
2 <xs:schema
3 xmlns:xs="http://www.w3.org/2001/XMLSchema"
4 targetNamespace="//LHickey/D/gfx/xml/examples"
5 xmlns="//LHickey/D/gfx/xml/examples"
6 elementFormDefault="qualified">
7
8 <xs:simpleType name="a32Def">
9 <xs:restriction base="xs:string">
10 <xs:maxLength value="32"/>
11 </xs:restriction>
12 </xs:simpleType>
13
14
15 <xs:complexType name="aleafset">
16 <xs:sequence>
17 <xs:element name="title" type= "xs:string" />
18 <xs:element name="a32arrayelement" type="a32Def"
minOccurs="0" maxOccurs="unbounded"
nillable="true" />
19 </xs:sequence>
20 <xs:attribute name="tid" type="xs:string"
use="required" fixed="A32"/>
21 <xs:attribute name="len" type="xs:integer"
use="required" />
22 </xs:complexType>
23
24
25 <xs:simpleType name="intDefx">
26 <xs:restriction base="xs:integer">
27 </xs:restriction>
28 </xs:simpleType>
29
30 <xs:complexType name="ileafset">
31 <xs:sequence>
32 <xs:element name="title" type= "xs:string" />
33 <xs:element name="iarrayelement" type="intDefx"
minOccurs="0" maxOccurs="unbounded"
nillable="true" />
34 </xs:sequence>
35 <xs:attribute name="tid" type="xs:string"
use="required" fixed="Int"/>
36 <xs:attribute name="len" type="xs:integer"
use="required" />
37 </xs:complexType>
38
39 <xs:simpleType name="dblDefx">
40 <xs:restriction base="xs:double">
41 </xs:restriction>
42 </xs:simpleType>
43
44 <xs:complexType name="dleafset">
45 <xs:sequence>
46 <xs:element name="title" type= "xs:string" />
47 <xs:element name="darrayelement" type="dblDefx"
minOccurs="0" maxOccurs="unbounded"
nillable="true" />
48 </xs:sequence>
49 <xs:attribute name="tid" type="xs:string"
use="required" fixed="Dbl" />
50 <xs:attribute name="len" type="xs:integer"
use="required" />
51 </xs:complexType>
52
53
54 <xs:complexType name="leafdef" >
55 <xs:choice minOccurs="0">
56 <xs:element name="A32Leaf" type="aleafset"/>
57 <xs:element name="ILeaf" type="ileafset"/>
58 <xs:element name="DLeaf" type="dleafset"/>
59 </xs:choice>
60 <xs:attribute name="tid" use="required" >
61 <xs:simpleType>
62 <xs:restriction base="xs:string">
63 <xs:pattern value="A32|Int|Dbl"/>
64 </xs:restriction>
65 </xs:simpleType>
66 </xs:attribute>
67 <xs:attribute name="name" type="xs:token"
use="required" />
68
69 </xs:complexType>
70
71 <xs:element name="note" >
72 <xs:complexType>
73 <xs:sequence>
74 <xs:element name="Leaf" type="leafdef"
minOccurs="0" maxOccurs="unbounded"/>
75 </xs:sequence>
76 </xs:complexType>
77 </xs:element>
78
79 </xs:schema>
Not only am I saddled with the creation of this container element Leaf,
but I can't even find a way to make the schema check that
Leaf.tid=either A32Leaf.tid or ILeaf.tid or DLeaf.tid.
What I really want is to declare Leaf IS.A A32Leaf or ILeaf or DLeaf.tid,
not Leaf CONTAINS.A.SINGLE.INSTANCE.OF (A32Leaf|ILeaf|DLeaf) like I have now.
---
This is what I want is an xml schema that works like this,
where the tid determines the legal content to follow.
<Leaf tid="A32" name="Clawsons" ,len="4">
<title>clawsons best </title>
<a32arrayelement xsi:nil="true" />
<a32arrayelement xsi:nil="true" />
<a32arrayelement>abcdef</a32arrayelement>
<a32arrayelement>
01234567890123456789012345678912
</a32arrayelement>
</Leaf>
<Leaf tid="Int" name="Fred" ,len="4">
<title> howdy fred </title>
<iarrayelement>1</iarrayelement>
<iarrayelement>2</iarrayelement>
<iarrayelement>3</iarrayelement>
<iarrayelement xsi:nil="true"/>
</Leaf>
<Leaf tid="Dbl" name="Wilma" , len="4">
<title> howdy wilma </title>
<darrayelement>1</darrayelement>
<darrayelement>2</darrayelement>
<darrayelement>3</darrayelement>
<darrayelement xsi:nil="true"/>
</Leaf>
This is what I want as a C program
nbf.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 struct LeafDef
5 {
6 char Name[32]; * no spaces- a compact identifier for leaf*/
7 char Title[128];/*display name for the leaf. max len=128*/
8 int Len; /* length of the array U */
9 enum TidDef {A32=0,Int=1,Dbl=2} tid;
10 union LeafTypeUnion /* array is of this type */
11 {
12 char (*a32arrayelement)[32+1]; /* use with tid=A32 */
13 int *iarrayelement; /* use with tid=Int */
14 double *darrayelement; /* use with tid=Dbl */
15 } *U; /* malloc Len of these pointers */
16 };
17 /*The U(pointed to) objects pointers too so they are nillable*/
18 main(int argc,char **argv)
19 {
20 struct LeafDef *L = calloc(1,sizeof(struct LeafDef));
21 L->tid = A32;
22 strcpy(L->Name, "Clawsons");
23 strcpy(L->Title, "clawsons best");
24 L->Len = 4;
25 L->U = calloc(L->Len,sizeof(union LeafTypeUnion));
26 L->U[0].a32arrayelement = (char (*)[32+1]) 0; /* nill */
27 L->U[1].a32arrayelement = (char (*)[32+1]) 0; /* nill */
28 {
29 L->U[2].a32arrayelement = calloc(1,sizeof (char [32+1]));
30 strcpy((char *)L->U[2].a32arrayelement ,"abcdef");
31 }
32 {
33 L->U[3].a32arrayelement = calloc(1,sizeof (char [32+1]));
34 strcpy((char *)L->U[2].a32arrayelement,
"01234567890123456789012345678912");
35 }
36 }
---------------------------------------------------------------
Is there some way I can read the xml into a C++ derivative of the above C prog
and use the xml and xsd schema to automatically load a Leaf struct? I undertand
this sort of thing is possible.
IS-A , not CONTAINS-A design possible?
