Re: [sca-assembly] [ASSEMBLY 127] Need definition of compatible forproperty types - Updated Proposal

Folks,

Response to the comments themselves
is inline as <mje> </mje>

Following the comments made, here is
an updated proposal to resolve Issue 127:

Add a new subsection following section "4.4 Property":

4.4.1 Property Type Compatibility 

There are a number of situations where the declared type of a property
element is matched with the declared type of 

another property element. These situations include:

o Where a component <property/> sets a value for a property of an
implementation, as declared in the componentType of the implementation

o Where a component <property/> gets its value from the value of
a composite <property/> by means of its @source attribute. This situation

can also involve the @source attribute referencing
a subelement of the composite <property/> value, in which case it
is the type of the

subelement which must be matched with the type
of the component <property/>

o Where the componentType of a composite used as an implementation is calculated
and componentType <property/> elements are 

created for each composite <property/> 

In these cases, the types declared for the two <property/> elements
MUST be compatible. [ASM50038] 

Two property types are compatible if they have the same XSD type (where
declared as XSD types) or the same XSD global element 

(where declared as XSD global elements). For cases where the type of a
property is declared using a different type system (eg Java), then the

type of the property is mapped to XSD using the mapping rules defined by
the appropriate implementation type specification 

-----------------------------------------------------------

Add the following in section 4.4 following
line 1039:

The meaning of "compatible"
for property types is defined in Section 4.4.1 Property
Type Compatibility 

-----------------------------------------------------------------------------------------

Yours,  Mike.

Strategist - Emerging Technologies, SCA & SDO.

Co Chair OASIS SCA Assembly TC.

IBM Hursley Park, Mail Point 146, Winchester, SO21 2JN, Great Britain.

Phone & FAX: +44-1962-818014    Mobile: +44-7802-467431  

Email:  

From:
David Booz <>

To:


Date:
21/04/2009 14:17

Subject:
Re: [sca-assembly] [ASSEMBLY 127] Need
definition of compatible for property types - Proposal

I'm in general agreement with the proposal, with the following
comments:

1) specifying a type on a component property element is optional, an aspect
which I think needs to be folded into the resolution. That is, I don't
think we are trying to assert that in the absence of a type specification
on a component property, the runtime would try to ascertain the type of
the property from the value and check for compatibility with the type of
the underlying componentType property.

<mje> ASM50036 already catches the
process for establishing the type for a <component/> <property/>
element with no type declared explicitly.

I don't think it is necessary to repeat this
in the resolution to this issue </mje>

2) Editorial wording:

(a) "There are a number of places where the declared type of a property
element must be matched... "

- Can we find a better word than places? situations? 

- lower case 'must' needs to be corrected.

(b) "Compatible here means that the two types have to be the same
XSD type ... "

- can we reword as: Two property types are compatible when they are the
same XSD type ...

- Is "same XSD type" sufficiently precise? Surely we mean same
complex or simple type (or same global element) in the same namespace.

<mje>

I think that "same XSD type" is
precise enough and covers both complex and simple types.  Global elements
are picked out

separately since I think they are a different
case.

</mje>

3) ASM50036 uses the term compatible referring to property types. I think
that statement needs to be updated to refer to the new def'n of compatible
that is in this proposal.

<mje> I added an explanatory sentence
after the normative one </mje>

Dave Booz

STSM, BPM and SCA Architecture

Co-Chair OASIS SCA-Policy TC and SCA-J TC

"Distributed objects first, then world hunger"

Poughkeepsie, NY (845)-435-6093 or 8-295-6093

e-mail:

Mike
Edwards ---04/20/2009 01:48:00 AM---Discussion: We discussed this a bit
on the last Assembly call, but I'll try to

From:

Mike Edwards <>

To:

"OASIS Assembly" <>

Date:

04/20/2009 01:48 AM

Subject:

[sca-assembly] [ASSEMBLY 127] Need definition of compatible for property
types - Proposal

Discussion: 

We discussed this a bit on the last Assembly call, but I'll try to summarize
it here. 

We could choose to define "compatible property types" in a similar
way that we define "compatible interfaces" and

this could lead us to define "compatible superset" and "compatible
subset" for property types. 

However, for property types this seems pretty heavy.

A simpler approach is to say that the property types of two SCDL elements
must be "compatible", pure and simple, 

where in XSD terms this means that they have the same XSD type. Where one
type is declared using a language 

other than XSD, say Java, then the appropriate C&I spec must define
the mapping rules of that type to XSD. So, for 

Java this might be the JAXB rules. 

So this would then apply to all cases where pairs of SCDL elements deal
with property types: 

<component/> <property/> and <componentType/> <property/>

<composite/> <property/> and <component/> <property/>
(@source attribute) 

<componentType/> <property/> and <composite/> <property/>
(when computing the componentType of a composite) 

Proposal: 

Add a new subsection following section "4.4 Property":

4.4.1 Property Type Compatibility 

There are a number of places where the declared type of a property element
must be matched with the declared type of 

another property element. These places include: 

o Where a component <property/> sets a value for a property of an
implementation, as declared in the componentType of the implementation

o Where a component <property/> gets is value from the value of a
composite <property/> by means of its @source attribute

o Where the componentType of a composite used as an implementation is calculated
and componentType <property/> elements are 

created for each composite <property/> 

In these cases, the types declared for the two <property/> elements
MUST be compatible. [ASM50038] 

Compatible here means that the two types have to be the same XSD type (where
declared as XSD types) or the same XSD global element 

(where declared as XSD global elements). For cases where the type of a
property is declared using a different type system (eg Java), then the

type of the property is mapped to XSD using the mapping rules defined by
the appropriate implementation type specification 

Yours, Mike.

Strategist - Emerging Technologies, SCA & SDO.

Co Chair OASIS SCA Assembly TC.

IBM Hursley Park, Mail Point 146, Winchester, SO21 2JN, Great Britain.

Phone & FAX: +44-1962-818014 Mobile: +44-7802-467431 

Email: 

Unless stated otherwise above:

IBM United Kingdom Limited - Registered in England and Wales with number
741598. 

Registered office: PO Box 41, North Harbour, Portsmouth, Hampshire PO6
3AU 

Unless stated otherwise above:

IBM United Kingdom Limited - Registered in England and Wales with number
741598. 

Registered office: PO Box 41, North Harbour, Portsmouth, Hampshire PO6
3AU