Scenarios

A: Client -> interface.java -> Databinding(JAXB) -> binding.sca -> Databinding(JAXB) -> interface.java -> Service (local)
B: Client -> interface.java -> Databinding(JAXB) -> binding.sca -> Databinding(JAXB) -> interface.java -> Service (@Remotable)
C: Client -> interface.java -> Databinding(JAXB) -> Databinding(Axiom) -> binding.ws -> interface.java -> Databindng(Axiom) -> Databinding(JAXB) -> Service (@Remotable)
D: Client -> interface.wsdl -> Databinding(JAXB) -> Databinding(Axiom) -> binding.ws -> interface.wsdl -> Databindng(Axiom) -> Databinding(JAXB) -> Service (@Remotable)
E: Client -> interface.java -> Databinding(JAXB) -> Databinding(Axiom) -> binding.ws -> interface.wsdl -> Databindng(Axiom) -> Databinding(JAXB) -> Service (@Remotable)
F: Client -> interface.wsdl -> Databinding(JAXB) -> Databinding(Axiom) -> binding.ws -> interface.java -> Databindng(Axiom) -> Databinding(JAXB) -> Service (@Remotable)

Support

Data Type	A	B	C doc/lit/wrapped	C doc/lit/bare	C ?wsdl	D	E	F	Notes
PrimitiveTypes
boolean
byte
short
int
long
float
double
Standard Types
java.lang.String
java.math.BigInteger
java.math.BigDecimal
java.util.Calendar
java.util.Date
javax.xml.namespace.QName
java.net.URI
javax.xml.datatype.XMLGregorianCalendar
javax.xml.datatype.Duration
java.lang.Object
java.awt.Image
javax.activation.DataHandler
javax.xml.transform.Source									How to compare two "source" objects?
java.util.UUID
Arrays
boolean
byte
short
int
long
float
double
java.lang.String
java.math.BigInteger
java.math.BigDecimal
java.util.Calendar
java.util.Date
javax.xml.namespace.QName
java.net.URI
javax.xml.datatype.XMLGregorianCalendar
javax.xml.datatype.Duration
java.lang.Object
java.awt.Image
javax.activation.DataHandler
javax.xml.transform.Source									How to compare two "source" objects?
java.util.UUID
Collections
List<String>, ArrayList<String>
Map<String, String>, HashMap<String, String>

Polymorphic Types
Case1: Bean3 extends Bean2
Parameterized Types
TypeExplicit
TypeUnbound
TypeExtends
RecursiveTypeBound
WildcardUnbound
WildcardSuper
WildcardExtends

Variable Arguments
String...
Exceptions

The following are notes to give more detail of the scenarios and data types.

WSDL

see http://www.ibm.com/developerworks/webservices/library/ws-whichwsdl/

JAXWS2.1 describes the supported mappings and the restrictions these place on the Java interfaces.

Docuement Wrapped
Document Bare (The java method basically one in and one out parameter)
RPC

A Service

public interface HelloWorldService {
    public String getGreetings(String firstName, String lastName);
}

doc / lit / wrapped (The only one supported in Tuscany)

WSDL

    <wsdl:types>
        <schema elementFormDefault="qualified" targetNamespace="http://helloworld" xmlns="http://www.w3.org/2001/XMLSchema">
            <element name="getGreetings">
                <complexType>
                    <sequence>
                        <element name="firstName" type="xsd:string"/>
                        <element name="lastName" type="xsd:string"/>
                    </sequence>
                </complexType>
            </element>

            <element name="getGreetingsResponse">
                <complexType>
                    <sequence>
                        <element name="getGreetingsReturn" type="xsd:string"/>
                    </sequence>
                </complexType>
            </element>
            
        </schema>
    </wsdl:types>

    <wsdl:message name="getGreetingsRequest">
        <wsdl:part element="tns:getGreetings" name="parameters"/>
    </wsdl:message>

    <wsdl:message name="getGreetingsResponse">
        <wsdl:part element="tns:getGreetingsResponse" name="parameters"/>
    </wsdl:message>

    <wsdl:portType name="HelloWorld">
        <wsdl:operation name="getGreetings">
            <wsdl:input message="tns:getGreetingsRequest" name="getGreetingsRequest"/>
            <wsdl:output message="tns:getGreetingsResponse" name="getGreetingsResponse"/>
        </wsdl:operation>
    </wsdl:portType>

    <wsdl:binding name="HelloWorldSoapBinding" type="tns:HelloWorld">
        <wsdlsoap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
        <wsdl:operation name="getGreetings">
            <wsdlsoap:operation soapAction=""/>
            <wsdl:input name="getGreetingsRequest">
                <wsdlsoap:body use="literal"/>
            </wsdl:input>
            <wsdl:output name="getGreetingsResponse">
                <wsdlsoap:body use="literal"/>
            </wsdl:output>
        </wsdl:operation>
    </wsdl:binding>

SOAP

<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/">
<Body>
<ns1:getGreetingsxmlns:ns1="http://helloworld">
<ns1:firstName>fred</ns1:firstName>
<ns1:secondNameName>bloggs</ns1:secondName>
</ns1:getGreetings>
</Body>
</Envelope>

doc / lit / bare (unwrapped) wsdl

There is some support but we need to find the tests

rpc / literal

We don't support this in Tuscany

rpc / encoded

Not supported by base

Not WS-I compliant

in/out, out params & Holders

Excluded by SCA
Discussed in JAXWS

There is a JIRA http://issues.apache.org/jira/browse/TUSCANY-2332

Namespaces

What do we need to say about this?

XSD (JAXB)

Am assuming as JAXB 2.1 (6)

Java (JAXB)

Primitive Types

As JAXB 2.1 (8.5.1)

boolean
byte
short 
int 
long
float 
double

Standard Types

As JAXB 2.1 (8.5.2)

java.lang.String
java.math.BigInteger
java.math.BigDecimal
java.util.Calendar
java.util.Date
javax.xml.namespace.QName
java.net.URI
javax.xml.datatype.XMLGregorianCalendar
javax.xml.datatype.Duration 
java.lang.Object 
java.awt.Image 
javax.activation.DataHandler 
javax.xml.transform.Source 
java.util.UUID

Parameterized Types/Generics

As JAXB (8.5.3)
XSD generated using wsgen

Some beans

class Bean1<T> {
  T item;
}

  <xs:complexType name="bean1">
    <xs:sequence>
      <xs:element name="item" type="xs:anyType" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

class Bean2 {
  String name
}

  <xs:complexType name="bean2">
    <xs:sequence>
      <xs:element name="name" type="xs:string" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

class Bean3 extends Bean2{
  String address
}

class Bean4<T extends Bean2> {
  T aType;
}

class Bean5 extends Bean1<String>{
}

class Bean6<T extends Bean5<String>> {
  T aType;
}

Method with explicit type -> type

Bean1<String> someMethodTypeExplicit(Bean1<String>)


  <xs:complexType name="someMethodTypeExplicit">
    <xs:sequence>
      <xs:element name="arg0" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="someMethodTypeExplicitResponse">
    <xs:sequence>
      <xs:element name="return" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:element name="someMethodTypeExplicit" type="tns:someMethodTypeExplicit"/>

  <xs:element name="someMethodTypeExplicitResponse" type="tns:someMethodTypeExplicitResponse"/>

  <message name="someMethodTypeExplicit">
    <part name="parameters" element="tns:someMethodTypeExplicit"/>
  </message>
  <message name="someMethodTypeExplicitResponse">
    <part name="parameters" element="tns:someMethodTypeExplicitResponse"/>
  </message>

Method without type bound -> any

<T> Bean1<T> someMethodTypeUnbound(T[] anArray)

  <xs:complexType name="someMethodTypeUnbound">
    <xs:sequence>
      <xs:element name="arg0" type="xs:anyType" nillable="true" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="someMethodTypeUnboundResponse">
    <xs:sequence>
      <xs:element name="return" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:element name="someMethodTypeUnbound" type="tns:someMethodTypeUnbound"/>

  <xs:element name="someMethodTypeUnboundResponse" type="tns:someMethodTypeUnboundResponse"/>

  <message name="someMethodTypeUnbound">
    <part name="parameters" element="tns:someMethodTypeUnbound"/>
  </message>
  <message name="someMethodTypeUnboundResponse">
    <part name="parameters" element="tns:someMethodTypeUnboundResponse"/>
  </message>

Method with type extends -> type

<T extends Bean2> Bean1<T> someMethodTypeExtends(T[] anArray)

  <xs:complexType name="someMethodTypeExtends">
    <xs:sequence>
      <xs:element name="arg0" type="tns:bean2" nillable="true" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="someMethodTypeExtendsResponse">
    <xs:sequence>
      <xs:element name="return" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:element name="someMethodTypeExtends" type="tns:someMethodTypeExtends"/>

  <xs:element name="someMethodTypeExtendsResponse" type="tns:someMethodTypeExtendsResponse"/>

  <message name="someMethodTypeExtends">
    <part name="parameters" element="tns:someMethodTypeExtends"/>
  </message>
  <message name="someMethodTypeExtendsResponse">
    <part name="parameters" element="tns:someMethodTypeExtendsResponse"/>
  </message>

Method with type super -> type

NOT SURE THIS IS VALID
<T super Bean3> Bean1<T> someMethodTypeSuper(T[] anArray)

This is not a valid construct.

Type variable with recursive type extends-> type

<T extends Bean1<String>> Bean1<T> someMethodRecursiveTypeBound(T[] anArray)

  <xs:complexType name="someMethodRecursiveTypeBound">
    <xs:sequence>
      <xs:element name="arg0" type="tns:bean1" nillable="true" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="someMethodRecursiveTypeBoundResponse">
    <xs:sequence>
      <xs:element name="return" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:element name="someMethodRecursiveTypeBound" type="tns:someMethodRecursiveTypeBound"/>

  <xs:element name="someMethodRecursiveTypeBoundResponse" type="tns:someMethodRecursiveTypeBoundResponse"/>

  <message name="someMethodRecursiveTypeBound">
    <part name="parameters" element="tns:someMethodRecursiveTypeBound"/>
  </message>
  <message name="someMethodRecursiveTypeBoundResponse">
    <part name="parameters" element="tns:someMethodRecursiveTypeBoundResponse"/>
  </message>

Wildcard without bounds -> any

Bean1<?> someMethodWildcardUnbound(Bean1<?>)

  <xs:complexType name="someMethodWildcardUnbound">
    <xs:sequence>
      <xs:element name="arg0" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="someMethodWildcardUnboundResponse">
    <xs:sequence>
      <xs:element name="return" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:element name="someMethodWildcardUnbound" type="tns:someMethodWildcardUnbound"/>

  <xs:element name="someMethodWildcardUnboundResponse" type="tns:someMethodWildcardUnboundResponse"/>

  <message name="someMethodWildcardUnbound">
    <part name="parameters" element="tns:someMethodWildcardUnbound"/>
  </message>
  <message name="someMethodWildcardUnboundResponse">
    <part name="parameters" element="tns:someMethodWildcardUnboundResponse"/>
  </message>

Wildcard with super type -> any

Bean1<? super Bean3> someMethodWildcardSuper(Bean1<? super Bean3>)

  <xs:complexType name="someMethodWildcardSuper">
    <xs:sequence>
      <xs:element name="arg0" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="someMethodWildcardSuperResponse">
    <xs:sequence>
      <xs:element name="return" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:element name="someMethodWildcardSuper" type="tns:someMethodWildcardSuper"/>

  <xs:element name="someMethodWildcardSuperResponse" type="tns:someMethodWildcardSuperResponse"/>

  <message name="someMethodWildcardSuper">
    <part name="parameters" element="tns:someMethodWildcardSuper"/>
  </message>
  <message name="someMethodWildcardSuperResponse">
    <part name="parameters" element="tns:someMethodWildcardSuperResponse"/>
  </message>

Wildcard with extends type -> type

Bean1<? extends Bean2> someMethodWildcardExtends(Bean1<? extends Bean2>)

  <xs:complexType name="someMethodWildcardExtends">
    <xs:sequence>
      <xs:element name="arg0" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="someMethodWildcardExtendsResponse">
    <xs:sequence>
      <xs:element name="return" type="tns:bean1" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:element name="someMethodWildcardExtends" type="tns:someMethodWildcardExtends"/>

  <xs:element name="someMethodWildcardExtendsResponse" type="tns:someMethodWildcardExtendsResponse"/>

  <message name="someMethodWildcardExtends">
    <part name="parameters" element="tns:someMethodWildcardExtends"/>
  </message>
  <message name="someMethodWildcardExtendsResponse">
    <part name="parameters" element="tns:someMethodWildcardExtendsResponse"/>
  </message>

Collections

As JAXB 2.1 (8.5.4)

java.util.Map and its subtypes

HashMap<String, Bean> someMethod(HashMap<String, Bean> aList)

java.util.Collection and its subtypes

List<String> someMethod(List<String> aList)

Arrays

String[] someMethod (String[], String[])
Bean1[1] someMethod(Bean1[], Bean1[])

Java Bean Indexed properties (effectively arrays)

Polymorphic Types

xsi:type

Case 1:

class Bean2 {
}

class Bean3 extends Bean2 {
}

Bean2 someMethod(Bean2)

ref.someMethod(Bean3)

Variable Arguments

String someMethod(String... params)

Tuscany

TODO - Add some details of which bits of tuscany do what w.r.t databindings, mappings and transformations in typical scenarios, e.g.

    <component name="HelloWorldClientComponent">
        <implementation.java class="helloworld.HelloWorldClientImpl" />
	 <reference name="helloWorldService">
	        <interface.wsdl interface="http://helloworld#wsdl.interface(HelloWorld)" />
	        <binding.ws uri="http://localhost:8085/HelloWorldService"/>
	 </reference>
    </component>

    <component name="HelloWorldServiceComponent">
        <implementation.java class="helloworld.HelloWorldImpl" />
	 <service name="HelloWorldService">
	        <interface.wsdl interface="http://helloworld#wsdl.interface(HelloWorld)" />
	        <binding.ws uri="http://localhost:8085/HelloWorldService"/>
	 </service>
    </component>

Where all the conversions and mapping happen.

databinding mapping - Creates in memory models of the WSDL interfaces and the java introspected component types.
interface contract mapper - Checks compatibility of
- interfaces with component types
- references with services

	 
            <service name="HelloWorldService">
	        <interface.java ...

Would lead to a java2wsdl mapping -

1 Specs

SCA
JAXWS
JAXB
WS-I
WSDL
?

Child pages

Databinding Scope

Scenarios

Support

WSDL

A Service

doc / lit / wrapped (The only one supported in Tuscany)

doc / lit / bare (unwrapped) wsdl

rpc / literal

rpc / encoded

in/out, out params & Holders

Namespaces

XSD (JAXB)

Java (JAXB)

Primitive Types

Standard Types

Parameterized Types/Generics

Some beans

Method with explicit type -> type

Method without type bound -> any

Method with type extends -> type

Method with type super -> type

Type variable with recursive type extends-> type

Wildcard without bounds -> any

Wildcard with super type -> any

Wildcard with extends type -> type

Collections

Polymorphic Types

Variable Arguments

Tuscany