Skip to main content

Notice: this Wiki will be going read only early in 2024 and edits will no longer be possible. Please see: https://gitlab.eclipse.org/eclipsefdn/helpdesk/-/wikis/Wiki-shutdown-plan for the plan.

Jump to: navigation, search

Difference between revisions of "ALF/Vocabularies/Event Declaration Schema"

< ALF
(Schema)
(Schema)
Line 361: Line 361:
  
 
</pre>
 
</pre>
 +
== WSDL ==

Revision as of 13:03, 6 September 2006

Schema

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:evt="http://www.eclipse.org/alf/XMLSchema/Events.xsd" xmlns="http://www.eclipse.org/alf/XMLSchema/Events.xsd" targetNamespace="http://www.eclipse.org/alf/XMLSchema/Events.xsd" elementFormDefault="qualified" attributeFormDefault="unqualified">
	<xs:include schemaLocation="ALFEventBase_001.xsd"/>
	<xs:annotation>
		<xs:documentation>
	WARNING: PRELIMINARY VERSION DO NOT USE
    </xs:documentation>
	</xs:annotation>
	<xs:annotation>
		<xs:documentation>
	Copyright Notice
	The material in this document is Copyright (c) Serena Software, Inc. and others, 2005
	Terms and Conditions:
	The Eclipse Foundation makes available all content in this document ("Content").
	Unless otherwise indicated below, the Content is provided to you under the terms
	and conditions of the Eclipse Public License Version 1.0 ("EPL").
	A copy of the EPL is available at http://www.eclipse.org/legal/epl-v10.html.
	For purposes of the EPL, "Program" will mean the Content.
	If you did not receive this Content directly from the Eclipse Foundation, the
	Content is being redistributed by another party ("Redistributor") and different
	terms and conditions may apply to your use of any object code in the Content.
	Check the Redistributor's license that was provided with the Content.
	If you did not receive any such license, contact the Redistributor.
	Unless otherwise indicated below, the terms and conditions of the EPL still apply to the Content.
    </xs:documentation>
	</xs:annotation>
	<!-- Begin BasicEventTypes -->
	<!-- These event declarations restrict the possible values for EventType, Object and Source.
	There are various options for declaring these derivied types depending on the valid combinations of EventType
	and Object values.
	If any EventType value can be combined with any Object value then all possible values can be declared in a single
	type.
	If only one or some EventType values can be combined with one or some Object value the separate types must be declared for the valid combinations
	Parts of Source is generally constant for any particular product. -->
	<!-- MyBasicEvent1Type is restricted to an event with the value "My Product Event Type A", and an object with the type value, "My Product Object Type A" -->
	<xs:complexType name="MyEventBase1Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="EventBaseType">
				<xs:sequence>
					<xs:element name="EventID" type="EventIDType"/>
					<xs:element name="Timestamp" type="TimestampType"/>
					<xs:element name="EventType" type="MyEventType1Type"/>
					<xs:element name="Object" type="MyObjectData1Type"/>
					<xs:element name="Source" type="MySourceType"/>
					<xs:element name="PredecedingEvent" type="EventIDType" nillable="true"/>
					<xs:element name="ApplicationName" type="ApplicationNameType" nillable="true"/>
					<xs:element name="Environment" type="EnvironmentType" nillable="true"/>
					<xs:element name="User" type="UserType"/>
				</xs:sequence>
				<xs:attribute name="alfEventVersion" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- MyBasicEvent2Type is restricted to an event with the event value "My Product Event Type B".  
	It may contain object with type values of, "My Product Object Type B" or "My Product Object Type C"-->
	<xs:complexType name="MyEventBase2Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="EventBaseType">
				<xs:sequence>
					<xs:element name="EventID" type="EventIDType"/>
					<xs:element name="Timestamp" type="TimestampType"/>
					<xs:element name="EventType" type="MyEventType2Type"/>
					<xs:element name="Object" type="MyObjectData2Type"/>
					<xs:element name="Source" type="MySourceType"/>
					<xs:element name="PredecedingEvent" type="EventIDType" nillable="true"/>
					<xs:element name="ApplicationName" type="ApplicationNameType" nillable="true"/>
					<xs:element name="Environment" type="EnvironmentType" nillable="true"/>
					<xs:element name="User" type="UserType"/>
				</xs:sequence>
				<xs:attribute name="alfEventVersion" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- MyBasicEvent3Type is restricted to an event with the event value "My Product Event Type C".  
	It may contain object with type values of, "My Product Object Type B",  "My Product Object Type C" or "My Product Object Type D"-->
	<xs:complexType name="MyEventBase3Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="EventBaseType">
				<xs:sequence>
					<xs:element name="EventID" type="EventIDType"/>
					<xs:element name="Timestamp" type="TimestampType"/>
					<xs:element name="EventType" type="MyEventType3Type"/>
					<xs:element name="Object" type="MyObjectData3Type"/>
					<xs:element name="Source" type="MySourceType"/>
					<xs:element name="PredecedingEvent" type="EventIDType" nillable="true"/>
					<xs:element name="ApplicationName" type="ApplicationNameType" nillable="true"/>
					<xs:element name="Environment" type="EnvironmentType" nillable="true"/>
					<xs:element name="User" type="UserType"/>
				</xs:sequence>
				<xs:attribute name="alfEventVersion" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- In order to restrict the EventType, Object and Source values we need to declare custom restricted types.
	Depending how the allowed values for EventType, Object and Source combine we can declare either one type
	that restricts to all possible values or a number of single value types or some combination -->
	<!-- These EventType variants each have a single possible value -->
	<xs:simpleType name="MyEventType1Type">
		<xs:restriction base="EventTypeType">
			<xs:enumeration value="My Product Event Type A"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:simpleType name="MyEventType2Type">
		<xs:restriction base="EventTypeType">
			<xs:enumeration value="My Product Event Type B"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:simpleType name="MyEventType3Type">
		<xs:restriction base="EventTypeType">
			<xs:enumeration value="My Product Event Type C"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- =============  Object that triggered the event  ============= -->
	<!-- MyObjectData1Type is restricted to one possible value -->
	<!--The ObjectData type derivations illustrate how to combine a number of possible values that may be used interchangeably.
	This can be useful shorthand to compact the event definitions by grouping set of values into a single definition.
	The values in a set may overlap with other sets of the same type but care must be taken to ensure ambiguous or duplicate defintions results.
	-->
	<xs:complexType name="MyObjectData1Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="ObjectDataType">
				<xs:sequence>
					<xs:element name="ObjectType" type="MyObjectType1Type"/>
					<xs:element name="ObjectId" type="ObjectIdType"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:simpleType name="MyObjectType1Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:restriction base="ObjectTypeType">
			<xs:enumeration value="My Product Object Type A"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- MyObjectData2Type is restricted to two possible values -->
	<xs:complexType name="MyObjectData2Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="ObjectDataType">
				<xs:sequence>
					<xs:element name="ObjectType" type="MyObjectType2Type"/>
					<xs:element name="ObjectId" type="ObjectIdType"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:simpleType name="MyObjectType2Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:restriction base="ObjectTypeType">
			<xs:enumeration value="My Product Object Type B"/>
			<xs:enumeration value="My Product Object Type C"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- MyObjectData3Type is restricted to three possible values -->
	<xs:complexType name="MyObjectData3Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="ObjectDataType">
				<xs:sequence>
					<xs:element name="ObjectType" type="MyObjectType3Type"/>
					<xs:element name="ObjectId" type="ObjectIdType"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:simpleType name="MyObjectType3Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:restriction base="ObjectTypeType">
			<xs:enumeration value="My Product Object Type B"/>
			<xs:enumeration value="My Product Object Type C"/>
			<xs:enumeration value="My Product Object Type D"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- =============  The source (i.e, tool or product) that emitted the event  ============= -->
	<!-- The values for Product and ProductVersion are constant for all events from a particular product installation -
	ProductInstance and ProductCallbackURI are determined at install time an will not have declared restricted values -->
	<xs:complexType name="MySourceType">
		<xs:complexContent>
			<xs:restriction base="SourceType">
				<xs:sequence>
					<xs:element name="Product" type="MyProductType"/>
					<xs:element name="ProductVersion" type="MyProductVersionType"/>
					<xs:element name="ProductInstance" type="ProductInstanceType"/>
					<xs:element name="ProductCallbackURI" type="ProductCallbackURIType" nillable="true" minOccurs="0"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:simpleType name="MyProductType">
		<xs:restriction base="ProductType">
			<xs:enumeration value="My Product Name"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:simpleType name="MyProductVersionType">
		<xs:restriction base="ProductVersionType">
			<xs:enumeration value="My Product Version"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- Each event type or object type could be associated with different event detail data.
	We need to declare the possible EventDetail types-->
	<xs:complexType name="MyEventDetail1Type">
		<xs:complexContent>
			<xs:restriction base="EventDetailType">
				<xs:sequence>
					<xs:any/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="MyEventDetail2Type">
		<xs:complexContent>
			<xs:restriction base="EventDetailType">
				<xs:sequence>
					<xs:any/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="MyEventDetail3Type">
		<xs:complexContent>
			<xs:restriction base="EventDetailType">
				<xs:sequence>
					<xs:element name="MyEventDetailDate1" type="xs:string"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="MyEventDetail4Type">
		<xs:complexContent>
			<xs:restriction base="EventExtensionType">
				<xs:sequence>
					<xs:choice>
						<xs:element name="MyEventDetail1" type="MyEventDetail1Type"/>
						<xs:element name="MyEventDetail2" type="MyEventDetail2Type"/>
						<xs:element name="MyEventDetail3" type="MyEventDetail3Type"/>
					</xs:choice>
				</xs:sequence>
				<xs:attribute name="schemaLocation" type="xs:anyURI" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- Each event type or object type could be associated with different ToolExtension data.
	We need to declare the possible ToolExtension types-->
	<xs:complexType name="MyEventExtension1Type">
		<xs:complexContent>
			<xs:restriction base="EventExtensionType">
				<xs:sequence>
					<xs:any/>
				</xs:sequence>
				<xs:attribute name="schemaLocation" type="xs:anyURI" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="MyEventExtension2Type">
		<xs:complexContent>
			<xs:restriction base="EventExtensionType">
				<xs:sequence>
					<xs:any/>
				</xs:sequence>
				<xs:attribute name="schemaLocation" type="xs:anyURI" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- End BasicEventTypes -->
	<!--  BEGIN ALFEvent -->
	<!-- We declare all the possible event structures -->
	<!-- MyALFEvent1Type is restricted to an event with the value "My Product Event Type A", and an object with the type value, "My Product Object Type A".
	The event comes with MyEventDetails1Types event details and MyToolExtensionData1Type tool extension data. -->
	<xs:complexType name="MyALFEvent1Type">
		<xs:complexContent>
			<xs:restriction base="ALFEventType">
				<xs:sequence>
					<xs:element name="Base" type="MyEventBase1Type"/>
					<xs:element name="Detail" type="MyEventDetail1Type"/>
					<xs:element name="Extension" type="MyEventExtension1Type"/>
				</xs:sequence>
				<xs:attribute name="version" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- MyALFEvent2Type is restricted to an event with the value "My Product Event Type B".  
	It may contain object with type values of, "My Product Object Type A" or "My Product Object Type B".
	The event comes with MyEventDetails2Types event details and MyToolExtensionData2Type tool extension data. -->
	<xs:complexType name="MyALFEvent2Type">
		<xs:complexContent>
			<xs:restriction base="ALFEventType">
				<xs:sequence>
					<xs:element name="Base" type="MyEventBase2Type"/>
					<xs:element name="Detail" type="MyEventDetail2Type"/>
					<xs:element name="Extension" type="MyEventExtension2Type"/>
				</xs:sequence>
				<xs:attribute name="version" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- MyALFEvent3Type iis restricted to an event with the event value "My Product Event Type C".  
	It may contain object with type values of, "My Product Object Type B",  "My Product Object Type C" or "My Product Object Type D"
	The event comes with MyEventDetails2Types event details and MyToolExtensionData2Type tool extension data. -->
	<xs:complexType name="MyALFEvent3Type">
		<xs:complexContent>
			<xs:restriction base="ALFEventType">
				<xs:sequence>
					<xs:element name="Base" type="MyEventBase3Type"/>
					<xs:element name="Detail" type="MyEventDetail2Type"/>
					<xs:element name="Extension" type="MyEventExtension2Type"/>
				</xs:sequence>
				<xs:attribute name="version" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="MyALFEvent3ResponseType">
		<xs:complexContent>
			<xs:restriction base="ALFEventResponseType">
				<xs:sequence>
					<xs:element name="Base" type="EventBaseType"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- My Event 1 -->
	<xs:element name="MyEventNotice1" type="MyALFEvent1Type"/>
	<!-- My Event 2 -->
	<xs:element name="MyEventNotice2" type="MyALFEvent2Type"/>
	<!-- My EventWithReply 3 -->
	<xs:element name="MyEventNotice3" type="MyALFEvent3Type"/>
	<xs:element name="MyEventNotice3Response" type="MyALFEvent3ResponseType"/>
</xs:schema>

WSDL

Back to the top