Copyright ©© 2007 W3C 2006®
(MIT, ERCIM,
Keio), All Rights Reserved. W3C
liability,
trademark
and document use rules apply.®
Web Services Description Language (WSDL) provides a model and an XML format for describing Web services. This document describes a representation of that model in the Resource Description Language (RDF) and in the Web Ontology Language (OWL), and a mapping procedure for transforming particular WSDL descriptions into their RDF form.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This is the W3C
LastWorking Draft of Web Services Description Language (WSDL) Version
2.0: RDF Mapping, produced by the Web Services Description
Working Group, as part of the W3C Web Services
Activity.Call
Once all the comments and issues about this document will have been addressed, the Working Group intends to publish a final version of this document as a W3C Working Group Note.
This version contains the complete RDF mapping for WSDL2.0,includingformalmappingWSDL 2.0. A diff-marked version against the previous version of
this document is available.tables.
Comments on this specification are to be sent to the public public-ws-desc-comments@w3.org
mailing list (public
archive )until17July2006,andarerecordedinthelastcallissueslist)..
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document wasis governed by producedagroupoperatingthe 24
January 2002 CPP as amended by the W3C Patent Policy
Transition Procedure. W3C maintains a public list of any patent
disclosures made in connection with the deliverables of the group;
that page also includes instructions for disclosing a patent. An
individual who has actual knowledge of a patent which the individual
believes contains Essential
Claim(s) must disclose the information in accordance with section
6 of the W3C Patent Policy. under
1. Introduction
1.1 Naming and Notation Conventions
1.2 Organization of this specification
2. WSDL Ontology
2.1 Core WSDL Components
2.1.1 Description component
2.1.2 Interface classes
2.1.3 Binding classes
2.1.4 Service classes
2.2 Handling Documentation,Features,PropertiesandExtensions Generic 2.2.1and Featuresproperties 2.2.2GenericDocumentationextensions
2.3 Message Exchange Patterns
2.4 Predefined Extensions
2.5 Operation Styles
2.6 SOAP Binding
2.7 HTTP Binding
3. Example WSDL document in RDF form
4. Differences from the WSDL Component Model
4.1 Component naming
4.2 Documents, imports and includes
4.3 Component references
4.4 Representing properties with classes
4.5 Other WSDL restrictions not enforced by the
ontology
5. References
Web Services Description Language is defined in XML, because XML is thea
common format for exchange of structured information. standardTheuseofXMLbringsbetterinteroperabilityWSDL generators and
toparsers benefit of the wide availability of XML processing libraries, and the
use of XML Schema makes the structure of WSDL well constrained, yet extensible.
On the other hand, XML parsers,in general vocabulariesdon'thaveclearcompositiondoes not provide generic rules for composing
different vocabularies,
so combining for example the WSDL description of a Web service, the service's
policies and other information (presumably expressed in XML) can be done in
many significantly different ways (e.g. extending WSDL, extending the policy
language, creating a special XML container for all the information etc.), and
little interoperability can be expected when such combined documents are
used.rules,
For example, a policy can be combined with WSDL by adding the policy
elements in WSDL service element. Equally, a WSDL description can be combined
with a policy by adding the WSDL description as part of the policy. While the
results should be similar (WSDL with policy information), they are in fact very different for the
processing software, and a policy in WSDL cannot easily be used by software
that does not know WSDL.doesn't
In contrast, the Semantic web allows knowledge from many different
sources to be easily combined so that unexpected data connections can be
used. For this purpose there is the Resource Description Framework (RDF),
whose graph requiresstructure, together with the use of URIs for identifying nodes
makes it very easy for different documents to be brought together. If structuresome WSDL
document describes a Web service, a policy document attaches
constraints to the service and a general description specifies the author of
the service, all this information can be merged and the resulting document
will contain all athree kinds of information associated with the single
service.the
The main objective of this specification is to present a standard RDF ([RDF]) and OWL ([OWL])
vocabulary to express WSDL 2.0, so that WSDL 2.0 documents can be
transformed into RDF and merged with other Semantic Web data.equivalent
Note: the readers of this document are expected to have an understanding of
the WSDL language and the WSDL component model (see [WSDL 2.0 Core Language]); this document is
not a standalone specification of the WSDL ontology, independent of
WSDL specification. Further, the readers are expected to have good knowledge
of RDF and at least basic knowledge of OWL.model;
The ontology presented in this specification isbaseddescribes concepts introduced in WSDL 2.0 (see [WSDL 2.0 Core Language] and [WSDL 2.0
Adjuncts]), from where we adopt the names for the ontology classes, properties and
distinguished instances.on
In WSDL 2.0, components and their properties are named with words
separated with spaces, for example Interface Operation component with
{message exchange pattern} property. In this document, we
write all WSDL 2.0 components and properties in italic. In the WSDL
ontology, we use the so-called camelCase, with upper-case first letter
for class names (InterfaceOperation
) and lower-case first letter for
properties (messageExchangePattern
). We write all the WSDL ontology
identifiers in monospace
.
The above naming transformation (remove spaces, use camelCase) is used for
the majority of components and their properties modeled in our ontology, with
several exception indicated in the text in this specification. One recurring
exception is that the multivalued properties (like Interface.{interface
operations}) are not modeled as a single plural property (say
interfaceOperations
) but instead as a singular property to be used
multiple times (i.e. interfaceOperation
in our case), as the order
of the values is irrelevant in WSDL.
In the mapping tables below, we use a simple triple syntax, each
triple on one line. Variables to be filled in (like generated IDs and
property values) are in angle brackets, for example <id> generally
means the ID of the current component. Literal values are in double quotes,
optionally indicating the data type after double caret, for example
"<code>"^^xs:int for HTTP status codes. The default data type is
xs:string. Finally, comments are in parentheses and italic (like
this).fairly
This specification uses predefined namespace prefixes throughout; they are given in the following list. Note that the choice of any namespace prefix is arbitrary and not semantically significant (see [XML Namespaces]).
The remainder of this specification is split into three sections and an appendix:
This section describes the OWL ontology for WSDL, comparing it to the WSDL
component model defined in [WSDL 2.0 Core
Language] and [WSDL 2.0
Adjuncts]. The text in this section aims to be a comprehensive explanation of
the mapping, and the formal normative mappings are specified in the mapping
tables at the end of each subsection. Note that the URIs defined by the
WSDL 2.0 specification (binding types,
operation styles, message exchange patterns etc.) verbosedefinedbytheWSDL 2.0are not repeated in the mapping tables.specification
This section also touches briefly mayon some differences between the OWL
ontology and the component model, but for the full account touchandof these differences and
for the rationales see section
4.rationales
The RDF mapping for the core WSDL components defined in [WSDL 2.0 Core Language] is described in section 2.1.
AllWSDL components are extensible, so section 2.2
describes how extensions are mapped to RDF. The
following sections, from 2.3 to these2.7, describe the mapping for
the various adjuncts specified in [WSDL 2.0
Adjuncts].2.7,
AllThe main components of WSDL are represented as classes in the WSDL
ontology: theDescription
, Interface
,
Binding
and Service
, as described in the following
subsections. This means that every interface, binding and service described
by WSDL will be mapped to a single instance in the RDF representation,linkedfromtheinstancemappedfromthetop-levelDescriptionrepresentation.component.
The top-level WSDL component — description — is mapped to a
single instance of the class Description
, which uses the
properties interface
, binding
and service
to point to its
constituents, i.e. all the interfaces, bindings and services. Note that since we
contents,do not model element declarations and type definitions further than just the
QNames, we don'talsodo not reference them from the don'tDescription
instance. This also means that while all WSDL component models implicitly
contain all XML Schema simple type definitions, the RDF mapping does not show
them.
NotethatA mapping of a single WSDL document (together with any imports or
includes) will always result in a single instance of the
aDescription
class. However, there can be multiple individuals of
the class Description
in a knowledge base that contains the
information from multiple WSDL documents. The core WSDL specification does not
consider the case of combining multiple independent WSDL documents and it
does not mandate that independent documents doesn'tconsistently describe components
with the same name. This is, however, an assumption when combining describemultipleWSDLdocumentsthe
RDF inrepresentation of multiple WSDL documents. See more on this point in section 4.2.representation.
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:Description . |
|
{interfaces} | (for interface mapping see Table 2-3) |
{bindings} | (for binding mapping see Table 2-8) |
{services} | (for service mapping see Table 2-13) |
{type definitions} | (not mapped) |
{element declarations} | (not mapped) |
RDF Form |
---|
(genId is a newly generated unique URI) <genId> rdf:type wsdl:QName . <genId> wsdl:localName "<localName>" . <genId> wsdl:namespace <namespace> . |
All WSDL interface components are represented in RDF as instances of the
interfacesInterface
class. WSDL interfaces can extend other WSDL interfaces,
which is indicated by the property extends
. Interfaces may
have operations and faults, represented as instances of the
InterfaceOperation
and InterfaceFault
classes, and
each pointed to with the properties classesinterfaceOperation
and
interfaceFault
, respectively.
There are a number of properties applicable to
InterfaceOperation
instances (corresponding to the properties of the WSDL Interface Operation component):instances:
messageExchangePattern
property points to an instance of
the class MessageExchangePattern
and thus indicates the
message exchange pattern (MEP) used by this operation; there can be only one
MEP on one operationoperationStyle
property points to an instance of the class
OperationStyle
and indicates that the operation adheres to the
given style; there can be multiple operation styles on a single
operationinterfaceMessageReference
and
interfaceFaultReference
properties point to instances of
InterfaceMessageReference
and
InterfaceFaultReference
classes Instances of InterfaceMessageReference
and
can indicate
their direction — input message references and input fault references
all belong to the class interfacefaultInterfaceFaultReferencereferencesInputMessage
and output message
references and output fault references all belong to the class
OutputMessage
. Further, both message references and fault
references indicate the appropriate message labels (instances of
MessageLabel
, representing particular messages in the
operation's MEP) using the property messageLabel
. (In section 2.3 we describe how message exchange patterns are
modeled in our RDF mapping.)
Furthermore, interfacemessageinstances of referencesInterfaceMessageReference
and of InterfaceFault
point to element declarations (as
QName
instances)
using the property elementDeclaration
and
specify their message content model with the property theymessageContentModel
, indicating one of the four
possible instances of the class MessageContentModel
. And finallyinterfacefaultfinally, instances of referencesInterfaceFaultReference
refer to their interface faults directly using the property
interfaceFault
.
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:Interface . <parentDescriptionId> wsdl:interface <id> . |
|
{extended interfaces} | (for each Interface component) <id> wsdl:extends <anotherInterfaceId> . |
{interface operations} | (for interface operation mapping see Table 2-4) |
{interface faults} | (for interface fault mapping see Table 2-5) |
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:InterfaceOperation . <parentInterfaceId> wsdl:interfaceOperation <id> . |
|
{interface message references} | (for interface message reference mapping see Table 2-6) |
{interface fault reference} | (for interface fault reference mapping see Table 2-7) |
{message exchange pattern} | <id> wsdl:messageExchangePattern <pattern> . |
{style} | (for each style URI) <id> wsdl:operationStyle <style> . |
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:InterfaceFault . <parentInterfaceId> wsdl:interfaceFault <id> . |
|
{element declaration} | <id> wsdl:elementDeclaration <qname> . (for qname mapping see Table 2-2) |
{message content model} | (for "#any") <id> wsdl:messageContentModel wsdl:AnyContent . (for "#none") <id> wsdl:messageContentModel wsdl:NoContent . (for "#other") <id> wsdl:messageContentModel wsdl:OtherContent . (for "#element") <id> wsdl:messageContentModel wsdl:ElementContent . |
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:InterfaceMessageReference . <parentInterfaceOpId> wsdl:interfaceMessageReference <id> . |
|
{element declaration} | <id> wsdl:elementDeclaration <qname> . (for qname mapping see Table 2-2) |
{direction} | (for "in") <id> rdf:type wsdl:InputMessage . (for "out") <id> rdf:type wsdl:OutputMessage . |
{message content model} | (for "#any") <id> wsdl:messageContentModel wsdl:AnyContent . (for "#none") <id> wsdl:messageContentModel wsdl:NoContent . (for "#other") <id> wsdl:messageContentModel wsdl:OtherContent . (for "#element") <id> wsdl:messageContentModel wsdl:ElementContent . |
{message label} | <id> wsdl:messageLabel <label> . (label as defined by the message exchange pattern's mapping to RDF, see section 2.3) |
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:InterfaceFaultReference . <parentInterfaceOpId> wsdl:interfaceFaultReference <id> . |
|
{interface fault} | <id> wsdl:interfaceFault <faultId> . (for interface fault mapping see Table 2-5) |
{direction} | (for "in") <id> rdf:type wsdl:InputMessage . (for "out") <id> rdf:type wsdl:OutputMessage . |
{message label} | <id> wsdl:messageLabel <label> . (label as defined by the message exchange pattern's mapping to RDF, see section 2.3) |
WSDL binding components are represented in RDF as instances of the class
bindingsBinding
. To indicate a particular interface for which binding
information is specified with this WSDL binding, the particular
Interface
instance is pointed to using the property
binds
. Binding types (for example SOAP binding or HTTP
binding, as specified in [WSDL 2.0 Adjuncts]) are themselves
classes in RDF, so a binding type is indicated by belonging to the
appropriate class (using the property rdf:type
).
As the structure of bindings follows the structure of interfaces, we
represent binding operations and faults using the classes
BindingOperation
and BindingFault
respectively. The
points to them using the similarly named properties
parentBindingbindingbindingOperation
and bindingFault
. Binding
operations further contain message and fault references, represented as
instances of the classes BindingMessageReference
and
BindingFaultReference
, and pointed to by the properties
bindingMessageReference
and
bindingFaultReference
.
Within this structure, each component points to the appropriate component
from the interface structure, i.e.
instances point to bindingBindingOperationoperations
instances,
interfaceoperations,bindingfaultsInterfaceOperationrespectivelyBindingFault
instances point to
instances and interfaceInterfaceFaultfaults
and bindingBindingMessageReferencemessage
instances point to faultBindingFaultReferencereferences
and interfaceInterfaceMessageReferencemessage
instances.
To provide these pointers, we use the property faultInterfaceFaultReferencereferences.binds
between the
pairs of components.
Finally, each component is supposed to contain extensions that provide the actual binding information. For the description of handling such extensions see section 2.2 and for the specific bindings included in WSDL 2.0 specification, see sections 2.6 and 2.7.
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:Binding . <parentDescriptionId> wsdl:binding <id> . |
|
{interface} | <id> wsdl:binds <interfaceId> . |
{type} | <id> rdf:type <type> . |
{binding operations} | (for binding operation mapping see Table 2-9) |
{binding faults} | (for binding fault mapping see Table 2-10) |
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:BindingOperation . <parentBindingId> wsdl:bindingOperation <id> . |
|
{interface operation} | <id> wsdl:binds <interfaceOpId> . |
{binding message references} | (for binding message reference mapping see Table 2-11) |
{binding fault references} | (for binding fault reference mapping see Table 2-12) |
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:BindingFault . <parentBindingId> wsdl:bindingFault <id> . |
|
{interface fault} | <id> wsdl:binds <interfaceFaultId> . |
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:BindingMessageReference . <parentBindingOperationId> wsdl:bindingMessageReference <id> . |
|
{interface message reference} | <id> wsdl:binds <interfaceMessageReferenceId> . |
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:BindingFaultReference . <parentBindingOperationId> wsdl:bindingFaultReference <id> . |
|
{interface fault reference} | <id> wsdl:binds <interfaceFaultReferenceId> . |
WSDL services are represented in RDF as instances of the class
Service
. Each instance mustpoints to a single interface; for
this purpose we reuse the property pointimplements
. Also, each service
has one or more endpoints, to which it points using the property
endpoint
.
Endpoints are represented as instances of the class Endpoint
,
with two notable properties: a mandatory single usesBinding
property points to
the binding used by this endpoint, and an optional single address
points to the network resource which actually offers the service.
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:Service . <parentDescriptionId> wsdl:service <id> . |
|
{interface} | <id> wsdl:implements <interfaceId> . |
{endpoints} | (for endpoint mapping see Table 2-14) |
Property | RDF Form |
---|---|
(id generated per IRI-References for <id> rdf:type wsdl:Endpoint . <parentServiceId> wsdl:endpoint <id> . |
|
{binding} | <id> wsdl:usesBinding <bindingId> . |
{address} | <id> wsdl:address <address> . |
In order to enable evolution and reusability of the language, WSDL 2.0
allows extensions on all components. In fact, there are two types of
extensibility in WSDL 2.0: explicit extension points, multipleabstractand featuresproperties,andXML-based
extensions.generic
Extension points are those places in WSDL where a number of options is
defined by the WSDL 2.0 specification, but the list is open. For example,
interface operations follow message exchange patterns (MEPs), and while
WSDL 2.0 provides alistofsome predefined MEPs, new ones can be specified by WSDL 2.0 users.
Similarly, WSDL 2.0 specifies two bindings (SOAP and HTTP), but more bindings
are expected to be specified in the future, either by the WS-Description
Working Group or by any interested third parties. Often, extension points use
URIs to refer to the various options, eightbutand these URIs are then reflected in
the RDF form as the appropriate property values. Additionally, some of the
extensions also introduce data that manyneedswould be touseful in the RDF
representation, in which case it is the responsibility of the extension
designers to describe their mappings to RDF. modeledFeaturesandpropertiesrepresentabstractThis document describes the
mapping of piecesfunctionalityandtheirrun-timeparameters.Mostly,featuresandpropertiessimplyuseURIstoidentifytheirsemantics,andthiseasilytranslatesintoRDF,asdescribedbelowinsection2.2.1the extensions defined together with the WSDL 2.0 specification.
.
Apart from the envisioned extensibility pointsandtheabstractfunctionalityextensibilityusingpoints, WSDL 2.0 allows the XML WSDL
documents to contain any "foreign" elements and attributes, so that
features,any extensions, even ones that change the core WSDL semantics, can
also be realized.
unexpectedMappingThe actual meaning of general WSDL extensions suchtoRDFisdescribedinsection2.2.2.Inis, by definition, unknown to the
additionextensions,core WSDL allXMLelementscancontaindocumentation.Suchdocumentationcanconsistofhuman-readabletextormachine-processiblespecification, and elementsattributes,it butisn'tmodeledinmoredetailinWSDL2.0.Thereforeis equally unknown to the RDF mapping inwerepresentdocumentationasXMLliteralsthat(apart
from the containwsdl:documentationelementandallitschildren.Theliteralispredefined extensions coming with WSDL 2.0, whose mapping to
attachedtheappropriateRDF is described in the componentRDFrepresentationusingthepropertydocumentation.Table2-15. MappingDocumentationtoRDFXMLFormRDFForm<wsdl:...> <wsdl:documentation ...> ... </wsdl:documentation></wsdl:...><parentComponentId> wsdl:documentation "<wsdl:documentation ...> ... </wsdl:documentation>"^^rdf:XMLLiteral(notethatthewhitespaceinsidetheXMLliteralaboveiscopiedfromtheXML)2.2.1FeaturesandpropertiesEveryfeaturecomponentismappedtoRDFasaninstanceoftheclassFeature.Thisinstanceisidentifiedbythefeature'sIRI,i.e.thevalueofthe{ref}propertyoftheFeaturecomponent.Featurescanberequiredoroptional.InRDF,thisisindicatedbythepropertythatpointsfromthefeature'sparentcomponenttothefeature—itiseithertherequiresFeatureortheoffersFeatureproperty.PropertycomponentsinWSDL 2.0servetospecifyorconstrainthevaluethatapropertycanhaveatruntime.AsoneofthefewnamingdifferencesbetweentheRDFrepresentationandtheWSDL 2.0componentmodel,thepropertycomponentsarerepresentedasinstancesoftheclassPropertyValue,pointedtofromtheproperty'sparentcomponentusingthepropertyValueRDFproperty.EveryPropertyValueinstancepointstotheactualpropertywhosevalueitspecifies,usingtheRDFpropertynamedproperty.PropertyValueinstancesalsoeitherspecifytheactualvalueoftheproperty(usingtheRDFpropertypropertyActualValue)ortheyconstrainthepossiblevaluesofthepropertyusingatypedefinitionidentifiedbyitsQName(referencedfromthePropertyValueinstancebytheRDFpropertypropertyValueType).Table2-16. MappingFeatureComponentstoRDFPropertyRDFForm{ref}<ref>rdf:typewsdl:Feature{required}(forrequired)<parentComponentId>wsdl:requiresFeature<ref>(fornotrequired)<parentComponentId>wsdl:offersFeature<ref>Table2-17. MappingPropertyComponentstoRDFPropertyRDFForm (idgeneratedperIRI-ReferencesforWSDL2.0Components)<id>rdf:typewsdl:PropertyValue<parentComponentId>wsdl:propertyValue<id>{ref}<id>wsdl:property<ref>{value}<id>wsdl:propertyActualValue"<value>"^^rdf:XMLLiteral(thevalueisanxmlliteralwithouttheenclosing<wsdl:value>element){valueconstraint}<id>wsdl:propertyValueType<qname>(forqnamemappingseeTable2-2)2.2.2GenericextensionsTheactualmeaningofgeneralextensionsis,bydefinition,unknowntotheWSDLspecification,anditisequallyunknowntotheRDFfollowing sections). Therefore
every extension should specify how it is mapped to RDF. For example, the SOAP
and HTTP bindings in WSDL 2.0 add many properties to the core binding
components and this document defines how these particular properties are
expressed in RDF. The mapping of WSDL extensions to RDF therefore depends on the
understanding of those extensions.mapping.
ThissectiondescribeshowunknownextensionsarehandledwhenmappingaWSDLdocumentintoIn WSDL 2.0, extensions can be marked as mandatory (or required).
Such extensions may alter the semantics of the extended components in ways
that invalidate the existing semantics. Since the RDF representation of WSDL
intends to represent the semantics of the WSDL data, components with required
extensions RDF.will be mapped to RDF according to the rules of the extension, not
according to the rules specified in this document. If a processor that does
the mapping of a WSDL document to RDF does not understand a particular
mandatory extension (in other words, when it encounters an unknown
mandatory extension, it mustmustcannot map the component that contains that extension
into any generic RDF representation, in other words the component will not be
present in the resulting RDF data. This is to avoid confusing processors that
notdo not understand a mandatory extension — RDF encourages the principle
of ignoring the unknown parts of an RDF graph (partial understanding) and
there is no agreed mechanism of marking some parts as mandatory, therefore if
we decided to map the known WSDL according to our rules don'tandabove, the potential
changes introduced by the mandatory unknown extensions addinthegraph,could be ignored by
some RDF processors, theyviolatingthemandatoriness.Finallyunknownoptionalextensions(notmandatory)canberepresentedintheRDFrepresentationusingthepropertiesextensionElementandextensionAttribute.ExtensionelementsarerepresentedasXMLliteralscontainingthewholeextensionXMLelements(andshouldalsoincludeallthein-scopenamespacesandtheXMLbase);extensionattributesarerepresentedasinstancesoftheclassExtensionAttributewhich ,inturnhaveaname(propertyattributeNamepointingtoaQName)andavalue(propertyrdf:valuepointingtoaliteralwould violate the containingattributevalue).Suchrepresentationofway WSDL considers them
mandatory.unknown
Unknown optional extensions isnotintendedalso cannot be tousedbyprocessorsthatunderstandthoseextensions;insteadsuchprocessorsshouldreinterprettheXMLliteralsandmapthemintotheappropriateRDFextensionsoftherestoftheRDFrepresentation.Table2-18. MappingUnknownmapped to RDF ExtensionsXMLFormRDFForm<wsdl:...> <ex:unknown ...> ... </ex:unknown></wsdl:...><parentComponentId> wsdl:extensionElement "<ex:unknown ...> ... </ex:unknown>"^^rdf:XMLLiteral(notethatthewhitespaceinsidetheXMLliteralaboveiscopiedfromtheXML)<wsdl:...> <ex:unknown wsdl:required="true" ...> ... </ex:unknown></wsdl:...>(cannotbemapped,with any
mapping rules defined in this document, because their meaning theis unknown.
However, the parent component is ofunknown)<wsdl:... ex:unknown="val"> ...</wsdl:...><parentComponentId> wsdl:extensionAttribute <genId><genId>rdf:typewsdl:ExtensionAttribute<genId>wsdl:attributeName<qname><genId>rdf:value"val"mapped into RDF as though the unknown
optional extension was not present at all. Effectively, this WSDL RDF mapping
ignores unknown optional extensions.(genId
In addition to the extensions, all WSDL XML elements can also contain
documentation. Such documentation can consist of human-readable text or
machine-processible elements and attributes, but it is anewlygenerateduniqueURI)(fornot modeled in more
detail in WSDL 2.0. This WSDL RDF mapping qnameseeTable2-2does not represent
documentation in the resulting RDF graph, because it would be an XML literal
with no explicit meaning.)
WSDL 2.0 defines an extensible set of message exchange
patterns (MEPs). There are 8 predefined MEPs (three in [WSDL 2.0 Adjuncts] and five in [WSDL 2.0 Additional MEPs]), each following one of the
three predefined fault propagation rules. Every WSDL MEP defines a set of
message labels by which message references in operations can position
themselves within the pattern.MEPs,
In the RDF representation of WSDL, message exchange patterns are
represented as instances of the class MessageExchangePattern
.
The three predefined fault propagation rules are disjoint subclasses of that
class, named NoFaults
, FaultReplacesMessage
and
MessageTriggersFault
.
All MEPs are identified by IRIs, and the RDF ontology for WSDL onlyputstheMEPsinthecorrectassigns classes to
MEPs; for example
classes;
is an instance of the
class http://www.w3.org/ns/wsdl/in-onlyhttp://www.w3.org/2006/01/wsdl/in-onlyNoFaults
. The message labels, however, are plain string
names, and the RDF ontology for WSDL gives each of them an IRI formed by the
MEP IRI, the hash sign '#' and the actual message label, and these IRIs are
referenced from the MEPs with the property definesMessageLabel
.
Any newly created MEPs should also provide IRIs for the message labels, as
the RDF mapping depends on being able to identify the message labels on
interface message references.
The following mapping table only shows the message label URIs defined by the WSDL ontology for the message labels defined by the message exchange patterns from [WSDL 2.0 Adjuncts] and [WSDL 2.0 Additional MEPs].
MEP | Label | Label URI |
---|---|---|
In-Only | In | |
Robust In-Only | In | |
In-Out | In | |
Out | |
|
In-Optional-Out | In | |
Out | |
|
Out-Only | Out | |
Robust Out-Only | Out | |
Out-In | Out | |
In | |
|
Out-Optional-In | Out | |
In | |
WSDL 2.0 Adjuncts contain a single predefined extension, called Operation Safety, which adds a property to interface operation components to indicate whether an interface operation is known to be safe in terms of [Web Architecture].
In the RDF representation of WSDL, we introduce the class SafeInteraction
, and we use the Semantic Annotations
for WSDL and XML Schema ([SAWSDL]) property
modelReference to annotate any —InterfaceOperation
instance that is alsoaSafeInteractionasserted to be
safe.is
Note: the fact that the SAWSDL modelReference RDF property is used in this WSDL RDF mapping does not introduce the dependency that WSDL processors or WSDL RDF mapping implementations would need to understand the SAWSDL extension.
Property | RDF Form |
---|---|
{safety} | (only if true) <operationId> |
WSDL 2.0 predefines 3 operation styles — RPC style, IRI style and
Multipart style. These styles are identified with their IRIs, which are, in the RDF
ontologyontology, instances of the class makesOperationStyle
.
The RPC style additionally introduces the property {rpc signature}, which
is represented in RDF using the property signature
, whose value
is a literal whose datatype is the signature type defined by WSDLWSDL 2.0. The
2.0.signature
property can be attached to interface operations
following the RPC style to indicate the parameter order for the
operation.
Note: the value of the RPC signature property uses QNames so it can only be parsed successfully if all in-scope namespace bindings are available.
Property | RDF Form |
---|---|
{rpc signature} | <operationId> wrpc:signature "<signature>"^^wrpc:signatureType |
WSDL bindings that bind to SOAP are identified (using the property
rdf:type
) as instances of the class
. Every such binding
http://www.w3.org/ns/wsdl/soaphttp://www.w3.org/2006/01/wsdl/soapmustindicates the SOAP version that it uses, this is done with the property
indicateversion
(with a value "1.2", for example, meaning SOAP version
1.2). Every binding also mustspecifies with the property specifyprotocol
the underlying protocol that is uses.
Each SOAP binding operation mustspecifies the SOAP message exchange pattern
it uses — the appropriate URI from the SOAP specification is pointed to
using the property specifysoapMEP
. The ontologyalsorange of this
property is the SOAP 1.2 class introduces
that contains all the SOAP
MEPs. Some bindings (especially those that are not specific to any interface)
will rely on defaulting to set the SOAP message exchange pattern, this
default is captured using the property http://www.w3.org/2006/02/soap12/abstractions#classOfMEPsSOAPMessageExchangePatterndefaultSoapMEP
.
SOAP binding operations can additionally specify the value of the action parameter
(known as SOAP action) for the initial message, using the property
action
.
Binding faults in the SOAP binding can specify two properties —
fault code and fault subcodes. Both fault code and subcodes are QNames, and
they are pointed to using the properties faultCode
and
faultSubcodes
. The latter points to an RDF
sequence ((rdf:Seq)rdf:Seq
) which contains all the
subcodes.
At any level within a SOAP binding, components can declare the use of a
SOAP module. Required modules are pointed to using the property
requiresSOAPModule
and optional modules are pointed to using the
property offersSOAPModule
— both of these properties point
directly from the parent component to the SOAP module, as identified by its
URI (parameter {ref} of the SOAP Module component).
Message references and faults in SOAP bindings can further declare that
they require or offer a specific SOAP headers. To do this, the properties
requiresHeader
and offersHeader
can point to an instance of
the class SOAPHeaderBlock
, which then uses the property
elementDeclaration
to specify the exact element that represents
the header. Instances of SOAPHeaderBlock
can also belong to the class
MustUnderstandSOAPHeaderBlock
, which means that this SOAP header will
be marked as mandatory (mustUnderstand="true") in the message.
Apart from these SOAP-binding-specific properties, the SOAP binding reuses underlying protocol properties, for example some HTTP binding properties when the underlying protocol is HTTP. The following section describes the HTTP binding properties.
Property | RDF Form |
---|---|
{soap mep default} | <bindingId> wsoap:defaultSoapMEP <pattern> . |
{soap underlying protocol} | <bindingId> wsoap:protocol <protocol> . |
{soap version} | <bindingId> wsoap:version "<version>" . |
{soap modules} | (for soap module mapping see Table |
Property | RDF Form |
---|---|
{soap action} | <bindingOpId> wsoap:action <action> . |
{soap mep} | <bindingOpId> wsoap:soapMEP <pattern> . |
{soap modules} | (for soap module mapping see Table |
Property | RDF Form |
---|---|
{soap fault code} | (only if not "#any") <bindingFaultId> wsoap:faultCode <qname> . (for qname mapping see Table 2-2) |
{soap fault subcodes} | (only if not "#any") <bindingFaultId> wsoap:faultSubcodes <genId> . <genId> rdf:type rdf:Seq . (for each subcode) <genId> rdf:_nnn <qname> . (genId is a newly generated unique URI) (_nnn starts from _1 and the number is increased by 1 for each subcode) (for qname mapping see Table 2-2) |
{soap modules} | (for soap module mapping see Table |
{soap headers} | (for soap header block mapping see Table |
Property | RDF Form |
---|---|
{soap modules} | (for soap module mapping see Table |
{soap headers} | (for soap header block mapping see Table |
Property | RDF Form |
---|---|
{soap modules} | (for soap module mapping see Table |
Property | RDF Form |
---|---|
{ref} | <ref> rdf:type wsoap:SOAPModule . |
{required} | (for required) <parentComponentId> wsoap:requiresSOAPModule <ref> . (for not required) <parentComponentId> wsoap:offersSOAPModule <ref> . |
Property | RDF Form |
---|---|
(id generated per IRI Identification Of A SOAP Header Block component) <id> rdf:type wsoap:SOAPHeaderBlock . |
|
{required} | (for required) <parentComponentId> wsoap:requiresHeader <id> . (for not required) <parentComponentId> wsoap:offersHeader <id> . |
{mustUnderstand} | (only if true) <id> rdf:type wsoap:MustUnderstandSOAPHeaderBlock . |
{element declaration} | <id> wsdl:elementDeclaration <qname> . (for qname mapping see Table 2-2) |
WSDL bindings that bind to HTTP are identified as instances of the class
. The HTTP bindings that make
use of HTTP cookies are further identified as instances of the class
http://www.w3.org/ns/wsdl/httphttp://www.w3.org/2006/01/wsdl/httpHTTPBindingWithCookies
.
HTTP binding operations can specify a number of HTTP parameters:
operation-specific location (and what to do with parameters that are not
serialized in it — ignore uncited), HTTP method, input and output and fault
serialization, and query parameter separator. These parameters are
represented in RDF with the properties location
, locationIgnoreUncited
,
method
, inputSerialization
,
outputSerialization
, faultSerialization
and
queryParameterSeparator
. The HTTP method and query parameter
separator can also be specified on the binding level as defaults, especially
in bindings that are not specific to any particular interface. Those defaults
are preserved using properties defaultMethod
and
defaultQueryParameterSeparator
. The values of all these properties
are literals, same as in the XML syntax of WSDL.
Message references and faults in an HTTP binding can specify the use of
extra HTTP headers. Required headers are pointed to using the property
requiresHeader
, whereas optional headers are referenced using the
property offersHeader
. Both properties point to an instance of the
class HTTPHeader
. Each HTTPHeader
instance has a property
headerName
that specifies the name of the header, and a property
typeDefinition
which defines the simple type of the header
value.
Message references and faults
can also specify the transfercontent encoding using the property
coding
with a literal string value, as in the XML
representation; and binding operations or even bindings may define the
default contentEncodingtransferCodingtransfercontent encoding values using the property
coding
. Finally, faults can further specify the HTTP
status code they will be accompanies with, using the property
defaultContentEncodingdefaultTransferCodingerrorCode
.
Service endpoints that use an HTTP binding can specify access authentication
parameters, in particular authentication scheme and realm. These parameters are
reflected with the properties authenticationScheme
and
authenticationRealm
with string values.
Property | RDF Form |
---|---|
{http cookies} | (only if true) <bindingId> rdf:type whttp:HTTPBindingWithCookies . |
{http |
<bindingId> |
{http method default} | <bindingId> whttp:defaultMethod "<method>" . |
{http query parameter separator default} | <bindingId> whttp:defaultQueryParameterSeparator "<separator>" . |
Property | RDF Form |
---|---|
{http location} | <bindingOpId> whttp:location "<location>" . |
{http |
<bindingOpId> |
{http input serialization} | <bindingOpId> whttp:inputSerialization "<serialization>" . |
{http output serialization} | <bindingOpId> whttp:outputSerialization "<serialization>" . |
{http fault serialization} | <bindingOpId> whttp:faultSerialization "<serialization>" . |
{http location ignore uncited} | <bindingOpId> whttp:locationIgnoreUncited "<ignoreFlag>"^^xs:boolean . |
{http method} | <bindingOpId> whttp:method "<method>" . |
{http query parameter separator} | <bindingOpId> whttp:queryParameterSeparator "<separator>" . |
Property | RDF Form |
---|---|
{http error status code} | (only if not "#any") <bindingFaultId> whttp:errorCode "<code>"^^xs:int . |
{http |
<bindingFaultId> |
{http headers} | (for http header mapping see Table |
Property | RDF Form |
---|---|
{http |
<bindingMessageRefId> |
{http headers} | (for http header mapping see Table |
Property | RDF Form |
---|---|
{http authentication realm} | <endpointId> whttp:authenticationRealm "<realm>" . |
{http authentication scheme} | <endpointId> whttp:authenticationScheme "<scheme>" . |
Property | RDF Form |
---|---|
(id generated per IRI Identification Of A HTTP Header component) <id> rdf:type whttp:HTTPHeader . |
|
{required} | (for required) <parentComponentId> whttp:requiresHeader <id> . (for not required) <parentComponentId> whttp:offersHeader <id> . |
{type definition} | <id> wsdl:typeDefinition <qname> . (for qname mapping see Table 2-2) |
The following is a listing of the RDF form of the WSDL description of the initial GreatH Web Service (listed as example 2-1) from the WSDL 2.0 primer (in triple notation):
@prefix wsdl:<http://www.w3.org/ns/wsdl-rdf#> . <http://greath.example.com/2004/wsdl/resSvc#wsdl.description()> a wsdl:Description ; wsdl:interface <http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)> ; wsdl:binding <http://greath.example.com/2004/wsdl/resSvc#wsdl.binding(reservationSOAPBinding)> ; wsdl:service <http://greath.example.com/2004/wsdl/resSvc#wsdl.service(reservationService)> . <http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)> a wsdl:Interface ; wsdl:interfaceFault <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)> ; wsdl:interfaceOperation <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceOperation(reservationInterface/opCheckAvailability)> . <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)> a wsdl:InterfaceFault ; wsdl:elementDeclaration _:L9C14 . <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFaultReference(reservationInterface/opCheckAvailability/Out/invalidDataFault)> a wsdl:InterfaceFaultReference ; a wsdl:OutputMessage; wsdl:messageLabel <>; wsdl:interfaceFault <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)> . <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/In)> a wsdl:InterfaceMessageReference ; a wsdl:InputMessage; wsdl:elementDeclaration _:L22C18 ; wsdl:messageLabel <>; wsdl:messageContentModel wsdl:element . <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/Out)> a wsdl:InterfaceMessageReference ; a wsdl:OutputMessage; wsdl:elementDeclaration _:L32C18 ; wsdl:messageLabel <>; wsdl:messageContentModel wsdl:element . <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceOperation(reservationInterface/opCheckAvailability)> a wsdl:InterfaceOperation ; wsdl:messageExchangePattern <http://www.w3.org/2004/03/wsdl/in-out> . wsdl:interfaceMessageReference <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/In)> ; wsdl:interfaceMessageReference <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/Out)> ; wsdl:interfaceFaultReference <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFaultReference(reservationInterface/opCheckAvailability/Out/invalidDataFault)> ; <http://greath.example.com/2004/wsdl/resSvc#wsdl.binding(reservationSOAPBinding)> a wsdl:Binding ; a<http://www.w3.org/2005/10/wsdl-rdf#><http://www.w3.org/ns/wsdl/soap>; wsdl:binds <http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)> ; wsdl:bindingFault <http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingFault(reservationSOAPBinding/invalidDataFault)> ; wsdl:bindingOperation <http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingOperation(reservationSOAPBinding/opCheckAvailability)> . <http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingFault(reservationSOAPBinding/invalidDataFault)> a wsdl:BindingFault ; wsdl:binds <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)> . <http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingOperation(reservationSOAPBinding/opCheckAvailability)> a wsdl:BindingOperation ; wsdl:binds <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceOperation(reservationInterface/opCheckAvailability)> . <http://greath.example.com/2004/wsdl/resSvc#wsdl.service(reservationService)> a wsdl:Service ; wsdl:implements <http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)> . wsdl:endpoint <http://greath.example.com/2004/wsdl/resSvc#wsdl.endpoint(reservationService/reservationEndpoint)> ; <http://greath.example.com/2004/wsdl/resSvc#wsdl.endpoint(reservationService/reservationEndpoint)> a wsdl:Endpoint ; wsdl:usesBinding <http://greath.example.com/2004/wsdl/resSvc#wsdl.binding(reservationSOAPBinding)>; wsdl:address <http://greath.example.com/2004/reservation> . _:L9C14 a wsdl:QName . wsdl:localName "invalidDataError"; wsdl:namespace "http://greath.example.com/2004/schemas/resSvc"; _:L22C18 a wsdl:QName . wsdl:localName "checkAvailability"; wsdl:namespace "http://greath.example.com/2004/schemas/resSvc"; _:L32C18 a wsdl:QName . wsdl:localName "checkAvailabilityResponse"; wsdl:namespace "http://greath.example.com/2004/schemas/resSvc";<http://www.w3.org/2006/01/wsdl/soap>;
WSDL defines a component model which consists of components, component properties and sets of components. This document supplies an ontology (i.e., a set of classes, properties, datatypes, and distinguished individuals) for representing WSDL data. This ontology contains axioms which express some of the constraints the WSDL specification imposes on legal sets of WSDL components whether indirectly (via the XML Schema constraints on the infoset which canonically encodes WSDL component models) or directly (via the natural language of the WSDL specs, or the corresponding Z formalizations of that language).
RDF, RDFS, and OWL are all less (and differently) expressive than the subset of Z used to formalize the WSDL specification, and are designed for different purposes. In a nutshell, RDF, RDFS, and OWL are relatively small fragments of first order logic, whereas Z encompasses all of first order logic plus set theory. Z supports validation of component models, that is, the acceptance or rejection of component models. This includes type checking, consistency checking, and the verification of integrity constraints. The current set of Semantic Web languages focus on inference and integration of information. To take a simple example, if a Z checkable representation of an Interface component lacks a {name} component property, a Z based validator will complain that that representation is ill formed (given the WSDL specification). An OWL reasoner encountering it will, all other things being equal, conclude that there is such a property, even though the reasoner has not seen it yet. In general, Semantic Web based descriptions of Web services using the WSDL conceptual framework tend to be looser than what the WSDL specification prescribes.
This difference effectively introduces two classes of documents that use the ontology from this document:
This document focuses on the mapping from valid WSDL component models, and this section in particular talks about differences between a valid component model and its RDF representation.
However, we must note that arbitrary RDF, RDFS, or OWL documents that use the
WSDL ontology may describe component models that are incomplete or even
illegal. For example, from the point of view of arbitrary RDF documents that
use the WSDL ontology, interfaces do not need to belong to any Description.
Therefore, the subsections also contain notes about arbitrary RDF
documents detailing further differences that an application consuming
WSDL RDF data can encounter in documents that are not the direct result of
mapping a valid WSDL document into its RDF form.
The last subsection (section 4.5) then describes
those constraints unenforced by the WSDL, that do not fit in any other
subsection above it.don't
In the RDF representation, all WSDL components are identified with their respective component designators (see [WSDL 2.0 Core Language] appendix C IRI-References for WSDL 2.0 Components), which are URIs generally constructed from the name and namespace of the component and from its parent component hierarchy. The original names and namespaces are not explicitly modeled in the RDF representation, which intends to convey the semantic meaning of the WSDL component, not the WSDL serialization details.
In some situations we can see the RDF representation to be used as an
exchange syntax for WSDL. While it is not an intended use, it is possible that
in some systems the XML syntax will be lost or inaccessibly hidden in several
layers of processing software. Such an application that only
receives the RDF form of WSDL can still need to reconstruct the original
component names, for example if it uses an API that identifies WSDL
operations by their parent interface's QName and the operation name. it's
The component designators put the names of the components in the fragment
identifier part of the resulting URIs. On the Web (see [Web Architecture]), the
interpretation of fragment identifiers is defined by the MIME media type of
the representation of the resource identified by the URI without the fragment
identifier. In our particular case, we expect that the namespace URI
identifies an application/wsdl+xml
document so that the constructed component
designator fragment identifiers can have their intended meaning. An
application working with the RDF representation of WSDL can reconstruct the
names of the components by reversing the process that resulted in the
component designator, for example for a URI
http://example.com/service#wsdl.interfaceOperation(TicketInterface/BookTicket)
we
could reconstruct that the name of the interface is "TicketInterface" in the
namespace http://example.com/service
and that the operation is named
"BookTicket".
Such decomposition is only valid, though, if the URI
http://example.com/service
identifies a document of MIME media
type application/wsdl+xml
, as explained above. Checking the MIME
media type of every resource identified by a URI in an RDF graph could be
prohibitively slow for some applications, therefore it may be practical
(albeit not entirely correct) simply to assume the correct media type and
deconstruct the component names without the preceding media type check.
Note about arbitrary RDF documents: in general,
it is possible to assert about any resource (identified by any
kind of URI) that it is, for example, a WSDL operation, and if an application
tries to deconstruct that URI according to WSDL component designator
specification, it may find that the URI does not conform to the syntax (e.g.
doesn'thttp://example.com/service/operation)
or, by accident or malice, it does
conform to the syntax but does not contain the correct data (e.g.
doesn'thttp://example.com/service#wsdl.interface(TicketInterface)
that is marked to
be a WSDL operation, not an interface as it would seem).
In the XML syntax for WSDL, documents can be included and imported,
allowing for modularization while keeping the ability to validate that a WSDL
document (plus all the includes and imports) does not use any unknown
components. Such modularization is lost when the WSDL files are parsed into a
component model, therefore a straigtforward transformation of such a
component model into RDF will result in a single RDF document.doesn't
As one exception, all references to element declarations and type definitions from XML Schema are done in the RDF representation by QName and we expect the applications processing this representation to have means of locating the appropriate descriptions for these QNames. We do not model XML Schema (or any other) type and element descriptions in this ontology.
Note about arbitrary RDF documents: RDF data can be split into any number of pieces, which can be put together by the processing application as appropriate. If a piece of WSDL/RDF description uses an unknown component (e.g. an interface described in one document may extend other interfaces, not described in this document), the application may, if necessary, attempt to locate the description of the unknown component, for example using its identifier IRI. Note that RDF does not provide a standard generic way of including external data, so any inclusion is application-specific.
Additionally, a single RDF document may also contain multiple unrelated Descriptions, that is, it may be an aggregation of many unrelated WSDL documents, and this may have unexpected results if the aggregated WSDL data contains conflicts, i.e. different definitions of components with the same name; especially when dealing with different versions of descriptions of the same entities.
In the XML representation of WSDL, components are referred to using their names, and extensibility points usually use IRIs to identify things. All these references are, from XML point of view, literals. In the RDF representation, on the other hand, most references are direct, using the particular identifier IRIs, not represented as literals. For example, most instances representing components are identified with their component designators (see [WSDL 2.0 Core Language] appendix C IRI-References for WSDL 2.0 Components) and all references point directly there — an operation within a binding points to its respective interface operation using the interface operation component designator IRI, whereas in the XML syntax the operations are correlated using the message label.
As a notable exception, references to type definitions and element
declarations (usually from XML Schema) are represented as instances of
our class QName
, with local part represented as literal and the
namespace as a resource. This might change if a standard RDF representation for XML
Schema element declarations and type definitions is developed — then
direct references to the URIs used in that representation would be used.
Additionally, certainthe SOAP Module component in WSDL components(Feature,SOAPModule)areonlypointers,is really only theya
havepointer: it has a literal property {ref} that singlepointscontains an toexternalthing.ForIRI identifying the
example,featurecomponentonlySOAP module, and a property {required} that indicates whether the carriesuse of URIthethat
SOAP module is required. While feature.thesethis component can contain documentation and
extensions in WSDL, we chose to represent componentstheseit as a direct componentslink from the parent
component to the target linksfeaturemodule, as the indirection seems to add very little
value and introduces naming difficulties or(seedescriptionof— we would have to have class
for the SOAP Module component Propertywhich would contain a pointer to SOAP Module.
The requiredness of the SOAP Module is expressed in mappingsection2.2.1the type of the property
that points to the module — the parent component either .)offersSOAPModule
or requiresSOAPModule
.
In certain cases the RDF mapping introduces classes where the WSDL 2.0
component model has a property with a limited number of values. For instance,
instead of having a direction property on message and fault references, with
the values either "in" or "out", we introduce two classes,
InputMessage
and OutputMessage
, and the direction
of a particular message or fault reference is then indicated by belonging to
either of these classes. Similarly,bindingtypesareclassesandthetypeofaparticularbindingisindicatedbyitsbelongingtothatclass;wepredefinethetwoclassesforthetwobindingsthatarepartofWSDL2.Finally,theoperationsafetypropertyisrepresentedwiththeclassSafeInteraction,andsafeoperationsareinstancesofthisclass.Onasimilarnote,inthecaseoffeatures,theflagthatafeatureisrequiredisnotmodeledasapropertyofthefeaturecomponent,requiredfeaturesareinsteadpointedtousingtheRDFpropertyrequiresFeature,whereasoptionalSimilarly, binding types are featuresclasses and the type of
a particular binding is indicated by its belonging to pointedthat class; we
predefine the usingpropertyoffersFeaturetwo classes for the two bindings that are part of WSDL 2.
.
As already mentioned, the validation-oriented WSDL specification and especially its Z formalization capture a number of restrictions and limitations that are not expressed in the RDF ontology. None of these restrictions or limitations can be violated when a valid WSDL document is mapped into its RDF form. When the RDF data is directly manipulated, for example merged with other RDF data (for example other WSDL documents mapped into RDF), or when new data is created that uses the WSDL ontology, further significant WSDL constraints might be violated:
Note that the ontology is also available in a separate RDF file.
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:owl="http://www.w3.org/2002/07/owl#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"xmlns:wsdl="http://www.w3.org/ns/wsdl-rdf#" xmlns:xml="http://www.w3.org/XML/1998/namespace"xmlns:wsdl="http://www.w3.org/2005/10/wsdl-rdf#"xml:base="http://www.w3.org/ns/wsdl-rdf"> <owl:Ontology rdf:about=""> </owl:Ontology> <owl:Class rdf:about="#Binding"> <rdfs:comment>The type of a binding is indicated with rdf:type</rdfs:comment> </owl:Class> <owl:Class rdf:about="#BindingFault"> </owl:Class> <owl:Class rdf:about="#BindingFaultReference"> </owl:Class> <owl:Class rdf:about="#BindingMessageReference"> </owl:Class> <owl:Class rdf:about="#BindingOperation"> </owl:Class> <owl:Class rdf:about="#Description"> </owl:Class> <owl:Class rdf:about="#Endpoint"> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#address"/> <owl:maxCardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:maxCardinality> </owl:Restriction> </rdfs:subClassOf> </owl:Class> <owl:Classxml:base="http://www.w3.org/2005/10/wsdl-rdf">rdf:about="#Feature"></owl:Class>rdf:about="#Interface"> <rdfs:label>WDSL Interface</rdfs:label> </owl:Class> <owl:Class rdf:about="#InterfaceFault"> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#messageContentModel"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> </owl:Class> <owl:Class rdf:about="#InterfaceFaultReference"> </owl:Class> <owl:Class rdf:about="#InterfaceMessageReference"> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#messageContentModel"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> </owl:Class> <owl:Class rdf:about="#InputMessage"> <rdfs:comment>To be used by message references and fault references instead of direction property</rdfs:comment> <owl:disjointWith rdf:resource="#OutputMessage"/> </owl:Class> <owl:Class rdf:about="#OutputMessage"> <rdfs:comment>To be used by message references and fault references instead of direction property</rdfs:comment> </owl:Class> <owl:Class rdf:about="#InterfaceOperation"> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#messageExchangePattern"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> </owl:Class> <owl:Class<owl:Classrdf:about="#PropertyValue"><rdfs:subClassOf><owl:Restriction><owl:onPropertyrdf:resource="#propertyValue"/><owl:cardinalityrdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality></owl:Restriction></rdfs:subClassOf></owl:Class><owl:Classrdf:about="#Property"></owl:Class>rdf:about="#Service"> </owl:Class> <owl:Class rdf:about="#MessageExchangePattern"> </owl:Class> <owl:Class rdf:about="#MessageLabel"> </owl:Class> <owl:ObjectProperty rdf:about="#definesMessageLabel"> <rdfs:domain rdf:resource="#MessageExchangePattern"/> <rdfs:range rdf:resource="#MessageLabel"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#address"> <rdfs:domain rdf:resource="#Endpoint"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#binding"> <rdfs:range rdf:resource="#Binding"/> <rdfs:comment>To be used for pointing to a Binding from Description</rdfs:comment> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#usesBinding"> <rdfs:range rdf:resource="#Binding"/> <rdfs:comment>To be used for pointing to a Binding from Endpoint</rdfs:comment> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#bindingFault"> <rdfs:range rdf:resource="#BindingFault"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#bindingOperation"> <rdfs:range rdf:resource="#BindingOperation"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#bindingMessageReference"> <rdfs:range rdf:resource="#BindingMessageReference"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#bindingFaultReference"> <rdfs:range rdf:resource="#BindingFaultReference"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#typeDefinition"> <rdfs:range rdf:resource="#QName"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#elementDeclaration"> <rdfs:range rdf:resource="#QName"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#endpoint"> <rdfs:range rdf:resource="#Endpoint"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#extends"> <rdfs:range rdf:resource="#Interface"/> <rdfs:domain rdf:resource="#Interface"/> </owl:ObjectProperty> <owl:Class rdf:about="#QName"> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#localName"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#namespace"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> </owl:Class> <owl:DatatypeProperty rdf:about="#localName"> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#NCName"/> </owl:DatatypeProperty> <owl:ObjectProperty rdf:about="#namespace"> </owl:ObjectProperty> <owl:ObjectProperty<owl:Classrdf:about="#offersFeature"><rdfs:rangerdf:resource="#Feature"/></owl:ObjectProperty><owl:ObjectPropertyrdf:about="#requiresFeature"><rdfs:rangerdf:resource="#Feature"/></owl:ObjectProperty>rdf:about="#interface"> <rdfs:range rdf:resource="#Interface"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#interfaceFault"> <rdfs:range rdf:resource="#InterfaceFault"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#interfaceFaultReference"> <rdfs:range rdf:resource="#InterfaceFaultReference"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#interfaceMessageReference"> <rdfs:range rdf:resource="#InterfaceMessageReference"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#binds"> <rdfs:comment> points from a binding component (or any sub-component) to the respective interface component (or sub-component) </rdfs:comment> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#operationStyle"> <rdfs:domain rdf:resource="#InterfaceOperation"/> <rdfs:range rdf:resource="#OperationStyle"/> <rdfs:comment> points to one style this operation conforms to (can be used multiple times to point to multiple styles) </rdfs:comment> </owl:ObjectProperty> <owl:Class rdf:about="#OperationStyle"> </owl:Class> <owl:ObjectProperty rdf:about="#interfaceOperation"> <rdfs:range rdf:resource="#InterfaceOperation"/> <rdfs:comment> used on interface to link to an operation </rdfs:comment> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#messageContentModel"> <rdfs:range rdf:resource="#MessageContentModel"/> </owl:ObjectProperty> <owl:Class rdf:about="#MessageContentModel"> <owl:oneOf rdf:parseType="Collection"> <wsdl:MessageContentModel rdf:about="#AnyContent"/> <wsdl:MessageContentModel rdf:about="#NoContent"/> <wsdl:MessageContentModel rdf:about="#ElementContent"/> <wsdl:MessageContentModel rdf:about="#OtherContent"/> </owl:oneOf> </owl:Class> <owl:ObjectProperty rdf:about="#messageExchangePattern"> <rdfs:range rdf:resource="#MessageExchangePattern"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#messageLabel"> <rdfs:range rdf:resource="#MessageLabel"/> </owl:ObjectProperty> <owl:ObjectProperty<owl:ObjectPropertyrdf:about="#propertyValue"><rdfs:rangerdf:resource="#PropertyValue"/></owl:ObjectProperty><owl:ObjectPropertyrdf:about="#property"><rdfs:rangerdf:resource="#Property"/></owl:ObjectProperty><owl:DatatypePropertyrdf:about="#propertyActualValue"><rdfs:domainrdf:resource="#PropertyValue"/><rdfs:rangerdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"/></owl:DatatypeProperty><owl:ObjectPropertyrdf:about="#propertyValueType"><rdfs:domainrdf:resource="#PropertyValue"/><rdfs:rangerdf:resource="#QName"/></owl:ObjectProperty>rdf:about="#service"> <rdfs:range rdf:resource="#Service"/> </owl:ObjectProperty><owl:ObjectProperty<owl:DatatypePropertyrdf:about="#documentation"><rdfs:rangerdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"/></owl:DatatypeProperty><owl:DatatypePropertyrdf:about="#extensionElement"><rdfs:rangerdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"/></owl:DatatypeProperty><owl:ObjectPropertyrdf:about="#extensionAttribute"><rdfs:rangerdf:resource="#ExtensionAttribute"/></owl:ObjectProperty><owl:Classrdf:about="#ExtensionAttribute"><rdfs:subClassOf><owl:Restriction><owl:onPropertyrdf:resource="#attributeName"/><owl:cardinalityrdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality></owl:Restriction></rdfs:subClassOf><rdfs:subClassOf><owl:Restriction><owl:onPropertyrdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#value"/><owl:cardinalityrdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality></owl:Restriction></rdfs:subClassOf><rdfs:comment>Representsanextensionattributewithanameandavalue.Thevalueshouldbealiteral.Thisshouldonlybeusedforextensionattributesthataren'tunderstoodbythegeneratoroftheRDFmodel,otherwisetheextensionshoulddefinehowtheattributeshowsintheRDFmodel.</rdfs:comment></owl:Class><owl:ObjectPropertyrdf:about="#attributeName"><rdfs:rangerdf:resource="#QName"/><!-- part 2: message exchange patterns --> <owl:Class rdf:about="#NoFaults"> <rdfs:subClassOf rdf:resource="#MessageExchangePattern" /> <owl:disjointWith rdf:resource="#FaultReplacesMessage"/> <owl:disjointWith rdf:resource="#MessageTriggersFault"/> </owl:Class> <owl:Class rdf:about="#FaultReplacesMessage"> <rdfs:subClassOf rdf:resource="#MessageExchangePattern" /> <owl:disjointWith rdf:resource="#MessageTriggersFault"/> </owl:Class> <owl:Class rdf:about="#MessageTriggersFault"> <rdfs:subClassOf rdf:resource="#MessageExchangePattern" /> </owl:Class> <wsdl:NoFaults</owl:ObjectProperty>rdf:about="http://www.w3.org/ns/wsdl/in-only"> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/in-only">rdf:about="http://www.w3.org/ns/wsdl/in-only#In"/> </wsdl:definesMessageLabel> </wsdl:NoFaults> <wsdl:NoFaultsrdf:about="http://www.w3.org/2006/01/wsdl/in-only#In"/>rdf:about="http://www.w3.org/ns/wsdl/out-only"> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/out-only">rdf:about="http://www.w3.org/ns/wsdl/out-only#Out"/> </wsdl:definesMessageLabel> </wsdl:NoFaults> <wsdl:MessageTriggersFaultrdf:about="http://www.w3.org/2006/01/wsdl/out-only#Out"/>rdf:about="http://www.w3.org/ns/wsdl/robust-in-only"> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/robust-in-only">rdf:about="http://www.w3.org/ns/wsdl/robust-in-only#In"/> </wsdl:definesMessageLabel> </wsdl:MessageTriggersFault> <wsdl:MessageTriggersFaultrdf:about="http://www.w3.org/2006/01/wsdl/robust-in-only#In"/>rdf:about="http://www.w3.org/ns/wsdl/in-opt-out"> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/in-opt-out">rdf:about="http://www.w3.org/ns/wsdl/in-opt-out#In"/> </wsdl:definesMessageLabel> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/in-opt-out#In"/>rdf:about="http://www.w3.org/ns/wsdl/in-opt-out#Out"/> </wsdl:definesMessageLabel> </wsdl:MessageTriggersFault> <wsdl:MessageTriggersFaultrdf:about="http://www.w3.org/2006/01/wsdl/in-opt-out#Out"/>rdf:about="http://www.w3.org/ns/wsdl/robust-out-only"> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/robust-out-only">rdf:about="http://www.w3.org/ns/wsdl/robust-out-only#Out"/> </wsdl:definesMessageLabel> </wsdl:MessageTriggersFault> <wsdl:MessageTriggersFaultrdf:about="http://www.w3.org/2006/01/wsdl/robust-out-only#Out"/>rdf:about="http://www.w3.org/ns/wsdl/out-opt-in"> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/out-opt-in">rdf:about="http://www.w3.org/ns/wsdl/out-opt-in#Out"/> </wsdl:definesMessageLabel> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/out-opt-in#Out"/>rdf:about="http://www.w3.org/ns/wsdl/out-opt-in#In"/> </wsdl:definesMessageLabel> </wsdl:MessageTriggersFault> <wsdl:FaultReplacesMessagerdf:about="http://www.w3.org/2006/01/wsdl/out-opt-in#In"/>rdf:about="http://www.w3.org/ns/wsdl/in-out"> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/in-out">rdf:about="http://www.w3.org/ns/wsdl/in-out#In"/> </wsdl:definesMessageLabel> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/in-out#In"/>rdf:about="http://www.w3.org/ns/wsdl/in-out#Out"/> </wsdl:definesMessageLabel> </wsdl:FaultReplacesMessage> <wsdl:FaultReplacesMessagerdf:about="http://www.w3.org/2006/01/wsdl/in-out#Out"/>rdf:about="http://www.w3.org/ns/wsdl/out-in"> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/out-in">rdf:about="http://www.w3.org/ns/wsdl/out-in#Out"/> </wsdl:definesMessageLabel> <wsdl:definesMessageLabel> <wsdl:MessageLabelrdf:about="http://www.w3.org/2006/01/wsdl/out-in#Out"/>rdf:about="http://www.w3.org/ns/wsdl/out-in#In"/> </wsdl:definesMessageLabel> </wsdl:FaultReplacesMessage> <!-- part 2: safety --> <owl:Classrdf:about="http://www.w3.org/2006/01/wsdl/out-in#In"/>rdf:about="http://www.w3.org/2006/01/wsdl-extensions#SafeInteraction"><rdfs:subClassOfrdf:resource="#InterfaceOperation"rdf:about="http://www.w3.org/ns/wsdl-extensions#SafeInteraction"> <rdfs:comment> Class/>ofalloperationsthatareassertedtorepresenting safe interactions as defined in Web Architecture at W3C. </rdfs:comment> </owl:Class> <!-- part 2: operation styles --> <wsdl:OperationStyleberdf:about="http://www.w3.org/ns/wsdl/style/rpc"> <rdfs:comment>RPC operation style</rdfs:comment> </wsdl:OperationStyle> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/style/rpc">rdf:about="http://www.w3.org/ns/wsdl/rpc#signature"> <rdfs:domain rdf:resource="#InterfaceOperation"/> <rdfs:rangerdf:about="http://www.w3.org/2006/01/wsdl/rpc#signature">rdf:resource="http://www.w3.org/ns/wsdl/rpc#signatureType"/> <rdfs:comment>todo - can we use the above URI for the datatype of this property?</rdfs:comment> </owl:DatatypeProperty> <wsdl:OperationStylerdf:resource="http://www.w3.org/2006/01/wsdl/rpc#signatureType"/>rdf:about="http://www.w3.org/ns/wsdl/style/iri"> <rdfs:comment>IRI operation style</rdfs:comment> </wsdl:OperationStyle> <wsdl:OperationStylerdf:about="http://www.w3.org/2006/01/wsdl/style/iri">rdf:about="http://www.w3.org/ns/wsdl/style/multipart"> <rdfs:comment>multipart operation style</rdfs:comment> </wsdl:OperationStyle> <!-- part 2: bindings --> <!-- SOAP binding --> <owl:Classrdf:about="http://www.w3.org/2006/01/wsdl/style/multipart">rdf:about="http://www.w3.org/ns/wsdl/soap"> <rdfs:comment>WSDL 2 SOAP binding</rdfs:comment> <rdfs:subClassOf rdf:resource="#Binding"/> <rdfs:subClassOf> <owl:Restriction> <owl:onPropertyrdf:about="http://www.w3.org/2006/01/wsdl/soap">rdf:resource="http://www.w3.org/ns/wsdl/soap#version"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> <rdfs:subClassOf> <owl:Restriction> <owl:onPropertyrdf:resource="http://www.w3.org/2006/01/wsdl/soap#version"/>rdf:resource="http://www.w3.org/ns/wsdl/soap#protocol"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> </owl:Class> <owl:DatatypePropertyrdf:resource="http://www.w3.org/2006/01/wsdl/soap#protocol"/>rdf:about="http://www.w3.org/ns/wsdl/soap#version"> <rdfs:comment> indicates what version of SOAP is used by the binding, usually "1.2" todo - using string is fairly ugly, but can we invent URIs? </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:ObjectPropertyrdf:about="http://www.w3.org/2006/01/wsdl/soap#version">rdf:about="http://www.w3.org/ns/wsdl/soap#protocol"> <rdfs:comment> indicates the underlying protocol used by a binding todo - protocol class and the known instances? ask the XMLP group </rdfs:comment> </owl:ObjectProperty> <owl:ObjectPropertyrdf:about="http://www.w3.org/2006/01/wsdl/soap#protocol">rdf:about="http://www.w3.org/ns/wsdl/soap#faultCode"> <rdfs:comment> indicates the fault code of a binding fault </rdfs:comment> <rdfs:range rdf:resource="#QName"/> </owl:ObjectProperty> <owl:ObjectPropertyrdf:about="http://www.w3.org/2006/01/wsdl/soap#faultCode">rdf:about="http://www.w3.org/ns/wsdl/soap#faultSubcodes"> <rdfs:comment> indicates the fault subcodes of a binding fault; there can be multiple subcodes todo - make the rangerdf:about="http://www.w3.org/2006/01/wsdl/soap#faultSubcodes">an rdf:Seq (maybe ofaQNames) </rdfs:comment> </owl:ObjectProperty> <owl:ObjectPropertyQNamesrdf:about="http://www.w3.org/ns/wsdl/soap#soapMEP"> <rdfs:comment> indicates the SOAP MEP this binding operation uses </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/> </owl:ObjectProperty> <owl:ObjectPropertyrdf:about="http://www.w3.org/2006/01/wsdl/soap#soapMEP">rdf:about="http://www.w3.org/ns/wsdl/soap#defaultSoapMEP"> <rdfs:comment> indicates the default SOAP MEP this binding's operations use </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/> </owl:ObjectProperty> <owl:Class rdf:about="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"> </owl:Class> <rdf:Description rdf:about="http://www.w3.org/2003/05/soap/mep/request-response/"> <rdf:type rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/> </rdf:Description> <rdf:Description rdf:about="http://www.w3.org/2003/05/soap/mep/soap-response/"> <rdf:type rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/> </rdf:Description> <owl:ObjectPropertyrdf:about="http://www.w3.org/2006/01/wsdl/soap#defaultSoapMEP">rdf:about="http://www.w3.org/ns/wsdl/soap#action"> <rdfs:comment> indicates the SOAP action this binding operation uses </rdfs:comment> </owl:ObjectProperty> <owl:ObjectPropertyrdf:about="http://www.w3.org/2006/01/wsdl/soap#action">rdf:about="http://www.w3.org/ns/wsdl/soap#offersSOAPModule"> <rdfs:rangerdf:about="http://www.w3.org/2006/01/wsdl/soap#offersSOAPModule">rdf:resource="http://www.w3.org/ns/wsdl/soap#SOAPModule"/> </owl:ObjectProperty> <owl:ObjectPropertyrdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPModule"/>rdf:about="http://www.w3.org/ns/wsdl/soap#requiresSOAPModule"> <rdfs:rangerdf:about="http://www.w3.org/2006/01/wsdl/soap#requiresSOAPModule">rdf:resource="http://www.w3.org/ns/wsdl/soap#SOAPModule"/> </owl:ObjectProperty> <owl:Classrdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPModule"/>rdf:about="http://www.w3.org/ns/wsdl/soap#SOAPModule"> <rdfs:comment> a SOAP module; a WSDL 2 SOAP binding (and subcomponents) may use or require any number of modules todo - should this class be created by xmlp group? </rdfs:comment> </owl:Class> <owl:ObjectPropertyrdf:about="http://www.w3.org/2006/01/wsdl/soap#SOAPModule">rdf:about="http://www.w3.org/ns/wsdl/soap#offersHeader"> <rdfs:rangerdf:about="http://www.w3.org/2006/01/wsdl/soap#offersHeader">rdf:resource="http://www.w3.org/ns/wsdl/soap#SOAPHeaderBlock"/> </owl:ObjectProperty> <owl:ObjectPropertyrdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPHeaderBlock"/>rdf:about="http://www.w3.org/ns/wsdl/soap#requiresHeader"> <rdfs:rangerdf:about="http://www.w3.org/2006/01/wsdl/soap#requiresHeader">rdf:resource="http://www.w3.org/ns/wsdl/soap#SOAPHeaderBlock"/> </owl:ObjectProperty> <owl:Classrdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPHeaderBlock"/>rdf:about="http://www.w3.org/ns/wsdl/soap#SOAPHeaderBlock"> <rdfs:comment> a SOAP header </rdfs:comment> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#elementDeclaration"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> </owl:Class> <owl:Classrdf:about="http://www.w3.org/2006/01/wsdl/soap#SOAPHeaderBlock">rdf:about="http://www.w3.org/ns/wsdl/soap#MustUnderstandSOAPHeaderBlock"> <rdfs:subClassOfrdf:about="http://www.w3.org/2006/01/wsdl/soap#MustUnderstandSOAPHeaderBlock">rdf:resource="http://www.w3.org/ns/wsdl/soap#SOAPHeaderBlock" /> <rdfs:comment> a SOAP header that must be marked as mustUnderstand by the sender </rdfs:comment> </owl:Class> <!-- HTTP binding --> <owl:Classrdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPHeaderBlock"rdf:about="http://www.w3.org/ns/wsdl/http"> <rdfs:comment>WSDL 2 HTTP binding</rdfs:comment> <rdfs:subClassOf rdf:resource="#Binding"/> </owl:Class> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http">rdf:about="http://www.w3.org/ns/wsdl/http#location"> <rdfs:comment> defines the location for an operation, relative to the address of the service; this is the only URI-valued property modeled as datatype property because the URI is not meant as pointer to a resource </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#anyURI"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#location">rdf:about="http://www.w3.org/ns/wsdl/http#locationIgnoreUncited"> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#boolean"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#locationIgnoreUncited">rdf:about="http://www.w3.org/ns/wsdl/http#defaultMethod"> <rdfs:comment> declares the default HTTP method used by this binding's operations </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#defaultMethod">rdf:about="http://www.w3.org/ns/wsdl/http#method"> <rdfs:comment> declares the HTTP method used by this operation </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#method">rdf:about="http://www.w3.org/ns/wsdl/http#inputSerialization"> <rdfs:comment> declares the media type of the input message of an operation </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#inputSerialization">rdf:about="http://www.w3.org/ns/wsdl/http#outputSerialization"> <rdfs:comment> declares the media type of the output message of an operation </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#outputSerialization">rdf:about="http://www.w3.org/ns/wsdl/http#faultSerialization"> <rdfs:comment> declares the media type of the fault messages of an operation </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#faultSerialization">rdf:about="http://www.w3.org/ns/wsdl/http#defaultQueryParameterSeparator"> <rdfs:comment> declares the default character to be used as query parameter separator by this binding's operations </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#defaultQueryParameterSeparator">rdf:about="http://www.w3.org/ns/wsdl/http#queryParameterSeparator"> <rdfs:comment> declares the character to be used as query parameter separator by an operation </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#queryParameterSeparator">rdf:about="http://www.w3.org/ns/wsdl/http#headerName"> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:ObjectPropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#headerName">rdf:about="http://www.w3.org/ns/wsdl/http#requiresHeader"> <rdfs:rangerdf:about="http://www.w3.org/2006/01/wsdl/http#requiresHeader">rdf:resource="http://www.w3.org/ns/wsdl/http#HTTPHeader"/> </owl:ObjectProperty> <owl:ObjectPropertyrdf:resource="http://www.w3.org/2006/01/wsdl/http#HTTPHeader"/>rdf:about="http://www.w3.org/ns/wsdl/http#offersHeader"> <rdfs:rangerdf:about="http://www.w3.org/2006/01/wsdl/http#offersHeader">rdf:resource="http://www.w3.org/ns/wsdl/http#HTTPHeader"/> </owl:ObjectProperty> <owl:Classrdf:resource="http://www.w3.org/2006/01/wsdl/http#HTTPHeader"/>rdf:about="http://www.w3.org/ns/wsdl/http#HTTPHeader"> <rdfs:comment> an HTTP header </rdfs:comment> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#typeDefinition"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> <rdfs:subClassOf> <owl:Restriction> <owl:onPropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#HTTPHeader">rdf:resource="http://www.w3.org/ns/wsdl/http#headerName"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> </owl:Class> <owl:DatatypePropertyrdf:resource="http://www.w3.org/2006/01/wsdl/http#headerName"/>rdf:about="http://www.w3.org/ns/wsdl/http#errorCode"> <rdfs:comment> declares the error status code that a fault will return </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#int"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#errorCode">rdf:about="http://www.w3.org/ns/wsdl/http#defaultContentEncoding"> <rdfs:comment> declares the defaultrdf:about="http://www.w3.org/2006/01/wsdl/http#defaultTransferCoding">transfercontent encoding to be used by this binding's operation messages </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:DatatypePropertycodingrdf:about="http://www.w3.org/ns/wsdl/http#contentEncoding"> <rdfs:comment> declares therdf:about="http://www.w3.org/2006/01/wsdl/http#transferCoding">transfercontent encoding to be used by operation messages </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:Classcodingrdf:about="http://www.w3.org/ns/wsdl/http#HTTPBindingWithCookies"> <rdfs:comment>WSDL 2 HTTP binding with cookies</rdfs:comment> <rdfs:subClassOfrdf:about="http://www.w3.org/2006/01/wsdl/http#HTTPBindingWithCookies">rdf:resource="http://www.w3.org/ns/wsdl/http"/> </owl:Class> <owl:DatatypePropertyrdf:resource="http://www.w3.org/2006/01/wsdl/http"/>rdf:about="http://www.w3.org/ns/wsdl/http#authenticationScheme"> <rdfs:comment> declares the authentication scheme used by an endpoint, by default "none" </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> <owl:DatatypePropertyrdf:about="http://www.w3.org/2006/01/wsdl/http#authenticationScheme">rdf:about="http://www.w3.org/ns/wsdl/http#authenticationRealm"> <rdfs:comment> declares the authentication realm used by an endpoint </rdfs:comment> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/> </owl:DatatypeProperty> </rdf:RDF>rdf:about="http://www.w3.org/2006/01/wsdl/http#authenticationRealm">