xml-dev - RE: XML Schemas: Best Practices

[johns@syscore.com (John F. Schlesinger)]

Caroline wrote:
"The way in which I saw it was that a 'class' would indeed by
analogous to the 'type' definition..."

The FpML Architecture
(http://www.fpml.org/spec/2000/tr-fpml-arch-1-0-2000-09-25/index.html - you
have to register) from September of this year in its content model has a
fairly thorough set of guidelines for taking the elements of a UML Class
diagram and representing them in XML - they include aggregation, subtypes,
classes, association and aggregation of subtypes.

Yours,
John F Schlesinger
SysCore Solutions
212 619 5200 x 219
917 886 5895 Mobile

-----Original Message-----
From: Caroline Clewlow [mailto:cclewlow@eris.dera.gov.uk]
Sent: Thursday, October 12, 2000 6:24 AM
To: xml-dev@lists.xml.org
Subject: Re: XML Schemas: Best Practices


I would agree with making this analogy to object-oriented
programming.
I had a similar idea.
The way in which I saw it was that a 'class' would indeed by
analogous
to the 'type' definition, and the object that is the instantiation of
the class would reflect the 'element' based on that 'type'.
I also saw the use of 'ref' as being similar to the use of a
'pointer'
variable in programming.  i.e. when would you use an object instance
and when would you use a pointer to an object ?

If you created a schema that contained elements which would only ever
be used as children of elements in a seperate schema, these could be
declared as types, and the 'instance' of the type created in the
accompanying schema.

I hope the above makes at least some sense ;-)

Caroline Clewlow
DERA, UK

--- In xml-dev@egroups.com, Caroline Weller <caroline.weller@a...>
wrote:
>
>
> Caveat: I have not spent much time looking at XMLSchema yet.
>
>  I do agree with the use of type:
> user defined types of data that are used to define many elements
that have
> different purposes.
> The handling of those different elements might be different.
>
> An analogy from another area would be in object-oriented
programming:
> "When would you just instanciate a class (the element being the
class),
> and when would you create a subclass (the type being the parent
class)"
>
> Do people think this analogy is useful?
>
> PS: love the spelling of Sydney, or maybe he meant the height of a
guy called
> Sidney?
> :> being from Canberra, I found that quite amusing......
>
>
> Caroline Weller
> Australian Bureau of Statistics.
>
>
>
> |--------+----------------------->
> |        |          "Roger L.    |
> |        |          Costello"    |
> |        |          <costello@mit|
> |        |          re.org>      |
> |        |                       |
> |        |          11/10/2000   |
> |        |          09:42 PM     |
> |        |                       |
> |--------+----------------------->
>   >-----------------------------------------------------------|
>   |                                                           |
>   |       To:     xml-dev@l..., "Ripley,Michael W."  |
>   |       <rip@m...>                                     |
>   |       cc:     costello@m..., "Cokus,Michael S."      |
>   |       <msc@m...>, "Pulvermacher,Mary K."             |
>   |       <pulver@m...>, "Heller,Mark J."                |
>   |       <heller@m...>, JohnSc@c..., (bcc:     |
>   |       Caroline Weller/Staff/ABS)                          |
>   |       Subject:     Re: XML Schemas: Best Practices        |
>   >-----------------------------------------------------------|
>
>
>
> [Here's a response that I received directly.  Any comments on it?]
>
> >"When should an item be declared as an element versus when should
an
> >item be declared as a type?"
>
> I think it's a matter of style.  As you showed in your examples, you
> can basically get done what needs to get done with either method.
>
> My take on the style would be:
>
> - use an element when all components of the element declaration
will
be
> reused and semantically the reuse will mean the same thing
(Elevation,
> BostonElevation, FrankfurtElevation, SidneyElevation, etc.)
>
> - use a type when the type definition will be reused for
semantically
> different elements (e.g., a 'money' type definition that is reused
for
> elements UnitPrice, Subtotal, ShippingAndHandling, Total, etc.).